pbft_manager.hpp

Go to the documentation of this file.

#pragma once
 
#include <thread>
 
#include "common/types.hpp"
#include "config/config.hpp"
#include "final_chain/final_chain.hpp"
#include "logger/logger.hpp"
#include "network/network.hpp"
#include "pbft/period_data_queue.hpp"
#include "pbft/proposed_blocks.hpp"
 
namespace taraxa {
 
namespace pillar_chain {
class PillarChainManager;
}
 
class FullNode;
class VoteManager;
 
enum PbftStates { value_proposal_state = 1, filter_state, certify_state, finish_state, finish_polling_state };
enum class PbftStateRootValidation { Valid = 0, Missing, Invalid };
 
class PbftManager {
 public:
  class EligibleWallets {
   public:
    EligibleWallets(const std::vector<WalletConfig> &wallets);
    void updateWalletsEligibility(PbftPeriod period, const std::shared_ptr<final_chain::FinalChain> &final_chain);
    const std::vector<std::pair<bool, WalletConfig>> &getWallets(PbftPeriod current_pbft_period) const;
 
    /*
     * @return period, for which wallets eligibility was updated
     */
    PbftPeriod getWalletsEligiblePeriod() const;
 
   private:
    // Period, for which wallets eligibility is set
    PbftPeriod period_{0};
    std::vector<std::pair<bool /* dpos eligibility flag */, WalletConfig>> wallets_;
  };
 
  struct ProposedBlockData {
    std::shared_ptr<PbftBlock> pbft_block;
    std::vector<std::shared_ptr<PbftVote>> reward_votes;
    std::shared_ptr<PbftVote> vote;
  };
 
  using time_point = std::chrono::system_clock::time_point;
 
 public:
  PbftManager(const FullNodeConfig &conf, std::shared_ptr<DbStorage> db, std::shared_ptr<PbftChain> pbft_chain,
              std::shared_ptr<VoteManager> vote_mgr, std::shared_ptr<DagManager> dag_mgr,
              std::shared_ptr<TransactionManager> trx_mgr, std::shared_ptr<final_chain::FinalChain> final_chain,
              std::shared_ptr<pillar_chain::PillarChainManager> pillar_chain_mgr);
  ~PbftManager();
  PbftManager(const PbftManager &) = delete;
  PbftManager(PbftManager &&) = delete;
  PbftManager &operator=(const PbftManager &) = delete;
  PbftManager &operator=(PbftManager &&) = delete;
 
  void setNetwork(std::weak_ptr<Network> network);
 
  void start();
 
  void stop();
 
  void run();
 
  void initialState();
 
  std::pair<bool, PbftPeriod> getDagBlockPeriod(const blk_hash_t &hash);
 
  PbftPeriod getPbftPeriod() const;
 
  PbftRound getPbftRound() const;
 
  // TODO: exchange round <-> period
  std::pair<PbftRound, PbftPeriod> getPbftRoundAndPeriod() const;
 
  PbftStep getPbftStep() const;
 
  void setPbftRound(PbftRound round);
 
  void setPbftStep(PbftStep pbft_step);
 
  std::optional<ProposedBlockData> generatePbftBlock(PbftPeriod propose_period, const blk_hash_t &prev_blk_hash,
                                                     const blk_hash_t &anchor_hash, const blk_hash_t &order_hash,
                                                     const std::optional<PbftBlockExtraData> &extra_data,
                                                     const std::vector<WalletConfig> &eligible_wallets);
 
  std::optional<uint64_t> getCurrentDposTotalVotesCount() const;
 
  std::optional<uint64_t> getCurrentNodeVotesCount() const;
 
  PbftPeriod pbftSyncingPeriod() const;
 
  size_t periodDataQueueSize() const;
 
  bool periodDataQueueEmpty() const;
 
  void periodDataQueuePush(PeriodData &&period_data, dev::p2p::NodeID const &node_id,
                           std::vector<std::shared_ptr<PbftVote>> &&current_block_cert_votes);
 
  blk_hash_t lastPbftBlockHashFromQueueOrChain();
 
  static blk_hash_t calculateOrderHash(const std::vector<blk_hash_t> &dag_block_hashes);
 
  static blk_hash_t calculateOrderHash(const std::vector<std::shared_ptr<DagBlock>> &dag_blocks);
 
