parachain_host_types.hpp

Go to the documentation of this file.

#ifndef KAGOME_CORE_RUNTIME_PARACHAIN_HOST_TYPES_HPP
#define KAGOME_CORE_RUNTIME_PARACHAIN_HOST_TYPES_HPP

#include <scale/bitvec.hpp>

#include "common/blob.hpp"
#include "common/unused.hpp"
#include "primitives/authority_discovery_id.hpp"
#include "primitives/block_id.hpp"
#include "primitives/common.hpp"
#include "primitives/parachain_host.hpp"

namespace kagome::runtime {

  using Buffer = common::Buffer;
  using ValidatorId = primitives::parachain::ValidatorId;
  using DutyRoster = primitives::parachain::DutyRoster;
  using ParachainId = primitives::parachain::ParaId;
  using GroupIndex = uint32_t;
  using CollatorId = common::Blob<32>;
  using Hash = common::Hash256;
  using CollatorSignature = common::Hash256;
  using ValidationCodeHash = common::Hash256;
  using BlockNumber = primitives::BlockNumber;
  using CandidateHash = common::Hash256;
  using HeadData = Buffer;
  using GroupRotatePeriod = uint32_t;
  using UpwardMessage = Buffer;
  using ValidationCode = Buffer;
  using SessionIndex = uint32_t;
  using CoreIndex = uint32_t;

  struct ScheduledCore {
    ParachainId para_id;
    std::optional<CollatorId> collator;
  };

  struct CandidateDescriptor {
    ParachainId para_id;
    Hash relay_parent;
    CollatorId collator;
    Hash persisted_validation_data_hash;
    Hash pov_hash;
    Hash erasure_root;
    CollatorSignature signature;
    Hash para_head;
    ValidationCodeHash validation_code_hash;
  };

  struct OccupiedCore {
    // NOTE: this has no ParaId as it can be deduced from the candidate
    // descriptor.
    std::optional<ScheduledCore> next_up_on_available;
    BlockNumber occupied_since;
    BlockNumber time_out_at;
    std::optional<ScheduledCore> next_up_on_time_out;
    scale::BitVec availability;
    GroupIndex group_responsible;
    CandidateHash candidate_hash;
    CandidateDescriptor candidate_descriptor;
  };

  using GroupDescriptor =
      std::tuple<BlockNumber, GroupRotatePeriod, BlockNumber>;
  using ValidatorGroup = std::tuple<std::vector<ValidatorId>, GroupDescriptor>;
  using CoreState = boost::variant<OccupiedCore,   // 0
                                   ScheduledCore,  // 1
                                   Unused<2>>;     // 2
  enum class OccupiedCoreAssumption {
    Included,  // 0
    TimedOut,  // 1
    Unused     // 2
  };
  struct PersistedValidationData {
    HeadData parent_head;
    BlockNumber relay_parent_number;
    Hash relay_parent_storage_root;
    uint32_t max_pov_size;
  };

  struct OutboundHrmpMessage {
    ParachainId recipient;
    Buffer data;
  };

  struct CandidateCommitments {
    std::vector<UpwardMessage> upward_messages;
    std::vector<OutboundHrmpMessage> horizontal_messages;
    std::optional<ValidationCode> new_validation_code;
    HeadData head_data;
    uint32_t processed_downward_messages;
    BlockNumber hrmp_watermark;
  };

  struct CommittedCandidateReceipt {
    CandidateDescriptor descriptor;
    CandidateCommitments commitments;
  };

  struct CandidateReceipt {
    CandidateDescriptor descriptor;
    Hash commitments_hash{};
  };

  struct Candidate {
    CandidateReceipt candidate_receipt;
    HeadData head_data;
    CoreIndex core_index;
  };

  struct CandidateBacked : public Candidate {
    GroupIndex group_index{};
  };

  struct CandidateIncluded : public Candidate {
    GroupIndex group_index{};
  };

  struct CandidateTimedOut : public Candidate {};

  using CandidateEvent = boost::variant<
      CandidateBacked,  // 0
      CandidateIncluded,  // 1
      CandidateTimedOut  // 2
      >;

  using ValidatorIndex = uint32_t;
  using AssignmentId = common::Blob<32>;
  struct SessionInfo {
    /****** New in v2 *******/
    std::vector<ValidatorIndex> active_validator_indices;
    common::Blob<32> random_seed;
    SessionIndex dispute_period;

    /****** Old fields ******/
    std::vector<ValidatorId> validators;
    std::vector<primitives::AuthorityDiscoveryId> discovery_keys;
    std::vector<AssignmentId> assignment_keys;
    std::vector<std::vector<ValidatorIndex>> validator_groups;
    uint32_t n_cores;
    uint32_t zeroth_delay_tranche_width;
    uint32_t relay_vrf_modulo_samples;
    uint32_t n_delay_tranches;
    uint32_t no_show_slots;
    uint32_t needed_approvals;
  };

  using DownwardMessage = Buffer;
  struct InboundDownwardMessage {
    BlockNumber sent_at;
    DownwardMessage msg;
  };

  struct InboundHrmpMessage {
    BlockNumber sent_at;
    Buffer data;
  };

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