Merge pull request #2151 from christophersanborn/cjs-bsip87

Implement BSIP87: Force-Settlement Fee

libraries/chain/asset_evaluator.cpp

@@ -66,7 +66,16 @@ namespace detail {
  }
  }
 
- void check_asset_claim_fees_hardfork_87_74_collatfee(const fc::time_point_sec& block_time, const asset_claim_fees_operation& op)
+ void check_bitasset_options_hf_bsip87(const fc::time_point_sec& block_time, const bitasset_options& options)
+ {
+ // HF_REMOVABLE: Following hardfork check should be removable after hardfork date passes:
+ FC_ASSERT( !options.extensions.value.force_settle_fee_percent.valid()
+ || block_time >= HARDFORK_CORE_BSIP87_TIME,
+ "A BitAsset's FSFP cannot be set before Hardfork BSIP87" );
+ }
+
+ void check_asset_claim_fees_hardfork_87_74_collatfee(const fc::time_point_sec& block_time,
+ const asset_claim_fees_operation& op)
  {
  // HF_REMOVABLE: Following hardfork check should be removable after hardfork date passes:
  FC_ASSERT( !op.extensions.value.claim_from_asset_id.valid() ||
@@ -80,15 +89,20 @@ void_result asset_create_evaluator::do_evaluate( const asset_create_operation& o
 { try {
 
  const database& d = db();
- // Define now from the current block time
  const time_point_sec now = d.head_block_time();
 
+ // Hardfork Checks:
+ detail::check_asset_options_hf_1774(now, op.common_options);
+ detail::check_asset_options_hf_bsip81(now, op.common_options);
+ if( op.bitasset_opts ) {
+ detail::check_bitasset_options_hf_bsip77( now, *op.bitasset_opts );
+ detail::check_bitasset_options_hf_bsip87( now, *op.bitasset_opts ); // HF_REMOVABLE
+ }
+
  const auto& chain_parameters = d.get_global_properties().parameters;
  FC_ASSERT( op.common_options.whitelist_authorities.size() <= chain_parameters.maximum_asset_whitelist_authorities );
  FC_ASSERT( op.common_options.blacklist_authorities.size() <= chain_parameters.maximum_asset_whitelist_authorities );
 
- detail::check_asset_options_hf_1774( now, op.common_options );
-
  // Check that all authorities do exist
  for( auto id : op.common_options.whitelist_authorities )
  d.get_object(id);
@@ -117,7 +131,6 @@ void_result asset_create_evaluator::do_evaluate( const asset_create_operation& o
 
  if( op.bitasset_opts )
  {
- detail::check_bitasset_options_hf_bsip77( now, *op.bitasset_opts );
  const asset_object& backing = op.bitasset_opts->short_backing_asset(d);
  if( backing.is_market_issued() )
  {
@@ -133,15 +146,13 @@ void_result asset_create_evaluator::do_evaluate( const asset_create_operation& o
  FC_ASSERT( op.bitasset_opts->feed_lifetime_sec > chain_parameters.block_interval &&
  op.bitasset_opts->force_settlement_delay_sec > chain_parameters.block_interval );
  }
+
  if( op.is_prediction_market )
  {
  FC_ASSERT( op.bitasset_opts );
  FC_ASSERT( op.precision == op.bitasset_opts->short_backing_asset(d).precision );
  }
 
- // Check the taker fee percent
- detail::check_asset_options_hf_bsip81(now, op.common_options);
-
  return void_result();
 } FC_CAPTURE_AND_RETHROW( (op) ) }
 
@@ -305,6 +316,10 @@ void_result asset_update_evaluator::do_evaluate(const asset_update_operation& o)
  const database& d = db();
  const time_point_sec now = d.head_block_time();
 
+ // Hardfork Checks:
+ detail::check_asset_options_hf_1774(now, o.new_options);
+ detail::check_asset_options_hf_bsip81(now, o.new_options);
+
  const asset_object& a = o.asset_to_update(d);
  auto a_copy = a;
  a_copy.options = o.new_options;
@@ -317,8 +332,6 @@ void_result asset_update_evaluator::do_evaluate(const asset_update_operation& o)
  validate_new_issuer( d, a, *o.new_issuer );
  }
 
- detail::check_asset_options_hf_1774( now, o.new_options );
-
  if( a.dynamic_asset_data_id(d).current_supply != 0 )
  {
  // new issuer_permissions must be subset of old issuer permissions
@@ -344,9 +357,6 @@ void_result asset_update_evaluator::do_evaluate(const asset_update_operation& o)
  for( auto id : o.new_options.blacklist_authorities )
  d.get_object(id);
 
- // Check the taker fee percent
- detail::check_asset_options_hf_bsip81(now, o.new_options);
-
  return void_result();
 } FC_CAPTURE_AND_RETHROW((o)) }
 
@@ -425,7 +435,7 @@ void_result asset_update_issuer_evaluator::do_apply(const asset_update_issuer_op
  * @param true if after hf 922/931 (if nothing triggers, this and the logic that depends on it
  * should be removed).
  */
-void check_children_of_bitasset(database& d, const asset_update_bitasset_operation& op,
+void check_children_of_bitasset(const database& d, const asset_update_bitasset_operation& op,
  const asset_object& new_backing_asset)
 {
  // no need to do these checks if the new backing asset is CORE
@@ -454,9 +464,12 @@ void check_children_of_bitasset(database& d, const asset_update_bitasset_operati
 
 void_result asset_update_bitasset_evaluator::do_evaluate(const asset_update_bitasset_operation& op)
 { try {
- database& d = db();
+ const database& d = db();
+ const time_point_sec now = d.head_block_time();
 
- detail::check_bitasset_options_hf_bsip77( d.head_block_time(), op.new_options );
+ // Hardfork Checks:
+ detail::check_bitasset_options_hf_bsip77( now, op.new_options );
+ detail::check_bitasset_options_hf_bsip87( now, op.new_options ); // HF_REMOVABLE
 
  const asset_object& asset_obj = op.asset_to_update(d);
 

libraries/chain/db_market.cpp

@@ -963,22 +963,55 @@ bool database::fill_call_order( const call_order_object& order, const asset& pay
  return collateral_freed.valid();
 } FC_CAPTURE_AND_RETHROW( (order)(pays)(receives) ) }
 
+/***
+ * @brief fullfill a settle order in the specified amounts
+ *
+ * @details Called from database::match(), this coordinates exchange of debt asset X held in the
+ * settle order for collateral asset Y held in a call order, and routes fees. Note that we
+ * don't touch the call order directly, as match() handles this via a separate call to
+ * fill_call_order(). We are told exactly how much X and Y to exchange, based on details of
+ * order matching determined higher up the call chain. Thus it is possible that the settle
+ * order is not completely satisfied at the conclusion of this function.
+ *
+ * @param settle the force_settlement object
+ * @param pays the quantity of market-issued debt asset X which the settler will yield in this
+ * round (may be less than the full amount indicated in settle object)
+ * @param receives the quantity of collateral asset Y which the settler will receive in
+ * exchange for X
+ * @param fill_price the price at which the settle order will execute (not used - passed through
+ * to virtual operation)
+ * @param is_maker TRUE if the settle order is the maker, FALSE if it is the taker (passed
+ * through to virtual operation)
+ * @returns TRUE if the settle order was completely filled, FALSE if only partially filled
+ */
 bool database::fill_settle_order( const force_settlement_object& settle, const asset& pays, const asset& receives,
  const price& fill_price, const bool is_maker )
 { try {
  bool filled = false;
 
  const account_object* settle_owner_ptr = nullptr;
- // The owner of the settle order pays market fees to the issuer of the collateral asset after HF core-1780
+ // The owner of the settle order pays market fees to the issuer of the collateral asset.
+ // After HF core-1780, these fees are shared to the referral program, which is flagged to
+ // pay_market_fees by setting settle_owner_ptr non-null.
  //
  // TODO Check whether the HF check can be removed after the HF.
  // Note: even if logically it can be removed, perhaps the removal will lead to a small performance
  // loss. Needs testing.
  if( head_block_time() >= HARDFORK_CORE_1780_TIME )
  settle_owner_ptr = &settle.owner(*this);
+ // Compute and pay the market fees:
+ asset market_fees = pay_market_fees( settle_owner_ptr, get(receives.asset_id), receives, is_maker );
+
+ // Issuer of the settled smartcoin asset lays claim to a force-settlement fee (BSIP87), but
+ // note that fee is denominated in collateral asset, not the debt asset. Asset object of
+ // debt asset is passed to the pay function so it knows where to put the fee. Note that
+ // amount of collateral asset upon which fee is assessed is reduced by market_fees already
+ // paid to prevent the total fee exceeding total collateral.
+ asset force_settle_fees = pay_force_settle_fees( get(pays.asset_id), receives - market_fees );
 
- auto issuer_fees = pay_market_fees( settle_owner_ptr, get(receives.asset_id), receives, is_maker );
+ auto total_collateral_denominated_fees = market_fees + force_settle_fees;
 
+ // If we don't consume entire settle order:
  if( pays < settle.balance )
  {
  modify(settle, [&pays](force_settlement_object& s) {
@@ -987,15 +1020,18 @@ bool database::fill_settle_order( const force_settlement_object& settle, const a
  } else {
  filled = true;
  }
- adjust_balance(settle.owner, receives - issuer_fees);
+ // Give released collateral not already taken as fees to settle order owner:
+ adjust_balance(settle.owner, receives - total_collateral_denominated_fees);
 
  assert( pays.asset_id != receives.asset_id );
- push_applied_operation( fill_order_operation( settle.id, settle.owner, pays, receives, issuer_fees, fill_price, is_maker ) );
+ push_applied_operation( fill_order_operation( settle.id, settle.owner, pays, receives,
+ total_collateral_denominated_fees, fill_price, is_maker ) );
 
  if (filled)
  remove(settle);
 
  return filled;
+
 } FC_CAPTURE_AND_RETHROW( (settle)(pays)(receives) ) }
 
 /**
@@ -1361,4 +1397,32 @@ asset database::pay_market_fees(const account_object* seller, const asset_object
  return market_fees;
 }
 
+/***
+ * @brief Calculate force-settlement fee and give it to issuer of the settled asset
+ * @param collecting_asset the smart asset object which should receive the fee
+ * @param collat_receives the amount of collateral the settler would expect to receive absent this fee
+ * (fee is computed as a percentage of this amount)
+ * @return asset denoting the amount of fee collected
+ */
+asset database::pay_force_settle_fees(const asset_object& collecting_asset, const asset& collat_receives)
+{
+ FC_ASSERT( collecting_asset.get_id() != collat_receives.asset_id );
+
+ const bitasset_options& collecting_bitasset_opts = collecting_asset.bitasset_data(*this).options;
+
+ if( !collecting_bitasset_opts.extensions.value.force_settle_fee_percent.valid()
+ || *collecting_bitasset_opts.extensions.value.force_settle_fee_percent == 0 )
+ return asset{ 0, collat_receives.asset_id };
+
+ auto value = detail::calculate_percent(collat_receives.amount,
+ *collecting_bitasset_opts.extensions.value.force_settle_fee_percent);
+ asset settle_fee = asset{ value, collat_receives.asset_id };
+
+ // Deposit fee in asset's dynamic data object:
+ if( value > 0) {
+ collecting_asset.accumulate_fee(*this, settle_fee);
+ }
+ return settle_fee;
+}
+
 } }

libraries/chain/hardfork.d/CORE_BSIP87.hf

@@ -0,0 +1,4 @@
+// bitshares-core BSIP 87: add force-settlement fee percentage:
+#ifndef HARDFORK_CORE_BSIP87_TIME
+#define HARDFORK_CORE_BSIP87_TIME (fc::time_point_sec( 1679955066 ) ) // Temporary date until actual hardfork date is set
+#endif

libraries/chain/include/graphene/chain/database.hpp

@@ -442,6 +442,7 @@ namespace graphene { namespace chain {
  asset calculate_market_fee(const asset_object& recv_asset, const asset& trade_amount, const bool& is_maker);
  asset pay_market_fees(const account_object* seller, const asset_object& recv_asset, const asset& receives,
  const bool& is_maker);
+ asset pay_force_settle_fees(const asset_object& collecting_asset, const asset& collat_receives);
  ///@}
 
 

libraries/chain/proposal_evaluator.cpp

@@ -30,9 +30,12 @@ namespace graphene { namespace chain {
 
 namespace detail {
  void check_asset_options_hf_1774(const fc::time_point_sec& block_time, const asset_options& options);
- void check_asset_options_hf_bsip81(const fc::time_point_sec& block_time, const asset_options& options);
  void check_bitasset_options_hf_bsip77(const fc::time_point_sec& block_time, const bitasset_options& options);
- void check_asset_claim_fees_hardfork_87_74_collatfee(const fc::time_point_sec& block_time, const asset_claim_fees_operation& op);
+ void check_asset_options_hf_bsip81(const fc::time_point_sec& block_time, const asset_options& options);
+ void check_bitasset_options_hf_bsip87(const fc::time_point_sec& block_time,
+ const bitasset_options& options); // HF_REMOVABLE
+ void check_asset_claim_fees_hardfork_87_74_collatfee(const fc::time_point_sec& block_time,
+ const asset_claim_fees_operation& op); // HF_REMOVABLE
 }
 
 struct proposal_operation_hardfork_visitor
@@ -49,30 +52,34 @@ struct proposal_operation_hardfork_visitor
  void operator()(const T &v) const {}
 
  void operator()(const graphene::chain::asset_create_operation &v) const {
- // hf_1774
- detail::check_asset_options_hf_1774(block_time, v.common_options);
 
- // HARDFORK_BSIP_77
- if( v.bitasset_opts.valid() )
+ detail::check_asset_options_hf_1774(block_time, v.common_options);
+ detail::check_asset_options_hf_bsip81(block_time, v.common_options);
+ if( v.bitasset_opts.valid() ) {
  detail::check_bitasset_options_hf_bsip77( block_time, *v.bitasset_opts );
+ detail::check_bitasset_options_hf_bsip87( block_time, *v.bitasset_opts ); // HF_REMOVABLE
+ }
 
- // HARDFORK_BSIP_81
- detail::check_asset_options_hf_bsip81(block_time, v.common_options);
  }
+
  void operator()(const graphene::chain::asset_update_operation &v) const {
- // hf_1774
- detail::check_asset_options_hf_1774(block_time, v.new_options);
 
- // HARDFORK_BSIP_81
+ detail::check_asset_options_hf_1774(block_time, v.new_options);
  detail::check_asset_options_hf_bsip81(block_time, v.new_options);
+
  }
+
  void operator()(const graphene::chain::asset_update_bitasset_operation &v) const {
- // HARDFORK_BSIP_77
+
  detail::check_bitasset_options_hf_bsip77( block_time, v.new_options );
+ detail::check_bitasset_options_hf_bsip87( block_time, v.new_options ); // HF_REMOVABLE
+
  }
 
  void operator()(const graphene::chain::asset_claim_fees_operation &v) const {
+
  detail::check_asset_claim_fees_hardfork_87_74_collatfee(block_time, v); // HF_REMOVABLE
+
  }
 
  void operator()(const graphene::chain::committee_member_update_global_parameters_operation &op) const {

libraries/protocol/asset_ops.cpp

@@ -216,6 +216,10 @@ void bitasset_options::validate() const
  FC_ASSERT( *extensions.value.initial_collateral_ratio >= GRAPHENE_MIN_COLLATERAL_RATIO );
  FC_ASSERT( *extensions.value.initial_collateral_ratio <= GRAPHENE_MAX_COLLATERAL_RATIO );
  }
+
+ if( extensions.value.force_settle_fee_percent.valid() )
+ FC_ASSERT( *extensions.value.force_settle_fee_percent <= GRAPHENE_100_PERCENT );
+
 }
 
 void asset_options::validate()const

libraries/protocol/include/graphene/protocol/asset_ops.hpp

@@ -106,7 +106,8 @@ namespace graphene { namespace protocol {
  /// After BSIP77, when creating a new debt position or updating an existing position,
  /// the position will be checked against this parameter.
  /// Unused for prediction markets, although we allow it to be set for simpler implementation
- fc::optional<uint16_t> initial_collateral_ratio;
+ fc::optional<uint16_t> initial_collateral_ratio; // BSIP-77
+ fc::optional<uint16_t> force_settle_fee_percent; // BSIP-87
  };
 
  /// Time before a price feed expires
@@ -562,7 +563,7 @@ FC_REFLECT( graphene::protocol::asset_options,
  (extensions)
  )
 
-FC_REFLECT( graphene::protocol::bitasset_options::ext, (initial_collateral_ratio) )
+FC_REFLECT( graphene::protocol::bitasset_options::ext, (initial_collateral_ratio)(force_settle_fee_percent) )
 
 FC_REFLECT( graphene::protocol::bitasset_options,
  (feed_lifetime_sec)
@@ -579,6 +580,7 @@ FC_REFLECT( graphene::protocol::additional_asset_options,
 
 FC_REFLECT( graphene::protocol::asset_create_operation::fee_parameters_type,
  (symbol3)(symbol4)(long_symbol)(price_per_kbyte) )
+
 FC_REFLECT( graphene::protocol::asset_global_settle_operation::fee_parameters_type, (fee) )
 FC_REFLECT( graphene::protocol::asset_settle_operation::fee_parameters_type, (fee) )
 FC_REFLECT( graphene::protocol::asset_settle_cancel_operation::fee_parameters_type, )