database.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/fee_schedule.hpp>

#include <graphene/chain/global_property_object.hpp>
#include <graphene/chain/node_property_object.hpp>
#include <graphene/chain/account_object.hpp>
#include <graphene/chain/asset_object.hpp>
#include <graphene/chain/fork_database.hpp>
#include <graphene/chain/block_database.hpp>
#include <graphene/chain/genesis_state.hpp>
#include <graphene/chain/evaluator.hpp>

#include <graphene/db/object_database.hpp>
#include <graphene/db/object.hpp>
#include <graphene/db/simple_index.hpp>
#include <fc/signals.hpp>

#include <fc/log/logger.hpp>

#include <map>

namespace graphene { namespace protocol { struct predicate_result; } }

namespace graphene { namespace chain {
   using graphene::db::abstract_object;
   using graphene::db::object;
   class op_evaluator;
   class transaction_evaluation_state;
   class proposal_object;
   class operation_history_object;
   class chain_property_object;
   class witness_schedule_object;
   class witness_object;
   class force_settlement_object;
   class limit_order_object;
   class collateral_bid_object;
   class call_order_object;

   struct budget_record;
   enum class vesting_balance_type;

   class database : public db::object_database
   {
      public:
         database();
         ~database() override;

         enum validation_steps
         {
            skip_nothing                = 0,
            skip_witness_signature      = 1 << 0,  
            skip_transaction_signatures = 1 << 1,  
            skip_transaction_dupe_check = 1 << 2,  
            skip_block_size_check       = 1 << 4,  
            skip_tapos_check            = 1 << 5,  
            // skip_authority_check        = 1 << 6,  // removed, effectively identical to skip_transaction_signatures
            skip_merkle_check           = 1 << 7,  
            skip_assert_evaluation      = 1 << 8,  
            skip_undo_history_check     = 1 << 9,  
            skip_witness_schedule_check = 1 << 10 
         };

          void open(
             const fc::path& data_dir,
             std::function<genesis_state_type()> genesis_loader,
             const std::string& db_version );

         void reindex(fc::path data_dir);

         void wipe(const fc::path& data_dir, bool include_blocks);
         void close(bool rewind = true);


         witness_id_type get_scheduled_witness(uint32_t slot_num)const;

         fc::time_point_sec get_slot_time(uint32_t slot_num)const;

         uint32_t get_slot_at_time(fc::time_point_sec when)const;

         uint32_t witness_participation_rate()const;
      private:
         uint32_t update_witness_missed_blocks( const signed_block& b );

         void update_witness_schedule();


      public:
         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();

         vector<authority> get_viable_custom_authorities(
                 account_id_type account, const operation& op,
                 rejected_predicate_map* rejected_authorities = nullptr )const;

         uint32_t last_non_undoable_block_num() const;

         const limit_order_object* find_settled_debt_order( const asset_id_type& a )const;

         const call_order_object* find_least_collateralized_short( const asset_bitasset_data_object& bitasset,
                                                                   bool force_by_collateral_index )const;


         void initialize_indexes(); // Mark as public since it is used in tests
      private:
         void initialize_evaluators();
         void init_genesis(const genesis_state_type& genesis_state = genesis_state_type());

         template<typename EvaluatorType>
         void register_evaluator()
         {
            const auto op_type = operation::tag<typename EvaluatorType::operation_type>::value;
            FC_ASSERT( op_type >= 0, "Negative operation type" );
            FC_ASSERT( op_type < _operation_evaluators.size(),
                       "The operation type (${a}) must be smaller than the size of _operation_evaluators (${b})",
                       ("a", op_type)("b", _operation_evaluators.size()) );
            _operation_evaluators[op_type] = std::make_unique<op_evaluator_impl<EvaluatorType>>();
         }


      public:
         asset get_balance(account_id_type owner, asset_id_type asset_id)const;
         asset get_balance(const account_object& owner, const asset_object& asset_obj)const;

         void adjust_balance(account_id_type account, asset delta);

         void deposit_market_fee_vesting_balance(const account_id_type &account_id, const asset &delta);
         asset get_market_fee_vesting_balance(const account_id_type &account_id, const asset_id_type &asset_id);

         optional< vesting_balance_id_type > deposit_lazy_vesting(
            const optional< vesting_balance_id_type >& ovbid,
            share_type amount,
            uint32_t req_vesting_seconds,
            vesting_balance_type balance_type,
            account_id_type req_owner,
            bool require_vesting );

         void deposit_cashback(const account_object& acct, share_type amount, bool require_vesting = true);
         void deposit_witness_pay(const witness_object& wit, share_type amount);

