fee_schedule.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/operations.hpp>

namespace graphene { namespace protocol {

   template<typename T> struct transform_to_fee_parameters;
   template<typename ...T>
   struct transform_to_fee_parameters<fc::static_variant<T...>>
   {
      using type = fc::static_variant< typename T::fee_parameters_type... >;
   };
   using fee_parameters = transform_to_fee_parameters<operation>::type;

   template<typename Operation>
   class fee_helper {
     public:
      const typename Operation::fee_parameters_type& cget(const fee_parameters::flat_set_type& parameters)const
      {
         auto itr = parameters.find( typename Operation::fee_parameters_type() );
         FC_ASSERT( itr != parameters.end() );
         return itr->template get<typename Operation::fee_parameters_type>();
      }
   };

   template<>
   class fee_helper<account_create_operation> {
     public:
      const account_create_operation::fee_parameters_type& cget(const fee_parameters::flat_set_type& parameters)const
      {
         auto itr = parameters.find( account_create_operation::fee_parameters_type() );
         FC_ASSERT( itr != parameters.end() );
         return itr->get<account_create_operation::fee_parameters_type>();
      }
      typename account_create_operation::fee_parameters_type& get(fee_parameters::flat_set_type& parameters)const
      {
         auto itr = parameters.find( account_create_operation::fee_parameters_type() );
         FC_ASSERT( itr != parameters.end() );
         return itr->get<account_create_operation::fee_parameters_type>();
      }
   };

   template<>
   class fee_helper<bid_collateral_operation> {
     public:
      const bid_collateral_operation::fee_parameters_type& cget(const fee_parameters::flat_set_type& parameters)const
      {
         auto itr = parameters.find( bid_collateral_operation::fee_parameters_type() );
         if ( itr != parameters.end() )
            return itr->get<bid_collateral_operation::fee_parameters_type>();

         static bid_collateral_operation::fee_parameters_type bid_collateral_dummy;
         bid_collateral_dummy.fee = fee_helper<call_order_update_operation>().cget(parameters).fee;
         return bid_collateral_dummy;
      }
   };

   template<>
   class fee_helper<asset_update_issuer_operation> {
     public:
      const asset_update_issuer_operation::fee_parameters_type& cget(const fee_parameters::flat_set_type& parameters)const
      {
         auto itr = parameters.find( asset_update_issuer_operation::fee_parameters_type() );
         if ( itr != parameters.end() )
            return itr->get<asset_update_issuer_operation::fee_parameters_type>();

         static asset_update_issuer_operation::fee_parameters_type dummy;
         dummy.fee = fee_helper<asset_update_operation>().cget(parameters).fee;
         return dummy;
      }
   };

   template<>
   class fee_helper<asset_claim_pool_operation> {
     public:
      const asset_claim_pool_operation::fee_parameters_type& cget(const fee_parameters::flat_set_type& parameters)const
      {
         auto itr = parameters.find( asset_claim_pool_operation::fee_parameters_type() );
         if ( itr != parameters.end() )
            return itr->get<asset_claim_pool_operation::fee_parameters_type>();

         static asset_claim_pool_operation::fee_parameters_type asset_claim_pool_dummy;
         asset_claim_pool_dummy.fee = fee_helper<asset_fund_fee_pool_operation>().cget(parameters).fee;
         return asset_claim_pool_dummy;
      }
   };

   template<>
   class fee_helper<ticket_create_operation> {
     public:
      const ticket_create_operation::fee_parameters_type& cget(const fee_parameters::flat_set_type& parameters)const
      {
         static ticket_create_operation::fee_parameters_type param;
         return param;
      }
   };

   template<>
   class fee_helper<ticket_update_operation> {
     public:
      const ticket_update_operation::fee_parameters_type& cget(const fee_parameters::flat_set_type& parameters)const
      {
         static ticket_update_operation::fee_parameters_type param;
         return param;
      }
   };

   template<>
   class fee_helper<htlc_create_operation> {
     public:
      const htlc_create_operation::fee_parameters_type& cget(const fee_parameters::flat_set_type& parameters)const
      {
         auto itr = parameters.find( htlc_create_operation::fee_parameters_type() );
         if ( itr != parameters.end() )
            return itr->get<htlc_create_operation::fee_parameters_type>();

         static htlc_create_operation::fee_parameters_type htlc_create_operation_fee_dummy;
         return htlc_create_operation_fee_dummy;
      }
   };

   template<>
   class fee_helper<htlc_redeem_operation> {
     public:
      const htlc_redeem_operation::fee_parameters_type& cget(const fee_parameters::flat_set_type& parameters)const
      {
         auto itr = parameters.find( htlc_redeem_operation::fee_parameters_type() );
         if ( itr != parameters.end() )
            return itr->get<htlc_redeem_operation::fee_parameters_type>();

         static htlc_redeem_operation::fee_parameters_type htlc_redeem_operation_fee_dummy;
         return htlc_redeem_operation_fee_dummy;
      }
   };
   template<>
   class fee_helper<htlc_extend_operation> {
     public:
      const htlc_extend_operation::fee_parameters_type& cget(const fee_parameters::flat_set_type& parameters)const
      {
         auto itr = parameters.find( htlc_extend_operation::fee_parameters_type() );
         if ( itr != parameters.end() )
            return itr->get<htlc_extend_operation::fee_parameters_type>();

         static htlc_extend_operation::fee_parameters_type htlc_extend_operation_fee_dummy;
         return htlc_extend_operation_fee_dummy;
      }
   };
   struct fee_schedule
   {
      static const fee_schedule& get_default();

      asset calculate_fee( const operation& op )const;
      asset calculate_fee( const operation& op, const price& core_exchange_rate )const;
      asset set_fee( operation& op, const price& core_exchange_rate = price::unit_price() )const;

      void zero_all_fees();

      void validate()const {}

      template<typename Operation>
      const typename Operation::fee_parameters_type& get()const
      {
         return fee_helper<Operation>().cget(parameters);
      }
      template<typename Operation>
      typename Operation::fee_parameters_type& get()
      {
         return fee_helper<Operation>().get(parameters);
      }
      template<typename Operation>
      bool exists()const
      {
         auto itr = parameters.find(typename Operation::fee_parameters_type());
         return itr != parameters.end();
      }

      fee_parameters::flat_set_type parameters;
      uint32_t                      scale = GRAPHENE_100_PERCENT; 
   private:
      static fee_schedule get_default_impl();
   };

   using fee_schedule_type = fee_schedule;

} } // graphene::protocol

FC_REFLECT_TYPENAME( graphene::protocol::fee_parameters )
FC_REFLECT( graphene::protocol::fee_schedule, (parameters)(scale) )

GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::fee_schedule )