parachain_host.hpp

Go to the documentation of this file.

#ifndef KAGOME_CORE_RUNTIME_PARACHAIN_HOST_HPP
#define KAGOME_CORE_RUNTIME_PARACHAIN_HOST_HPP

#include "common/blob.hpp"
#include "common/unused.hpp"
#include "primitives/block_id.hpp"
#include "primitives/common.hpp"
#include "primitives/parachain_host.hpp"
#include "runtime/runtime_api/parachain_host_types.hpp"

namespace kagome::runtime {

  class ParachainHost {
   protected:
   public:
    virtual ~ParachainHost() = default;

    virtual outcome::result<DutyRoster> duty_roster(
        const primitives::BlockHash &block) = 0;

    virtual outcome::result<std::vector<ParachainId>> active_parachains(
        const primitives::BlockHash &block) = 0;

    virtual outcome::result<std::optional<Buffer>> parachain_head(
        const primitives::BlockHash &block, ParachainId id) = 0;

    virtual outcome::result<std::optional<kagome::common::Buffer>>
    parachain_code(const primitives::BlockHash &block, ParachainId id) = 0;

    virtual outcome::result<std::vector<ValidatorId>> validators(
        const primitives::BlockHash &block) = 0;

    virtual outcome::result<std::vector<ValidatorGroup>> validator_groups(
        const primitives::BlockHash &block) = 0;

    virtual outcome::result<std::vector<CoreState>> availability_cores(
        const primitives::BlockHash &block) = 0;

    virtual outcome::result<std::optional<PersistedValidationData>>
    persisted_validation_data(const primitives::BlockHash &block,
                              ParachainId id,
                              OccupiedCoreAssumption assumption) = 0;

    virtual outcome::result<bool> check_validation_outputs(
        const primitives::BlockHash &block,
        ParachainId id,
        CandidateCommitments outputs) = 0;

    virtual outcome::result<SessionIndex> session_index_for_child(
        const primitives::BlockHash &block) = 0;

    virtual outcome::result<std::optional<ValidationCode>> validation_code(
        const primitives::BlockHash &block,
        ParachainId id,
        OccupiedCoreAssumption assumption) = 0;

    virtual outcome::result<std::optional<ValidationCode>>
    validation_code_by_hash(const primitives::BlockHash &block,
                            ValidationCodeHash hash) = 0;

    virtual outcome::result<std::optional<CommittedCandidateReceipt>>
    candidate_pending_availability(const primitives::BlockHash &block,
                                   ParachainId id) = 0;


    virtual outcome::result<std::vector<CandidateEvent>> candidate_events(
        const primitives::BlockHash &block) = 0;

    virtual outcome::result<std::optional<SessionInfo>> session_info(
        const primitives::BlockHash &block, SessionIndex index) = 0;

    virtual outcome::result<std::vector<InboundDownwardMessage>> dmq_contents(
        const primitives::BlockHash &block, ParachainId id) = 0;

    virtual outcome::result<
        std::map<ParachainId, std::vector<InboundHrmpMessage>>>
    inbound_hrmp_channels_contents(const primitives::BlockHash &block,
                                   ParachainId id) = 0;
  };

}  // namespace kagome::runtime
#endif  // KAGOME_CORE_RUNTIME_PARACHAIN_HOST_HPP