Merge remote-tracking branch 'origin/fix_asset_create_fee' into testnet-beatrice

libraries/chain/asset_evaluator.cpp

@@ -93,8 +93,6 @@ void_result asset_create_evaluator::do_evaluate( const asset_create_operation& o
           wlog( "Asset ${s} has a name which requires hardfork 385", ("s",op.symbol) );
    }
 
-   core_fee_paid -= core_fee_paid.value/2;
-
    if( op.bitasset_opts )
    {
       const asset_object& backing = op.bitasset_opts->short_backing_asset(d);
@@ -121,12 +119,19 @@ void_result asset_create_evaluator::do_evaluate( const asset_create_operation& o
    return void_result();
 } FC_CAPTURE_AND_RETHROW( (op) ) }
 
+void asset_create_evaluator::pay_fee()
+{
+   fee_is_odd = core_fee_paid.value & 1;
+   core_fee_paid -= core_fee_paid.value/2;
+   generic_evaluator::pay_fee();
+}
+
 object_id_type asset_create_evaluator::do_apply( const asset_create_operation& op )
 { try {
    const asset_dynamic_data_object& dyn_asset =
       db().create<asset_dynamic_data_object>( [&]( asset_dynamic_data_object& a ) {
          a.current_supply = 0;
-         a.fee_pool = core_fee_paid; //op.calculate_fee(db().current_fee_schedule()).value / 2;
+         a.fee_pool = core_fee_paid - (fee_is_odd ? 1 : 0);
       });
 
    asset_bitasset_data_id_type bit_asset_id;

libraries/chain/include/graphene/chain/asset_evaluator.hpp

@@ -35,6 +35,13 @@ namespace graphene { namespace chain {
 
          void_result do_evaluate( const asset_create_operation& o );
          object_id_type do_apply( const asset_create_operation& o );
+
+         /** override the default behavior defined by generic_evalautor which is to
+          * post the fee to fee_paying_account_stats.pending_fees
+          */
+         virtual void pay_fee() override;
+      private:
+         bool fee_is_odd;
    };
 
    class asset_issue_evaluator : public evaluator<asset_issue_evaluator>

tests/tests/fee_tests.cpp

@@ -31,6 +31,7 @@
 
 #include <graphene/chain/fba_object.hpp>
 #include <graphene/chain/market_object.hpp>
+#include <graphene/chain/proposal_object.hpp>
 #include <graphene/chain/vesting_balance_object.hpp>
 #include <graphene/chain/exceptions.hpp>
 
@@ -947,4 +948,145 @@ BOOST_AUTO_TEST_CASE( stealth_fba_test )
    }
 }
 
+BOOST_AUTO_TEST_CASE( issue_429_test )
+{
+   try
+   {
+      ACTORS((alice));
+
+      transfer( committee_account, alice_id, asset( 1000000 * asset::scaled_precision( asset_id_type()(db).precision ) ) );
+
+      // make sure the database requires our fee to be nonzero
+      enable_fees();
+
+      auto fees_to_pay = db.get_global_properties().parameters.current_fees->get<asset_create_operation>();
+
+      {
+         signed_transaction tx;
+         asset_create_operation op;
+         op.issuer = alice_id;
+         op.symbol = "ALICE";
+         op.common_options.core_exchange_rate = asset( 1 ) / asset( 1, asset_id_type( 1 ) );
+         op.fee = asset( (fees_to_pay.long_symbol + fees_to_pay.price_per_kbyte) & (~1) );
+         tx.operations.push_back( op );
+         set_expiration( db, tx );
+         sign( tx, alice_private_key );
+         PUSH_TX( db, tx );
+      }
+
+      verify_asset_supplies( db );
+
+      {
+         signed_transaction tx;
+         asset_create_operation op;
+         op.issuer = alice_id;
+         op.symbol = "ALICE.ODD";
+         op.common_options.core_exchange_rate = asset( 1 ) / asset( 1, asset_id_type( 1 ) );
+         op.fee = asset((fees_to_pay.long_symbol + fees_to_pay.price_per_kbyte) | 1);
+         tx.operations.push_back( op );
+         set_expiration( db, tx );
+         sign( tx, alice_private_key );
+         PUSH_TX( db, tx );
+      }
+
+      verify_asset_supplies( db );
+
+      {
+         signed_transaction tx;
+         asset_create_operation op;
+         op.issuer = alice_id;
+         op.symbol = "ALICE.ODDER";
+         op.common_options.core_exchange_rate = asset( 1 ) / asset( 1, asset_id_type( 1 ) );
+         op.fee = asset((fees_to_pay.long_symbol + fees_to_pay.price_per_kbyte) | 1);
+         tx.operations.push_back( op );
+         set_expiration( db, tx );
+         sign( tx, alice_private_key );
+         PUSH_TX( db, tx );
+      }
+
+      verify_asset_supplies( db );
+   }
+   catch( const fc::exception& e )
+   {
+      edump((e.to_detail_string()));
+      throw;
+   }
+}
+
+BOOST_AUTO_TEST_CASE( issue_433_test )
+{
+   try
+   {
+      ACTORS((alice));
+
+      auto& core = asset_id_type()(db);
+
+      transfer( committee_account, alice_id, asset( 1000000 * asset::scaled_precision( core.precision ) ) );
+
+      const auto& myusd = create_user_issued_asset( "MYUSD", alice, 0 );
+      issue_uia( alice, myusd.amount( 2000000000 ) );
+
+      // make sure the database requires our fee to be nonzero
+      enable_fees();
+
+      const auto& fees = *db.get_global_properties().parameters.current_fees;
+      const auto asset_create_fees = fees.get<asset_create_operation>();
+
+      fund_fee_pool( alice, myusd, 5*asset_create_fees.long_symbol );
+
+      asset_create_operation op;
+      op.issuer = alice_id;
+      op.symbol = "ALICE";
+      op.common_options.core_exchange_rate = asset( 1 ) / asset( 1, asset_id_type( 1 ) );
+      op.fee = myusd.amount( ((asset_create_fees.long_symbol + asset_create_fees.price_per_kbyte) & (~1)) );
+      {
+         signed_transaction tx;
+         tx.operations.push_back( op );
+         set_expiration( db, tx );
+         sign( tx, alice_private_key );
+         PUSH_TX( db, tx );
+      }
+
+      verify_asset_supplies( db );
+
+      const auto proposal_create_fees = fees.get<proposal_create_operation>();
+      proposal_create_operation prop;
+      op.symbol = "ALICE.PROP";
+      prop.fee_paying_account = alice_id;
+      prop.proposed_ops.emplace_back( op );
+      prop.expiration_time =  db.head_block_time() + fc::days(1);
+      prop.fee = asset( proposal_create_fees.fee + proposal_create_fees.price_per_kbyte );
+      object_id_type proposal_id;
+      {
+         signed_transaction tx;
+         tx.operations.push_back( prop );
+         set_expiration( db, tx );
+         sign( tx, alice_private_key );
+         proposal_id = PUSH_TX( db, tx ).operation_results.front().get<object_id_type>();
+      }
+      const proposal_object& proposal = db.get<proposal_object>( proposal_id );
+
+      const auto proposal_update_fees = fees.get<proposal_update_operation>();
+      proposal_update_operation pup;
+      pup.proposal = proposal.id;
+      pup.fee_paying_account = alice_id;
+      pup.active_approvals_to_add.insert(alice_id);
+      pup.fee = asset( proposal_update_fees.fee + proposal_update_fees.price_per_kbyte );
+      {
+         signed_transaction tx;
+         tx.operations.push_back( pup );
+         set_expiration( db, tx );
+         sign( tx, alice_private_key );
+         PUSH_TX( db, tx );
+      }
+
+      verify_asset_supplies( db );
+   }
+   catch( const fc::exception& e )
+   {
+      edump((e.to_detail_string()));
+      throw;
+   }
+}
+
 BOOST_AUTO_TEST_SUITE_END()