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 {
 
class FullNode;
 
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:
  using time_point = std::chrono::system_clock::time_point;
 
  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<std::pair<std::shared_ptr<PbftBlock>, std::vector<std::shared_ptr<PbftVote>>>> 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);
 
  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();
 
  std::chrono::milliseconds getPbftInitialLambda() const { return kMinLambda; }
 
  static blk_hash_t calculateOrderHash(const std::vector<blk_hash_t> &dag_block_hashes);
 
  static blk_hash_t calculateOrderHash(const std::vector<DagBlock> &dag_blocks);
 
  static void reorderTransactions(SharedTransactions &transactions);
 
  bool checkBlockWeight(const std::vector<DagBlock> &dag_blocks) const;
 
  blk_hash_t getLastPbftBlockHash();
 
  void processProposedBlock(const std::shared_ptr<PbftBlock> &proposed_block,
                            const std::shared_ptr<PbftVote> &propose_vote);
 
  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);
 
 private:
  void broadcastVotes();
 
  void resetStep();
 
  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 placeVote(const std::shared_ptr<PbftVote> &vote, std::string_view log_vote_id,
                 const std::shared_ptr<PbftBlock> &voted_block);
 
  bool genAndPlaceProposeVote(const std::shared_ptr<PbftBlock> &proposed_block,
                              std::vector<std::shared_ptr<PbftVote>> &&reward_votes);
 
  void gossipNewVote(const std::shared_ptr<PbftVote> &vote, const std::shared_ptr<PbftBlock> &voted_block);
 
  std::optional<std::pair<std::shared_ptr<PbftBlock>, std::vector<std::shared_ptr<PbftVote>>>> proposePbftBlock();
 
  std::optional<PbftBlockExtraData> createPbftBlockExtraData(PbftPeriod pbft_period) const;
 
  // TODO: exchange round <-> period
  std::shared_ptr<PbftBlock> identifyLeaderBlock_(PbftRound round, PbftPeriod period);
 
  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;
 
  bool canParticipateInConsensus(PbftPeriod period) const;
 
  void printVotingSummary() const;
 
  void processPillarBlock(PbftPeriod period);
 
  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<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 addr_t node_addr_;
  const secret_t node_sk_;
 
  const std::chrono::milliseconds kMinLambda;         // [ms]
  std::chrono::milliseconds lambda_{0};               // [ms]
  const std::chrono::milliseconds kMaxLambda{60000};  // in ms, max lambda is 1 minutes
 
  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_;
 
  LOG_OBJECTS_DEFINE
};
 
}  // namespace taraxa