asset_ops.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>
#include <graphene/protocol/memo.hpp>
 
namespace graphene { namespace protocol {
 
   struct additional_asset_options
   {
      fc::optional<uint16_t>                  reward_percent;
      fc::optional<flat_set<account_id_type>> whitelist_market_fee_sharing;
      // After BSIP81 activation, taker_fee_percent is the taker fee
      fc::optional<uint16_t>                  taker_fee_percent;
   };
   typedef extension<additional_asset_options> additional_asset_options_t;
 
   bool is_valid_symbol( const string& symbol );
 
   struct asset_options {
      share_type max_supply = GRAPHENE_MAX_SHARE_SUPPLY;
      // BSIP81: Asset owners may specify different market fee rate for maker orders and taker orders
      // After BSIP81 activation, market_fee_percent is the maker fee
      uint16_t market_fee_percent = 0;
      share_type max_market_fee = GRAPHENE_MAX_SHARE_SUPPLY;
 
      uint16_t issuer_permissions = DEFAULT_UIA_ASSET_ISSUER_PERMISSION;
      uint16_t flags = 0;
 
      uint16_t get_enabled_issuer_permissions_mask() const;
 
      price core_exchange_rate = price(asset(), asset(0, asset_id_type(1)));
 
      flat_set<account_id_type> whitelist_authorities;
      flat_set<account_id_type> blacklist_authorities;
 
      flat_set<asset_id_type>   whitelist_markets;
      flat_set<asset_id_type>   blacklist_markets;
 
      string description;
      additional_asset_options_t extensions;
 
      void validate()const;
 
      void validate_flags( bool is_market_issued, bool allow_disable_collateral_bid = true )const;
   };
 
   struct bitasset_options {
 
      enum class black_swan_response_type
      {
         global_settlement = 0,
         no_settlement = 1,
         individual_settlement_to_fund = 2,
         individual_settlement_to_order = 3,
         BSRM_TYPE_COUNT = 4
      };
 
      struct ext
      {
         fc::optional<uint16_t> initial_collateral_ratio;  // BSIP-77
         fc::optional<uint16_t> maintenance_collateral_ratio; // BSIP-75
         fc::optional<uint16_t> maximum_short_squeeze_ratio;  // BSIP-75
         fc::optional<uint16_t> margin_call_fee_ratio; // BSIP 74
         fc::optional<uint16_t> force_settle_fee_percent;  // BSIP-87
         // https://github.com/bitshares/bitshares-core/issues/2467
         fc::optional<uint8_t> black_swan_response_method;
      };
 
      uint32_t feed_lifetime_sec = GRAPHENE_DEFAULT_PRICE_FEED_LIFETIME;
      uint8_t minimum_feeds = 1;
      uint32_t force_settlement_delay_sec = GRAPHENE_DEFAULT_FORCE_SETTLEMENT_DELAY;
      uint16_t force_settlement_offset_percent = GRAPHENE_DEFAULT_FORCE_SETTLEMENT_OFFSET;
      uint16_t maximum_force_settlement_volume = GRAPHENE_DEFAULT_FORCE_SETTLEMENT_MAX_VOLUME;
      asset_id_type short_backing_asset;
 
      extension<ext> extensions;
 
      void validate()const;
 
      black_swan_response_type get_black_swan_response_method() const
      {
         if( !extensions.value.black_swan_response_method.valid() )
            return black_swan_response_type::global_settlement;
         return static_cast<black_swan_response_type>( *extensions.value.black_swan_response_method );
      }
   };
 
 
   struct asset_create_operation : public base_operation
   {
      struct fee_params_t {
         uint64_t symbol3        = 500000 * GRAPHENE_BLOCKCHAIN_PRECISION;
         uint64_t symbol4        = 300000 * GRAPHENE_BLOCKCHAIN_PRECISION;
         uint64_t long_symbol    = 5000   * GRAPHENE_BLOCKCHAIN_PRECISION;
         uint32_t price_per_kbyte = 10; 
      };
 
      asset                   fee;
      account_id_type         issuer;
      string                  symbol;
      uint8_t                 precision = 0;
 
      asset_options              common_options;
      optional<bitasset_options> bitasset_opts;
      bool is_prediction_market = false;
      extensions_type extensions;
 
      account_id_type fee_payer()const { return issuer; }
      void            validate()const;
      share_type      calculate_fee( const fee_params_t& k,
                                     const optional<uint64_t>& sub_asset_creation_fee )const;
   };
 
