// Copyright (C) Parity Technologies (UK) Ltd.

// This file is part of Polkadot.

// Polkadot is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// Polkadot is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.

//! `V7` Primitives.

use alloc::{

	vec,

	vec::{IntoIter, Vec},

};

use bitvec::{field::BitField, slice::BitSlice, vec::BitVec};

use codec::{Decode, Encode};

use core::{

	marker::PhantomData,

	slice::{Iter, IterMut},

};

use scale_info::TypeInfo;

use sp_application_crypto::KeyTypeId;

use sp_arithmetic::traits::{BaseArithmetic, Saturating};

use sp_core::RuntimeDebug;

use sp_inherents::InherentIdentifier;

use sp_runtime::traits::{AppVerify, Header as HeaderT};

pub use sp_runtime::traits::{BlakeTwo256, Hash as HashT};

// Export some core primitives.

pub use polkadot_core_primitives::v2::{

	AccountId, AccountIndex, AccountPublic, Balance, Block, BlockId, BlockNumber, CandidateHash,

	ChainId, DownwardMessage, Hash, Header, InboundDownwardMessage, InboundHrmpMessage, Moment,

	Nonce, OutboundHrmpMessage, Remark, Signature, UncheckedExtrinsic,

};

// Export some polkadot-parachain primitives

pub use polkadot_parachain_primitives::primitives::{

	HeadData, HorizontalMessages, HrmpChannelId, Id, UpwardMessage, UpwardMessages, ValidationCode,

	ValidationCodeHash, LOWEST_PUBLIC_ID,

};

use serde::{Deserialize, Serialize};

pub use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId;

pub use sp_consensus_slots::Slot;

pub use sp_staking::SessionIndex;

/// Signed data.

mod signed;

pub use signed::{EncodeAs, Signed, UncheckedSigned};

pub mod async_backing;

pub mod executor_params;

pub mod slashing;

pub use async_backing::AsyncBackingParams;

pub use executor_params::{

	ExecutorParam, ExecutorParamError, ExecutorParams, ExecutorParamsHash, ExecutorParamsPrepHash,

};

mod metrics;

pub use metrics::{

	metric_definitions, RuntimeMetricLabel, RuntimeMetricLabelValue, RuntimeMetricLabelValues,

	RuntimeMetricLabels, RuntimeMetricOp, RuntimeMetricUpdate,

};

/// The key type ID for a collator key.

pub const COLLATOR_KEY_TYPE_ID: KeyTypeId = KeyTypeId(*b"coll");

const LOG_TARGET: &str = "runtime::primitives";

mod collator_app {

	use sp_application_crypto::{app_crypto, sr25519};

	app_crypto!(sr25519, super::COLLATOR_KEY_TYPE_ID);

}

/// Identity that collators use.

pub type CollatorId = collator_app::Public;

/// A Parachain collator keypair.

#[cfg(feature = "std")]

pub type CollatorPair = collator_app::Pair;

/// Signature on candidate's block data by a collator.

pub type CollatorSignature = collator_app::Signature;

/// The key type ID for a parachain validator key.

pub const PARACHAIN_KEY_TYPE_ID: KeyTypeId = KeyTypeId(*b"para");

mod validator_app {

	use sp_application_crypto::{app_crypto, sr25519};

	app_crypto!(sr25519, super::PARACHAIN_KEY_TYPE_ID);

}

/// Identity that parachain validators use when signing validation messages.

///

/// For now we assert that parachain validator set is exactly equivalent to the authority set, and

/// so we define it to be the same type as `SessionKey`. In the future it may have different crypto.

pub type ValidatorId = validator_app::Public;

/// Trait required for type specific indices e.g. `ValidatorIndex` and `GroupIndex`

pub trait TypeIndex {

	/// Returns the index associated to this value.

	fn type_index(&self) -> usize;

}

/// Index of the validator is used as a lightweight replacement of the `ValidatorId` when

/// appropriate.

pub struct ValidatorIndex(pub u32);

