vote_graph.hpp

Go to the documentation of this file.

#ifndef KAGOME_CORE_CONSENSUS_GRANDPA_VOTE_GRAPH_HPP
#define KAGOME_CORE_CONSENSUS_GRANDPA_VOTE_GRAPH_HPP

#include <boost/operators.hpp>

#include "consensus/grandpa/chain.hpp"
#include "consensus/grandpa/vote_types.hpp"
#include "consensus/grandpa/vote_weight.hpp"

namespace kagome::consensus::grandpa {

  struct VoteGraph {
    // graph entry
    struct Entry : public boost::equality_comparable<Entry> {
      BlockNumber number{};
      std::vector<BlockHash> ancestors{};
      std::vector<BlockHash> descendants{};
      VoteWeight cumulative_vote;

      bool operator==(const Entry &o) const {
        // clang-format off
        return number == o.number
               && ancestors == o.ancestors
               && descendants == o.descendants
               && cumulative_vote == o.cumulative_vote;
        // clang-format on
      }

      // Get ancestor block by number. Returns `None` if there is no block
      // by that number in the direct ancestry.
      std::optional<BlockHash> getAncestorBlockBy(BlockNumber n) const {
        if (n >= number) {
          return std::nullopt;
        }
        const auto offset = number - n - 1u;
        if (offset >= ancestors.size()) {
          return std::nullopt;
        }
        return ancestors[offset];
      }
    };

    struct Subchain {
      std::vector<BlockHash> hashes;
      BlockNumber best_number;
    };

    virtual ~VoteGraph() = default;

    using Condition = std::function<bool(const VoteWeight &)>;
    using Comparator =
        std::function<bool(const VoteWeight &, const VoteWeight &)>;

    virtual const BlockInfo &getBase() const = 0;

    virtual void adjustBase(const std::vector<BlockHash> &ancestry_proof) = 0;

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

    virtual void remove(VoteType vote_type, const Id &voter) = 0;

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

    virtual std::optional<BlockInfo> findGhost(
        VoteType vote_type,
        const std::optional<BlockInfo> &current_best,
        const Condition &condition) const = 0;
  };

}  // namespace kagome::consensus::grandpa

#endif  // KAGOME_CORE_CONSENSUS_GRANDPA_VOTE_GRAPH_HPP