dag_block_proposer.hpp

Go to the documentation of this file.

#pragma once
 
#include <atomic>
#include <thread>
#include <vector>
 
#include "dag/dag_block.hpp"
#include "logger/logging.hpp"
#include "network/network.hpp"
 
namespace taraxa {
 
class TransactionManager;
class KeyManager;
class DagManager;
struct FullNodeConfig;
 
namespace final_chain {
class FinalChain;
}
 
class DagBlockProposer {
 public:
  struct NodeDagProposerData {
    NodeDagProposerData(const WalletConfig& wallet, const uint16_t max_tries, const uint16_t shard)
        : wallet(wallet),
          max_num_tries(max_tries + (wallet.node_addr[0] % (10 * max_tries))),
          trx_shard(std::stoull(wallet.node_addr.toString().substr(0, 6).c_str(), NULL, 16) % shard) {}
 
    const WalletConfig wallet;
 
    // Add a random component in proposing stale blocks so that not all nodes propose stale blocks at the same time
    // This will make stale block be proposed after waiting random interval between 2 and 20 seconds
    const uint16_t max_num_tries;
    const uint16_t trx_shard;
 
    uint16_t num_tries{0};
    uint64_t last_propose_level{0};
  };
 
 public:
  DagBlockProposer(const FullNodeConfig& config, std::shared_ptr<DagManager> dag_mgr,
                   std::shared_ptr<TransactionManager> trx_mgr, std::shared_ptr<final_chain::FinalChain> final_chain,
                   std::shared_ptr<DbStorage> db, std::shared_ptr<KeyManager> key_manager);
  ~DagBlockProposer() { stop(); }
  DagBlockProposer(const DagBlockProposer&) = delete;
  DagBlockProposer(DagBlockProposer&&) = delete;
  DagBlockProposer& operator=(const DagBlockProposer&) = delete;
  DagBlockProposer& operator=(DagBlockProposer&&) = delete;
 
  void start();
 
  void stop();
 
  bool proposeDagBlock();
 
  void setNetwork(std::weak_ptr<Network> network);
 
  uint64_t getProposedBlocksCount() const { return proposed_blocks_count_; }
 
  vec_blk_t selectDagBlockTips(const vec_blk_t& frontier_tips, uint64_t gas_limit) const;
 
 private:
  std::shared_ptr<DagBlock> createDagBlock(DagFrontier&& frontier, level_t level, const SharedTransactions& trxs,
                                           std::vector<uint64_t>&& estimations, VdfSortition&& vdf,
                                           const dev::Secret& node_secret) const;
 
  std::pair<SharedTransactions, std::vector<uint64_t>> getShardedTrxs(PbftPeriod proposal_period, uint64_t weight_limit,
                                                                      const uint16_t node_trx_shard) const;
 
  level_t getProposeLevel(blk_hash_t const& pivot, vec_blk_t const& tips) const;
 
  bool isValidDposProposer(PbftPeriod propose_period, const addr_t& node_addr) const;
 
 private:
  const uint16_t max_num_tries_{20};  // Wait 2000(ms)
                                      //  uint16_t num_tries_{0};
                                      //  uint64_t last_propose_level_{0};
  util::ThreadPool executor_{1};
 
  std::atomic<uint64_t> proposed_blocks_count_{0};
  std::atomic<bool> stopped_{true};
 
  const uint16_t total_trx_shards_;
 
  std::shared_ptr<DagManager> dag_mgr_;
  std::shared_ptr<TransactionManager> trx_mgr_;
  std::shared_ptr<final_chain::FinalChain> final_chain_;
  std::shared_ptr<KeyManager> key_manager_;
  std::shared_ptr<DbStorage> db_;
  std::shared_ptr<std::thread> proposer_worker_;
  std::weak_ptr<Network> network_;
 
  std::vector<NodeDagProposerData> nodes_dag_proposers_data_;
 
  const uint64_t kDagProposeGasLimit;
  const uint64_t kPbftGasLimit;
  const uint64_t kDagGasLimit;
 
  const HardforksConfig kHardforks;
  const uint64_t kValidatorMaxVote;
  const uint64_t kShardProposePeriodInterval = 10;
 
  logger::Logger logger_;
};
 
}  // namespace taraxa