babe_block_validator.hpp

Go to the documentation of this file.

#ifndef KAGOME_BABE_BLOCK_VALIDATOR_HPP
#define KAGOME_BABE_BLOCK_VALIDATOR_HPP

#include <memory>
#include <unordered_map>
#include <unordered_set>
#include <utility>

#include "blockchain/block_tree.hpp"
#include "consensus/babe/types/babe_block_header.hpp"
#include "consensus/babe/types/seal.hpp"
#include "consensus/validation/block_validator.hpp"
#include "crypto/hasher.hpp"
#include "crypto/vrf_provider.hpp"
#include "log/logger.hpp"
#include "primitives/authority.hpp"
#include "primitives/babe_configuration.hpp"
#include "primitives/transcript.hpp"
#include "runtime/runtime_api/tagged_transaction_queue.hpp"

namespace kagome::crypto {
  class Sr25519Provider;
}

namespace kagome::consensus {

  class BabeBlockValidator : public BlockValidator {
   public:
    ~BabeBlockValidator() override = default;

    BabeBlockValidator(
        std::shared_ptr<blockchain::BlockTree> block_tree,
        std::shared_ptr<runtime::TaggedTransactionQueue> tx_queue,
        std::shared_ptr<crypto::Hasher> hasher,
        std::shared_ptr<crypto::VRFProvider> vrf_provider,
        std::shared_ptr<crypto::Sr25519Provider> sr25519_provider);

    enum class ValidationError {
      NO_AUTHORITIES = 1,
      INVALID_SIGNATURE,
      INVALID_VRF,
      TWO_BLOCKS_IN_SLOT,
      SECONDARY_SLOT_ASSIGNMENTS_DISABLED
    };

    outcome::result<void> validateHeader(
        const primitives::BlockHeader &header,
        const EpochNumber epoch_number,
        const primitives::AuthorityId &authority_id,
        const Threshold &threshold,
        const primitives::BabeConfiguration &babe_config) const override;

   private:
    bool verifySignature(const primitives::BlockHeader &header,
                         const BabeBlockHeader &babe_header,
                         const Seal &seal,
                         const primitives::BabeSessionKey &public_key) const;

    bool verifyVRF(const BabeBlockHeader &babe_header,
                   const EpochNumber epoch_number,
                   const primitives::BabeSessionKey &public_key,
                   const Threshold &threshold,
                   const Randomness &randomness,
                   const bool checkThreshold) const;

    std::shared_ptr<blockchain::BlockTree> block_tree_;
    std::shared_ptr<runtime::TaggedTransactionQueue> tx_queue_;
    std::shared_ptr<crypto::Hasher> hasher_;
    std::shared_ptr<crypto::VRFProvider> vrf_provider_;
    std::shared_ptr<crypto::Sr25519Provider> sr25519_provider_;

    mutable std::unordered_map<BabeSlotNumber,
                               std::unordered_set<primitives::AuthorityIndex>>
        blocks_producers_;

    log::Logger log_;
  };
}  // namespace kagome::consensus

OUTCOME_HPP_DECLARE_ERROR(kagome::consensus,
                          BabeBlockValidator::ValidationError)

#endif  // KAGOME_BABE_BLOCK_VALIDATOR_HPP