asset.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/types.hpp>
 
namespace graphene { namespace protocol {
 
   struct price;
 
   struct asset
   {
      asset( share_type a = 0, asset_id_type id = asset_id_type() )
      :amount(a),asset_id(id){}
 
      share_type    amount;
      asset_id_type asset_id;
 
      asset& operator += ( const asset& o )
      {
         FC_ASSERT( asset_id == o.asset_id );
         amount += o.amount;
         return *this;
      }
      asset& operator -= ( const asset& o )
      {
         FC_ASSERT( asset_id == o.asset_id );
         amount -= o.amount;
         return *this;
      }
      asset operator -()const { return asset( -amount, asset_id ); }
 
      friend bool operator == ( const asset& a, const asset& b )
      {
         return std::tie( a.asset_id, a.amount ) == std::tie( b.asset_id, b.amount );
      }
      friend bool operator < ( const asset& a, const asset& b )
      {
         FC_ASSERT( a.asset_id == b.asset_id );
         return a.amount < b.amount;
      }
      friend inline bool operator <= ( const asset& a, const asset& b )
      {
         return !(b < a);
      }
 
      friend inline bool operator != ( const asset& a, const asset& b )
      {
         return !(a == b);
      }
      friend inline bool operator > ( const asset& a, const asset& b )
      {
         return (b < a);
      }
      friend inline bool operator >= ( const asset& a, const asset& b )
      {
         return !(a < b);
      }
 
      friend asset operator - ( const asset& a, const asset& b )
      {
         FC_ASSERT( a.asset_id == b.asset_id );
         return asset( a.amount - b.amount, a.asset_id );
      }
      friend asset operator + ( const asset& a, const asset& b )
      {
         FC_ASSERT( a.asset_id == b.asset_id );
         return asset( a.amount + b.amount, a.asset_id );
      }
 
      static share_type scaled_precision( uint8_t precision );
 
      asset multiply_and_round_up( const price& p )const; 
   };
 
   struct price
   {
      explicit price(const asset& _base = asset(), const asset& _quote = asset())
         : base(_base),quote(_quote){}
 
      asset base;
      asset quote;
 
      static price max(asset_id_type base, asset_id_type quote );
      static price min(asset_id_type base, asset_id_type quote );
 
      static price call_price(const asset& debt, const asset& collateral, uint16_t collateral_ratio);
 
      static price unit_price(asset_id_type a = asset_id_type()) { return price(asset(1, a), asset(1, a)); }
 
      price max()const { return price::max( base.asset_id, quote.asset_id ); }
      price min()const { return price::min( base.asset_id, quote.asset_id ); }
 
      double to_real()const { return double(base.amount.value)/double(quote.amount.value); }
 
      bool is_null()const;
      void validate( bool check_upper_bound = false )const;
   };
 
   price operator / ( const asset& base, const asset& quote );
   inline price operator~( const price& p ) { return price{p.quote,p.base}; }
 
   bool  operator <  ( const price& a, const price& b );
   bool  operator == ( const price& a, const price& b );
 
   inline bool  operator >  ( const price& a, const price& b ) { return (b < a); }
   inline bool  operator <= ( const price& a, const price& b ) { return !(b < a); }
   inline bool  operator >= ( const price& a, const price& b ) { return !(a < b); }
   inline bool  operator != ( const price& a, const price& b ) { return !(a == b); }
 
   asset operator *  ( const asset& a, const price& b ); 
 
   price operator *  ( const price& p, const ratio_type& r );
   price operator /  ( const price& p, const ratio_type& r );
 
   inline price& operator *=  ( price& p, const ratio_type& r )
   { p = p * r; return p; }
   inline price& operator /=  ( price& p, const ratio_type& r )
   { p = p / r; return p; }
 
   struct price_feed
   {
 
      price settlement_price;
 
      price core_exchange_rate;
 
      uint16_t maintenance_collateral_ratio = GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO;
 
      uint16_t maximum_short_squeeze_ratio = GRAPHENE_DEFAULT_MAX_SHORT_SQUEEZE_RATIO;
 
      price max_short_squeeze_price()const;
      price max_short_squeeze_price_before_hf_1270()const;
 
      price margin_call_order_price(const fc::optional<uint16_t>& margin_call_fee_ratio)const;
 
      ratio_type margin_call_order_ratio( const fc::optional<uint16_t>& margin_call_fee_ratio )const;
 
      ratio_type margin_call_pays_ratio(const fc::optional<uint16_t>& margin_call_fee_ratio)const;
 
      price maintenance_collateralization()const;
 
      bool margin_call_params_equal( const price_feed& b ) const
      {
         if( this == &b )
            return true;
         return std::tie(   settlement_price,   maintenance_collateral_ratio,   maximum_short_squeeze_ratio ) ==
                std::tie( b.settlement_price, b.maintenance_collateral_ratio, b.maximum_short_squeeze_ratio );
      }
 
      void validate() const;
      bool is_for( asset_id_type asset_id ) const;
   private:
      uint16_t get_margin_call_price_numerator(const fc::optional<uint16_t>& margin_call_fee_ratio)const;
   };
 
} }
 
FC_REFLECT( graphene::protocol::asset, (amount)(asset_id) )
FC_REFLECT( graphene::protocol::price, (base)(quote) )
 
FC_REFLECT( graphene::protocol::price_feed,
            (settlement_price)(maintenance_collateral_ratio)(maximum_short_squeeze_ratio)(core_exchange_rate) )
 
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::asset )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::price )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::protocol::price_feed )