Table of Contents


The blockchain parameters can be modified in the libraries/chain/include/graphene/chain/config.hpp file:




#define GRAPHENE_MAX_SHARE_SUPPLY int64_t(1000000000000000ll)
 * Don't allow the committee_members to publish a limit that would
 * make the network unable to operate.
#define GRAPHENE_MIN_BLOCK_INTERVAL   1 /* seconds */
#define GRAPHENE_MAX_BLOCK_INTERVAL  30 /* seconds */

#define GRAPHENE_DEFAULT_BLOCK_INTERVAL  5 /* seconds */
#define GRAPHENE_DEFAULT_MAX_BLOCK_SIZE  (2*1000*1000) /* < 2 MiB (less than MAX_MESSAGE_SIZE in graphene/net/config.hpp) */
#define GRAPHENE_DEFAULT_MAX_TIME_UNTIL_EXPIRATION (60*60*24) // seconds,  aka: 1 day
#define GRAPHENE_DEFAULT_MAINTENANCE_INTERVAL  (60*60*24) // seconds, aka: 1 day
#define GRAPHENE_DEFAULT_MAINTENANCE_SKIP_SLOTS 3  // number of slots to skip for maintenance interval


#define GRAPHENE_BLOCKCHAIN_PRECISION                           uint64_t( 100000 )

/** percentage fields are fixed point with a denominator of 10,000 */
#define GRAPHENE_100_PERCENT                                    10000
#define GRAPHENE_1_PERCENT                                      (GRAPHENE_100_PERCENT/100)
/** NOTE: making this a power of 2 (say 2^15) would greatly accelerate fee calcs */
#define GRAPHENE_MAX_MARKET_FEE_PERCENT                         GRAPHENE_100_PERCENT
#define GRAPHENE_DEFAULT_FORCE_SETTLEMENT_DELAY                 (60*60*24) ///< 1 day
#define GRAPHENE_DEFAULT_FORCE_SETTLEMENT_OFFSET                0 ///< 1%
#define GRAPHENE_DEFAULT_PRICE_FEED_LIFETIME                    (60*60*24) ///< 1 day

 *  These ratios are fixed point numbers with a denominator of GRAPHENE_COLLATERAL_RATIO_DENOM, the
 *  minimum maitenance collateral is therefore 1.001x and the default
 *  maintenance ratio is 1.75x
#define GRAPHENE_COLLATERAL_RATIO_DENOM                 1000
#define GRAPHENE_MIN_COLLATERAL_RATIO                   1001  ///< lower than this could result in divide by 0
#define GRAPHENE_MAX_COLLATERAL_RATIO                   32000 ///< higher than this is unnecessary and may exceed int16 storage
#define GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO   1750 ///< Call when collateral only pays off 175% the debt
#define GRAPHENE_DEFAULT_MAX_SHORT_SQUEEZE_RATIO        1500 ///< Stop calling when collateral only pays off 150% of the debt
#define GRAPHENE_DEFAULT_MARGIN_PERIOD_SEC              (30*60*60*24)

#define GRAPHENE_DEFAULT_MIN_WITNESS_COUNT                    (11)
#define GRAPHENE_DEFAULT_MAX_WITNESSES                        (1001) // SHOULD BE ODD
#define GRAPHENE_DEFAULT_MAX_COMMITTEE                        (1001) // SHOULD BE ODD
#define GRAPHENE_DEFAULT_MAX_PROPOSAL_LIFETIME_SEC            (60*60*24*7*4) // Four weeks
#define GRAPHENE_DEFAULT_CASHBACK_VESTING_PERIOD_SEC          (60*60*24*365) ///< 1 year
#define GRAPHENE_DEFAULT_MAX_ASSERT_OPCODE                    1

#define GRAPHENE_MAX_WORKER_NAME_LENGTH                       63

#define GRAPHENE_MAX_URL_LENGTH                               127

 * every second, the fraction of burned core asset which cycles is
#define GRAPHENE_CORE_ASSET_CYCLE_RATE                        17
#define GRAPHENE_CORE_ASSET_CYCLE_RATE_BITS                   32


#define GRAPHENE_DEFAULT_MINIMUM_FEEDS                       7


#define GRAPHENE_CURRENT_DB_VERSION                          "BTS2.181127"


 *  Reserved Account IDs with special meaning
