signer.hpp

Go to the documentation of this file.

#ifndef KAGOME_PARACHAIN_VALIDATOR_SIGNER_HPP
#define KAGOME_PARACHAIN_VALIDATOR_SIGNER_HPP

#include <optional>

#include "crypto/crypto_store/session_keys.hpp"
#include "crypto/sr25519_provider.hpp"
#include "network/types/collator_messages.hpp"
#include "runtime/runtime_api/parachain_host.hpp"

namespace kagome::parachain {
  class SigningContext {
   private:
    static auto &toSignable(const crypto::Hasher &, const scale::BitVec &v) {
      return v;
    }
    static auto toSignable(const crypto::Hasher &hasher,
                           const network::CandidateState &v) {
      constexpr std::array<uint8_t, 4> kMagic{'B', 'K', 'N', 'G'};
      return std::make_tuple(
          kMagic, static_cast<uint8_t>(v.which()), candidateHash(hasher, v));
    }

   public:
    SCALE_TIE(2);

    static outcome::result<SigningContext> make(
        const std::shared_ptr<runtime::ParachainHost> &parachain_api,
        const primitives::BlockHash &relay_parent);

    template <typename T>
    auto signable(const crypto::Hasher &hasher, const T &payload) const {
      auto &&signable = toSignable(hasher, payload);
      return scale::encode(std::tie(signable, *this)).value();
    }

    runtime::SessionIndex session_index;
    primitives::BlockHash relay_parent;
  };

  class ValidatorSigner {
   public:
    using ValidatorIndex = network::ValidatorIndex;

    ValidatorSigner(ValidatorIndex validator_index,
                    SigningContext context,
                    std::shared_ptr<crypto::Sr25519Keypair> keypair,
                    std::shared_ptr<crypto::Hasher> hasher,
                    std::shared_ptr<crypto::Sr25519Provider> sr25519_provider);

    template <typename T>
    outcome::result<network::Signed<T>> sign(T payload) const {
      auto data = context_.signable(*hasher_, payload);
      OUTCOME_TRY(signature, sr25519_provider_->sign(*keypair_, data));
      return network::Signed<T>{
          std::move(payload),
          validator_index_,
          signature,
      };
    }

    ValidatorIndex validatorIndex() const;

    const primitives::BlockHash &relayParent() const;

   private:
    ValidatorIndex validator_index_;
    SigningContext context_;
    std::shared_ptr<crypto::Sr25519Keypair> keypair_;
    std::shared_ptr<crypto::Hasher> hasher_;
    std::shared_ptr<crypto::Sr25519Provider> sr25519_provider_;
  };

  class ValidatorSignerFactory {
   public:
    ValidatorSignerFactory(
        std::shared_ptr<runtime::ParachainHost> parachain_api,
        std::shared_ptr<crypto::SessionKeys> session_keys,
        std::shared_ptr<crypto::Hasher> hasher,
        std::shared_ptr<crypto::Sr25519Provider> sr25519_provider);

    outcome::result<std::optional<ValidatorSigner>> at(
        const primitives::BlockHash &relay_parent);

   private:
    std::shared_ptr<runtime::ParachainHost> parachain_api_;
    std::shared_ptr<crypto::SessionKeys> session_keys_;
    std::shared_ptr<crypto::Hasher> hasher_;
    std::shared_ptr<crypto::Sr25519Provider> sr25519_provider_;
  };
}  // namespace kagome::parachain

#endif  // KAGOME_PARACHAIN_VALIDATOR_SIGNER_HPP