Progress bitshares#1604: Basic implementation

Define and implement the limit_order_update_operation. Still needs
testing.

Author: nathanielhourt

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

@@ -63,6 +63,17 @@ namespace graphene { namespace chain {
          const asset_object*                 _receive_asset = nullptr;
    };
 
+   class limit_order_update_evaluator : public evaluator<limit_order_update_operation>
+   {
+   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);
+
+       const limit_order_object* _order = nullptr;
+   };
+
    class limit_order_cancel_evaluator : public evaluator<limit_order_cancel_evaluator>
    {
       public:
@@ -71,7 +82,7 @@ namespace graphene { namespace chain {
          void_result do_evaluate( const limit_order_cancel_operation& o );
          asset do_apply( const limit_order_cancel_operation& o );
 
-         const limit_order_object* _order;
+         const limit_order_object* _order = nullptr;
    };
 
    class call_order_update_evaluator : public evaluator<call_order_update_evaluator>

libraries/chain/include/graphene/chain/protocol/market.hpp

@@ -73,6 +73,35 @@ namespace graphene { namespace chain {
       price           get_price()const { return amount_to_sell / min_to_receive; }
    };
 
+   /**
+    * @ingroup operations
+    * Used to update an existing limit order.
+    *
+    * Charges a higher fee if @ref delta_amount_to_sell is set, as this requires updating
+    * the account balance as well as the order object.
+    */
+   struct limit_order_update_operation : public base_operation
+   {
+       struct fee_parameters_type {
+           uint64_t price_fee = GRAPHENE_BLOCKCHAIN_PRECISION / 2;
+           uint64_t amount_fee = GRAPHENE_BLOCKCHAIN_PRECISION;
+       };
+
+       asset fee;
+       account_id_type seller;
+       limit_order_id_type order;
+       optional<price> new_price;
+       optional<asset> delta_amount_to_sell;
+       optional<time_point_sec> new_expiration;
+
+       extensions_type extensions;
+
+       account_id_type fee_payer() { return seller; }
+       void validate() const;
+       share_type calculate_fee(const fee_parameters_type& k) const {
+           return delta_amount_to_sell? k.amount_fee : k.price_fee;
+       }
+   };
 
    /**
     *  @ingroup operations
@@ -219,6 +248,7 @@ namespace graphene { namespace chain {
 } } // graphene::chain
 
 FC_REFLECT( graphene::chain::limit_order_create_operation::fee_parameters_type, (fee) )
+FC_REFLECT( graphene::chain::limit_order_update_operation::fee_parameters_type, (price_fee)(amount_fee) )
 FC_REFLECT( graphene::chain::limit_order_cancel_operation::fee_parameters_type, (fee) )
 FC_REFLECT( graphene::chain::call_order_update_operation::fee_parameters_type, (fee) )
 FC_REFLECT( graphene::chain::bid_collateral_operation::fee_parameters_type, (fee) )
@@ -230,6 +260,7 @@ FC_REFLECT( graphene::chain::call_order_update_operation::options_type, (target_
 FC_REFLECT_TYPENAME( graphene::chain::call_order_update_operation::extensions_type )
 
 FC_REFLECT( graphene::chain::limit_order_create_operation,(fee)(seller)(amount_to_sell)(min_to_receive)(expiration)(fill_or_kill)(extensions))
+FC_REFLECT( graphene::chain::limit_order_update_operation,(fee)(seller)(order)(new_price)(delta_amount_to_sell)(new_expiration)(extensions))
 FC_REFLECT( graphene::chain::limit_order_cancel_operation,(fee)(fee_paying_account)(order)(extensions) )
 FC_REFLECT( graphene::chain::call_order_update_operation, (fee)(funding_account)(delta_collateral)(delta_debt)(extensions) )
 FC_REFLECT( graphene::chain::fill_order_operation, (fee)(order_id)(account_id)(pays)(receives)(fill_price)(is_maker) )

libraries/chain/market_evaluator.cpp

@@ -126,6 +126,58 @@ object_id_type limit_order_create_evaluator::do_apply(const limit_order_create_o
    return order_id;
 } FC_CAPTURE_AND_RETHROW( (op) ) }
 
+void_result limit_order_update_evaluator::do_evaluate(const limit_order_update_operation& o)
+{ try {
+    const database& d = db();
+    _order = &o.order(d);
+
+    // Check this is my order
+    FC_ASSERT(o.seller == _order->seller, "Cannot update someone else's order");
+
+    // Check new price is compatible
+    if (o.new_price)
+        FC_ASSERT(o.new_price->base.asset_id == _order->sell_price.base.asset_id &&
+                  o.new_price->quote.asset_id == _order->sell_price.quote.asset_id,
+                  "Cannot update limit order with incompatible price");
+
+    // Check delta asset is compatible
+    if (o.delta_amount_to_sell) {
+        const auto& delta = *o.delta_amount_to_sell;
+        FC_ASSERT(delta.asset_id == _order->sell_price.base.asset_id,
+                  "Cannot update limit order with incompatible asset");
+        if (delta.amount > 0)
+            FC_ASSERT(d.get_balance(o.seller, delta.asset_id) > delta,
+                      "Insufficient balance to increase order amount");
+        else
+            FC_ASSERT(_order->for_sale > -delta.amount,
+                      "Cannot deduct more from order than order contains");
+    }
+
+    // Check expiration is in the future
+    if (o.new_expiration)
+        FC_ASSERT(*o.new_expiration >= d.head_block_time(),
+                  "Cannot update limit order with past expiration");
+} FC_CAPTURE_AND_RETHROW((o)) }
+
+void_result limit_order_update_evaluator::do_apply(const limit_order_update_operation& o)
+{ try {
+   database& d = db();
+
+   // Adjust account balance
+   if (o.delta_amount_to_sell)
+      d.adjust_balance(o.seller, *o.delta_amount_to_sell);
+
+   // Update order
+   d.modify(*_order, [&o](limit_order_object& loo) {
+      if (o.new_price)
+         loo.sell_price = *o.new_price;
+      if (o.delta_amount_to_sell)
+         loo.for_sale += o.delta_amount_to_sell->amount;
+      if (o.new_expiration)
+         loo.expiration = *o.new_expiration;
+   });
+} FC_CAPTURE_AND_RETHROW((o)) }
+
 void_result limit_order_cancel_evaluator::do_evaluate(const limit_order_cancel_operation& o)
 { try {
    database& d = db();

libraries/chain/protocol/market.cpp

@@ -33,6 +33,17 @@ void limit_order_create_operation::validate()const
    FC_ASSERT( min_to_receive.amount > 0 );
 }
 
+void limit_order_update_operation::validate() const
+{
+   FC_ASSERT(fee.amount >= 0, "Fee must not be negative");
+   FC_ASSERT(new_price || delta_amount_to_sell || new_expiration,
+              "Cannot update limit order if nothing is specified to update");
+   if (new_price)
+       new_price->validate();
+   if (delta_amount_to_sell)
+       FC_ASSERT(delta_amount_to_sell->amount != 0, "Cannot change limit order amount by zero");
+}
+
 void limit_order_cancel_operation::validate()const
 {
    FC_ASSERT( fee.amount >= 0 );
@@ -54,4 +65,6 @@ void bid_collateral_operation::validate()const
    FC_ASSERT( debt_covered.amount == 0 || (debt_covered.amount > 0 && additional_collateral.amount > 0) );
 } FC_CAPTURE_AND_RETHROW((*this)) }
 
-} } // graphene::chain
+}
+
+} // graphene::chain