/// Index of an availability chunk.

///

/// The underlying type is identical to `ValidatorIndex`, because

/// the number of chunks will always be equal to the number of validators.

/// However, the chunk index held by a validator may not always be equal to its `ValidatorIndex`, so

/// we use a separate type to make code easier to read.

pub struct ChunkIndex(pub u32);

impl From<ChunkIndex> for ValidatorIndex {

}

impl From<ValidatorIndex> for ChunkIndex {

}

impl From<u32> for ChunkIndex {

}

// We should really get https://github.com/paritytech/polkadot/issues/2403 going ..

impl From<u32> for ValidatorIndex {

}

impl TypeIndex for ValidatorIndex {

}

sp_application_crypto::with_pair! {

	/// A Parachain validator keypair.

	pub type ValidatorPair = validator_app::Pair;

}

/// Signature with which parachain validators sign blocks.

///

/// For now we assert that parachain validator set is exactly equivalent to the authority set, and

/// so we define it to be the same type as `SessionKey`. In the future it may have different crypto.

pub type ValidatorSignature = validator_app::Signature;

/// A declarations of storage keys where an external observer can find some interesting data.

pub mod well_known_keys {

	use super::{HrmpChannelId, Id, WellKnownKey};

	use alloc::vec::Vec;

	use codec::Encode as _;

	use hex_literal::hex;

	use sp_io::hashing::twox_64;

	// A note on generating these magic values below:

	//

	// The `StorageValue`, such as `ACTIVE_CONFIG` was obtained by calling:

	//

	//     ActiveConfig::<T>::hashed_key()

	//

	// The `StorageMap` values require `prefix`, and for example for `hrmp_egress_channel_index`,

	// it could be obtained like:

	//

	//     HrmpEgressChannelsIndex::<T>::prefix_hash();

	//

	/// The current epoch index.

	///

	/// The storage item should be access as a `u64` encoded value.

	pub const EPOCH_INDEX: &[u8] =

		&hex!["1cb6f36e027abb2091cfb5110ab5087f38316cbf8fa0da822a20ac1c55bf1be3"];

	/// The current relay chain block randomness

	///

	/// The storage item should be accessed as a `schnorrkel::Randomness` encoded value.

	pub const CURRENT_BLOCK_RANDOMNESS: &[u8] =

		&hex!["1cb6f36e027abb2091cfb5110ab5087fd077dfdb8adb10f78f10a5df8742c545"];

	/// The randomness for one epoch ago

	///

	/// The storage item should be accessed as a `schnorrkel::Randomness` encoded value.

	pub const ONE_EPOCH_AGO_RANDOMNESS: &[u8] =

		&hex!["1cb6f36e027abb2091cfb5110ab5087f7ce678799d3eff024253b90e84927cc6"];

	/// The randomness for two epochs ago

	///

	/// The storage item should be accessed as a `schnorrkel::Randomness` encoded value.

	pub const TWO_EPOCHS_AGO_RANDOMNESS: &[u8] =

		&hex!["1cb6f36e027abb2091cfb5110ab5087f7a414cb008e0e61e46722aa60abdd672"];

	/// The current slot number.

	///

	/// The storage entry should be accessed as a `Slot` encoded value.

	pub const CURRENT_SLOT: &[u8] =

		&hex!["1cb6f36e027abb2091cfb5110ab5087f06155b3cd9a8c9e5e9a23fd5dc13a5ed"];

	/// The currently active host configuration.

	///

	/// The storage entry should be accessed as an `AbridgedHostConfiguration` encoded value.

	pub const ACTIVE_CONFIG: &[u8] =

		&hex!["06de3d8a54d27e44a9d5ce189618f22db4b49d95320d9021994c850f25b8e385"];

	/// Hash of the committed head data for a given registered para.

	///

	/// The storage entry stores wrapped `HeadData(Vec<u8>)`.

	/// The upward message dispatch queue for the given para id.

	///

	/// The storage entry stores a tuple of two values:

	///

