Implement Limit Order Modification Feature

libraries/chain/db_init.cpp

@@ -97,6 +97,7 @@ void database::initialize_evaluators()
    register_evaluator<asset_global_settle_evaluator>();
    register_evaluator<assert_evaluator>();
    register_evaluator<limit_order_create_evaluator>();
+   register_evaluator<limit_order_update_evaluator>();
    register_evaluator<limit_order_cancel_evaluator>();
    register_evaluator<call_order_update_evaluator>();
    register_evaluator<bid_collateral_evaluator>();

libraries/chain/db_market.cpp

@@ -537,7 +537,7 @@ void database::cancel_limit_order( const limit_order_object& order, bool create_
    // 1. due to expiration: always deduct a fee if there is any fee deferred
    // 2. due to cull_small: deduct a fee after hard fork 604, but not before (will set skip_cancel_fee)
    const account_statistics_object* seller_acc_stats = nullptr;
-   const asset_dynamic_data_object* fee_asset_dyn_data = nullptr;
+   const asset_dynamic_data_object* deferred_fee_asset_dyn_data = nullptr;
    limit_order_cancel_operation vop;
    share_type deferred_fee = order.deferred_fee;
    asset deferred_paid_fee = order.deferred_paid_fee;
@@ -576,8 +576,8 @@ void database::cancel_limit_order( const limit_order_object& order, bool create_
                fee128 /= order.deferred_fee.value;
                share_type cancel_fee_amount = static_cast<int64_t>(fee128);
                // cancel_fee should be positive, pay it to asset's accumulated_fees
-               fee_asset_dyn_data = &deferred_paid_fee.asset_id(*this).dynamic_asset_data_id(*this);
-               modify( *fee_asset_dyn_data, [&cancel_fee_amount](asset_dynamic_data_object& addo) {
+               deferred_fee_asset_dyn_data = &deferred_paid_fee.asset_id(*this).dynamic_asset_data_id(*this);
+               modify( *deferred_fee_asset_dyn_data, [&cancel_fee_amount](asset_dynamic_data_object& addo) {
                   addo.accumulated_fees += cancel_fee_amount;
                });
                // cancel_fee should be no more than deferred_paid_fee
@@ -613,9 +613,9 @@ void database::cancel_limit_order( const limit_order_object& order, bool create_
    {
       adjust_balance(order.seller, deferred_paid_fee);
       // be here, must have: fee_asset != CORE
-      if( !fee_asset_dyn_data )
-         fee_asset_dyn_data = &deferred_paid_fee.asset_id(*this).dynamic_asset_data_id(*this);
-      modify( *fee_asset_dyn_data, [&](asset_dynamic_data_object& addo) {
+      if( !deferred_fee_asset_dyn_data )
+         deferred_fee_asset_dyn_data = &deferred_paid_fee.asset_id(*this).dynamic_asset_data_id(*this);
+      modify( *deferred_fee_asset_dyn_data, [&deferred_fee](asset_dynamic_data_object& addo) {
          addo.fee_pool += deferred_fee;
       });
    }

libraries/chain/db_notify.cpp

@@ -56,6 +56,10 @@ struct get_impacted_account_visitor
    {
       _impacted.insert( op.fee_payer() ); // seller
    }
+   void operator()(const limit_order_update_operation& op)
+   {
+      _impacted.insert(op.fee_payer()); // seller
+   }
    void operator()( const limit_order_cancel_operation& op )
    {
       _impacted.insert( op.fee_payer() ); // fee_paying_account

libraries/chain/exceptions.cpp

@@ -84,6 +84,10 @@ namespace graphene { namespace chain {
    GRAPHENE_IMPLEMENT_OP_EVALUATE_EXCEPTION( insufficient_balance, limit_order_create, 6,
          "Insufficient balance" )
 
+   GRAPHENE_IMPLEMENT_OP_BASE_EXCEPTIONS( limit_order_update );
+   GRAPHENE_IMPLEMENT_OP_EVALUATE_EXCEPTION( nonexist_order, limit_order_update, 1, "Order does not exist" )
+   GRAPHENE_IMPLEMENT_OP_EVALUATE_EXCEPTION( owner_mismatch, limit_order_update, 2, "Order owned by someone else" )
+
    GRAPHENE_IMPLEMENT_OP_BASE_EXCEPTIONS( limit_order_cancel );
    GRAPHENE_IMPLEMENT_OP_EVALUATE_EXCEPTION( nonexist_order, limit_order_cancel, 1, "Order does not exist" )
    GRAPHENE_IMPLEMENT_OP_EVALUATE_EXCEPTION( owner_mismatch, limit_order_cancel, 2, "Order owned by someone else" )

libraries/chain/hardfork.d/CORE_1604.hf

@@ -0,0 +1,5 @@
+// bitshares-core issue #1604 Operation to modify existing limit order
+#ifndef HARDFORK_CORE_1604_TIME
+#define HARDFORK_CORE_1604_TIME (fc::time_point_sec(1893456000)) // Jan 1 00:00:00 2030 (Not yet scheduled)
+#define HARDFORK_CORE_1604_PASSED(head_block_time) (head_block_time >= HARDFORK_CORE_1604_TIME)
+#endif

libraries/chain/include/graphene/chain/exceptions.hpp

@@ -138,6 +138,10 @@ namespace graphene { namespace chain {
    GRAPHENE_DECLARE_OP_EVALUATE_EXCEPTION( receiving_asset_unauthorized, limit_order_create, 5 )
    GRAPHENE_DECLARE_OP_EVALUATE_EXCEPTION( insufficient_balance, limit_order_create, 6 )
 
+   GRAPHENE_DECLARE_OP_BASE_EXCEPTIONS( limit_order_update );
+   GRAPHENE_DECLARE_OP_EVALUATE_EXCEPTION( nonexist_order, limit_order_update, 1 )
+   GRAPHENE_DECLARE_OP_EVALUATE_EXCEPTION( owner_mismatch, limit_order_update, 2 )
+
    GRAPHENE_DECLARE_OP_BASE_EXCEPTIONS( limit_order_cancel );
    GRAPHENE_DECLARE_OP_EVALUATE_EXCEPTION( nonexist_order, limit_order_cancel, 1 )
    GRAPHENE_DECLARE_OP_EVALUATE_EXCEPTION( owner_mismatch, limit_order_cancel, 2 )

libraries/chain/include/graphene/chain/hardfork_visitor.hpp

@@ -47,6 +47,7 @@ struct hardfork_visitor {
    using BSIP_40_ops = fc::typelist::list< protocol::custom_authority_create_operation,
                                            protocol::custom_authority_update_operation,
                                            protocol::custom_authority_delete_operation>;
+   using hf1604_ops = fc::typelist::list< protocol::limit_order_update_operation>;
    using hf2103_ops = fc::typelist::list< protocol::ticket_create_operation,
                                           protocol::ticket_update_operation>;
    using liquidity_pool_ops = fc::typelist::list< protocol::liquidity_pool_create_operation,
@@ -82,6 +83,9 @@ struct hardfork_visitor {
    std::enable_if_t<fc::typelist::contains<BSIP_40_ops, Op>(), bool>
    visit() { return HARDFORK_BSIP_40_PASSED(now); }
    template<typename Op>
+   std::enable_if_t<fc::typelist::contains<hf1604_ops, Op>(), bool>
+   visit() { return HARDFORK_CORE_1604_PASSED(now); }
+   template<typename Op>
    std::enable_if_t<fc::typelist::contains<hf2103_ops, Op>(), bool>
    visit() { return HARDFORK_CORE_2103_PASSED(now); }
    template<typename Op>

libraries/chain/include/graphene/chain/market_evaluator.hpp

@@ -42,14 +42,14 @@ namespace graphene { namespace chain {
          void_result do_evaluate( const limit_order_create_operation& o );
          object_id_type do_apply( const limit_order_create_operation& o ) const;
 
-         /** override the default behavior defined by generic_evalautor
+         /** override the default behavior defined by generic_evaluator
           */
-         virtual void convert_fee() override;
+         void convert_fee() override;
 
-         /** override the default behavior defined by generic_evalautor which is to
+         /** override the default behavior defined by generic_evaluator which is to
           * post the fee to fee_paying_account_stats.pending_fees
           */
-         virtual void pay_fee() override;
+         void pay_fee() override;
 
       private:
          share_type                          _deferred_fee  = 0;
@@ -59,6 +59,32 @@ namespace graphene { namespace chain {
          const asset_object*                 _receive_asset = nullptr;
    };
 
+   class limit_order_update_evaluator : public evaluator<limit_order_update_evaluator>
+   {
+   public:
+       using operation_type = limit_order_update_operation;
+
+       void_result do_evaluate(const limit_order_update_operation& o);
+       void_result do_apply(const limit_order_update_operation& o);
+
+       /** override the default behavior defined by generic_evaluator
+        */
+       void convert_fee() override;
+
+       /** override the default behavior defined by generic_evaluator which is to
+        * post the fee to fee_paying_account_stats.pending_fees
+        */
+       void pay_fee() override;
+
+   private:
+       void process_deferred_fee();
+
+       share_type                _deferred_fee;
+       asset                     _deferred_paid_fee;
+       const limit_order_object* _order = nullptr;
+       const account_statistics_object* _seller_acc_stats = nullptr;
+   };
+
    class limit_order_cancel_evaluator : public evaluator<limit_order_cancel_evaluator>
    {
       public:
@@ -68,7 +94,7 @@ namespace graphene { namespace chain {
          asset do_apply( const limit_order_cancel_operation& o ) const;
 
       private:
-         const limit_order_object* _order;
+         const limit_order_object* _order = nullptr;
    };
 
    class call_order_update_evaluator : public evaluator<call_order_update_evaluator>