Implement #583 percentage based transfer fee and #603 coin-days based free transaction

.gitignore

@@ -16,6 +16,7 @@ libraries/wallet/Doxyfile
 libraries/wallet/api_documentation.cpp
 libraries/wallet/doxygen
 
+programs/build_helpers/cat-parts
 programs/cli_wallet/cli_wallet
 programs/js_operation_serializer/js_operation_serializer
 programs/witness_node/witness_node
@@ -39,3 +40,8 @@ object_database/*
 
 *.pyc
 *.pyo
+
+libraries/egenesis/egenesis_brief.cpp
+libraries/egenesis/egenesis_full.cpp
+libraries/egenesis/embed_genesis
+

libraries/app/database_api.cpp

@@ -130,6 +130,7 @@ class database_api_impl : public std::enable_shared_from_this<database_api_impl>
       bool verify_account_authority( const string& name_or_id, const flat_set<public_key_type>& signers )const;
       processed_transaction validate_transaction( const signed_transaction& trx )const;
       vector< fc::variant > get_required_fees( const vector<operation>& ops, asset_id_type id )const;
+      asset get_operation_fee( const operation& op, const asset_id_type id = asset_id_type(0) )const;
 
       // Proposed transactions
       vector<proposal_object> get_proposed_transactions( account_id_type id )const;
@@ -1626,18 +1627,25 @@ vector< fc::variant > database_api::get_required_fees( const vector<operation>&
    return my->get_required_fees( ops, id );
 }
 
+asset database_api::get_operation_fee( const operation& op, const asset_id_type id )const
+{
+   return my->get_operation_fee( op, id );
+}
+
 /**
  * Container method for mutually recursive functions used to
  * implement get_required_fees() with potentially nested proposals.
  */
 struct get_required_fees_helper
 {
    get_required_fees_helper(
+      graphene::chain::database& _db,
       const fee_schedule& _current_fee_schedule,
       const price& _core_exchange_rate,
       uint32_t _max_recursion
       )
-      : current_fee_schedule(_current_fee_schedule),
+      : db(_db),
+        current_fee_schedule(_current_fee_schedule),
         core_exchange_rate(_core_exchange_rate),
         max_recursion(_max_recursion)
    {}
@@ -1650,7 +1658,9 @@ struct get_required_fees_helper
       }
       else
       {
-         asset fee = current_fee_schedule.set_fee( op, core_exchange_rate );
+         fc::variant extended_fee_parameters;
+         db.build_extended_fee_parameters( op, extended_fee_parameters );
+         asset fee = current_fee_schedule.set_fee_extended( op, extended_fee_parameters, core_exchange_rate );
          fc::variant result;
          fc::to_variant( fee, result );
          return result;
@@ -1676,6 +1686,7 @@ struct get_required_fees_helper
       return vresult;
    }
 
+   graphene::chain::database& db;
    const fee_schedule& current_fee_schedule;
    const price& core_exchange_rate;
    uint32_t max_recursion;
@@ -1694,6 +1705,7 @@ vector< fc::variant > database_api_impl::get_required_fees( const vector<operati
    result.reserve(ops.size());
    const asset_object& a = id(_db);
    get_required_fees_helper helper(
+      _db,
       _db.current_fee_schedule(),
       a.options.core_exchange_rate,
       GET_REQUIRED_FEES_MAX_RECURSION );
@@ -1704,6 +1716,17 @@ vector< fc::variant > database_api_impl::get_required_fees( const vector<operati
    return result;
 }
 
+asset database_api_impl::get_operation_fee( const operation& op, const asset_id_type id )const
+{
+   // we copy the op because we need to mutate an operation to reliably
+   // determine its fee
+   operation _op = op;
+   fc::variant extended_fee_parameters;
+   _db.build_extended_fee_parameters( _op, extended_fee_parameters );
+   const asset_object& a = id(_db);
+   return _db.current_fee_schedule().set_fee_extended( _op, extended_fee_parameters, a.options.core_exchange_rate );
+}
+
 //////////////////////////////////////////////////////////////////////
 //                                                                  //
 // Proposed transactions                                            //

libraries/app/impacted.cpp

@@ -42,6 +42,11 @@ struct get_impacted_account_visitor
       _impacted.insert( op.to );
    }
 