/// Represents the current committee members, two-week review period
#define GRAPHENE_COMMITTEE_ACCOUNT (graphene::chain::account_id_type(0))
/// Represents the current witnesses
#define GRAPHENE_WITNESS_ACCOUNT (graphene::chain::account_id_type(1))
/// Represents the current committee members
#define GRAPHENE_RELAXED_COMMITTEE_ACCOUNT (graphene::chain::account_id_type(2))
/// Represents the canonical account with NO authority (nobody can access funds in null account)
#define GRAPHENE_NULL_ACCOUNT (graphene::chain::account_id_type(3))
/// Represents the canonical account with WILDCARD authority (anybody can access funds in temp account)
#define GRAPHENE_TEMP_ACCOUNT (graphene::chain::account_id_type(4))
/// Represents the canonical account for specifying you will vote directly (as opposed to a proxy)
#define GRAPHENE_PROXY_TO_SELF_ACCOUNT (graphene::chain::account_id_type(5))
/// Sentinel value used in the scheduler.
#define GRAPHENE_NULL_WITNESS (graphene::chain::witness_id_type(0))

#define GRAPHENE_FBA_STEALTH_DESIGNATED_ASSET (asset_id_type(743))





namespace graphene { namespace chain {
   using graphene::db::abstract_object;
   using graphene::db::object;
   class op_evaluator;
   class transaction_evaluation_state;

   struct budget_record;

        *   @class database
        *   @brief tracks the blockchain state in an extensible manner
   class database : public db::object_database
                 //////////////////// db_management.cpp ////////////////////


                 enum validation_steps
                        skip_nothing                = 0,
                        skip_witness_signature      = 1 << 0,  ///< used while reindexing
                        skip_transaction_signatures = 1 << 1,  ///< used by non-witness nodes
                        skip_transaction_dupe_check = 1 << 2,  ///< used while reindexing
                        skip_fork_db                = 1 << 3,  ///< used while reindexing
                        skip_block_size_check       = 1 << 4,  ///< used when applying locally generated transactions
                        skip_tapos_check            = 1 << 5,  ///< used while reindexing -- note this skips expiration check as well
                        skip_authority_check        = 1 << 6,  ///< used while reindexing -- disables any checking of authority on transactions
                        skip_merkle_check           = 1 << 7,  ///< used while reindexing
                        skip_assert_evaluation      = 1 << 8,  ///< used while reindexing
                        skip_undo_history_check     = 1 << 9,  ///< used while reindexing
                        skip_witness_schedule_check = 1 << 10, ///< used while reindexing
                        skip_validate               = 1 << 11  ///< used prior to checkpoint, skips validate() call on transaction

                  * @brief Open a database, creating a new one if necessary
                  * Opens a database in the specified directory. If no initialized database is found, genesis_loader is called
                  * and its return value is used as the genesis state when initializing the new database
                  * genesis_loader will not be called if an existing database is found.
                  * @param data_dir Path to open or create database in
                  * @param genesis_loader A callable object which returns the genesis state to initialize new databases on
                  * @param db_version a version string that changes when the internal database format and/or logic is modified
                  void open(
                         const fc::path& data_dir,
                         std::function<genesis_state_type()> genesis_loader,
                         const std::string& db_version );

                  * @brief Rebuild object graph from block history and open detabase
                  * This method may be called after or instead of @ref database::open, and will rebuild the object graph by
                  * replaying blockchain history. When this method exits successfully, the database will be open.
                 void reindex(fc::path data_dir);

                  * @brief wipe Delete database from disk, and potentially the raw chain as well.
                  * @param include_blocks If true, delete the raw chain as well as the database.
                  * Will close the database before wiping. Database will be closed when this function returns.
                 void wipe(const fc::path& data_dir, bool include_blocks);
                 void close(bool rewind = true);

                 //////////////////// db_block.cpp ////////////////////

                  *  @return true if the block is in our fork DB or saved to disk as
                  *  part of the official chain, otherwise return false
                 bool                       is_known_block( const block_id_type& id )const;
                 bool                       is_known_transaction( const transaction_id_type& id )const;
                 block_id_type              get_block_id_for_num( uint32_t block_num )const;
                 optional<signed_block>     fetch_block_by_id( const block_id_type& id )const;
                 optional<signed_block>     fetch_block_by_number( uint32_t num )const;
                 const signed_transaction&  get_recent_transaction( const transaction_id_type& trx_id )const;
                 std::vector<block_id_type> get_block_ids_on_fork(block_id_type head_of_fork) const;

