market.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 Cryptonomex, Inc., and contributors.
 *
 * The MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#pragma once
#include <graphene/protocol/base.hpp>
#include <graphene/protocol/asset.hpp>
 
namespace graphene { namespace protocol {
 
   struct create_take_profit_order_action
   {
      asset_id_type   fee_asset_id;
      uint16_t        spread_percent = 0;
      uint16_t        size_percent = GRAPHENE_100_PERCENT;
      uint32_t        expiration_seconds = 0;
      bool            repeat = false;
 
      extensions_type extensions;  
 
      void            validate()const;
   };
 
   using limit_order_auto_action = static_variant< create_take_profit_order_action >;
 
   struct limit_order_create_operation : public base_operation
   {
      struct options_type
      {
         optional< vector< limit_order_auto_action > > on_fill;
      };
 
      struct fee_params_t { uint64_t fee = 5 * GRAPHENE_BLOCKCHAIN_PRECISION; };
 
      asset           fee;
      account_id_type seller;
      asset           amount_to_sell;
      asset           min_to_receive;
 
      time_point_sec expiration = time_point_sec::maximum();
 
      bool fill_or_kill = false;
 
      using extensions_type = extension<options_type>; // note: will be jsonified to {...} but not [...]
      extensions_type   extensions;
 
      pair<asset_id_type,asset_id_type> get_market()const
      {
         return amount_to_sell.asset_id < min_to_receive.asset_id ?
                std::make_pair(amount_to_sell.asset_id, min_to_receive.asset_id) :
                std::make_pair(min_to_receive.asset_id, amount_to_sell.asset_id);
      }
      account_id_type fee_payer()const { return seller; }
      void            validate()const;
      price           get_price()const { return amount_to_sell / min_to_receive; }
   };
 
   struct limit_order_update_operation : public base_operation
   {
       struct fee_params_t {
           uint64_t fee = ( GRAPHENE_BLOCKCHAIN_PRECISION * 3 ) / 8;
       };
 
       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;
       optional< vector< limit_order_auto_action > > on_fill;
 
       extensions_type extensions;
 
       account_id_type fee_payer() const { return seller; }
       void validate() const override;
   };
 
   struct limit_order_cancel_operation : public base_operation
   {
      struct fee_params_t { uint64_t fee = 0; };
 
      asset               fee;
      limit_order_id_type order;
      account_id_type     fee_paying_account;
      extensions_type   extensions;
 
      account_id_type fee_payer()const { return fee_paying_account; }
      void            validate()const;
   };
 
   struct call_order_update_operation : public base_operation
   {
      struct options_type
      {
         optional<uint16_t> target_collateral_ratio;
      };
 
      struct fee_params_t { uint64_t fee = 20 * GRAPHENE_BLOCKCHAIN_PRECISION; };
 
      asset               fee;
      account_id_type     funding_account; 
      asset               delta_collateral; 
      asset               delta_debt; 
 
      using extensions_type = extension<options_type>; // note: this will be jsonified to {...} but no longer [...]
      extensions_type     extensions;
 
      account_id_type fee_payer()const { return funding_account; }
      void            validate()const;
   };
 
   struct fill_order_operation : public base_operation
   {
      struct fee_params_t {};
 
      fill_order_operation(){}
      fill_order_operation( object_id_type o, account_id_type a, asset p, asset r, asset f, price fp, bool m )
         :order_id(o),account_id(a),pays(p),receives(r),fee(f),fill_price(fp),is_maker(m) {}
 
      object_id_type      order_id;
      account_id_type     account_id;
      asset               pays;
      asset               receives;
      asset               fee; // paid by receiving account
      price               fill_price;
      bool                is_maker = true;
 
      pair<asset_id_type,asset_id_type> get_market()const
      {
         return pays.asset_id < receives.asset_id ?
                std::make_pair( pays.asset_id, receives.asset_id ) :
                std::make_pair( receives.asset_id, pays.asset_id );
      }
      account_id_type fee_payer()const { return account_id; }
      void            validate()const { FC_ASSERT( !"virtual operation" ); }
 
