account_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/chain/types.hpp>
#include <graphene/db/generic_index.hpp>
#include <graphene/protocol/account.hpp>
 
#include <boost/multi_index/composite_key.hpp>
 
namespace graphene { namespace chain {
   class database;
   class account_object;
   class vesting_balance_object;
 
   class account_statistics_object : public graphene::db::abstract_object<account_statistics_object,
                                               implementation_ids, impl_account_statistics_object_type>
   {
      public:
         account_id_type  owner;
 
         string           name; 
 
         account_history_id_type most_recent_op;
         uint64_t                            total_ops = 0;
         uint64_t                            removed_ops = 0;
 
         share_type total_core_in_orders;
 
         share_type total_core_inactive;
 
         share_type total_core_pob;
 
         share_type total_core_pol;
 
         share_type total_pob_value;
 
         share_type total_pol_value;
 
         share_type core_in_balance;
 
         bool has_cashback_vb = false; 
 
         bool is_voting = false; 
 
         time_point_sec last_vote_time; 
 
         uint64_t vp_all = 0;           
         uint64_t vp_active = 0;        
         uint64_t vp_committee = 0;     
         uint64_t vp_witness = 0;       
         uint64_t vp_worker = 0;        
         time_point_sec vote_tally_time;
 
         inline bool has_some_core_voting() const
         {
            return is_voting && ( total_core_in_orders > 0 || core_in_balance > 0 || has_cashback_vb
                                  || total_core_pol > 0 );
         }
 
         share_type lifetime_fees_paid;
 
         share_type pending_fees;
         share_type pending_vested_fees;
 
         inline bool has_pending_fees() const { return pending_fees > 0 || pending_vested_fees > 0; }
 
         inline bool need_maintenance() const { return has_some_core_voting() || has_pending_fees(); }
 
         void process_fees(const account_object& a, database& d) const;
 
         void pay_fee( share_type core_fee, share_type cashback_vesting_threshold );
   };
 
   class account_balance_object : public abstract_object<account_balance_object,
                                            implementation_ids, impl_account_balance_object_type>
   {
      public:
         account_id_type   owner;
         asset_id_type     asset_type;
         share_type        balance;
         bool              maintenance_flag = false;
 
         asset get_balance()const { return asset(balance, asset_type); }
         void  adjust_balance(const asset& delta);
   };
 
 
   class account_object : public graphene::db::abstract_object<account_object, protocol_ids, account_object_type>
   {
      public:
         time_point_sec membership_expiration_date;
 
         account_id_type registrar;
         account_id_type referrer;
         account_id_type lifetime_referrer;
 
         uint16_t network_fee_percentage = GRAPHENE_DEFAULT_NETWORK_PERCENT_OF_FEE;
         uint16_t lifetime_referrer_fee_percentage = 0;
         uint16_t referrer_rewards_percentage = 0;
 
         string name;
 
         authority owner;
         authority active;
 
         account_options options;
 
         uint16_t num_committee_voted;
 
         account_statistics_id_type statistics;
 
         flat_set<account_id_type> whitelisting_accounts;
 
         set<account_id_type> whitelisted_accounts;
         set<account_id_type> blacklisted_accounts;
 
 
         flat_set<account_id_type> blacklisting_accounts;
 
         optional<vesting_balance_id_type> cashback_vb;
 
         special_authority owner_special_authority = no_special_authority();
         special_authority active_special_authority = no_special_authority();
 
         uint8_t top_n_control_flags = 0;
         static const uint8_t top_n_control_owner  = 1;
         static const uint8_t top_n_control_active = 2;
 
         optional< flat_set<asset_id_type> > allowed_assets;
 
         uint32_t       creation_block_num = 0;
         time_point_sec creation_time;
 
         bool has_special_authority()const
         {
            return (!owner_special_authority.is_type< no_special_authority >())
                || (!active_special_authority.is_type< no_special_authority >());
         }
 
         template<typename DB>
         const vesting_balance_object& cashback_balance(const DB& db)const
         {
            FC_ASSERT(cashback_vb);
            return db.get(*cashback_vb);
         }
 
         bool is_lifetime_member()const
         {
            return membership_expiration_date == time_point_sec::maximum();
         }
         bool is_basic_account(time_point_sec now)const
         {
            return now > membership_expiration_date;
         }
         bool is_annual_member(time_point_sec now)const
         {
            return !is_lifetime_member() && !is_basic_account(now);
         }
         bool is_member(time_point_sec now)const
         {
            return !is_basic_account(now);
         }
   };
 