	/// - `count: u32`, the number of messages currently in the queue for given para,

	/// - `total_size: u32`, the total size of all messages in the queue.

	#[deprecated = "Use `relay_dispatch_queue_remaining_capacity` instead"]

	/// Type safe version of `relay_dispatch_queue_size`.

	#[deprecated = "Use `relay_dispatch_queue_remaining_capacity` instead"]

	/// The upward message dispatch queue remaining capacity for the given para id.

	///

	/// The storage entry stores a tuple of two values:

	///

	/// - `count: u32`, the number of additional messages which may be enqueued for the given para,

	/// - `total_size: u32`, the total size of additional messages which may be enqueued for the

	/// given para.

	/// The HRMP channel for the given identifier.

	///

	/// The storage entry should be accessed as an `AbridgedHrmpChannel` encoded value.

	/// The list of inbound channels for the given para.

	///

	/// The storage entry stores a `Vec<ParaId>`

	/// The list of outbound channels for the given para.

	///

	/// The storage entry stores a `Vec<ParaId>`

	/// The MQC head for the downward message queue of the given para. See more in the `Dmp` module.

	///

	/// The storage entry stores a `Hash`. This is polkadot hash which is at the moment

	/// `blake2b-256`.

	/// The signal that indicates whether the parachain should go-ahead with the proposed validation

	/// code upgrade.

	///

	/// The storage entry stores a value of `UpgradeGoAhead` type.

	/// The signal that indicates whether the parachain is disallowed to signal an upgrade at this

	/// relay-parent.

	///

	/// The storage entry stores a value of `UpgradeRestriction` type.

}

/// Unique identifier for the Parachains Inherent

pub const PARACHAINS_INHERENT_IDENTIFIER: InherentIdentifier = *b"parachn0";

/// The key type ID for parachain assignment key.

pub const ASSIGNMENT_KEY_TYPE_ID: KeyTypeId = KeyTypeId(*b"asgn");

/// Compressed or not the wasm blob can never be less than 9 bytes.

pub const MIN_CODE_SIZE: u32 = 9;

/// Maximum compressed code size we support right now.

/// At the moment we have runtime upgrade on chain, which restricts scalability severely. If we want

/// to have bigger values, we should fix that first.

///

/// Used for:

/// * initial genesis for the Parachains configuration

/// * checking updates to this stored runtime configuration do not exceed this limit

/// * when detecting a code decompression bomb in the client

// NOTE: This value is used in the runtime so be careful when changing it.

pub const MAX_CODE_SIZE: u32 = 3 * 1024 * 1024;

/// Maximum head data size we support right now.

///

/// Used for:

/// * initial genesis for the Parachains configuration

/// * checking updates to this stored runtime configuration do not exceed this limit

// NOTE: This value is used in the runtime so be careful when changing it.

pub const MAX_HEAD_DATA_SIZE: u32 = 1 * 1024 * 1024;

/// Maximum PoV size we support right now.

///

/// Used for:

/// * initial genesis for the Parachains configuration

/// * checking updates to this stored runtime configuration do not exceed this limit

/// * when detecting a PoV decompression bomb in the client

// NOTE: This value is used in the runtime so be careful when changing it.

pub const MAX_POV_SIZE: u32 = 5 * 1024 * 1024;

/// Default queue size we use for the on-demand order book.

///

/// Can be adjusted in configuration.

pub const ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE: u32 = 10_000;

/// Maximum for maximum queue size.

///

/// Setting `on_demand_queue_max_size` to a value higher than this is unsound. This is more a

/// theoretical limit, just below enough what the target type supports, so comparisons are possible

/// even with indices that are overflowing the underyling type.

pub const ON_DEMAND_MAX_QUEUE_MAX_SIZE: u32 = 1_000_000_000;

/// Backing votes threshold used from the host prior to runtime API version 6 and from the runtime

/// prior to v9 configuration migration.

pub const LEGACY_MIN_BACKING_VOTES: u32 = 2;

// The public key of a keypair used by a validator for determining assignments

