pillar_chain_manager.hpp

Go to the documentation of this file.

#pragma once
 
#include <memory>
 
#include "common/event.hpp"
#include "final_chain/data.hpp"
#include "logger/logging.hpp"
#include "pillar_chain/pillar_block.hpp"
#include "pillar_chain/pillar_votes.hpp"
 
namespace taraxa {
class DbStorage;
class Network;
class KeyManager;
struct FicusHardforkConfig;
}  // namespace taraxa
 
namespace taraxa::final_chain {
class FinalChain;
}
 
namespace taraxa::pillar_chain {
 
class PillarChainManager {
 private:
  const util::EventEmitter<const PillarBlockData&> pillar_block_finalized_emitter_{};
 
 public:
  const decltype(pillar_block_finalized_emitter_)::Subscriber& pillar_block_finalized_ =
      pillar_block_finalized_emitter_;
 
 public:
  PillarChainManager(const FicusHardforkConfig& ficus_hf_config, std::shared_ptr<DbStorage> db,
                     std::shared_ptr<final_chain::FinalChain> final_chain, std::shared_ptr<KeyManager> key_manager);
 
  std::shared_ptr<PillarBlock> createPillarBlock(PbftPeriod period,
                                                 const std::shared_ptr<const final_chain::BlockHeader>& block_header,
                                                 const h256& bridge_root, const h256& bridge_epoch);
 
  std::shared_ptr<PillarVote> genAndPlacePillarVote(PbftPeriod period, const blk_hash_t& pillar_block_hash,
                                                    const secret_t& node_sk, bool broadcast_vote);
 
  void setNetwork(std::weak_ptr<Network> network);
 
  bool isRelevantPillarVote(const std::shared_ptr<PillarVote> vote) const;
 
  bool validatePillarVote(const std::shared_ptr<PillarVote> vote) const;
 
  bool isPillarBlockLatestFinalized(const blk_hash_t& block_hash) const;
 
  std::shared_ptr<PillarBlock> getLastFinalizedPillarBlock() const;
 
  uint64_t addVerifiedPillarVote(const std::shared_ptr<PillarVote>& vote);
 
  std::vector<std::shared_ptr<PillarVote>> finalizePillarBlock(const blk_hash_t& pillar_block_hash);
 
  std::shared_ptr<PillarBlock> getCurrentPillarBlock() const;
 
  std::vector<std::shared_ptr<PillarVote>> getVerifiedPillarVotes(PbftPeriod period, const blk_hash_t pillar_block_hash,
                                                                  bool above_threshold = false) const;
 
  bool isValidPillarBlock(const std::shared_ptr<PillarBlock>& pillar_block) const;
 
  std::optional<uint64_t> getPillarConsensusThreshold(PbftPeriod period) const;
 
 private:
  std::vector<PillarBlock::ValidatorVoteCountChange> getOrderedValidatorsVoteCountsChanges(
      const std::vector<state_api::ValidatorVoteCount>& current_vote_counts,
      const std::vector<state_api::ValidatorVoteCount>& previous_pillar_block_vote_counts);
 
  void saveNewPillarBlock(const std::shared_ptr<PillarBlock>& pillar_block,
                          std::vector<state_api::ValidatorVoteCount>&& new_vote_counts);
 
 private:
  // Node config
  const FicusHardforkConfig& kFicusHfConfig;
 
  std::shared_ptr<DbStorage> db_;
  std::weak_ptr<Network> network_;
  std::shared_ptr<final_chain::FinalChain> final_chain_;
  std::shared_ptr<KeyManager> key_manager_;
 
  // Last finalized pillar block - saved into db together with > threshold votes
  std::shared_ptr<PillarBlock> last_finalized_pillar_block_;
  // Current pillar block
  std::shared_ptr<PillarBlock> current_pillar_block_;
  // Full list of validators vote counts for tbe current pillar block period - no concurrent access protection needed
  std::vector<state_api::ValidatorVoteCount> current_pillar_block_vote_counts_;
 
  // Pillar votes for latest_pillar_block_.period - 1, latest_pillar_block_.period and potential +1 future pillar
  // block period
  PillarVotes pillar_votes_;
 
  // Protects last_finalized_pillar_block_ & current_pillar_block_
  mutable std::shared_mutex mutex_;
 
  logger::Logger logger_;
};
 
}  // namespace taraxa::pillar_chain