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 limit_order_create_operation : public base_operation
   {
      struct fee_parameters_type { 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;
      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_cancel_operation : public base_operation
   {
      struct fee_parameters_type { 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_parameters_type { uint64_t fee = 20 * GRAPHENE_BLOCKCHAIN_PRECISION; };

      asset               fee;
      account_id_type     funding_account; 
      asset               delta_collateral; 
      asset               delta_debt; 

      typedef extension<options_type> extensions_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_parameters_type {};

      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_parameters_type& k)const { return 0; }
   };

   struct bid_collateral_operation : public base_operation
   {
      struct fee_parameters_type { 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_parameters_type {};

      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_parameters_type& k)const { return 0; }
   };
} } // graphene::protocol

FC_REFLECT( graphene::protocol::limit_order_create_operation::fee_parameters_type, (fee) )
FC_REFLECT( graphene::protocol::limit_order_cancel_operation::fee_parameters_type, (fee) )
FC_REFLECT( graphene::protocol::call_order_update_operation::fee_parameters_type, (fee) )
FC_REFLECT( graphene::protocol::bid_collateral_operation::fee_parameters_type, (fee) )
FC_REFLECT( graphene::protocol::fill_order_operation::fee_parameters_type,  ) // VIRTUAL
FC_REFLECT( graphene::protocol::execute_bid_operation::fee_parameters_type,  ) // VIRTUAL

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_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::call_order_update_operation::options_type )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::limit_order_create_operation::fee_parameters_type )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::limit_order_cancel_operation::fee_parameters_type )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::call_order_update_operation::fee_parameters_type )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::bid_collateral_operation::fee_parameters_type )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::limit_order_create_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 )