/// to approve included parachain candidates.

mod assignment_app {

	use sp_application_crypto::{app_crypto, sr25519};

	app_crypto!(sr25519, super::ASSIGNMENT_KEY_TYPE_ID);

}

/// The public key of a keypair used by a validator for determining assignments

/// to approve included parachain candidates.

pub type AssignmentId = assignment_app::Public;

sp_application_crypto::with_pair! {

	/// The full keypair used by a validator for determining assignments to approve included

	/// parachain candidates.

	pub type AssignmentPair = assignment_app::Pair;

}

/// The index of the candidate in the list of candidates fully included as-of the block.

pub type CandidateIndex = u32;

/// Get a collator signature payload on a relay-parent, block-data combo.

	} else {

	}

/// A unique descriptor of the candidate receipt.

#[cfg_attr(feature = "std", derive(Hash))]

pub struct CandidateDescriptor<H = Hash> {

	/// The ID of the para this is a candidate for.

	pub para_id: Id,

	/// The hash of the relay-chain block this is executed in the context of.

	pub relay_parent: H,

	/// The collator's sr25519 public key.

	pub collator: CollatorId,

	/// The blake2-256 hash of the persisted validation data. This is extra data derived from

	/// relay-chain state which may vary based on bitfields included before the candidate.

	/// Thus it cannot be derived entirely from the relay-parent.

	pub persisted_validation_data_hash: Hash,

	/// The blake2-256 hash of the PoV.

	pub pov_hash: Hash,

	/// The root of a block's erasure encoding Merkle tree.

	pub erasure_root: Hash,

	/// Signature on blake2-256 of components of this receipt:

	/// The parachain index, the relay parent, the validation data hash, and the `pov_hash`.

	pub signature: CollatorSignature,

	/// Hash of the para header that is being generated by this candidate.

	pub para_head: Hash,

	/// The blake2-256 hash of the validation code bytes.

	pub validation_code_hash: ValidationCodeHash,

}

impl<H: AsRef<[u8]>> CandidateDescriptor<H> {

	/// Check the signature of the collator within this descriptor.

}

/// A candidate-receipt.

pub struct CandidateReceipt<H = Hash> {

	/// The descriptor of the candidate.

	pub descriptor: CandidateDescriptor<H>,

	/// The hash of the encoded commitments made as a result of candidate execution.

	pub commitments_hash: Hash,

}

impl<H> CandidateReceipt<H> {

	/// Get a reference to the candidate descriptor.

	/// Computes the blake2-256 hash of the receipt.

}

/// A candidate-receipt with commitments directly included.

#[cfg_attr(feature = "std", derive(Hash))]

pub struct CommittedCandidateReceipt<H = Hash> {

	/// The descriptor of the candidate.

	pub descriptor: CandidateDescriptor<H>,

	/// The commitments of the candidate receipt.

	pub commitments: CandidateCommitments,

}

impl<H> CommittedCandidateReceipt<H> {

	/// Get a reference to the candidate descriptor.

}

impl<H: Clone> CommittedCandidateReceipt<H> {

	/// Transforms this into a plain `CandidateReceipt`.

	/// Computes the hash of the committed candidate receipt.

	///

	/// This computes the canonical hash, not the hash of the directly encoded data.

	/// Thus this is a shortcut for `candidate.to_plain().hash()`.

	/// Does this committed candidate receipt corresponds to the given [`CandidateReceipt`]?

}

impl PartialOrd for CommittedCandidateReceipt {

}

impl Ord for CommittedCandidateReceipt {

}

/// The validation data provides information about how to create the inputs for validation of a

/// candidate. This information is derived from the chain state and will vary from para to para,

/// although some fields may be the same for every para.

///

/// Since this data is used to form inputs to the validation function, it needs to be persisted by

/// the availability system to avoid dependence on availability of the relay-chain state.

///

/// Furthermore, the validation data acts as a way to authorize the additional data the collator

/// needs to pass to the validation function. For example, the validation function can check whether

