manager for sport_obj, event_grp_obj and event_obj

libraries/chain/CMakeLists.txt

@@ -108,7 +108,7 @@ add_library( graphene_chain
              betting_market_evaluator.cpp
              betting_market_object.cpp
              betting_market_group_object.cpp
-
+             manager.cpp
              affiliate_payout.cpp
 
              ${HEADERS}

libraries/chain/account_evaluator.cpp

@@ -279,6 +279,17 @@ void_result account_update_evaluator::do_evaluate( const account_update_operatio
 void_result account_update_evaluator::do_apply( const account_update_operation& o )
 { try {
    database& d = db();
+
+   if( o.new_options.valid() )
+   {
+      d.modify( acnt->statistics( d ), [&]( account_statistics_object& aso )
+      {
+         if((o.new_options->votes != acnt->options.votes ||
+             o.new_options->voting_account != acnt->options.voting_account))
+            aso.last_vote_time = d.head_block_time();
+      } );
+   }
+
    bool sa_before, sa_after;
    d.modify( *acnt, [&](account_object& a){
       if( o.owner )
@@ -320,7 +331,6 @@ void_result account_update_evaluator::do_apply( const account_update_operation&
          sa.account = o.account;
       } );
    }
-
    return void_result();
 } FC_CAPTURE_AND_RETHROW( (o) ) }
 

libraries/chain/asset_evaluator.cpp

@@ -57,35 +57,37 @@ void_result asset_create_evaluator::do_evaluate( const asset_create_operation& o
 
    if( d.head_block_time() > HARDFORK_385_TIME )
    {
-
-   if( d.head_block_time() <= HARDFORK_409_TIME )
-   {
-      auto dotpos = op.symbol.find( '.' );
-      if( dotpos != std::string::npos )
+      if( d.head_block_time() <= HARDFORK_409_TIME )
       {
-         auto prefix = op.symbol.substr( 0, dotpos );
-         auto asset_symbol_itr = asset_indx.find( op.symbol );
-         FC_ASSERT( asset_symbol_itr != asset_indx.end(), "Asset ${s} may only be created by issuer of ${p}, but ${p} has not been registered",
-                    ("s",op.symbol)("p",prefix) );
-         FC_ASSERT( asset_symbol_itr->issuer == op.issuer, "Asset ${s} may only be created by issuer of ${p}, ${i}",
-                    ("s",op.symbol)("p",prefix)("i", op.issuer(d).name) );
+         auto dotpos = op.symbol.find( '.' );
+         if( dotpos != std::string::npos )
+         {
+            auto prefix = op.symbol.substr( 0, dotpos );
+            auto asset_symbol_itr = asset_indx.find( op.symbol );
+            FC_ASSERT( asset_symbol_itr != asset_indx.end(),
+                       "Asset ${s} may only be created by issuer of ${p}, but ${p} has not been registered",
+                       ("s",op.symbol)("p",prefix) );
+            FC_ASSERT( asset_symbol_itr->issuer == op.issuer,
+                       "Asset ${s} may only be created by issuer of ${p}, ${i}",
+                       ("s",op.symbol)("p",prefix)("i", op.issuer(d).name) );
+         }
       }
-   }
-   else
-   {
-      auto dotpos = op.symbol.rfind( '.' );
-      if( dotpos != std::string::npos )
+      else
       {
-         auto prefix = op.symbol.substr( 0, dotpos );
-         auto asset_symbol_itr = asset_indx.find( prefix );
-         FC_ASSERT( asset_symbol_itr != asset_indx.end(), "Asset ${s} may only be created by issuer of ${p}, but ${p} has not been registered",
-                    ("s",op.symbol)("p",prefix) );
-         FC_ASSERT( asset_symbol_itr->issuer == op.issuer, "Asset ${s} may only be created by issuer of ${p}, ${i}",
-                    ("s",op.symbol)("p",prefix)("i", op.issuer(d).name) );
+         auto dotpos = op.symbol.rfind( '.' );
+         if( dotpos != std::string::npos )
+         {
+            auto prefix = op.symbol.substr( 0, dotpos );
+            auto asset_symbol_itr = asset_indx.find( prefix );
+            FC_ASSERT( asset_symbol_itr != asset_indx.end(),
+                       "Asset ${s} may only be created by issuer of ${p}, but ${p} has not been registered",
+                       ("s",op.symbol)("p",prefix) );
+            FC_ASSERT( asset_symbol_itr->issuer == op.issuer,
+                       "Asset ${s} may only be created by issuer of ${p}, ${i}",
+                       ("s",op.symbol)("p",prefix)("i", op.issuer(d).name) );
+         }
       }
    }
-
-   }
    else
    {
       auto dotpos = op.symbol.find( '.' );

libraries/chain/betting_market_evaluator.cpp

@@ -31,6 +31,7 @@
 #include <graphene/chain/exceptions.hpp>
 #include <graphene/chain/hardfork.hpp>
 #include <graphene/chain/is_authorized_asset.hpp>
+#include <graphene/chain/manager.hpp>
 
 namespace graphene { namespace chain {
 
@@ -75,8 +76,6 @@ void_result betting_market_group_create_evaluator::do_evaluate(const betting_mar
 { try {
    database& d = db();
    FC_ASSERT(d.head_block_time() >= HARDFORK_1000_TIME);
-   FC_ASSERT(trx_state->_is_proposed_trx);
-
    // the event_id in the operation can be a relative id.  If it is,
    // resolve it and verify that it is truly an event
    object_id_type resolved_event_id = op.event_id;
@@ -89,6 +88,15 @@ void_result betting_market_group_create_evaluator::do_evaluate(const betting_mar
    _event_id = resolved_event_id;
    FC_ASSERT(d.find_object(_event_id), "Invalid event specified");
 
+   if( d.head_block_time() < HARDFORK_MANAGER_TIME ) {
+      FC_ASSERT( trx_state->_is_proposed_trx );
+      FC_ASSERT( !op.extensions.value.fee_paying_account );
+   }
+   else {
+      FC_ASSERT( is_manager( db(), _event_id, op.fee_payer() ),
+         "fee_payer is not the manager of this object" );   
+   }
+
    FC_ASSERT(d.find_object(op.asset_id), "Invalid asset specified");
 
    // the rules_id in the operation can be a relative id.  If it is,
@@ -123,7 +131,16 @@ void_result betting_market_group_update_evaluator::do_evaluate(const betting_mar
 { try {
    database& d = db();
    FC_ASSERT(d.head_block_time() >= HARDFORK_1000_TIME);
-   FC_ASSERT(trx_state->_is_proposed_trx);
+
+   if( d.head_block_time() < HARDFORK_MANAGER_TIME ) {
+      FC_ASSERT( trx_state->_is_proposed_trx );
+      FC_ASSERT( !op.extensions.value.fee_paying_account );
+   }
+   else {
+      FC_ASSERT( is_manager( db(), op.betting_market_group_id, op.fee_payer() ),
+         "fee_payer is not the manager of this object" );   
+   }
+
    _betting_market_group = &op.betting_market_group_id(d);
 
    FC_ASSERT(op.new_description || op.new_rules_id || op.status, "nothing to change");
@@ -197,7 +214,6 @@ void_result betting_market_group_update_evaluator::do_apply(const betting_market
 void_result betting_market_create_evaluator::do_evaluate(const betting_market_create_operation& op)
 { try {
    FC_ASSERT(db().head_block_time() >= HARDFORK_1000_TIME);
-   FC_ASSERT(trx_state->_is_proposed_trx);
 
    // the betting_market_group_id in the operation can be a relative id.  If it is,
    // resolve it and verify that it is truly an betting_market_group
@@ -211,6 +227,15 @@ void_result betting_market_create_evaluator::do_evaluate(const betting_market_cr
    _group_id = resolved_betting_market_group_id;
    FC_ASSERT(db().find_object(_group_id), "Invalid betting_market_group specified");
 
+   if( db().head_block_time() < HARDFORK_MANAGER_TIME ) {
+      FC_ASSERT( trx_state->_is_proposed_trx );
+      FC_ASSERT( !op.extensions.value.fee_paying_account );
+   }
+   else {
+      FC_ASSERT( is_manager( db(), _group_id, op.fee_payer() ),
+         "fee_payer is not the manager of this object" );   
+   }
+
    return void_result();
 } FC_CAPTURE_AND_RETHROW( (op) ) }
 
@@ -229,7 +254,16 @@ void_result betting_market_update_evaluator::do_evaluate(const betting_market_up
 { try {
    database& d = db();
    FC_ASSERT(d.head_block_time() >= HARDFORK_1000_TIME);
-   FC_ASSERT(trx_state->_is_proposed_trx);
+
+   if( d.head_block_time() < HARDFORK_MANAGER_TIME ) {
+      FC_ASSERT(trx_state->_is_proposed_trx);
+      FC_ASSERT( !op.extensions.value.fee_paying_account );
+   }
+   else {
+      FC_ASSERT( is_manager( db(), op.betting_market_id, op.fee_payer() ),
+         "fee_payer is not the manager of this object" );   
+   }
+
    _betting_market = &op.betting_market_id(d);
    FC_ASSERT(op.new_group_id.valid() || op.new_description.valid() || op.new_payout_condition.valid(), "nothing to change");
 
@@ -245,6 +279,13 @@ void_result betting_market_update_evaluator::do_evaluate(const betting_market_up
                 resolved_betting_market_group_id.type() == betting_market_group_id_type::type_id,
                 "betting_market_group_id must refer to a betting_market_group_id_type");
       _group_id = resolved_betting_market_group_id;
+
+      if( db().head_block_time() >= HARDFORK_MANAGER_TIME )
+      {
+         FC_ASSERT( is_manager( db(), _group_id, op.fee_payer() ),
+            "no manager permission for the new_betting_market_group_id" );   
+      }
+
       FC_ASSERT(d.find_object(_group_id), "invalid betting_market_group specified");
    }
 
@@ -365,6 +406,16 @@ void_result betting_market_group_resolve_evaluator::do_evaluate(const betting_ma
 { try {
    database& d = db();
    FC_ASSERT(d.head_block_time() >= HARDFORK_1000_TIME);
+
+   if( d.head_block_time() <= HARDFORK_MANAGER_TIME ) {
+      FC_ASSERT( trx_state->_is_proposed_trx );
+      FC_ASSERT( !op.extensions.value.fee_paying_account );
+   }
+   else {
+      FC_ASSERT( is_manager( d, op.betting_market_group_id, op.fee_payer() ),
+         "fee_payer is not the manager of this object" );
+   }
+
    _betting_market_group = &op.betting_market_group_id(d);
    d.validate_betting_market_group_resolutions(*_betting_market_group, op.resolutions);
    return void_result();
@@ -379,6 +430,14 @@ void_result betting_market_group_resolve_evaluator::do_apply(const betting_marke
 void_result betting_market_group_cancel_unmatched_bets_evaluator::do_evaluate(const betting_market_group_cancel_unmatched_bets_operation& op)
 { try {
    FC_ASSERT(db().head_block_time() >= HARDFORK_1000_TIME);
+   if( db().head_block_time() <= HARDFORK_MANAGER_TIME ) {
+      FC_ASSERT( trx_state->_is_proposed_trx );
+      FC_ASSERT( !op.extensions.value.fee_paying_account );
+   }
+   else {
+      FC_ASSERT( is_manager( db(), op.betting_market_group_id, op.fee_payer() ),
+         "fee_payer is not the manager of this object" );
+   }
    _betting_market_group = &op.betting_market_group_id(db());
    return void_result();
 } FC_CAPTURE_AND_RETHROW( (op) ) }

libraries/chain/db_bet.cpp

@@ -476,7 +476,8 @@ int match_bet(database& db, const bet_object& taker_bet, const bet_object& maker
    share_type maximum_factor = std::min(maximum_taker_factor, maximum_maker_factor);
    share_type maker_amount_to_match = maximum_factor * maker_odds_ratio;
    share_type taker_amount_to_match = maximum_factor * taker_odds_ratio;
-   fc_idump(fc::logger::get("betting"), (maker_amount_to_match)(taker_amount_to_match));
+   //TODO
+   //fc_idump(fc::logger::get("betting"), (maker_amount_to_match)(taker_amount_to_match));
 
    // TODO: analyze whether maximum_maker_amount_to_match can ever be zero here 
    assert(maker_amount_to_match != 0);
@@ -554,7 +555,8 @@ int match_bet(database& db, const bet_object& taker_bet, const bet_object& maker
                  ("taker_refund_amount", taker_refund_amount)
                  ("maker_odds", maker_bet.backer_multiplier)
                  ("taker_odds", taker_bet.backer_multiplier));
-         fc_ddump(fc::logger::get("betting"), (taker_bet));
+         // TODO
+         //fc_ddump(fc::logger::get("betting"), (taker_bet));
 
          db.adjust_balance(taker_bet.bettor_id, asset(taker_refund_amount, taker_bet.amount_to_bet.asset_id));
          // TODO: update global statistics
@@ -635,8 +637,9 @@ bool database::place_bet(const bet_object& new_bet_object)
       // we continue if the maker bet was completely consumed AND the taker bet was not
       finished = orders_matched_flags != 2;
    }
-   if (!(orders_matched_flags & 1))
-      fc_ddump(fc::logger::get("betting"), (new_bet_object));
+   //TODO
+   //if (!(orders_matched_flags & 1))
+   //   fc_ddump(fc::logger::get("betting"), (new_bet_object));
 
 
    // return true if the taker bet was completely consumed

libraries/chain/event_evaluator.cpp

@@ -24,18 +24,19 @@
 #include <graphene/chain/event_evaluator.hpp>
 #include <graphene/chain/event_object.hpp>
 #include <graphene/chain/event_group_object.hpp>
+#include <graphene/chain/sport_object.hpp>
 #include <graphene/chain/database.hpp>
 #include <graphene/chain/exceptions.hpp>
 #include <graphene/chain/hardfork.hpp>
 #include <graphene/chain/is_authorized_asset.hpp>
 #include <graphene/chain/global_betting_statistics_object.hpp>
+#include <graphene/chain/manager.hpp>
 
 namespace graphene { namespace chain {
 
 void_result event_create_evaluator::do_evaluate(const event_create_operation& op)
 { try {
    FC_ASSERT(db().head_block_time() >= HARDFORK_1000_TIME);
-   FC_ASSERT(trx_state->_is_proposed_trx);
 
    //database& d = db();
    // the event_group_id in the operation can be a relative id.  If it is,
@@ -48,7 +49,15 @@ void_result event_create_evaluator::do_evaluate(const event_create_operation& op
              resolved_event_group_id.type() == event_group_id_type::type_id, 
              "event_group_id must refer to a event_group_id_type");
    event_group_id = resolved_event_group_id;
-   //const event_group_object& event_group = event_group_id(d);
+
+   if( db().head_block_time() < HARDFORK_MANAGER_TIME ) { // remove after HARDFORK_MANAGER_TIME
+      FC_ASSERT( trx_state->_is_proposed_trx );
+      FC_ASSERT( !op.extensions.value.new_manager && !op.extensions.value.fee_paying_account );
+   }
+   else {
+      FC_ASSERT( is_manager( db(), event_group_id, op.fee_payer() ),
+         "trx is not proposed and fee_payer is not the manager of this object" );
+   }
 
    return void_result();
 } FC_CAPTURE_AND_RETHROW( (op) ) }
@@ -62,7 +71,10 @@ object_id_type event_create_evaluator::do_apply(const event_create_operation& op
          event_obj.season = op.season;
          event_obj.start_time = op.start_time;
          event_obj.event_group_id = event_group_id;
+         if( op.extensions.value.new_manager ) 
+            event_obj.manager = *op.extensions.value.new_manager;
      });
+
    //increment number of active events in global betting statistics object
    const global_betting_statistics_object& betting_statistics = global_betting_statistics_id_type()(d);
    d.modify( betting_statistics, [&](global_betting_statistics_object& bso) {
@@ -74,10 +86,20 @@ object_id_type event_create_evaluator::do_apply(const event_create_operation& op
 void_result event_update_evaluator::do_evaluate(const event_update_operation& op)
 { try {
    FC_ASSERT(db().head_block_time() >= HARDFORK_1000_TIME);
-   FC_ASSERT(trx_state->_is_proposed_trx);
-   FC_ASSERT(op.new_event_group_id || op.new_name || op.new_season ||
-             op.new_start_time || op.new_status, "nothing to change");
-
+   if( db().head_block_time() < HARDFORK_MANAGER_TIME ) { // remove after HARDFORK_MANAGER_TIME
+      FC_ASSERT( trx_state->_is_proposed_trx );
+      FC_ASSERT( !op.extensions.value.new_manager && !op.extensions.value.fee_paying_account );
+      FC_ASSERT( op.new_event_group_id || op.new_name || op.new_season || 
+         op.new_start_time || op.new_status, "nothing to change"); 
+   }
+   else {
+      FC_ASSERT( is_manager( db(), op.event_id, op.fee_payer() ),
+         "fee_payer is not the manager of this object" );
+      FC_ASSERT( op.new_event_group_id || op.new_name || op.new_season || 
+         op.new_start_time || op.new_status || op.extensions.value.new_manager,
+         "nothing to change" );   
+   }
+
    if (op.new_event_group_id)
    {
       object_id_type resolved_event_group_id = *op.new_event_group_id;
@@ -88,6 +110,12 @@ void_result event_update_evaluator::do_evaluate(const event_update_operation& op
                 resolved_event_group_id.type() == event_group_id_type::type_id,
                 "event_group_id must refer to a event_group_id_type");
       event_group_id = resolved_event_group_id;
+
+      if( db().head_block_time() >= HARDFORK_MANAGER_TIME )
+      {
+         FC_ASSERT( is_manager( db(), event_group_id, *op.extensions.value.fee_paying_account ),
+            "no manager permission for the new_event_group_id" );   
+      }
    }
 
    return void_result();
@@ -108,16 +136,25 @@ void_result event_update_evaluator::do_apply(const event_update_operation& op)
                     eo.event_group_id = event_group_id;
                  if( op.new_status )
                     eo.dispatch_new_status(_db, *op.new_status);
+                 if( op.extensions.value.new_manager )
+                    eo.manager = *op.extensions.value.new_manager;
               });
    return void_result();
 } FC_CAPTURE_AND_RETHROW( (op) ) }
 
 void_result event_update_status_evaluator::do_evaluate(const event_update_status_operation& op)
 { try {
-   FC_ASSERT(trx_state->_is_proposed_trx);
-
    database& d = db();
    FC_ASSERT(d.head_block_time() >= HARDFORK_1000_TIME);
+   if( d.head_block_time() < HARDFORK_MANAGER_TIME ) { // remove after HARDFORK_MANAGER_TIME
+      FC_ASSERT( trx_state->_is_proposed_trx );
+      FC_ASSERT( !op.extensions.value.fee_paying_account );
+   }
+   else {
+      FC_ASSERT( is_manager( db(), op.event_id, op.fee_payer() ),
+         "fee_payer is not the manager of this object" );
+   }
+
    //check that the event to update exists
    _event_to_update = &op.event_id(d);