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

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


         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;

         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 precomputable_transaction& trx, uint32_t skip = skip_nothing );
         bool _push_block( const signed_block& b );
         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
            );
         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();

         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;

         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;


         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;

         void update_witness_schedule();


         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;

         void initialize_evaluators();
         void initialize_indexes();
         void init_genesis(const genesis_state_type& genesis_state = genesis_state_type());

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


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

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


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

      private:
         template<typename IndexType>
         void globally_settle_asset_impl( const asset_object& bitasset,
                                          const price& settle_price,
                                          const IndexType& call_index );

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

         int match( 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 feed_price the price of the current feed
          * @param maintenance_collateral_ratio the maintenance collateral ratio
          * @param maintenance_collateralization the maintenance collateralization
          * @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
          */
         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,
                    const optional<price>& maintenance_collateralization,
                    const price& call_pays_price);
         // If separate call_pays_price not provided, assume call pays at 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,
                    const optional<price>& maintenance_collateralization) {
            return match(taker, maker, trade_price, feed_price, maintenance_collateral_ratio,
                         maintenance_collateralization, trade_price);
         }


         asset match(const call_order_object& call,
                   const force_settlement_object& settle,
                   const price& match_price,
                   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
          * @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 );

         // Overload provides compatible default value for margin_fee: (margin_fee.asset_id == pays.asset_id)
         bool fill_call_order( const call_order_object& order, const asset& pays, const asset& receives,
                               const price& fill_price, const bool is_maker )
         {
            return fill_call_order( order, pays, receives, fill_price, is_maker, asset(0, pays.asset_id) );
         }

         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& trade_asset, const asset& trade_amount, const bool& is_maker);
         asset pay_market_fees(const account_object* seller, const asset_object& recv_asset, const asset& receives,
                               const bool& is_maker);
         asset pay_force_settle_fees(const asset_object& collecting_asset, const asset& collat_receives);



         processed_transaction validate_transaction( const signed_transaction& trx );


         std::deque< precomputable_transaction > _popped_tx;

         inline void enable_standby_votes_tracking(bool enable)  { _track_standby_votes = enable; }

         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(); }
         void notify_applied_block( const signed_block& block );
         void notify_on_pending_transaction( const signed_transaction& tx );
         void notify_changed_objects();

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

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


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


         uint32_t update_witness_missed_blocks( const signed_block& b );

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

         block_database   _block_id_to_block;

         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;
         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;
         uint64_t                          _total_voting_stake[2]; // 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;
   };

   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)... };
           (void)l;
       }
   }

} }