vote_graph_impl.hpp

Go to the documentation of this file.

#ifndef KAGOME_CORE_CONSENSUS_GRANDPA_VOTE_GRAPH_VOTE_GRAPH_IMPL_HPP
#define KAGOME_CORE_CONSENSUS_GRANDPA_VOTE_GRAPH_VOTE_GRAPH_IMPL_HPP

#include "consensus/grandpa/vote_graph.hpp"

#include <numeric>
#include <unordered_map>
#include <unordered_set>

namespace kagome::consensus::grandpa {

  class VoteGraphImpl : public VoteGraph {
   public:
    VoteGraphImpl(const BlockInfo &base,
                  std::shared_ptr<VoterSet> voter_set,
                  std::shared_ptr<Chain> chain);

    void adjustBase(const std::vector<BlockHash> &ancestry_proof) override;

    outcome::result<void> insert(VoteType vote_type,
                                 const BlockInfo &block,
                                 const Id &voter) override;

    void remove(VoteType vote_type, const Id &voter) override;

    std::optional<BlockInfo> findAncestor(
        VoteType vote_type,
        const BlockInfo &block,
        const Condition &condition) const override;

    std::optional<BlockInfo> findGhost(
        VoteType vote_type,
        const std::optional<BlockInfo> &current_best,
        const Condition &condition) const override;

    // introduce a branch to given vote-nodes.
    //
    // `descendants` is a list of nodes with ancestor-edges containing the given
    // ancestor.
    //
    // This function panics if any member of `descendants` is not a vote-node
    // or does not have ancestor with given hash and number OR if
    // `ancestor_hash` is already a known entry.
    void introduceBranch(const std::vector<primitives::BlockHash> &descendants,
                         const BlockInfo &ancestor);

    // append a vote-node onto the chain-tree. This should only be called if
    // no node in the tree keeps the target anyway.
    outcome::result<void> append(const BlockInfo &block);

    // given a key, node pair (which must correspond), assuming this node
    // fulfills the condition, this function will find the highest point at
    // which its descendants merge, which may be the node itself.
    Subchain ghostFindMergePoint(
        VoteType vote_type,
        const BlockHash &active_node_hash,
        const Entry &active_node,
        const std::optional<BlockInfo> &force_constrain,
        const Condition &condition) const;

    // attempts to find the containing node keys for the given hash and number.
    //
    // returns `None` if there is a node by that key already, and a vector
    // (potentially empty) of nodes with the given block in its ancestor-edge
    // otherwise.
    std::optional<std::vector<primitives::BlockHash>> findContainingNodes(
        const BlockInfo &block) const;

    const BlockInfo &getBase() const override {
      return base_;
    }

    const auto &getEntries() const {
      return entries_;
    }

    const auto &getHeads() const {
      return heads_;
    }

   private:
    BlockInfo base_;
    std::shared_ptr<VoterSet> voter_set_;
    std::shared_ptr<Chain> chain_;
    log::Logger logger_;

    std::unordered_map<BlockHash, Entry> entries_;
    std::unordered_set<BlockHash> heads_;
  };

}  // namespace kagome::consensus::grandpa

#endif  // KAGOME_CORE_CONSENSUS_GRANDPA_VOTE_GRAPH_VOTE_GRAPH_IMPL_HPP