dag_manager.hpp

Go to the documentation of this file.

#pragma once
 
#include "common/thread_pool.hpp"
#include "dag.hpp"
#include "dag/dag_block.hpp"
#include "pbft/pbft_chain.hpp"
#include "sortition_params_manager.hpp"
#include "storage/storage.hpp"
#include "transaction/transaction_manager.hpp"
 
namespace taraxa {
 
class Network;
class KeyManager;
struct DagConfig;
 
class DagManager : public std::enable_shared_from_this<DagManager> {
 public:
  enum class VerifyBlockReturnType : uint32_t {
    Verified = 0,
    MissingTransaction,
    AheadBlock,
    FailedVdfVerification,
    FutureBlock,
    NotEligible,
    ExpiredBlock,
    IncorrectTransactionsEstimation,
    BlockTooBig,
    FailedTipsVerification,
    MissingTip
  };
 
  explicit DagManager(const FullNodeConfig &config, std::shared_ptr<TransactionManager> trx_mgr,
                      std::shared_ptr<PbftChain> pbft_chain, std::shared_ptr<final_chain::FinalChain> final_chain,
                      std::shared_ptr<DbStorage> db, std::shared_ptr<KeyManager> key_manager);
 
  DagManager(const DagManager &) = delete;
  DagManager(DagManager &&) = delete;
  DagManager &operator=(const DagManager &) = delete;
  DagManager &operator=(DagManager &&) = delete;
 
  std::shared_ptr<DagManager> getShared();
 
  void setNetwork(std::weak_ptr<Network> network) { network_ = std::move(network); }
 
  bool isDagBlockKnown(const blk_hash_t &hash) const;
 
  std::shared_ptr<DagBlock> getDagBlock(const blk_hash_t &hash) const;
 
  std::pair<VerifyBlockReturnType, SharedTransactions> verifyBlock(
      const std::shared_ptr<DagBlock> &blk,
      const std::unordered_map<trx_hash_t, std::shared_ptr<Transaction>> &trxs = {});
 
  std::pair<bool, std::vector<blk_hash_t>> pivotAndTipsAvailable(const std::shared_ptr<DagBlock> &blk);
 
  std::pair<bool, std::vector<blk_hash_t>> addDagBlock(const std::shared_ptr<DagBlock> &blk,
                                                       SharedTransactions &&trxs = {}, bool proposed = false,
                                                       bool save = true);  // insert to buffer if fail
 
  vec_blk_t getDagBlockOrder(blk_hash_t const &anchor, PbftPeriod period);
 
  uint setDagBlockOrder(blk_hash_t const &anchor, PbftPeriod period, vec_blk_t const &dag_order);
 
  std::optional<std::pair<blk_hash_t, std::vector<blk_hash_t>>> getLatestPivotAndTips() const;
 
  std::vector<blk_hash_t> getGhostPath(const blk_hash_t &source) const;
 
  std::vector<blk_hash_t> getGhostPath() const;  // get ghost path from last anchor
 
  // ----- Total graph
  void drawTotalGraph(std::string const &str) const;
 
  // ----- Pivot graph
  // can return self as pivot chain
  void drawPivotGraph(std::string const &str) const;
  void drawGraph(std::string const &dotfile) const;
 
  std::pair<uint64_t, uint64_t> getNumVerticesInDag() const;
  std::pair<uint64_t, uint64_t> getNumEdgesInDag() const;
  level_t getMaxLevel() const { return max_level_; }
 
  // DAG anchors
  PbftPeriod getLatestPeriod() const {
    std::shared_lock lock(mutex_);
    return period_;
  }
  std::pair<blk_hash_t, blk_hash_t> getAnchors() const {
    std::shared_lock lock(mutex_);
    return std::make_pair(old_anchor_, anchor_);
  }
 
  uint32_t getDagExpiryLimit() const { return dag_expiry_limit_; }
 
  const std::pair<PbftPeriod, std::map<uint64_t, std::unordered_set<blk_hash_t>>> getNonFinalizedBlocks() const;
 