         string to_pretty_string( const asset& a )const;


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



         void globally_settle_asset( const asset_object& bitasset, const price& settle_price,
                                     bool check_margin_calls = false );
         void cancel_settle_order( const force_settlement_object& order );
         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, const asset_bitasset_data_object& bad );
         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 );

      private:
         void _cancel_bids_and_revive_mpa( const asset_object& bitasset, const asset_bitasset_data_object& bad );
         bool check_for_blackswan( const asset_object& mia, bool enable_black_swan = true,
                                   const asset_bitasset_data_object* bitasset_ptr = nullptr );
         template<typename IndexType>
         void globally_settle_asset_impl( const asset_object& bitasset,
                                          const price& settle_price,
                                          const IndexType& call_index,
                                          bool check_margin_calls = false );
         void individually_settle( const asset_bitasset_data_object& bitasset, const call_order_object& call_order );
         bool match_force_settlements( const asset_bitasset_data_object& bitasset );
         asset match_impl( const force_settlement_object& settle,
                           const call_order_object& call,
                           const price& match_price,
                           const asset_bitasset_data_object& bitasset,
                           const asset& max_settlement,
                           const price& fill_price,
                           bool is_margin_call = false,
                           bool settle_order_is_taker = true );

      public:
         bool apply_order_before_hardfork_625( const limit_order_object& new_order_object );
         bool apply_order(                     const limit_order_object& new_order_object );

