environment.hpp

Go to the documentation of this file.

#ifndef KAGOME_CORE_CONSENSUS_GRANDPA_ENVIRONMENT_HPP
#define KAGOME_CORE_CONSENSUS_GRANDPA_ENVIRONMENT_HPP

#include "consensus/grandpa/chain.hpp"

#include <functional>
#include <memory>

#include "consensus/grandpa/common.hpp"
#include "consensus/grandpa/movable_round_state.hpp"
#include "consensus/grandpa/structs.hpp"
#include "primitives/block_id.hpp"

namespace kagome::blockchain {
  class BlockHeaderRepository;
  class BlockTree;
}  // namespace kagome::blockchain

namespace kagome::primitives {
  struct Justification;
}
namespace libp2p::peer {
  class PeerId;
}
namespace kagome::consensus::grandpa {
  struct JustificationObserver;
}

namespace kagome::consensus::grandpa {

  class Grandpa;

  struct Environment : public virtual Chain {
    using CompleteHandler =
        std::function<void(outcome::result<MovableRoundState>)>;

    ~Environment() override = default;

    virtual void setJustificationObserver(
        std::weak_ptr<JustificationObserver> justification_observer) = 0;

    virtual outcome::result<void> onCatchUpRequested(
        const libp2p::peer::PeerId &peer_id,
        VoterSetId set_id,
        RoundNumber round_number) = 0;

    virtual outcome::result<void> onCatchUpRespond(
        const libp2p::peer::PeerId &peer_id,
        VoterSetId set_id,
        RoundNumber round_number,
        std::vector<SignedPrevote> prevote_justification,
        std::vector<SignedPrecommit> precommit_justification,
        BlockInfo best_final_candidate) = 0;

    virtual void sendState(const libp2p::peer::PeerId &peer_id,
                           const MovableRoundState &state,
                           VoterSetId voter_set_id) = 0;

    virtual outcome::result<void> onVoted(RoundNumber round,
                                          VoterSetId set_id,
                                          const SignedMessage &vote) = 0;

    virtual outcome::result<void> onCommitted(
        RoundNumber round,
        VoterSetId voter_ser_id,
        const BlockInfo &vote,
        const GrandpaJustification &justification) = 0;

    virtual outcome::result<void> onNeighborMessageSent(
        RoundNumber round, VoterSetId set_id, BlockNumber last_finalized) = 0;

    virtual outcome::result<void> applyJustification(
        const BlockInfo &block_info,
        const primitives::Justification &justification) = 0;

    virtual outcome::result<void> finalize(
        VoterSetId id, const GrandpaJustification &justification) = 0;

    virtual outcome::result<GrandpaJustification> getJustification(
        const BlockHash &block_hash) = 0;
  };

}  // namespace kagome::consensus::grandpa

#endif  // KAGOME_CORE_CONSENSUS_GRANDPA_ENVIRONMENT_HPP