vote_manager.hpp

Go to the documentation of this file.

#pragma once
 
#include "common/util.hpp"
#include "common/vrf_wrapper.hpp"
#include "final_chain/final_chain.hpp"
#include "key_manager/key_manager.hpp"
#include "pbft/pbft_chain.hpp"
#include "vote/pbft_vote.hpp"
#include "vote_manager/verified_votes.hpp"
 
namespace taraxa {
 
class Network;
class SlashingManager;
class PbftVote;
struct PbftConfig;
struct FullNodeConfig;
 
namespace network::tarcap {
class TaraxaPeer;
}
 
class VoteManager {
 public:
  VoteManager(const FullNodeConfig& config, std::shared_ptr<DbStorage> db, std::shared_ptr<PbftChain> pbft_chain,
              std::shared_ptr<final_chain::FinalChain> final_chain, std::shared_ptr<KeyManager> key_manager,
              std::shared_ptr<SlashingManager> slashing_manager);
  ~VoteManager() = default;
  VoteManager(const VoteManager&) = delete;
  VoteManager(VoteManager&&) = delete;
  VoteManager& operator=(const VoteManager&) = delete;
  VoteManager& operator=(VoteManager&&) = delete;
 
  void setNetwork(std::weak_ptr<Network> network);
 
  bool addVerifiedVote(const std::shared_ptr<PbftVote>& vote);
 
  bool voteInVerifiedMap(std::shared_ptr<PbftVote> const& vote) const;
 
  std::pair<bool, std::shared_ptr<PbftVote>> isUniqueVote(const std::shared_ptr<PbftVote>& vote) const;
 
  std::vector<std::shared_ptr<PbftVote>> getVerifiedVotes() const;
 
  uint64_t getVerifiedVotesSize() const;
 
  void cleanupVotesByPeriod(PbftPeriod pbft_period);
 
  std::vector<std::shared_ptr<PbftVote>> getProposalVotes(PbftPeriod period, PbftRound round) const;
 
  std::optional<PbftRound> determineNewRound(PbftPeriod current_pbft_period, PbftRound current_pbft_round);
 
  void resetRewardVotes(PbftPeriod period, PbftRound round, PbftStep step, const blk_hash_t& block_hash, Batch& batch);
 
  std::pair<bool, std::vector<std::shared_ptr<PbftVote>>> checkRewardVotes(const std::shared_ptr<PbftBlock>& pbft_block,
                                                                           bool copy_votes);
 
  std::vector<std::shared_ptr<PbftVote>> getRewardVotes();
 
  PbftPeriod getRewardVotesPbftBlockPeriod();
 
  void saveOwnVerifiedVote(const std::shared_ptr<PbftVote>& vote);
 
  std::vector<std::shared_ptr<PbftVote>> getOwnVerifiedVotes();
 
  void clearOwnVerifiedVotes(Batch& write_batch);
 
  std::shared_ptr<PbftVote> generateVoteWithWeight(const blk_hash_t& blockhash, PbftVoteTypes vote_type,
                                                   PbftPeriod period, PbftRound round, PbftStep step);
 
  std::shared_ptr<PbftVote> generateVote(const blk_hash_t& blockhash, PbftVoteTypes type, PbftPeriod period,
                                         PbftRound round, PbftStep step);
 
  std::pair<bool, std::string> validateVote(const std::shared_ptr<PbftVote>& vote, bool strict = true) const;
 
  std::optional<uint64_t> getPbftTwoTPlusOne(PbftPeriod pbft_period, PbftVoteTypes vote_type) const;
 
  bool voteAlreadyValidated(const vote_hash_t& vote_hash) const;
 
  bool genAndValidateVrfSortition(PbftPeriod pbft_period, PbftRound pbft_round) const;
 
  std::optional<blk_hash_t> getTwoTPlusOneVotedBlock(PbftPeriod period, PbftRound round,
                                                     TwoTPlusOneVotedBlockType type) const;
 
  std::vector<std::shared_ptr<PbftVote>> getTwoTPlusOneVotedBlockVotes(PbftPeriod period, PbftRound round,
                                                                       TwoTPlusOneVotedBlockType type) const;
 
  void setCurrentPbftPeriodAndRound(PbftPeriod pbft_period, PbftRound pbft_round);
 
  PbftStep getNetworkTplusOneNextVotingStep(PbftPeriod period, PbftRound round) const;
 
 private:
  bool isValidRewardVote(const std::shared_ptr<PbftVote>& vote) const;
 
  std::pair<bool, std::shared_ptr<PbftVote>> insertUniqueVote(const std::shared_ptr<PbftVote>& vote);
 
  uint64_t getPbftSortitionThreshold(uint64_t total_dpos_votes_count, PbftVoteTypes vote_type) const;
 
 private:
  const addr_t kNodeAddr;
  const PbftConfig& kPbftConfig;
  const vrf_wrapper::vrf_sk_t kVrfSk;
  const secret_t kNodeSk;
  const dev::Public kNodePub;
 
  std::shared_ptr<DbStorage> db_;
  std::shared_ptr<PbftChain> pbft_chain_;
  std::shared_ptr<final_chain::FinalChain> final_chain_;
  std::shared_ptr<KeyManager> key_manager_;
  std::weak_ptr<Network> network_;
  std::shared_ptr<SlashingManager> slashing_manager_;
 
  // Current pbft period based on pbft_manager
  std::atomic<PbftPeriod> current_pbft_period_{0};
  // Current pbft round based on pbft_manager
  std::atomic<PbftRound> current_pbft_round_{0};
 
  // Main storage for all verified votes
  std::map<PbftPeriod, std::map<PbftRound, VerifiedVotes>> verified_votes_;
  mutable std::shared_mutex verified_votes_access_;
 
  // Reward votes related info
  blk_hash_t reward_votes_block_hash_;
  PbftRound reward_votes_period_;
  PbftRound reward_votes_round_;
  std::vector<vote_hash_t> extra_reward_votes_;
  mutable std::shared_mutex reward_votes_info_mutex_;
 
  // Own votes generated during current period & round
  std::vector<std::shared_ptr<PbftVote>> own_verified_votes_;
 
  // Cache for current 2T+1 - <Vote type, <period, two_t_plus_one for period>>
  // !!! Important: do not access it directly as it is not updated automatically, always call getPbftTwoTPlusOne instead
  // !!!
  mutable std::unordered_map<PbftVoteTypes, std::pair<PbftPeriod, uint64_t>> current_two_t_plus_one_;
  mutable std::shared_mutex current_two_t_plus_one_mutex_;
 
  // Votes that have been already validated in terms of signature, stake, etc...
  // It is used as protection against ddos attack so we do no validate/process vote more than once
  mutable ExpirationCache<vote_hash_t> already_validated_votes_;
 
  LOG_OBJECTS_DEFINE
};
 
}  // namespace taraxa