         void apply_force_settlement( const force_settlement_object& new_settlement,
                                      const asset_bitasset_data_object& bitasset,
                                      const asset_object& asset_obj );

         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,
                                 bool mute_exceptions = false,
                                 bool skip_matching_settle_orders = false );

         // Note: Ideally this should be private.
         //       Now it is public because we use it in a non-member function in db_market.cpp .
         enum class match_result_type
         {
            none_filled = 0,
            only_taker_filled = 1,
            only_maker_filled = 2,
            both_filled = 3
         };

      private:
         match_result_type match( const limit_order_object& taker, const limit_order_object& maker,
                                  const price& trade_price );
         match_result_type match_limit_normal_limit( const limit_order_object& taker, const limit_order_object& maker,
                                                     const price& trade_price );
         match_result_type match_limit_settled_debt( const limit_order_object& taker, const limit_order_object& maker,
                                                     const price& trade_price );
         /***
          * @brief Match limit order as taker to a call order as maker
          * @param taker the order that is removing liquidity from the book
          * @param maker the order that put liquidity on the book
          * @param trade_price the price the trade should execute at
          * @param bitasset the bitasset object corresponding to debt asset of the call order
          * @param call_pays_price price call order pays. Call order may pay more collateral
          *    than limit order takes if call order subject to a margin call fee.
          * @returns 0 if no orders were matched, 1 if taker was filled, 2 if maker was filled, 3 if both were filled
          */
         match_result_type match( const limit_order_object& taker, const call_order_object& maker,
                    const price& trade_price,
                    const asset_bitasset_data_object& bitasset,
                    const price& call_pays_price);
         match_result_type match( const limit_order_object& taker, const call_order_object& maker,
                    const price& trade_price,
                    const asset_bitasset_data_object& bitasset) {
            return match(taker, maker, trade_price, bitasset, trade_price);
         }


         asset match( const force_settlement_object& settle,
                      const call_order_object& call,
                      const price& match_price,
                      const asset_bitasset_data_object& bitasset,
                      const asset& max_settlement,
                      const price& fill_price,
                      bool is_margin_call = false );

         asset match( const call_order_object& call,
                      const force_settlement_object& settle,
                      const price& match_price,
                      const asset_bitasset_data_object& bitasset,
                      const asset& max_settlement,
                      const price& fill_price );

         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 );
         /***
          * @brief attempt to fill a call order
          * @param order the order
          * @param pays what the buyer pays for the collateral
          * @param receives the collateral received by the buyer
          * @param fill_price the price the transaction executed at
          * @param is_maker TRUE if the buyer is the maker, FALSE if the buyer is the taker
          * @param margin_fee Margin call fees paid in collateral asset
          * @param reduce_current_supply Whether to reduce current supply of the asset. Usually it is true.
          *                              When globally settleing or individually settling it is false.
          * @returns TRUE if the order was completely filled
          */
         bool fill_call_order( const call_order_object& order, const asset& pays, const asset& receives,
                               const price& fill_price, const bool is_maker, const asset& margin_fee,
                               bool reduce_current_supply = true );

         bool fill_call_order( const call_order_object& order, const asset& pays, const asset& receives,
                               const price& fill_price, const bool is_maker,
                               bool reduce_current_supply = true )
         {
            return fill_call_order( order, pays, receives, fill_price, is_maker, asset(0, pays.asset_id),
                                    reduce_current_supply );
         }

         bool fill_settle_order( const force_settlement_object& settle, const asset& pays, const asset& receives,
                                 const price& fill_price, bool is_maker, bool pay_force_settle_fee = true );

         void pay_order( const account_object& receiver, const asset& receives, const asset& pays );

      public:
         asset calculate_market_fee( const asset_object& trade_asset, const asset& trade_amount,
                                     const bool& is_maker )const;
         asset pay_market_fees(const account_object* seller, const asset_object& recv_asset, const asset& receives,
                               const bool& is_maker, const optional<asset>& calculated_market_fees = {});
         asset pay_force_settle_fees(const asset_object& collecting_asset, const asset& collat_receives);


         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;

         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 precomputable_transaction& trx, uint32_t skip = skip_nothing );
      private:
         bool _push_block( const signed_block& b );
      public:
         // It is public because it is used in pending_transactions_restorer in db_with.hpp
         processed_transaction _push_transaction( const precomputable_transaction& trx );
         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
            );
      private:
         signed_block _generate_block(
            const fc::time_point_sec when,
            witness_id_type witness_id,
            const fc::ecc::private_key& block_signing_private_key
            );

      public:
         void pop_block();
         void clear_pending();

         uint32_t  push_applied_operation( const operation& op, bool is_virtual = true );
         void      set_applied_operation_result( uint32_t op_id, const operation_result& r );
         const vector<optional< operation_history_object > >& get_applied_operations()const;

         fc::signal<void(const signed_block&)>           applied_block;

         fc::signal<void(const signed_transaction&)>     on_pending_transaction;

         fc::signal<void(const vector<object_id_type>&, const flat_set<account_id_type>&)> new_objects;

         fc::signal<void(const vector<object_id_type>&, const flat_set<account_id_type>&)> changed_objects;

         fc::signal<void(const vector<object_id_type>&,
                         const vector<const object*>&, const flat_set<account_id_type>&)>  removed_objects;


         processed_transaction validate_transaction( const signed_transaction& trx );


         std::deque< precomputable_transaction > _popped_tx;

         fc::future<void> precompute_parallel( const signed_block& block, const uint32_t skip = skip_nothing )const;

         fc::future<void> precompute_parallel( const precomputable_transaction& trx )const;
      private:
         template<typename Trx>
         void _precompute_parallel( const Trx* trx, const size_t count, const uint32_t skip )const;

      protected:
         // 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(); }

      private:
         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;

      public:
         // 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,
                                                bool is_virtual = true );

      private:
         void                  _apply_block( const signed_block& next_block );
         processed_transaction _apply_transaction( const signed_transaction& trx );


         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 verify_signing_witness( const signed_block& new_block, const fork_item& fork_entry )const;
         void update_witnesses( fork_item& fork_entry )const;
         void create_block_summary(const signed_block& next_block);


      protected:
         void notify_applied_block( const signed_block& block );
         void notify_on_pending_transaction( const signed_transaction& tx );
         void notify_changed_objects();

      public:
         generic_operation_result process_tickets();
         void update_bitasset_current_feed( const asset_bitasset_data_object& bitasset,
                                            bool skip_median_update = false );
      private:
         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 clear_expired_force_settlements();
         void update_expired_feeds();
         void update_core_exchange_rates();
         void update_maintenance_flag( bool new_maintenance_flag );
         void update_withdraw_permissions();
         void update_credit_offers_and_deals();
         void clear_expired_htlcs();



         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 );
         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;

         block_database   _block_id_to_block;

         vector<optional<operation_history_object> >  _applied_ops;

      public:
         fc::time_point_sec                _current_block_time;
         uint32_t                          _current_block_num    = 0;
      private:
         uint16_t                          _current_trx_in_block = 0;
         uint16_t                          _current_op_in_trx    = 0;
         uint32_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;
         std::array<uint64_t,2>            _total_voting_stake; // 0=committee, 1=witness,
                                                                // as in vote_id_type::vote_type

         flat_map<uint32_t,block_id_type>  _checkpoints;

         node_property_object              _node_property_object;

         bool                              _track_standby_votes = true;

         bool                              _opened = false;

         // Counts nested proposal updates
         uint32_t                          _push_proposal_nesting_depth = 0;

         flat_set<asset_id_type>           _issue_453_affected_assets;

         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;
      public:
         inline void enable_standby_votes_tracking(bool enable)  { _track_standby_votes = enable; }
   };

} }