/// the incoming messages (e.g. downward messages) were actually sent by using the data provided in

/// the validation data using so called MQC heads.

///

/// Since the commitments of the validation function are checked by the relay-chain, secondary

/// checkers can rely on the invariant that the relay-chain only includes para-blocks for which

/// these checks have already been done. As such, there is no need for the validation data used to

/// inform validators and collators about the checks the relay-chain will perform to be persisted by

/// the availability system.

///

/// The `PersistedValidationData` should be relatively lightweight primarily because it is

/// constructed during inclusion for each candidate and therefore lies on the critical path of

/// inclusion.

#[cfg_attr(feature = "std", derive(Default))]

pub struct PersistedValidationData<H = Hash, N = BlockNumber> {

	/// The parent head-data.

	pub parent_head: HeadData,

	/// The relay-chain block number this is in the context of.

	pub relay_parent_number: N,

	/// The relay-chain block storage root this is in the context of.

	pub relay_parent_storage_root: H,

	/// The maximum legal size of a POV block, in bytes.

	pub max_pov_size: u32,

}

impl<H: Encode, N: Encode> PersistedValidationData<H, N> {

	/// Compute the blake2-256 hash of the persisted validation data.

}

/// Commitments made in a `CandidateReceipt`. Many of these are outputs of validation.

#[cfg_attr(feature = "std", derive(Default, Hash))]

pub struct CandidateCommitments<N = BlockNumber> {

	/// Messages destined to be interpreted by the Relay chain itself.

	pub upward_messages: UpwardMessages,

	/// Horizontal messages sent by the parachain.

	pub horizontal_messages: HorizontalMessages,

	/// New validation code.

	pub new_validation_code: Option<ValidationCode>,

	/// The head-data produced as a result of execution.

	pub head_data: HeadData,

	/// The number of messages processed from the DMQ.

	pub processed_downward_messages: u32,

	/// The mark which specifies the block number up to which all inbound HRMP messages are

	/// processed.

	pub hrmp_watermark: N,

}

impl CandidateCommitments {

	/// Compute the blake2-256 hash of the commitments.

}

/// A bitfield concerning availability of backed candidates.

///

/// Every bit refers to an availability core index.

pub struct AvailabilityBitfield(pub BitVec<u8, bitvec::order::Lsb0>);

impl From<BitVec<u8, bitvec::order::Lsb0>> for AvailabilityBitfield {

}

/// A signed compact statement, suitable to be sent to the chain.

pub type SignedStatement = Signed<CompactStatement>;

/// A signed compact statement, with signature not yet checked.

pub type UncheckedSignedStatement = UncheckedSigned<CompactStatement>;

/// A bitfield signed by a particular validator about the availability of pending candidates.

pub type SignedAvailabilityBitfield = Signed<AvailabilityBitfield>;

/// A signed bitfield with signature not yet checked.

pub type UncheckedSignedAvailabilityBitfield = UncheckedSigned<AvailabilityBitfield>;

/// A set of signed availability bitfields. Should be sorted by validator index, ascending.

pub type SignedAvailabilityBitfields = Vec<SignedAvailabilityBitfield>;

/// A set of unchecked signed availability bitfields. Should be sorted by validator index,

/// ascending.

pub type UncheckedSignedAvailabilityBitfields = Vec<UncheckedSignedAvailabilityBitfield>;

/// A backed (or backable, depending on context) candidate.

pub struct BackedCandidate<H = Hash> {

	/// The candidate referred to.

	candidate: CommittedCandidateReceipt<H>,

	/// The validity votes themselves, expressed as signatures.

	validity_votes: Vec<ValidityAttestation>,

	/// The indices of the validators within the group, expressed as a bitfield. May be extended

	/// beyond the backing group size to contain the assigned core index, if ElasticScalingMVP is

	/// enabled.

	validator_indices: BitVec<u8, bitvec::order::Lsb0>,

}

impl<H> BackedCandidate<H> {

	/// Constructor

	/// Get a reference to the descriptor of the candidate.