                  *  Calculate the percent of block production slots that were missed in the
                  *  past 128 blocks, not including the current block.
                 uint32_t witness_participation_rate()const;

                 void                              add_checkpoints( const flat_map<uint32_t,block_id_type>& checkpts );
                 const flat_map<uint32_t,block_id_type> get_checkpoints()const { return _checkpoints; }
                 bool before_last_checkpoint()const;

                 bool push_block( const signed_block& b, uint32_t skip = skip_nothing );
                 processed_transaction push_transaction( const signed_transaction& trx, uint32_t skip = skip_nothing );
                 bool _push_block( const signed_block& b );
                 processed_transaction _push_transaction( const signed_transaction& trx );

                 ///@throws fc::exception if the proposed transaction fails to apply.
                 processed_transaction push_proposal( const proposal_object& proposal );

                 signed_block generate_block(
                        const fc::time_point_sec when,
                        witness_id_type witness_id,
                        const fc::ecc::private_key& block_signing_private_key,
                        uint32_t skip
                 signed_block _generate_block(
                        const fc::time_point_sec when,
                        witness_id_type witness_id,
                        const fc::ecc::private_key& block_signing_private_key

                 void pop_block();
                 void clear_pending();

                  *  This method is used to track appied operations during the evaluation of a block, these
                  *  operations should include any operation actually included in a transaction as well
                  *  as any implied/virtual operations that resulted, such as filling an order.  The
                  *  applied operations is cleared after applying each block and calling the block
                  *  observers which may want to index these operations.
                  *  @return the op_id which can be used to set the result after it has finished being applied.
                 uint32_t  push_applied_operation( const operation& op );
                 void      set_applied_operation_result( uint32_t op_id, const operation_result& r );
                 const vector<optional< operation_history_object > >& get_applied_operations()const;

                 string to_pretty_string( const asset& a )const;

                  *  This signal is emitted after all operations and virtual operation for a
                  *  block have been applied but before the get_applied_operations() are cleared.
                  *  You may not yield from this callback because the blockchain is holding
                  *  the write lock and may be in an "inconstant state" until after it is
                  *  released.
                 fc::signal<void(const signed_block&)>           applied_block;

                  * This signal is emitted any time a new transaction is added to the pending
                  * block state.
                 fc::signal<void(const signed_transaction&)>     on_pending_transaction;

                  *  Emitted After a block has been applied and committed.  The callback
                  *  should not yield and should execute quickly.
                 fc::signal<void(const vector<object_id_type>&, const flat_set<account_id_type>&)> new_objects;

                  *  Emitted After a block has been applied and committed.  The callback
                  *  should not yield and should execute quickly.
                 fc::signal<void(const vector<object_id_type>&, const flat_set<account_id_type>&)> changed_objects;

                 /** this signal is emitted any time an object is removed and contains a
                  * pointer to the last value of every object that was removed.
                 fc::signal<void(const vector<object_id_type>&, const vector<const object*>&, const flat_set<account_id_type>&)>  removed_objects;

                 //////////////////// db_witness_schedule.cpp ////////////////////

                  * @brief Get the witness scheduled for block production in a slot.
                  * slot_num always corresponds to a time in the future.
                  * If slot_num == 1, returns the next scheduled witness.
                  * If slot_num == 2, returns the next scheduled witness after
                  * 1 block gap.
                  * Use the get_slot_time() and get_slot_at_time() functions
                  * to convert between slot_num and timestamp.
                  * Passing slot_num == 0 returns GRAPHENE_NULL_WITNESS
                 witness_id_type get_scheduled_witness(uint32_t slot_num)const;

                  * Get the time at which the given slot occurs.
                  * If slot_num == 0, return time_point_sec().
                  * If slot_num == N for N > 0, return the Nth next
                  * block-interval-aligned time greater than head_block_time().
                 fc::time_point_sec get_slot_time(uint32_t slot_num)const;

                  * Get the last slot which occurs AT or BEFORE the given time.
                  * The return value is the greatest value N such that
                  * get_slot_time( N ) <= when.
                  * If no such N exists, return 0.
                 uint32_t get_slot_at_time(fc::time_point_sec when)const;

                 void update_witness_schedule();

                 //////////////////// db_getter.cpp ////////////////////

                 const chain_id_type&                   get_chain_id()const;
                 const asset_object&                    get_core_asset()const;
                 const asset_dynamic_data_object&       get_core_dynamic_data()const;
                 const chain_property_object&           get_chain_properties()const;
                 const global_property_object&          get_global_properties()const;
                 const dynamic_global_property_object&  get_dynamic_global_properties()const;
                 const node_property_object&            get_node_properties()const;
                 const fee_schedule&                    current_fee_schedule()const;
                 const account_statistics_object&       get_account_stats_by_owner( account_id_type owner )const;
                 const witness_schedule_object&         get_witness_schedule_object()const;

                 time_point_sec   head_block_time()const;
                 uint32_t         head_block_num()const;
                 block_id_type    head_block_id()const;
                 witness_id_type  head_block_witness()const;

                 decltype( chain_parameters::block_interval ) block_interval( )const;

                 node_property_object& node_properties();

                 uint32_t last_non_undoable_block_num() const;
                 //////////////////// db_init.cpp ////////////////////

                 void initialize_evaluators();
                 /// Reset the object graph in-memory
                 void initialize_indexes();
                 void init_genesis(const genesis_state_type& genesis_state = genesis_state_type());

                 template<typename EvaluatorType>
                 void register_evaluator()
                           operation::tag<typename EvaluatorType::operation_type>::value].reset( new op_evaluator_impl<EvaluatorType>() );

                 //////////////////// db_balance.cpp ////////////////////

                  * @brief Retrieve a particular account's balance in a given asset
                  * @param owner Account whose balance should be retrieved
                  * @param asset_id ID of the asset to get balance in
                  * @return owner's balance in asset
                 asset get_balance(account_id_type owner, asset_id_type asset_id)const;
                 /// This is an overloaded method.
                 asset get_balance(const account_object& owner, const asset_object& asset_obj)const;

                  * @brief Adjust a particular account's balance in a given asset by a delta
                  * @param account ID of account whose balance should be adjusted
                  * @param delta Asset ID and amount to adjust balance by
                 void adjust_balance(account_id_type account, asset delta);

                  * @brief Helper to make lazy deposit to CDD VBO.
                  * If the given optional VBID is not valid(),
                  * or it does not have a CDD vesting policy,
                  * or the owner / vesting_seconds of the policy
                  * does not match the parameter, then credit amount
                  * to newly created VBID and return it.
                  * Otherwise, credit amount to ovbid.
                  * @return ID of newly created VBO, but only if VBO was created.
                 optional< vesting_balance_id_type > deposit_lazy_vesting(
                        const optional< vesting_balance_id_type >& ovbid,
                        share_type amount,
                        uint32_t req_vesting_seconds,
                        account_id_type req_owner,
                        bool require_vesting );

                 // helper to handle cashback rewards
                 void deposit_cashback(const account_object& acct, share_type amount, bool require_vesting = true);
                 // helper to handle witness pay
                 void deposit_witness_pay(const witness_object& wit, share_type amount);

                 //////////////////// db_debug.cpp ////////////////////

                 void debug_dump();
                 void apply_debug_updates();
                 void debug_update( const fc::variant_object& update );

                 //////////////////// db_market.cpp ////////////////////

                 /// @{ @group Market Helpers
                 void globally_settle_asset( const asset_object& bitasset, const price& settle_price );
                 void cancel_settle_order(const force_settlement_object& order, bool create_virtual_op = true);
                 void cancel_limit_order(const limit_order_object& order, bool create_virtual_op = true, bool skip_cancel_fee = false);
                 void revive_bitasset( const asset_object& bitasset );
                 void cancel_bid(const collateral_bid_object& bid, bool create_virtual_op = true);
                 void execute_bid( const collateral_bid_object& bid, share_type debt_covered, share_type collateral_from_fund, const price_feed& current_feed );

                  * @brief Process a new limit order through the markets
                  * @param order The new order to process
                  * @return true if order was completely filled; false otherwise
                  * This function takes a new limit order, and runs the markets attempting to match it with existing orders
                  * already on the books.
                 bool apply_order_before_hardfork_625(const limit_order_object& new_order_object, bool allow_black_swan = true);
                 bool apply_order(const limit_order_object& new_order_object, bool allow_black_swan = true);

                  * Matches the two orders, the first parameter is taker, the second is maker.
                  * @return a bit field indicating which orders were filled (and thus removed)
                  * 0 - no orders were matched
                  * 1 - taker was filled
                  * 2 - maker was filled
                  * 3 - both were filled
                 int match( const limit_order_object& taker, const limit_order_object& maker, const price& trade_price );
                 int match( const limit_order_object& taker, const call_order_object& maker, const price& trade_price,
                                        const price& feed_price, const uint16_t maintenance_collateral_ratio );
                 /// @return the amount of asset settled
                 asset match(const call_order_object& call,
                                   const force_settlement_object& settle,
                                   const price& match_price,
                                   asset max_settlement,
                                   const price& fill_price);

                  * @return true if the order was completely filled and thus freed.
                 bool fill_limit_order( const limit_order_object& order, const asset& pays, const asset& receives, bool cull_if_small,
                                                                const price& fill_price, const bool is_maker );
                 bool fill_call_order( const call_order_object& order, const asset& pays, const asset& receives,
                                                           const price& fill_price, const bool is_maker );
                 bool fill_settle_order( const force_settlement_object& settle, const asset& pays, const asset& receives,
                                                                 const price& fill_price, const bool is_maker );

                 bool check_call_orders( const asset_object& mia, bool enable_black_swan = true, bool for_new_limit_order = false,
                                                                 const asset_bitasset_data_object* bitasset_ptr = nullptr );

                 // helpers to fill_order
                 void pay_order( const account_object& receiver, const asset& receives, const asset& pays );

                 asset calculate_market_fee(const asset_object& recv_asset, const asset& trade_amount);
                 asset pay_market_fees( const asset_object& recv_asset, const asset& receives );

                  *  This method validates transactions without adding it to the pending state.
                  *  @return true if the transaction would validate
                 processed_transaction validate_transaction( const signed_transaction& trx );

                 /** when popping a block, the transactions that were removed get cached here so they
                  * can be reapplied at the proper time */
                 std::deque< signed_transaction >       _popped_tx;

                  * @}

                 /// Enable or disable tracking of votes of standby witnesses and committee members
                 inline void enable_standby_votes_tracking(bool enable)  { _track_standby_votes = enable; }

                 //Mark pop_undo() as protected -- we do not want outside calling pop_undo(); it should call pop_block() instead
                 void pop_undo() { object_database::pop_undo(); }
                 void notify_applied_block( const signed_block& block );
                 void notify_on_pending_transaction( const signed_transaction& tx );
                 void notify_changed_objects();

                 optional<undo_database::session>       _pending_tx_session;
                 vector< unique_ptr<op_evaluator> >     _operation_evaluators;

                 template<class Index>
                 vector<std::reference_wrapper<const typename Index::object_type>> sort_votable_objects(size_t count)const;

                 //////////////////// db_block.cpp ////////////////////

                 // these were formerly private, but they have a fairly well-defined API, so let's make them public
                 void                  apply_block( const signed_block& next_block, uint32_t skip = skip_nothing );
                 processed_transaction apply_transaction( const signed_transaction& trx, uint32_t skip = skip_nothing );
                 operation_result      apply_operation( transaction_evaluation_state& eval_state, const operation& op );
                 void                  _apply_block( const signed_block& next_block );
                 processed_transaction _apply_transaction( const signed_transaction& trx );
                 void                  _cancel_bids_and_revive_mpa( const asset_object& bitasset, const asset_bitasset_data_object& bad );

                 ///Steps involved in applying a new block

                 const witness_object& validate_block_header( uint32_t skip, const signed_block& next_block )const;
                 const witness_object& _validate_block_header( const signed_block& next_block )const;
                 void create_block_summary(const signed_block& next_block);

                 //////////////////// db_witness_schedule.cpp ////////////////////

                 uint32_t update_witness_missed_blocks( const signed_block& b );

                 //////////////////// db_update.cpp ////////////////////
                 void update_global_dynamic_data( const signed_block& b, const uint32_t missed_blocks );
                 void update_signing_witness(const witness_object& signing_witness, const signed_block& new_block);
                 void update_last_irreversible_block();
                 void clear_expired_transactions();
                 void clear_expired_proposals();
                 void clear_expired_orders();
                 void update_expired_feeds();
                 void update_core_exchange_rates();
                 void update_maintenance_flag( bool new_maintenance_flag );
                 void update_withdraw_permissions();
                 bool check_for_blackswan( const asset_object& mia, bool enable_black_swan = true,
                                                                   const asset_bitasset_data_object* bitasset_ptr = nullptr );

                 ///Steps performed only at maintenance intervals

                 //////////////////// db_maint.cpp ////////////////////

                 void initialize_budget_record( fc::time_point_sec now, budget_record& rec )const;
                 void process_budget();
                 void pay_workers( share_type& budget );
                 void perform_chain_maintenance(const signed_block& next_block, const global_property_object& global_props);
                 void update_active_witnesses();
                 void update_active_committee_members();
                 void update_worker_votes();
                 void process_bids( const asset_bitasset_data_object& bad );
                 void process_bitassets();

                 template<class Type>
                 void perform_account_maintenance( Type tally_helper );

                 vector< processed_transaction >        _pending_tx;
                 fork_database                          _fork_db;

                  *  Note: we can probably store blocks by block num rather than
                  *  block id because after the undo window is past the block ID
                  *  is no longer relevant and its number is irreversible.
                  *  During the "fork window" we can cache blocks in memory
                  *  until the fork is resolved.  This should make maintaining
                  *  the fork tree relatively simple.
                 block_database   _block_id_to_block;

                  * Contains the set of ops that are in the process of being applied from
                  * the current block.  It contains real and virtual operations in the
                  * order they occur and is cleared after the applied_block signal is
                  * emited.
                 vector<optional<operation_history_object> >  _applied_ops;

                 uint32_t                          _current_block_num    = 0;
                 uint16_t                          _current_trx_in_block = 0;
                 uint16_t                          _current_op_in_trx    = 0;
                 uint16_t                          _current_virtual_op   = 0;

                 vector<uint64_t>                  _vote_tally_buffer;
                 vector<uint64_t>                  _witness_count_histogram_buffer;
                 vector<uint64_t>                  _committee_count_histogram_buffer;
                 uint64_t                          _total_voting_stake;

                 flat_map<uint32_t,block_id_type>  _checkpoints;

                 node_property_object              _node_property_object;

                 /// Whether to update votes of standby witnesses and committee members when performing chain maintenance.
                 /// Set it to true to provide accurate data to API clients, set to false to have better performance.
                 bool                              _track_standby_votes = true;

                  * Whether database is successfully opened or not.
                  * The database is considered open when there's no exception
                  * or assertion fail during database::open() method, and
                  * database::close() has not been called, or failed during execution.
                 bool                              _opened = false;

                 // Counts nested proposal updates
                 uint32_t                           _push_proposal_nesting_depth = 0;

                 /// Tracks assets affected by bitshares-core issue #453 before hard fork #615 in one block
                 flat_set<asset_id_type>           _issue_453_affected_assets;

                 /// Pointers to core asset object and global objects who will have immutable addresses after created
                 const asset_object*                    _p_core_asset_obj          = nullptr;
                 const asset_dynamic_data_object*       _p_core_dynamic_data_obj   = nullptr;
                 const global_property_object*          _p_global_prop_obj         = nullptr;
                 const dynamic_global_property_object*  _p_dyn_global_prop_obj     = nullptr;
                 const chain_property_object*           _p_chain_property_obj      = nullptr;
                 const witness_schedule_object*         _p_witness_schedule_obj    = nullptr;

   namespace detail
           template<int... Is>
           struct seq { };

           template<int N, int... Is>
           struct gen_seq : gen_seq<N - 1, N - 1, Is...> { };

           template<int... Is>
           struct gen_seq<0, Is...> : seq<Is...> { };

           template<typename T, int... Is>
           void for_each(T&& t, const account_object& a, seq<Is...>)
                   auto l = { (std::get<Is>(t)(a), 0)... };

} }

// (**11/27/2018)