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 )