vesting_balance_object.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/db/generic_index.hpp>
#include <graphene/protocol/asset.hpp>
 
#include <boost/multi_index/composite_key.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/identity.hpp>
 
#include <fc/static_variant.hpp>
#include <fc/uint128.hpp>
 
namespace graphene { namespace chain {
   using namespace graphene::db;
   using namespace graphene::protocol;
 
   struct vesting_policy_context
   {
      vesting_policy_context(
         asset _balance,
         fc::time_point_sec _now,
         asset _amount)
         : balance(_balance), now(_now), amount(_amount) {}
 
      asset              balance;
      fc::time_point_sec now;
      asset              amount;
   };
 
   struct linear_vesting_policy
   {
      fc::time_point_sec begin_timestamp;
      uint32_t vesting_cliff_seconds = 0;
      uint32_t vesting_duration_seconds = 0;
      share_type begin_balance;
 
      asset get_allowed_withdraw(const vesting_policy_context& ctx)const;
      bool is_deposit_allowed(const vesting_policy_context& ctx)const;
      bool is_deposit_vested_allowed(const vesting_policy_context&)const { return false; }
      bool is_withdraw_allowed(const vesting_policy_context& ctx)const;
      void on_deposit(const vesting_policy_context& ctx);
      void on_deposit_vested(const vesting_policy_context&)
      { FC_THROW( "May not deposit vested into a linear vesting balance." ); }
      void on_withdraw(const vesting_policy_context& ctx);
   };
 
   struct cdd_vesting_policy
   {
      uint32_t                         vesting_seconds = 0;
      fc::uint128_t                    coin_seconds_earned;
      fc::time_point_sec               start_claim;
      fc::time_point_sec               coin_seconds_earned_last_update;
 
      fc::uint128_t compute_coin_seconds_earned(const vesting_policy_context& ctx)const;
 
      void update_coin_seconds_earned(const vesting_policy_context& ctx);
 
      asset get_allowed_withdraw(const vesting_policy_context& ctx)const;
      bool is_deposit_allowed(const vesting_policy_context& ctx)const;
      bool is_deposit_vested_allowed(const vesting_policy_context& ctx)const;
      bool is_withdraw_allowed(const vesting_policy_context& ctx)const;
      void on_deposit(const vesting_policy_context& ctx);
      void on_deposit_vested(const vesting_policy_context& ctx);
      void on_withdraw(const vesting_policy_context& ctx);
   };
 
   struct instant_vesting_policy
   {
      asset get_allowed_withdraw(const vesting_policy_context& ctx)const;
      bool is_deposit_allowed(const vesting_policy_context& ctx)const;
      bool is_deposit_vested_allowed(const vesting_policy_context&)const { return false; }
      bool is_withdraw_allowed(const vesting_policy_context& ctx)const;
      void on_deposit(const vesting_policy_context& ctx);
      void on_deposit_vested(const vesting_policy_context&);
      void on_withdraw(const vesting_policy_context& ctx);
   };
 
   typedef fc::static_variant<
      linear_vesting_policy,
      cdd_vesting_policy,
      instant_vesting_policy
      > vesting_policy;
 
   enum class vesting_balance_type {   unspecified,
                                       cashback,
                                       worker,
                                       witness,
                                       market_fee_sharing };
   class vesting_balance_object : public abstract_object<vesting_balance_object,
                                            protocol_ids, vesting_balance_object_type>
   {
      public:
         account_id_type owner;
         asset balance;
         vesting_policy policy;
         vesting_balance_type balance_type = vesting_balance_type::unspecified;
 
         vesting_balance_object() {}
 
         void deposit(const fc::time_point_sec& now, const asset& amount);
         bool is_deposit_allowed(const fc::time_point_sec& now, const asset& amount)const;
 
         void deposit_vested(const fc::time_point_sec& now, const asset& amount);
         bool is_deposit_vested_allowed(const fc::time_point_sec& now, const asset& amount)const;
 
         void withdraw(const fc::time_point_sec& now, const asset& amount);
         bool is_withdraw_allowed(const fc::time_point_sec& now, const asset& amount)const;
 
         asset get_allowed_withdraw(const time_point_sec& now)const;
   };
   struct by_account;
   // by_vesting_type index MUST NOT be used for iterating because order is not well-defined.
   struct by_vesting_type;
 
namespace detail {
 
   inline uint64_t vbo_mfs_hash(const account_id_type& account_id, const asset_id_type& asset_id)
   {
      return (asset_id.instance.value << 40) ^ account_id.instance.value;
   }
 
   struct vesting_balance_object_hash
   {
      uint64_t operator()(const vesting_balance_object& vbo) const
      {
         if ( vbo.balance_type == vesting_balance_type::market_fee_sharing )
         {
            return vbo_mfs_hash(vbo.owner, vbo.balance.asset_id);
         }
         return hash_value(vbo.id);
      }
   };
 
   struct vesting_balance_object_equal
   {
      bool operator() (const vesting_balance_object& lhs, const vesting_balance_object& rhs) const
      {
         if ( ( lhs.balance_type == vesting_balance_type::market_fee_sharing ) &&
              ( lhs.balance_type == rhs.balance_type ) &&
              ( lhs.owner == rhs.owner ) &&
              ( lhs.balance.asset_id == rhs.balance.asset_id)
            )
         {
               return true;
         }
         return ( lhs.id == rhs.id );
      }
   };
} // detail
 
   typedef multi_index_container<
      vesting_balance_object,
      indexed_by<
         ordered_unique< tag<by_id>, member< object, object_id_type, &object::id >
         >,
         ordered_non_unique< tag<by_account>,
            member<vesting_balance_object, account_id_type, &vesting_balance_object::owner>
         >,
         hashed_unique< tag<by_vesting_type>,
            identity<vesting_balance_object>,
            detail::vesting_balance_object_hash,
            detail::vesting_balance_object_equal
         >
      >
   > vesting_balance_multi_index_type;
   typedef generic_index<vesting_balance_object, vesting_balance_multi_index_type> vesting_balance_index;
 
} } // graphene::chain
 
MAP_OBJECT_ID_TO_TYPE(graphene::chain::vesting_balance_object)
 
FC_REFLECT(graphene::chain::linear_vesting_policy,
           (begin_timestamp)
           (vesting_cliff_seconds)
           (vesting_duration_seconds)
           (begin_balance)
          )
 
FC_REFLECT(graphene::chain::cdd_vesting_policy,
           (vesting_seconds)
           (start_claim)
           (coin_seconds_earned)
           (coin_seconds_earned_last_update)
          )
 
FC_REFLECT_EMPTY( graphene::chain::instant_vesting_policy )
 
FC_REFLECT_TYPENAME( graphene::chain::vesting_policy )
 
FC_REFLECT_DERIVED(graphene::chain::vesting_balance_object, (graphene::db::object),
                   (owner)
                   (balance)
                   (policy)
                   (balance_type)
                  )
 
FC_REFLECT_ENUM( graphene::chain::vesting_balance_type, (unspecified)(cashback)(worker)(witness)(market_fee_sharing) )
 
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::chain::linear_vesting_policy )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::chain::cdd_vesting_policy )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::chain::vesting_balance_object )