  static void reorderTransactions(SharedTransactions &transactions);
 
  bool checkBlockWeight(const std::vector<std::shared_ptr<DagBlock>> &dag_blocks, PbftPeriod period) const;
 
  blk_hash_t getLastPbftBlockHash();
 
  void processProposedBlock(const std::shared_ptr<PbftBlock> &proposed_block);
 
  std::shared_ptr<PbftBlock> getPbftProposedBlock(PbftPeriod period, const blk_hash_t &block_hash) const;
 
  size_t getPbftCommitteeSize() const { return kGenesisConfig.pbft.committee_size; }
 
  void testBroadcastVotesFunctionality();
 
  void pushSyncedPbftBlocksIntoChain();
 
  // DPOS
  void waitForPeriodFinalization();
 
  bool validatePillarDataInPeriodData(const PeriodData &period_data) const;
 
  void gossipVote(const std::shared_ptr<PbftVote> &vote, const std::shared_ptr<PbftBlock> &voted_block,
                  bool rebroadcast = false);
 
  bool canParticipateInConsensus(PbftPeriod period, const addr_t &node_addr) const;
 
  std::map<PbftPeriod, std::vector<std::shared_ptr<PbftBlock>>> getProposedBlocks() const;
 
 private:
  void broadcastVotes();
 
  bool advanceRound();
 
  bool advancePeriod();
 
  bool tryPushCertVotesBlock();
 
  void resetPbftConsensus(PbftRound round);
 
  std::chrono::milliseconds elapsedTimeInMs(const time_point &start_time);
 
  void sleep_();
 
  void setFilterState_();
 
  void setCertifyState_();
 
  void setFinishState_();
 
  void setFinishPollingState_();
 
  void loopBackFinishState_();
 
  bool stateOperations_();
 
  void proposeBlock_();
 
  void identifyBlock_();
 
  void certifyBlock_();
 
  void firstFinish_();
 
  void secondFinish_();
 
  bool genAndPlaceVote(PbftVoteTypes vote_type, PbftPeriod period, PbftRound round, PbftStep step,
                       const blk_hash_t &block_hash, std::shared_ptr<PbftBlock> pbft_block = nullptr);
 
  bool genAndPlaceProposeVote(const std::shared_ptr<PbftBlock> &proposed_block,
                              std::vector<std::shared_ptr<PbftVote>> &&reward_votes);
 
  void gossipNewOwnVote(const std::shared_ptr<PbftVote> &vote, const std::shared_ptr<PbftBlock> &voted_block);
 
  void gossipNewOwnVotesBundle(const std::vector<std::shared_ptr<PbftVote>> &votes);
 
  std::optional<ProposedBlockData> proposePbftBlock();
 
  std::optional<PbftBlockExtraData> createPbftBlockExtraData(PbftPeriod pbft_period) const;
 
  std::optional<std::pair<std::shared_ptr<PbftBlock>, std::shared_ptr<PbftVote>>> identifyLeaderBlock(
      const ProposedBlocks &propose_blocks, std::vector<std::shared_ptr<PbftVote>> &&propose_votes);
 
  h256 getProposal(const std::shared_ptr<PbftVote> &vote) const;
 
  bool validatePbftBlock(const std::shared_ptr<PbftBlock> &pbft_block) const;
 
  PbftStateRootValidation validateFinalChainHash(const std::shared_ptr<PbftBlock> &pbft_block) const;
 
  bool validatePbftBlockExtraData(const std::shared_ptr<PbftBlock> &pbft_block) const;
 
  bool pushCertVotedPbftBlockIntoChain_(const std::shared_ptr<PbftBlock> &pbft_block,
                                        std::vector<std::shared_ptr<PbftVote>> &&current_round_cert_votes);
 
  void finalize_(PeriodData &&period_data, std::vector<h256> &&finalized_dag_blk_hashes,
                 bool synchronous_processing = false);
 
  bool pushPbftBlock_(PeriodData &&period_data, std::vector<std::shared_ptr<PbftVote>> &&cert_votes);
 
  std::shared_ptr<PbftBlock> getValidPbftProposedBlock(PbftPeriod period, const blk_hash_t &block_hash);
 
  std::optional<std::pair<PeriodData, std::vector<std::shared_ptr<PbftVote>>>> processPeriodData();
 
