final_chain.hpp

Go to the documentation of this file.

#pragma once
 
#include <future>
 
#include "common/event.hpp"
#include "common/types.hpp"
#include "config/config.hpp"
#include "config/state_config.hpp"
#include "final_chain/cache.hpp"
#include "final_chain/data.hpp"
#include "final_chain/state_api.hpp"
#include "rewards/rewards_stats.hpp"
#include "storage/storage.hpp"
 
namespace taraxa::final_chain {
 
class FinalChain {
 protected:
  util::EventEmitter<std::shared_ptr<FinalizationResult>> const block_finalized_emitter_{};
  util::EventEmitter<uint64_t> const block_applying_emitter_{};
 
 public:
  decltype(block_finalized_emitter_)::Subscriber const& block_finalized_ = block_finalized_emitter_;
  decltype(block_applying_emitter_)::Subscriber const& block_applying_ = block_applying_emitter_;
 
  FinalChain() = default;
  ~FinalChain() = default;
  FinalChain(const std::shared_ptr<DbStorage>& db, const taraxa::FullNodeConfig& config, const addr_t& node_addr);
  FinalChain(const FinalChain&) = delete;
  FinalChain(FinalChain&&) = delete;
  FinalChain& operator=(const FinalChain&) = delete;
  FinalChain& operator=(FinalChain&&) = delete;
 
  void stop();
 
  EthBlockNumber delegationDelay() const;
 
  std::future<std::shared_ptr<const FinalizationResult>> finalize(PeriodData&& period_data,
                                                                  std::vector<h256>&& finalized_dag_blk_hashes,
                                                                  std::shared_ptr<DagBlock>&& anchor = nullptr);
 
  std::shared_ptr<const BlockHeader> blockHeader(std::optional<EthBlockNumber> n = {}) const;
 
  EthBlockNumber lastBlockNumber() const;
 
  std::optional<EthBlockNumber> blockNumber(h256 const& h) const;
 
  std::optional<h256> blockHash(std::optional<EthBlockNumber> n = {}) const;
 
  std::optional<h256> finalChainHash(EthBlockNumber n) const;
 
  void updateStateConfig(const state_api::Config& new_config);
 
  std::shared_ptr<const TransactionHashes> transactionHashes(std::optional<EthBlockNumber> n = {}) const;
 
  const SharedTransactions transactions(std::optional<EthBlockNumber> n = {}) const;
 
  std::optional<TransactionLocation> transactionLocation(h256 const& trx_hash) const;
 
  std::optional<TransactionReceipt> transactionReceipt(h256 const& _transactionHash) const;
 
  uint64_t transactionCount(std::optional<EthBlockNumber> n = {}) const;
 
  std::vector<EthBlockNumber> withBlockBloom(LogBloom const& b, EthBlockNumber from, EthBlockNumber to) const;
 
  std::optional<state_api::Account> getAccount(addr_t const& addr, std::optional<EthBlockNumber> blk_n = {}) const;
 
  h256 getAccountStorage(addr_t const& addr, u256 const& key, std::optional<EthBlockNumber> blk_n = {}) const;
  bytes getCode(addr_t const& addr, std::optional<EthBlockNumber> blk_n = {}) const;
 
  state_api::ExecutionResult call(state_api::EVMTransaction const& trx, std::optional<EthBlockNumber> blk_n = {}) const;
 
  std::string trace(std::vector<state_api::EVMTransaction> trx, EthBlockNumber blk_n,
                    std::optional<state_api::Tracing> params = {}) const;
 
  uint64_t dposEligibleTotalVoteCount(EthBlockNumber blk_num) const;
 
  uint64_t dposEligibleVoteCount(EthBlockNumber blk_num, addr_t const& addr) const;
 
  bool dposIsEligible(EthBlockNumber blk_num, addr_t const& addr) const;
 
  vrf_wrapper::vrf_pk_t dposGetVrfKey(EthBlockNumber blk_n, const addr_t& addr) const;
 
  void prune(EthBlockNumber blk_n);
 
  void waitForFinalized();
 
  std::vector<state_api::ValidatorStake> dposValidatorsTotalStakes(EthBlockNumber blk_num) const;
 
  uint256_t dposTotalAmountDelegated(EthBlockNumber blk_num) const;
 
  std::vector<state_api::ValidatorVoteCount> dposValidatorsVoteCounts(EthBlockNumber blk_num) const;
 