	/// Get a reference to the committed candidate receipt of the candidate.

	/// Get a reference to the validity votes of the candidate.

	/// Get a mutable reference to validity votes of the para.

	/// Compute this candidate's hash.

	/// Get this candidate's receipt.

	/// Get a copy of the validator indices and the assumed core index, if any.

	/// Inject a core index in the validator_indices bitvec.

	/// Update the validator indices and core index in the candidate.

}

/// Verify the backing of the given candidate.

///

/// Provide a lookup from the index of a validator within the group assigned to this para,

/// as opposed to the index of the validator within the overall validator set, as well as

/// the number of validators in the group.

///

/// Also provide the signing context.

///

/// Returns either an error, indicating that one of the signatures was invalid or that the index

/// was out-of-bounds, or the number of signatures checked.

			target: LOG_TARGET,

		);

			target: LOG_TARGET,

		);

	{

				target: LOG_TARGET,

				validator_id,

				val_in_group_idx,

			);

		}

	}

			target: LOG_TARGET,

			signed,

		);

/// The unique (during session) index of a core.

#[derive(

)]

#[cfg_attr(feature = "std", derive(Hash))]

pub struct CoreIndex(pub u32);

impl From<u32> for CoreIndex {

}

impl TypeIndex for CoreIndex {

}

/// The unique (during session) index of a validator group.

#[cfg_attr(feature = "std", derive(Hash))]

pub struct GroupIndex(pub u32);

impl From<u32> for GroupIndex {

}

impl TypeIndex for GroupIndex {

}

/// A claim on authoring the next block for a given parathread (on-demand parachain).

pub struct ParathreadClaim(pub Id, pub Option<CollatorId>);

/// An entry tracking a claim to ensure it does not pass the maximum number of retries.

pub struct ParathreadEntry {

	/// The claim.

	pub claim: ParathreadClaim,

	/// Number of retries

	pub retries: u32,

}

/// A helper data-type for tracking validator-group rotations.

#[cfg_attr(feature = "std", derive(PartialEq))]

pub struct GroupRotationInfo<N = BlockNumber> {

	/// The block number where the session started.

	pub session_start_block: N,

	/// How often groups rotate. 0 means never.

	pub group_rotation_frequency: N,

	/// The current block number.

	pub now: N,

}

impl GroupRotationInfo {

	/// Returns the index of the group needed to validate the core at the given index, assuming

	/// the given number of cores.

	///

	/// `core_index` should be less than `cores`, which is capped at `u32::max()`.

	/// Returns the index of the group assigned to the given core. This does no checking or

	/// whether the group index is in-bounds.

	///

	/// `core_index` should be less than `cores`, which is capped at `u32::max()`.

	/// Create a new `GroupRotationInfo` with one further rotation applied.

}

impl<N: Saturating + BaseArithmetic + Copy> GroupRotationInfo<N> {

	/// Returns the block number of the next rotation after the current block. If the current block

	/// is 10 and the rotation frequency is 5, this should return 15.

	/// Returns the block number of the last rotation before or including the current block. If the

	/// current block is 10 and the rotation frequency is 5, this should return 10.

}

/// Information about a core which is currently occupied.

#[cfg_attr(feature = "std", derive(PartialEq))]

pub struct OccupiedCore<H = Hash, N = BlockNumber> {

	// NOTE: this has no ParaId as it can be deduced from the candidate descriptor.

	/// If this core is freed by availability, this is the assignment that is next up on this

	/// core, if any. None if there is nothing queued for this core.

	pub next_up_on_available: Option<ScheduledCore>,

	/// The relay-chain block number this began occupying the core at.

	pub occupied_since: N,

	/// The relay-chain block this will time-out at, if any.

	pub time_out_at: N,

	/// If this core is freed by being timed-out, this is the assignment that is next up on this

	/// core. None if there is nothing queued for this core or there is no possibility of timing

	/// out.

	pub next_up_on_time_out: Option<ScheduledCore>,