  const std::tuple<PbftPeriod, std::vector<std::shared_ptr<DagBlock>>, SharedTransactions>
  getNonFinalizedBlocksWithTransactions(const std::unordered_set<blk_hash_t> &known_hashes) const;
 
  DagFrontier getDagFrontier();
 
  std::pair<size_t, size_t> getNonFinalizedBlocksSize() const;
 
  uint32_t getNonFinalizedBlocksMinDifficulty() const;
 
  util::Event<DagManager, std::shared_ptr<DagBlock>> const block_verified_{};
 
  std::shared_mutex &getDagMutex() { return mutex_; }
 
  SortitionParamsManager &sortitionParamsManager() { return sortition_params_manager_; }
 
  const DagConfig &getDagConfig() const { return dag_config_; }
 
  uint64_t getDagExpiryLevel() { return dag_expiry_level_; }
 
  static dev::bytes getVdfMessage(blk_hash_t const &hash, SharedTransactions const &trxs);
 
  static dev::bytes getVdfMessage(blk_hash_t const &hash, std::vector<trx_hash_t> const &trx_hashes);
 
  void clearLightNodeHistory(uint64_t light_node_history);
 
 private:
  void recoverDag();
  void addToDag(blk_hash_t const &hash, blk_hash_t const &pivot, std::vector<blk_hash_t> const &tips, uint64_t level,
                bool finalized = false);
  bool validateBlockNotExpired(const std::shared_ptr<DagBlock> &dag_block,
                               std::unordered_map<blk_hash_t, std::shared_ptr<DagBlock>> &expired_dag_blocks_to_remove);
  void handleExpiredDagBlocksTransactions(const std::vector<trx_hash_t> &transactions_from_expired_dag_blocks) const;
 
  std::pair<blk_hash_t, std::vector<blk_hash_t>> getFrontier() const;  // return pivot and tips
  void updateFrontier();
  std::atomic<level_t> max_level_ = 0;
  mutable std::shared_mutex mutex_;
  mutable std::shared_mutex order_dag_blocks_mutex_;
  std::shared_ptr<PivotTree> pivot_tree_;  // only contains pivot edges
  std::shared_ptr<Dag> total_dag_;         // contains both pivot and tips
  std::shared_ptr<TransactionManager> trx_mgr_;
  std::shared_ptr<PbftChain> pbft_chain_;
  std::weak_ptr<Network> network_;
  std::shared_ptr<DbStorage> db_;
  std::shared_ptr<KeyManager> key_manager_;
  blk_hash_t anchor_;      // anchor of the last period
  blk_hash_t old_anchor_;  // anchor of the second to last period
  PbftPeriod period_;      // last period
  std::map<uint64_t, std::unordered_set<blk_hash_t>> non_finalized_blks_;
  uint32_t non_finalized_blks_min_difficulty_ = UINT32_MAX;
  DagFrontier frontier_;
  SortitionParamsManager sortition_params_manager_;
  const DagConfig &dag_config_;
  const std::shared_ptr<DagBlock> genesis_block_;
  const uint32_t max_levels_per_period_;
  const uint32_t dag_expiry_limit_;  // Any non finalized dag block with a level smaller by
  // dag_expiry_limit_ than the current period anchor level is considered
  // expired and it should be ignored or removed from DAG
 
  std::atomic_uint64_t dag_expiry_level_ =
      0;  // Level below which dag blocks are considered expired, it's value is
          // always current anchor level minus dag_expiry_limit_ of non empty pbft periods
 
  const uint32_t cache_max_size_ = 10000;
  const uint32_t cache_delete_step_ = 100;
  ExpirationCacheMap<blk_hash_t, std::shared_ptr<DagBlock>> seen_blocks_;
  std::shared_ptr<final_chain::FinalChain> final_chain_;
  const GenesisConfig kGenesis;
  const uint64_t kValidatorMaxVote;
 
  logger::Logger logger_;
};
 
}  // namespace taraxa