      share_type      calculate_fee(const fee_params_t&)const { return 0; }
   };
 
   struct bid_collateral_operation : public base_operation
   {
      struct fee_params_t { uint64_t fee = 20 * GRAPHENE_BLOCKCHAIN_PRECISION; };
 
      asset               fee;
      account_id_type     bidder; 
      asset               additional_collateral; 
      asset               debt_covered; 
      extensions_type     extensions;
 
      account_id_type fee_payer()const { return bidder; }
      void            validate()const;
   };
 
   struct execute_bid_operation : public base_operation
   {
      struct fee_params_t {};
 
      execute_bid_operation(){}
      execute_bid_operation( account_id_type a, asset d, asset c )
         : bidder(a), debt(d), collateral(c) {}
 
      account_id_type     bidder;
      asset               debt;
      asset               collateral;
      asset               fee;
 
      account_id_type fee_payer()const { return bidder; }
      void            validate()const { FC_ASSERT( !"virtual operation" ); }
 
      share_type      calculate_fee(const fee_params_t&)const { return 0; }
   };
} } // graphene::protocol
 
FC_REFLECT( graphene::protocol::create_take_profit_order_action,
            (fee_asset_id)(spread_percent)(size_percent)(expiration_seconds)(repeat)(extensions) )
 
FC_REFLECT( graphene::protocol::limit_order_create_operation::fee_params_t, (fee) )
FC_REFLECT( graphene::protocol::limit_order_update_operation::fee_params_t, (fee) )
FC_REFLECT( graphene::protocol::limit_order_cancel_operation::fee_params_t, (fee) )
FC_REFLECT( graphene::protocol::call_order_update_operation::fee_params_t, (fee) )
FC_REFLECT( graphene::protocol::bid_collateral_operation::fee_params_t, (fee) )
FC_REFLECT( graphene::protocol::fill_order_operation::fee_params_t,  ) // VIRTUAL
FC_REFLECT( graphene::protocol::execute_bid_operation::fee_params_t,  ) // VIRTUAL
 
FC_REFLECT( graphene::protocol::limit_order_create_operation::options_type, (on_fill) )
FC_REFLECT( graphene::protocol::call_order_update_operation::options_type, (target_collateral_ratio) )
 
FC_REFLECT( graphene::protocol::limit_order_create_operation,
            (fee)(seller)(amount_to_sell)(min_to_receive)(expiration)(fill_or_kill)(extensions))
FC_REFLECT( graphene::protocol::limit_order_update_operation,
            (fee)(seller)(order)(new_price)(delta_amount_to_sell)(new_expiration)(on_fill)(extensions))
FC_REFLECT( graphene::protocol::limit_order_cancel_operation,
            (fee)(fee_paying_account)(order)(extensions) )
FC_REFLECT( graphene::protocol::call_order_update_operation,
            (fee)(funding_account)(delta_collateral)(delta_debt)(extensions) )
FC_REFLECT( graphene::protocol::fill_order_operation,
            (fee)(order_id)(account_id)(pays)(receives)(fill_price)(is_maker) )
FC_REFLECT( graphene::protocol::bid_collateral_operation,
            (fee)(bidder)(additional_collateral)(debt_covered)(extensions) )
FC_REFLECT( graphene::protocol::execute_bid_operation,
            (fee)(bidder)(debt)(collateral) )
 
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::create_take_profit_order_action)
 
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::limit_order_create_operation::options_type )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::call_order_update_operation::options_type )
 
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::limit_order_create_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::limit_order_update_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::limit_order_cancel_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::call_order_update_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::bid_collateral_operation::fee_params_t )
 
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::limit_order_create_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::limit_order_update_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::limit_order_cancel_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::call_order_update_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::bid_collateral_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::fill_order_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::execute_bid_operation )