+   void operator()( const transfer_v2_operation& op )
+   {
+      _impacted.insert( op.to );
+   }
+
    void operator()( const asset_claim_fees_operation& op ){}
    void operator()( const limit_order_create_operation& op ) {}
    void operator()( const limit_order_cancel_operation& op )
@@ -152,6 +157,7 @@ struct get_impacted_account_visitor
       _impacted.insert( op.committee_member_account );
    }
    void operator()( const committee_member_update_global_parameters_operation& op ) {}
+   void operator()( const committee_member_update_core_asset_operation& op ) {}
 
    void operator()( const vesting_balance_create_operation& op )
    {

libraries/app/include/graphene/app/database_api.hpp

@@ -530,6 +530,13 @@ class database_api
        */
       vector< fc::variant > get_required_fees( const vector<operation>& ops, asset_id_type id )const;
 
+      /**
+       * Get minimum fee required by the given operation. Won't recursively check if the operation
+       * is a proposal.
+       * @return the fee
+       */
+      asset get_operation_fee( const operation& op, const asset_id_type id = asset_id_type(0) )const;
+
       ///////////////////////////
       // Proposed transactions //
       ///////////////////////////
@@ -642,6 +649,7 @@ FC_API(graphene::app::database_api,
    (verify_account_authority)
    (validate_transaction)
    (get_required_fees)
+   (get_operation_fee)
 
    // Proposed transactions
    (get_proposed_transactions)

libraries/chain/CMakeLists.txt

@@ -12,6 +12,7 @@ if( GRAPHENE_DISABLE_UNITY_BUILD )
         db_balance.cpp
         db_block.cpp
         db_debug.cpp
+        db_fee.cpp
         db_getter.cpp
         db_init.cpp
         db_maint.cpp

libraries/chain/account_object.cpp

@@ -29,6 +29,7 @@
 
 namespace graphene { namespace chain {
 
+/// @return a * p% / 100%
 share_type cut_fee(share_type a, uint16_t p)
 {
    if( a == 0 || p == 0 )
@@ -42,6 +43,20 @@ share_type cut_fee(share_type a, uint16_t p)
    return r.to_uint64();
 }
 
+/// @return a * p% / t%
+share_type cut_fee(share_type a, uint16_t p, uint16_t t)
+{
+   if( a == 0 || p == 0 )
+      return 0;
+   if( p >= t )
+      return a;
+
+   fc::uint128 r(a.value);
+   r *= p;
+   r /= t;
+   return r.to_uint64();
+}
+
 void account_balance_object::adjust_balance(const asset& delta)
 {
    assert(delta.asset_id == asset_type);
@@ -50,8 +65,11 @@ void account_balance_object::adjust_balance(const asset& delta)
 
 void account_statistics_object::process_fees(const account_object& a, database& d) const
 {
-   if( pending_fees > 0 || pending_vested_fees > 0 )
+   if( pending_fees > 0 || pending_vested_fees > 0
+         || pending_fees_to_network > 0 || pending_fees_to_non_network > 0
+         || pending_vested_fees_to_non_network > 0)
    {
+      // split pending fees among network, lifetime referrer, registrar, referrer
       auto pay_out_fees = [&](const account_object& account, share_type core_fee_total, bool require_vesting)
       {
          // Check the referrer -- if he's no longer a member, pay to the lifetime referrer instead.
@@ -94,10 +112,65 @@ void account_statistics_object::process_fees(const account_object& a, database&
       pay_out_fees(a, pending_fees, true);
       pay_out_fees(a, pending_vested_fees, false);
 
+
+      // pay pending network fees to network
+      auto pay_out_network_fees = [&]( share_type network_fee_total )
+      {
+
+#ifndef NDEBUG
+         const auto& props = d.get_global_properties();
+
+         share_type reserved = cut_fee(network_fee_total, props.parameters.reserve_percent_of_fee);
+         share_type accumulated = network_fee_total - reserved;
+         assert( accumulated + reserved == network_fee_total );
+#endif
+         d.modify(asset_dynamic_data_id_type()(d), [network_fee_total](asset_dynamic_data_object& d) {
+            d.accumulated_fees += network_fee_total;
+         });
+      };
+
+      pay_out_network_fees(pending_fees_to_network);
+
+
+      // split pending non-network fees among lifetime referrer, registrar, referrer
+      auto pay_out_non_network_fees = [&](const account_object& account, share_type core_fee_total, bool require_vesting)
+      {
+         // Check the referrer -- if he's no longer a member, pay to the lifetime referrer instead.
+         // No need to check the registrar; registrars are required to be lifetime members.
+         if( account.referrer(d).is_basic_account(d.head_block_time()) )
+            d.modify(account, [](account_object& a) {
+               a.referrer = a.lifetime_referrer;
+            });
+
+         share_type lifetime_cut = cut_fee(core_fee_total,
+                                           account.lifetime_referrer_fee_percentage,
+                                           GRAPHENE_100_PERCENT - account.network_fee_percentage);
+         share_type referral = core_fee_total - lifetime_cut;
+
+         // Potential optimization: Skip some of this math and object lookups by special casing on the account type.
+         // For example, if the account is a lifetime member, we can skip all this and just deposit the referral to
+         // it directly.
+         share_type referrer_cut = cut_fee(referral, account.referrer_rewards_percentage);
+         share_type registrar_cut = referral - referrer_cut;
+
+         d.deposit_cashback(d.get(account.lifetime_referrer), lifetime_cut, require_vesting);
+         d.deposit_cashback(d.get(account.referrer), referrer_cut, require_vesting);
+         d.deposit_cashback(d.get(account.registrar), registrar_cut, require_vesting);
+
+         assert( referrer_cut + registrar_cut + lifetime_cut == core_fee_total );
+      };
+
+      pay_out_non_network_fees(a, pending_fees_to_non_network, true);
+      pay_out_non_network_fees(a, pending_vested_fees_to_non_network, false);
+
       d.modify(*this, [&](account_statistics_object& s) {
-         s.lifetime_fees_paid += pending_fees + pending_vested_fees;
+         s.lifetime_fees_paid += ( pending_fees + pending_vested_fees + pending_fees_to_network
+                                 + pending_fees_to_non_network + pending_vested_fees_to_non_network );
          s.pending_fees = 0;
          s.pending_vested_fees = 0;
+         s.pending_fees_to_network = 0;
+         s.pending_fees_to_non_network = 0;
+         s.pending_vested_fees_to_non_network = 0;
       });
    }
 }
@@ -110,6 +183,46 @@ void account_statistics_object::pay_fee( share_type core_fee, share_type cashbac
       pending_vested_fees += core_fee;
 }
 
+void account_statistics_object::pay_fee_pre_split_network( share_type core_fee,
+                                                           share_type cashback_vesting_threshold,
+                                                           share_type network_fee )
+{
+   if( core_fee <= 0 ) return;
+   share_type new_network_fee = network_fee;
+   if( core_fee < network_fee ) new_network_fee = core_fee;
+   pending_fees_to_network += new_network_fee;
+   if( core_fee > cashback_vesting_threshold )
+      pending_fees_to_non_network += ( core_fee - new_network_fee );
+   else
+      pending_vested_fees_to_non_network += ( core_fee - new_network_fee );
+}
+
+fc::uint128_t account_statistics_object::compute_coin_seconds_earned(const asset& balance, fc::time_point_sec now)const
+{
+   if( now <= coin_seconds_earned_last_update )
+      return coin_seconds_earned;
+   int64_t delta_seconds = (now - coin_seconds_earned_last_update).to_seconds();
+
+   fc::uint128_t delta_coin_seconds = balance.amount.value;
+   delta_coin_seconds *= delta_seconds;
+
+   return (coin_seconds_earned + delta_coin_seconds);
+}
+
+void account_statistics_object::update_coin_seconds_earned(const asset& balance, fc::time_point_sec now)
+{
+   if( now <= coin_seconds_earned_last_update )
+      return;
+   coin_seconds_earned = compute_coin_seconds_earned(balance, now);
+   coin_seconds_earned_last_update = now;
+}
+
+void account_statistics_object::set_coin_seconds_earned(const fc::uint128_t new_coin_seconds, fc::time_point_sec now)
+{
+   coin_seconds_earned = new_coin_seconds;
+   coin_seconds_earned_last_update = now;
+}
+
 set<account_id_type> account_member_index::get_account_members(const account_object& a)const
 {
    set<account_id_type> result;

libraries/chain/asset_evaluator.cpp

@@ -105,6 +105,16 @@ void_result asset_create_evaluator::do_evaluate( const asset_create_operation& o
       FC_ASSERT( op.precision == op.bitasset_opts->short_backing_asset(d).precision );
    }
 
+   // #583 BSIP10 hard fork check
+   if( d.head_block_time() <= HARDFORK_583_TIME )
+   {
+      for( const auto& e : op.common_options.extensions )
+      {
+         FC_ASSERT( e.which() != asset_options::future_extensions::tag<asset_options::ext::transfer_fee_mode_options>::value,
+                    "Asset ${s} has an extension which requires hardfork #583.", ("s",op.symbol) );
+      }
+   }
+
    return void_result();
 } FC_CAPTURE_AND_RETHROW( (op) ) }
 
@@ -233,6 +243,13 @@ void_result asset_update_evaluator::do_evaluate(const asset_update_operation& o)
    const asset_object& a = o.asset_to_update(d);
    auto a_copy = a;
    a_copy.options = o.new_options;
+   // check whether hard fork time passed
+   if( d.head_block_time() > HARDFORK_583_TIME )
+   {
+      // if new options contain a null CER, replace it with current CER before validate
+      if( o.new_options.core_exchange_rate.is_null() )
+         a_copy.options.core_exchange_rate = a.options.core_exchange_rate;
+   }
    a_copy.validate();
 
    if( o.new_issuer )
@@ -275,6 +292,16 @@ void_result asset_update_evaluator::do_evaluate(const asset_update_operation& o)
    for( auto id : o.new_options.blacklist_authorities )
       d.get_object(id);
 
+   // #583 BSIP10 hard fork check
+   if( d.head_block_time() <= HARDFORK_583_TIME )
+   {
+      for( const auto& e : o.new_options.extensions )
+      {
+         FC_ASSERT( e.which() != asset_options::future_extensions::tag<asset_options::ext::transfer_fee_mode_options>::value,
+                    "Asset ${s} has an extension which requires hardfork #583.", ("s",a.symbol) );
+      }
+   }
+
    return void_result();
 } FC_CAPTURE_AND_RETHROW((o)) }
 
@@ -297,7 +324,11 @@ void_result asset_update_evaluator::do_apply(const asset_update_operation& o)
    d.modify(*asset_to_update, [&](asset_object& a) {
       if( o.new_issuer )
          a.issuer = *o.new_issuer;
-      a.options = o.new_options;
+      // make a copy of new_options; if CER is null, replace it with current CER
+      auto copy_new_options = o.new_options;
+      if( copy_new_options.core_exchange_rate.is_null() )
+         copy_new_options.core_exchange_rate = a.options.core_exchange_rate;
+      a.options = copy_new_options;
    });
 
    return void_result();