   struct asset_global_settle_operation : public base_operation
   {
      struct fee_params_t { uint64_t fee = 500 * GRAPHENE_BLOCKCHAIN_PRECISION; };
 
      asset           fee;
      account_id_type issuer; 
      asset_id_type   asset_to_settle;
      price           settle_price;
      extensions_type extensions;
 
      account_id_type fee_payer()const { return issuer; }
      void            validate()const;
   };
 
   struct asset_settle_operation : public base_operation
   {
      struct fee_params_t {
         uint64_t fee      = 100 * GRAPHENE_BLOCKCHAIN_PRECISION;
      };
 
      asset           fee;
      account_id_type account;
      asset           amount;
      extensions_type extensions;
 
      account_id_type fee_payer()const { return account; }
      void            validate()const;
   };
 
   struct asset_settle_cancel_operation : public base_operation
   {
      struct fee_params_t { };
 
      asset_settle_cancel_operation() = default;
      asset_settle_cancel_operation( const force_settlement_id_type& fsid, const account_id_type& aid,
            const asset& a ) : settlement(fsid), account(aid), amount(a) {}
 
      asset           fee;
      force_settlement_id_type settlement;
      account_id_type account;
      asset           amount;
 
      account_id_type fee_payer()const { return account; }
      /***
       * This is a virtual operation and should never be placed in a block
       * (i.e. in a proposal)
       */
      void validate() const { FC_ASSERT( !"Virtual operation"); }
 
      share_type calculate_fee(const fee_params_t& params)const
      { return 0; }
   };
 
   struct asset_fund_fee_pool_operation : public base_operation
   {
      struct fee_params_t { uint64_t fee =  GRAPHENE_BLOCKCHAIN_PRECISION; };
 
      asset           fee; 
      account_id_type from_account;
      asset_id_type   asset_id;
      share_type      amount; 
      extensions_type extensions;
 
      account_id_type fee_payer()const { return from_account; }
      void       validate()const;
   };
 
   struct asset_update_operation : public base_operation
   {
      struct ext
      {
         fc::optional<uint8_t> new_precision;
         fc::optional<bool> skip_core_exchange_rate;
      };
 
      struct fee_params_t {
         uint64_t fee            = 500 * GRAPHENE_BLOCKCHAIN_PRECISION;
         uint32_t price_per_kbyte = 10;
      };
 
      asset_update_operation(){}
 
      asset           fee;
      account_id_type issuer;
      asset_id_type   asset_to_update;
 
      optional<account_id_type>   new_issuer;
      asset_options               new_options;
      extension<ext>              extensions;
 
      account_id_type fee_payer()const { return issuer; }
      void            validate()const;
      share_type      calculate_fee(const fee_params_t& k)const;
   };
 
   struct asset_update_bitasset_operation : public base_operation
   {
      struct fee_params_t { uint64_t fee = 500 * GRAPHENE_BLOCKCHAIN_PRECISION; };
 
      asset           fee;
      account_id_type issuer;
      asset_id_type   asset_to_update;
 
      bitasset_options new_options;
      extensions_type  extensions;
 
      account_id_type fee_payer()const { return issuer; }
      void            validate()const;
   };
 
   struct asset_update_feed_producers_operation : public base_operation
   {
      struct fee_params_t { uint64_t fee = 500 * GRAPHENE_BLOCKCHAIN_PRECISION; };
 
      asset           fee;
      account_id_type issuer;
      asset_id_type   asset_to_update;
 
      flat_set<account_id_type> new_feed_producers;
      extensions_type           extensions;
 
      account_id_type fee_payer()const { return issuer; }
      void            validate()const;
   };
 
   struct asset_publish_feed_operation : public base_operation
   {
      struct ext
      {
         fc::optional<uint16_t> initial_collateral_ratio;  // BSIP-77
      };
 
      struct fee_params_t { uint64_t fee = GRAPHENE_BLOCKCHAIN_PRECISION; };
 
      asset                  fee; 
      account_id_type        publisher;
      asset_id_type          asset_id; 
      price_feed             feed;
      extension<ext>         extensions;
 
      account_id_type fee_payer()const { return publisher; }
      void            validate()const;
   };
 