  uint64_t dposYield(EthBlockNumber blk_num) const;
 
  u256 dposTotalSupply(EthBlockNumber blk_num) const;
 
  h256 getBridgeRoot(EthBlockNumber blk_num) const;
 
  h256 getBridgeEpoch(EthBlockNumber blk_num) const;
 
  // TODO move out of here:
  std::pair<val_t, bool> getBalance(addr_t const& addr) const;
  std::shared_ptr<const FinalizationResult> finalize_(PeriodData&& new_blk,
                                                      std::vector<h256>&& finalized_dag_blk_hashes,
                                                      std::shared_ptr<DagBlock>&& anchor);
 
 private:
  std::shared_ptr<TransactionHashes> getTransactionHashes(std::optional<EthBlockNumber> n = {}) const;
  const SharedTransactions getTransactions(std::optional<EthBlockNumber> n = {}) const;
  std::shared_ptr<const BlockHeader> getBlockHeader(EthBlockNumber n) const;
  std::optional<h256> getBlockHash(EthBlockNumber n) const;
  EthBlockNumber lastIfAbsent(const std::optional<EthBlockNumber>& client_blk_n) const;
  static state_api::EVMTransaction toEvmTransaction(const SharedTransaction& trx);
  static void appendEvmTransactions(std::vector<state_api::EVMTransaction>& evm_trxs, const SharedTransactions& trxs);
  BlocksBlooms blockBlooms(const h256& chunk_id) const;
  static h256 blockBloomsChunkId(EthBlockNumber level, EthBlockNumber index);
  std::vector<EthBlockNumber> withBlockBloom(const LogBloom& b, EthBlockNumber from, EthBlockNumber to,
                                             EthBlockNumber level, EthBlockNumber index) const;
  bool isNeedToFinalize(EthBlockNumber blk_num) const;
 
  SharedTransaction makeBridgeFinalizationTransaction();
  std::vector<SharedTransaction> makeSystemTransactions(PbftPeriod blk_num);
 
  std::shared_ptr<BlockHeader> makeGenesisHeader(std::string&& raw_header) const;
  std::shared_ptr<BlockHeader> makeGenesisHeader(const h256& state_root) const;
 
  std::shared_ptr<BlockHeader> appendBlock(Batch& batch, const PbftBlock& pbft_blk, const h256& state_root,
                                           u256 total_reward, const SharedTransactions& transactions = {},
                                           const TransactionReceipts& receipts = {});
  std::shared_ptr<BlockHeader> appendBlock(Batch& batch, std::shared_ptr<BlockHeader> header,
                                           const SharedTransactions& transactions = {},
                                           const TransactionReceipts& receipts = {});
 
 private:
  std::shared_ptr<DbStorage> db_;
  const uint64_t kBlockGasLimit;
  StateAPI state_api_;
  const bool kLightNode = false;
  const uint32_t kMaxLevelsPerPeriod;
  rewards::Stats rewards_;
 
  // It is not prepared to use more then 1 thread. Examine it if you want to change threads count
  boost::asio::thread_pool executor_thread_{1};
 
  std::atomic<uint64_t> num_executed_dag_blk_ = 0;
  std::atomic<uint64_t> num_executed_trx_ = 0;
 
  EthBlockNumber delegation_delay_;
 
  ValueByBlockCache<std::shared_ptr<const BlockHeader>> block_headers_cache_;
  ValueByBlockCache<std::optional<const h256>> block_hashes_cache_;
  ValueByBlockCache<const SharedTransactions> transactions_cache_;
  ValueByBlockCache<std::shared_ptr<const TransactionHashes>> transaction_hashes_cache_;
  MapByBlockCache<addr_t, std::optional<const state_api::Account>> accounts_cache_;
 
  ValueByBlockCache<uint64_t> total_vote_count_cache_;
  MapByBlockCache<addr_t, uint64_t> dpos_vote_count_cache_;
  MapByBlockCache<addr_t, uint64_t> dpos_is_eligible_cache_;
 
  std::condition_variable finalized_cv_;
  std::mutex finalized_mtx_;
 
  std::atomic<EthBlockNumber> last_block_number_;
 
  const FullNodeConfig& kConfig;
  LOG_OBJECTS_DEFINE
};
 
}  // namespace taraxa::final_chain