	/// A bitfield with 1 bit for each validator in the set. `1` bits mean that the corresponding

	/// validators has attested to availability on-chain. A 2/3+ majority of `1` bits means that

	/// this will be available.

	pub availability: BitVec<u8, bitvec::order::Lsb0>,

	/// The group assigned to distribute availability pieces of this candidate.

	pub group_responsible: GroupIndex,

	/// The hash of the candidate occupying the core.

	pub candidate_hash: CandidateHash,

	/// The descriptor of the candidate occupying the core.

	pub candidate_descriptor: CandidateDescriptor<H>,

}

impl<H, N> OccupiedCore<H, N> {

	/// Get the Para currently occupying this core.

}

/// Information about a core which is currently occupied.

#[cfg_attr(feature = "std", derive(PartialEq))]

pub struct ScheduledCore {

	/// The ID of a para scheduled.

	pub para_id: Id,

	/// DEPRECATED: see: <https://github.com/paritytech/polkadot/issues/7575>

	///

	/// Will be removed in a future version.

	pub collator: Option<CollatorId>,

}

/// The state of a particular availability core.

#[cfg_attr(feature = "std", derive(PartialEq))]

pub enum CoreState<H = Hash, N = BlockNumber> {

	#[codec(index = 0)]

	/// to occupy.

	///

	/// If a particular Collator is required to author this block, that is also present in this

	/// variant.

	#[codec(index = 1)]

}

impl<N> CoreState<N> {

	/// Returns the scheduled `ParaId` for the core or `None` if nothing is scheduled.

	///

	/// This function is deprecated. `ClaimQueue` should be used to obtain the scheduled `ParaId`s

	/// for each core.

	#[deprecated(

		note = "`para_id` will be removed. Use `ClaimQueue` to query the scheduled `para_id` instead."

	)]

		}

	/// Is this core state `Self::Occupied`?

}

/// An assumption being made about the state of an occupied core.

#[cfg_attr(feature = "std", derive(PartialEq, Eq, Hash))]

pub enum OccupiedCoreAssumption {

}

/// An even concerning a candidate.

#[cfg_attr(feature = "std", derive(PartialEq))]

pub enum CandidateEvent<H = Hash> {

	/// This includes the core index the candidate is now occupying.

	#[codec(index = 0)]

	/// This includes the core index the candidate was occupying as well as the group responsible

	/// for backing the candidate.

	#[codec(index = 1)]

	/// This includes the core index the candidate was occupying.

	#[codec(index = 2)]

}

/// Scraped runtime backing votes and resolved disputes.

#[cfg_attr(feature = "std", derive(PartialEq))]

pub struct ScrapedOnChainVotes<H: Encode + Decode = Hash> {

	/// The session in which the block was included.

	pub session: SessionIndex,

	/// Set of backing validators for each candidate, represented by its candidate

	/// receipt.

	pub backing_validators_per_candidate:

		Vec<(CandidateReceipt<H>, Vec<(ValidatorIndex, ValidityAttestation)>)>,

	/// On-chain-recorded set of disputes.

	/// Note that the above `backing_validators` are

	/// unrelated to the backers of the disputes candidates.

	pub disputes: MultiDisputeStatementSet,

}

/// A vote of approval on a candidate.

pub struct ApprovalVote(pub CandidateHash);

impl ApprovalVote {

	/// Yields the signing payload for this approval vote.

		const MAGIC: [u8; 4] = *b"APPR";

}

/// A vote of approval for multiple candidates.

pub struct ApprovalVoteMultipleCandidates<'a>(pub &'a [CandidateHash]);

impl<'a> ApprovalVoteMultipleCandidates<'a> {

	/// Yields the signing payload for this approval vote.

		const MAGIC: [u8; 4] = *b"APPR";

		// Make this backwards compatible with `ApprovalVote` so if we have just on candidate the

		// signature will look the same.

		// This gives us the nice benefit that old nodes can still check signatures when len is 1

		// and the new node can check the signature coming from old nodes.

		} else {

		}

}