   struct asset_issue_operation : public base_operation
   {
      struct fee_params_t {
         uint64_t fee = 20 * GRAPHENE_BLOCKCHAIN_PRECISION;
         uint32_t price_per_kbyte = GRAPHENE_BLOCKCHAIN_PRECISION;
      };
 
      asset            fee;
      account_id_type  issuer; 
      asset            asset_to_issue;
      account_id_type  issue_to_account;
 
 
      optional<memo_data>  memo;
      extensions_type      extensions;
 
      account_id_type fee_payer()const { return issuer; }
      void            validate()const;
      share_type      calculate_fee(const fee_params_t& k)const;
   };
 
   struct asset_reserve_operation : public base_operation
   {
      struct fee_params_t { uint64_t fee = 20 * GRAPHENE_BLOCKCHAIN_PRECISION; };
 
      asset             fee;
      account_id_type   payer;
      asset             amount_to_reserve;
      extensions_type   extensions;
 
      account_id_type fee_payer()const { return payer; }
      void            validate()const;
   };
 
   struct asset_claim_fees_operation : public base_operation
   {
      struct fee_params_t {
         uint64_t fee = 20 * GRAPHENE_BLOCKCHAIN_PRECISION;
      };
 
      struct additional_options_type
      {
         fc::optional<asset_id_type> claim_from_asset_id;
      };
 
      asset           fee;
      account_id_type issuer; 
      asset           amount_to_claim;
 
      extension<additional_options_type> extensions;
 
      account_id_type fee_payer()const { return issuer; }
      void            validate()const;
   };
 
   struct asset_update_issuer_operation : public base_operation
   {
      struct fee_params_t {
         uint64_t fee            = 20 * GRAPHENE_BLOCKCHAIN_PRECISION;
      };
 
      asset           fee;
      account_id_type issuer;
      asset_id_type   asset_to_update;
      account_id_type new_issuer;
      extensions_type extensions;
 
      account_id_type fee_payer()const { return issuer; }
      void            validate()const;
 
      void get_required_owner_authorities( flat_set<account_id_type>& a )const
      { a.insert( issuer ); }
 
      void get_required_active_authorities( flat_set<account_id_type>& a )const
      {  }
 
   };
 
   struct asset_claim_pool_operation : public base_operation
   {
      struct fee_params_t {
         uint64_t fee = 20 * GRAPHENE_BLOCKCHAIN_PRECISION;
      };
 
      asset           fee;
      account_id_type issuer;
      asset_id_type   asset_id;        
      asset           amount_to_claim; 
      extensions_type extensions;
 
      account_id_type fee_payer()const { return issuer; }
      void            validate()const;
   };
 
} } // graphene::protocol
 
FC_REFLECT( graphene::protocol::asset_claim_fees_operation, (fee)(issuer)(amount_to_claim)(extensions) )
FC_REFLECT( graphene::protocol::asset_claim_fees_operation::fee_params_t, (fee) )
FC_REFLECT( graphene::protocol::asset_claim_fees_operation::additional_options_type, (claim_from_asset_id) )
 
FC_REFLECT( graphene::protocol::asset_claim_pool_operation, (fee)(issuer)(asset_id)(amount_to_claim)(extensions) )
FC_REFLECT( graphene::protocol::asset_claim_pool_operation::fee_params_t, (fee) )
 
FC_REFLECT( graphene::protocol::asset_options,
            (max_supply)
            (market_fee_percent)
            (max_market_fee)
            (issuer_permissions)
            (flags)
            (core_exchange_rate)
            (whitelist_authorities)
            (blacklist_authorities)
            (whitelist_markets)
            (blacklist_markets)
            (description)
            (extensions)
          )
 
FC_REFLECT( graphene::protocol::bitasset_options::ext,
            (initial_collateral_ratio)
            (maintenance_collateral_ratio)
            (maximum_short_squeeze_ratio)
            (margin_call_fee_ratio)
            (force_settle_fee_percent)
            (black_swan_response_method)
          )
 
FC_REFLECT( graphene::protocol::bitasset_options,
            (feed_lifetime_sec)
            (minimum_feeds)
            (force_settlement_delay_sec)
            (force_settlement_offset_percent)
            (maximum_force_settlement_volume)
            (short_backing_asset)
            (extensions)
          )
 
FC_REFLECT( graphene::protocol::additional_asset_options,
            (reward_percent)(whitelist_market_fee_sharing)(taker_fee_percent) )
 