   class account_member_index : public secondary_index
   {
      public:
         virtual void object_inserted( const object& obj ) override;
         virtual void object_removed( const object& obj ) override;
         virtual void about_to_modify( const object& before ) override;
         virtual void object_modified( const object& after  ) override;
 
 
         map< account_id_type, set<account_id_type> >                    account_to_account_memberships;
         map< public_key_type, set<account_id_type>, pubkey_comparator > account_to_key_memberships;
         map< address, set<account_id_type> >                            account_to_address_memberships;
 
 
      protected:
         set<account_id_type>                    get_account_members( const account_object& a )const;
         set<public_key_type, pubkey_comparator> get_key_members( const account_object& a )const;
         set<address>                            get_address_members( const account_object& a )const;
 
         set<account_id_type>                    before_account_members;
         set<public_key_type, pubkey_comparator> before_key_members;
         set<address>                            before_address_members;
   };
 
 
   class balances_by_account_index : public secondary_index
   {
      public:
         virtual void object_inserted( const object& obj ) override;
         virtual void object_removed( const object& obj ) override;
         virtual void about_to_modify( const object& before ) override;
         virtual void object_modified( const object& after  ) override;
 
         const map< asset_id_type, const account_balance_object* >& get_account_balances(
                  const account_id_type& acct )const;
         const account_balance_object* get_account_balance( const account_id_type& acct,
                                                            const asset_id_type& asset )const;
 
      private:
         static const uint8_t  bits;
         static const uint64_t mask;
 
         vector< vector< map< asset_id_type, const account_balance_object* > > > balances;
         std::stack< object_id_type > ids_being_modified;
   };
 
   struct by_asset_balance;
   struct by_maintenance_flag;
   typedef multi_index_container<
      account_balance_object,
      indexed_by<
         ordered_unique< tag<by_id>, member< object, object_id_type, &object::id > >,
         ordered_non_unique< tag<by_maintenance_flag>,
                             member< account_balance_object, bool, &account_balance_object::maintenance_flag > >,
         ordered_unique< tag<by_asset_balance>,
            composite_key<
               account_balance_object,
               member<account_balance_object, asset_id_type, &account_balance_object::asset_type>,
               member<account_balance_object, share_type, &account_balance_object::balance>,
               member<account_balance_object, account_id_type, &account_balance_object::owner>
            >,
            composite_key_compare<
               std::less< asset_id_type >,
               std::greater< share_type >,
               std::less< account_id_type >
            >
         >
      >
   > account_balance_object_multi_index_type;
 
   typedef generic_index<account_balance_object, account_balance_object_multi_index_type> account_balance_index;
 
   struct by_name;
 
   typedef multi_index_container<
      account_object,
      indexed_by<
         ordered_unique< tag<by_id>, member< object, object_id_type, &object::id > >,
         ordered_unique< tag<by_name>, member<account_object, string, &account_object::name> >
      >
   > account_multi_index_type;
 
   typedef generic_index<account_object, account_multi_index_type> account_index;
 
   struct by_maintenance_seq;
   struct by_voting_power_active;
 
   typedef multi_index_container<
      account_statistics_object,
      indexed_by<
         ordered_unique< tag<by_id>, member< object, object_id_type, &object::id > >,
         ordered_unique< tag<by_maintenance_seq>,
            composite_key<
               account_statistics_object,
               const_mem_fun<account_statistics_object, bool, &account_statistics_object::need_maintenance>,
               member<account_statistics_object, string, &account_statistics_object::name>
            >
         >,
         ordered_non_unique< tag<by_voting_power_active>,
            composite_key<
               account_statistics_object,
               member<account_statistics_object, time_point_sec, &account_statistics_object::vote_tally_time>,
               member<account_statistics_object, uint64_t, &account_statistics_object::vp_active>
            >,
            composite_key_compare<
               std::greater< time_point_sec >,
               std::greater< uint64_t >
            >
         >
      >
   > account_stats_multi_index_type;
 
   typedef generic_index<account_statistics_object, account_stats_multi_index_type> account_stats_index;
 
}}
 
MAP_OBJECT_ID_TO_TYPE(graphene::chain::account_object)
MAP_OBJECT_ID_TO_TYPE(graphene::chain::account_balance_object)
MAP_OBJECT_ID_TO_TYPE(graphene::chain::account_statistics_object)
 
FC_REFLECT_TYPENAME( graphene::chain::account_object )
FC_REFLECT_TYPENAME( graphene::chain::account_balance_object )
FC_REFLECT_TYPENAME( graphene::chain::account_statistics_object )
 
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::chain::account_object )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::chain::account_balance_object )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::chain::account_statistics_object )