/// Approval voting configuration parameters

#[derive(

	Copy,

	Clone,

	PartialEq,

	Encode,

	Decode,

	serde::Serialize,

)]

pub struct ApprovalVotingParams {

	/// The maximum number of candidates `approval-voting` can vote for with

	/// a single signatures.

	///

	/// Setting it to 1, means we send the approval as soon as we have it available.

	pub max_approval_coalesce_count: u32,

}

impl Default for ApprovalVotingParams {

}

/// Custom validity errors used in Polkadot while validating transactions.

#[repr(u8)]

pub enum ValidityError {

	/// The Ethereum signature is invalid.

	InvalidEthereumSignature = 0,

	/// The signer has no claim.

	SignerHasNoClaim = 1,

	/// No permission to execute the call.

	NoPermission = 2,

	/// An invalid statement was made for a claim.

	InvalidStatement = 3,

}

impl From<ValidityError> for u8 {

}

/// Abridged version of `HostConfiguration` (from the `Configuration` parachains host runtime

/// module) meant to be used by a parachain or PDK such as cumulus.

#[cfg_attr(feature = "std", derive(PartialEq))]

pub struct AbridgedHostConfiguration {

	/// The maximum validation code size, in bytes.

	pub max_code_size: u32,

	/// The maximum head-data size, in bytes.

	pub max_head_data_size: u32,

	/// Total number of individual messages allowed in the parachain -> relay-chain message queue.

	pub max_upward_queue_count: u32,

	/// Total size of messages allowed in the parachain -> relay-chain message queue before which

	/// no further messages may be added to it. If it exceeds this then the queue may contain only

	/// a single message.

	pub max_upward_queue_size: u32,

	/// The maximum size of an upward message that can be sent by a candidate.

	///

	/// This parameter affects the size upper bound of the `CandidateCommitments`.

	pub max_upward_message_size: u32,

	/// The maximum number of messages that a candidate can contain.

	///

	/// This parameter affects the size upper bound of the `CandidateCommitments`.

	pub max_upward_message_num_per_candidate: u32,

	/// The maximum number of outbound HRMP messages can be sent by a candidate.

	///

	/// This parameter affects the upper bound of size of `CandidateCommitments`.

	pub hrmp_max_message_num_per_candidate: u32,

	/// The minimum period, in blocks, between which parachains can update their validation code.

	pub validation_upgrade_cooldown: BlockNumber,

	/// The delay, in blocks, before a validation upgrade is applied.

	pub validation_upgrade_delay: BlockNumber,

	/// Asynchronous backing parameters.

	pub async_backing_params: AsyncBackingParams,

}

/// Abridged version of `HrmpChannel` (from the `Hrmp` parachains host runtime module) meant to be

/// used by a parachain or PDK such as cumulus.

#[cfg_attr(feature = "std", derive(PartialEq))]

pub struct AbridgedHrmpChannel {

	/// The maximum number of messages that can be pending in the channel at once.

	pub max_capacity: u32,

	/// The maximum total size of the messages that can be pending in the channel at once.

	pub max_total_size: u32,

	/// The maximum message size that could be put into the channel.

	pub max_message_size: u32,

	/// The current number of messages pending in the channel.

	/// Invariant: should be less or equal to `max_capacity`.s`.

	pub msg_count: u32,

	/// The total size in bytes of all message payloads in the channel.

	/// Invariant: should be less or equal to `max_total_size`.

	pub total_size: u32,

	/// A head of the Message Queue Chain for this channel. Each link in this chain has a form:

	/// `(prev_head, B, H(M))`, where

	/// - `prev_head`: is the previous value of `mqc_head` or zero if none.

	/// - `B`: is the [relay-chain] block number in which a message was appended

	/// - `H(M)`: is the hash of the message being appended.

	/// This value is initialized to a special value that consists of all zeroes which indicates

	/// that no messages were previously added.

	pub mqc_head: Option<Hash>,

}

/// A possible upgrade restriction that prevents a parachain from performing an upgrade.