FC_REFLECT( graphene::protocol::asset_update_operation::ext, (new_precision)(skip_core_exchange_rate) )
FC_REFLECT( graphene::protocol::asset_publish_feed_operation::ext, (initial_collateral_ratio) )
 
FC_REFLECT( graphene::protocol::asset_create_operation::fee_params_t,
            (symbol3)(symbol4)(long_symbol)(price_per_kbyte) )
 
FC_REFLECT( graphene::protocol::asset_global_settle_operation::fee_params_t, (fee) )
FC_REFLECT( graphene::protocol::asset_settle_operation::fee_params_t, (fee) )
FC_REFLECT( graphene::protocol::asset_settle_cancel_operation::fee_params_t, )
FC_REFLECT( graphene::protocol::asset_fund_fee_pool_operation::fee_params_t, (fee) )
FC_REFLECT( graphene::protocol::asset_update_operation::fee_params_t, (fee)(price_per_kbyte) )
FC_REFLECT( graphene::protocol::asset_update_issuer_operation::fee_params_t, (fee) )
FC_REFLECT( graphene::protocol::asset_update_bitasset_operation::fee_params_t, (fee) )
FC_REFLECT( graphene::protocol::asset_update_feed_producers_operation::fee_params_t, (fee) )
FC_REFLECT( graphene::protocol::asset_publish_feed_operation::fee_params_t, (fee) )
FC_REFLECT( graphene::protocol::asset_issue_operation::fee_params_t, (fee)(price_per_kbyte) )
FC_REFLECT( graphene::protocol::asset_reserve_operation::fee_params_t, (fee) )
 
 
FC_REFLECT( graphene::protocol::asset_create_operation,
            (fee)
            (issuer)
            (symbol)
            (precision)
            (common_options)
            (bitasset_opts)
            (is_prediction_market)
            (extensions)
          )
FC_REFLECT( graphene::protocol::asset_update_operation,
            (fee)
            (issuer)
            (asset_to_update)
            (new_issuer)
            (new_options)
            (extensions)
          )
FC_REFLECT( graphene::protocol::asset_update_issuer_operation,
            (fee)
            (issuer)
            (asset_to_update)
            (new_issuer)
            (extensions)
          )
FC_REFLECT( graphene::protocol::asset_update_bitasset_operation,
            (fee)
            (issuer)
            (asset_to_update)
            (new_options)
            (extensions)
          )
FC_REFLECT( graphene::protocol::asset_update_feed_producers_operation,
            (fee)(issuer)(asset_to_update)(new_feed_producers)(extensions)
          )
FC_REFLECT( graphene::protocol::asset_publish_feed_operation,
            (fee)(publisher)(asset_id)(feed)(extensions) )
FC_REFLECT( graphene::protocol::asset_settle_operation, (fee)(account)(amount)(extensions) )
FC_REFLECT( graphene::protocol::asset_settle_cancel_operation, (fee)(settlement)(account)(amount) )
FC_REFLECT( graphene::protocol::asset_global_settle_operation,
            (fee)(issuer)(asset_to_settle)(settle_price)(extensions) )
FC_REFLECT( graphene::protocol::asset_issue_operation,
            (fee)(issuer)(asset_to_issue)(issue_to_account)(memo)(extensions) )
FC_REFLECT( graphene::protocol::asset_reserve_operation,
            (fee)(payer)(amount_to_reserve)(extensions) )
 
FC_REFLECT( graphene::protocol::asset_fund_fee_pool_operation, (fee)(from_account)(asset_id)(amount)(extensions) )
 
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_options )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::bitasset_options::ext )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::bitasset_options )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::additional_asset_options )
 
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_update_operation::ext )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_publish_feed_operation::ext )
 
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_create_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_global_settle_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_settle_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_fund_fee_pool_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_claim_pool_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_claim_fees_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_claim_fees_operation::additional_options_type )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_update_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_update_issuer_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_update_bitasset_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION(
   graphene::protocol::asset_update_feed_producers_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_publish_feed_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_issue_operation::fee_params_t )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_reserve_operation::fee_params_t )
 
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_create_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_global_settle_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_settle_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_settle_cancel_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_fund_fee_pool_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_claim_pool_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_claim_fees_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_update_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_update_issuer_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_update_bitasset_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_update_feed_producers_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_publish_feed_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_issue_operation )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset_reserve_operation )