grandpa_impl.hpp

Go to the documentation of this file.

#ifndef KAGOME_CONSENSUS_GRANDPA_GRANDPAIMPL
#define KAGOME_CONSENSUS_GRANDPA_GRANDPAIMPL

#include "consensus/grandpa/grandpa.hpp"
#include "consensus/grandpa/grandpa_observer.hpp"

#include <boost/operators.hpp>

#include "application/app_state_manager.hpp"
#include "application/chain_spec.hpp"
#include "blockchain/block_tree.hpp"
#include "consensus/authority/authority_manager.hpp"
#include "consensus/grandpa/environment.hpp"
#include "consensus/grandpa/impl/voting_round_impl.hpp"
#include "consensus/grandpa/movable_round_state.hpp"
#include "consensus/grandpa/voter_set.hpp"
#include "crypto/ed25519_provider.hpp"
#include "crypto/hasher.hpp"
#include "log/logger.hpp"
#include "metrics/metrics.hpp"
#include "network/peer_manager.hpp"
#include "network/reputation_repository.hpp"
#include "network/synchronizer.hpp"
#include "runtime/runtime_api/grandpa_api.hpp"

namespace kagome::consensus::grandpa {

  // clang-format off
  // clang-format on

  class GrandpaImpl : public Grandpa,
                      public GrandpaObserver,
                      public std::enable_shared_from_this<GrandpaImpl> {
   public:
    static const size_t kCatchUpThreshold = 2;

    static const size_t kKeepRecentRounds = 3;

    static constexpr Clock::Duration kCatchupRequestTimeout =
        std::chrono::milliseconds(45'000);

    ~GrandpaImpl() override = default;

    GrandpaImpl(
        std::shared_ptr<application::AppStateManager> app_state_manager,
        std::shared_ptr<Environment> environment,
        std::shared_ptr<crypto::Ed25519Provider> crypto_provider,
        std::shared_ptr<runtime::GrandpaApi> grandpa_api,
        const std::shared_ptr<crypto::Ed25519Keypair> &keypair,
        const application::ChainSpec &chain_spec,
        std::shared_ptr<Clock> clock,
        std::shared_ptr<libp2p::basic::Scheduler> scheduler,
        std::shared_ptr<authority::AuthorityManager> authority_manager,
        std::shared_ptr<network::Synchronizer> synchronizer,
        std::shared_ptr<network::PeerManager> peer_manager,
        std::shared_ptr<blockchain::BlockTree> block_tree,
        std::shared_ptr<network::ReputationRepository> reputation_repository);

    bool prepare();

    bool start();

    void stop();

    void onNeighborMessage(const libp2p::peer::PeerId &peer_id,
                           const network::GrandpaNeighborMessage &msg) override;

    // Catch-up methods

    void onCatchUpRequest(const libp2p::peer::PeerId &peer_id,
                          const network::CatchUpRequest &msg) override;

    void onCatchUpResponse(const libp2p::peer::PeerId &peer_id,
                           const network::CatchUpResponse &msg) override;

    // Voting methods

    void onVoteMessage(const libp2p::peer::PeerId &peer_id,
                       const network::VoteMessage &msg) override;

    void onCommitMessage(const libp2p::peer::PeerId &peer_id,
                         const network::FullCommitMessage &msg) override;

    outcome::result<void> applyJustification(
        const BlockInfo &block_info,
        const GrandpaJustification &justification) override;

    // Round processing method

    void tryExecuteNextRound(
        const std::shared_ptr<VotingRound> &round) override;

    void updateNextRound(RoundNumber round_number) override;

   private:
    std::optional<std::shared_ptr<VotingRound>> selectRound(
        RoundNumber round_number, std::optional<VoterSetId> voter_set_id);

    outcome::result<MovableRoundState> getLastCompletedRound() const;

    std::shared_ptr<VotingRound> makeInitialRound(
        const MovableRoundState &round_state, std::shared_ptr<VoterSet> voters);

    std::shared_ptr<VotingRound> makeNextRound(
        const std::shared_ptr<VotingRound> &previous_round);

    void loadMissingBlocks();

    const Clock::Duration round_time_factor_;

    std::shared_ptr<Environment> environment_;
    std::shared_ptr<crypto::Ed25519Provider> crypto_provider_;
    std::shared_ptr<runtime::GrandpaApi> grandpa_api_;
    const std::shared_ptr<crypto::Ed25519Keypair> &keypair_;
    std::shared_ptr<Clock> clock_;
    std::shared_ptr<libp2p::basic::Scheduler> scheduler_;
    std::shared_ptr<authority::AuthorityManager> authority_manager_;
    std::shared_ptr<network::Synchronizer> synchronizer_;
    std::shared_ptr<network::PeerManager> peer_manager_;
    std::shared_ptr<blockchain::BlockTree> block_tree_;
    std::shared_ptr<network::ReputationRepository> reputation_repository_;

    std::shared_ptr<VotingRound> current_round_;
    std::optional<
        const std::tuple<libp2p::peer::PeerId, network::CatchUpRequest>>
        pending_catchup_request_;
    libp2p::basic::Scheduler::Handle catchup_request_timer_handle_;
    libp2p::basic::Scheduler::Handle fallback_timer_handle_;

    // Metrics
    metrics::RegistryPtr metrics_registry_ = metrics::createRegistry();
    metrics::Gauge *metric_highest_round_;

    log::Logger logger_ = log::createLogger("Grandpa", "grandpa");
  };

}  // namespace kagome::consensus::grandpa

#endif  // KAGOME_CONSENSUS_GRANDPA_GRANDPAIMPL