  bool validatePbftBlockCertVotes(const std::shared_ptr<PbftBlock> pbft_block,
                                  const std::vector<std::shared_ptr<PbftVote>> &cert_votes) const;
 
  bool validatePbftBlockPillarVotes(const PeriodData &period_data) const;
 
  void printVotingSummary() const;
 
  void processPillarBlock(PbftPeriod period);
 
  std::chrono::milliseconds getPbftDeadline(PbftPeriod period) const;
 
  void adjustDynamicLambda(PbftPeriod finalized_period, PbftRound finalized_round);
 
  std::atomic<bool> stopped_ = true;
 
  // Multiple proposed pbft blocks could have same dag block anchor at same period so this cache improves retrieval of
  // dag block order for specific anchor
  mutable std::unordered_map<blk_hash_t, std::vector<std::shared_ptr<DagBlock>>> anchor_dag_block_order_cache_;
 
  std::unique_ptr<std::thread> daemon_;
  std::shared_ptr<DbStorage> db_;
  std::shared_ptr<PbftChain> pbft_chain_;
  std::shared_ptr<VoteManager> vote_mgr_;
  std::shared_ptr<DagManager> dag_mgr_;
  std::weak_ptr<Network> network_;
  std::shared_ptr<TransactionManager> trx_mgr_;
  std::shared_ptr<final_chain::FinalChain> final_chain_;
  std::shared_ptr<pillar_chain::PillarChainManager> pillar_chain_mgr_;
 
  const FullNodeConfig kConfig;
  const uint32_t kSyncingThreadPoolSize;
  std::shared_ptr<util::ThreadPool>
      sync_thread_pool_;  // Thread pool used for transaction sender retrieval in syncing blocks
 
  const std::chrono::milliseconds kMaxExponentialLambda{60000};  // [ms], max lambda is 1 minute
 
  uint32_t rounds_count_dynamic_lambda_{0};  // rounds count per cacti_hf.lambda_change_interval blocks
  uint32_t dynamic_lambda_{0};               // [ms] - dynamic lambda that can be anywhere between <500ms, 1500ms>
  std::chrono::milliseconds current_round_lambda_{0};  // [ms] - current round lambda
 
  const uint32_t kBroadcastVotesLambdaTime = 20;
  const uint32_t kRebroadcastVotesLambdaTime = 60;
  uint32_t broadcast_votes_counter_ = 1;
  uint32_t rebroadcast_votes_counter_ = 1;
  uint32_t broadcast_reward_votes_counter_ = 1;
  uint32_t rebroadcast_reward_votes_counter_ = 1;
 
  PbftStates state_ = value_proposal_state;
  std::atomic<PbftRound> round_ = 1;
  PbftStep step_ = 1;
 
  // Block that node cert voted
  std::optional<std::shared_ptr<PbftBlock>> cert_voted_block_for_round_{};
 
  // All broadcasted votes created by a node in current round - just for summary logging purposes
  std::map<blk_hash_t, std::vector<PbftStep>> current_round_broadcasted_votes_;
 
  time_point current_round_start_datetime_;
  time_point current_period_start_datetime_;
  time_point second_finish_step_start_datetime_;
  std::chrono::milliseconds next_step_time_ms_{0};
 
  bool executed_pbft_block_ = false;
  bool already_next_voted_value_ = false;
  bool already_next_voted_null_block_hash_ = false;
  bool go_finish_state_ = false;
  bool loop_back_finish_state_ = false;
  PbftPeriod last_placed_pillar_vote_period_ = 0;
 
  // Used to avoid cyclic logging in voting steps that are called repeatedly
  bool printSecondFinishStepInfo_ = true;
  bool printCertStepInfo_ = true;
 
  const blk_hash_t dag_genesis_block_hash_;
 
  const GenesisConfig &kGenesisConfig;
 
  std::condition_variable stop_cv_;
  std::mutex stop_mtx_;
 
  PeriodDataQueue sync_queue_;
 
  // Proposed blocks based on received propose votes
  ProposedBlocks proposed_blocks_;
 
  // Wallets with flag if they are/are not dpos eligible for specified period
  EligibleWallets eligible_wallets_;
 
  LOG_OBJECTS_DEFINE
};
 
}  // namespace taraxa