Elastic scaling: introduce new candidate receipt primitive

cumulus/client/relay-chain-inprocess-interface/src/lib.rs

@@ -137,7 +137,11 @@ impl RelayChainInterface for RelayChainInProcessInterface {
 		hash: PHash,
 		para_id: ParaId,
 	) -> RelayChainResult<Option<CommittedCandidateReceipt>> {
-		Ok(self.full_client.runtime_api().candidate_pending_availability(hash, para_id)?)
+		Ok(self
+			.full_client
+			.runtime_api()
+			.candidate_pending_availability(hash, para_id)?
+			.map(|receipt| receipt.into()))
 	}
 
 	async fn session_index_for_child(&self, hash: PHash) -> RelayChainResult<SessionIndex> {
@@ -260,15 +264,27 @@ impl RelayChainInterface for RelayChainInProcessInterface {
 		&self,
 		relay_parent: PHash,
 	) -> RelayChainResult<Vec<CoreState<PHash, BlockNumber>>> {
-		Ok(self.full_client.runtime_api().availability_cores(relay_parent)?)
+		Ok(self
+			.full_client
+			.runtime_api()
+			.availability_cores(relay_parent)?
+			.into_iter()
+			.map(|core_state| core_state.into())
+			.collect::<Vec<_>>())
 	}
 
 	async fn candidates_pending_availability(
 		&self,
 		hash: PHash,
 		para_id: ParaId,
 	) -> RelayChainResult<Vec<CommittedCandidateReceipt>> {
-		Ok(self.full_client.runtime_api().candidates_pending_availability(hash, para_id)?)
+		Ok(self
+			.full_client
+			.runtime_api()
+			.candidates_pending_availability(hash, para_id)?
+			.into_iter()
+			.map(|receipt| receipt.into())
+			.collect::<Vec<_>>())
 	}
 }
 

polkadot/node/service/src/fake_runtime_api.rs

@@ -21,12 +21,16 @@
 
 use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo};
 use polkadot_primitives::{
-	runtime_api, slashing, AccountId, AuthorityDiscoveryId, Balance, Block, BlockNumber,
-	CandidateCommitments, CandidateEvent, CandidateHash, CommittedCandidateReceipt, CoreState,
-	DisputeState, ExecutorParams, GroupRotationInfo, Hash, Id as ParaId, InboundDownwardMessage,
-	InboundHrmpMessage, Nonce, OccupiedCoreAssumption, PersistedValidationData, PvfCheckStatement,
-	ScrapedOnChainVotes, SessionIndex, SessionInfo, ValidationCode, ValidationCodeHash,
-	ValidatorId, ValidatorIndex, ValidatorSignature,
+	runtime_api, slashing,
+	vstaging::{
+		CandidateEvent, CommittedCandidateReceiptV2 as CommittedCandidateReceipt, CoreState,
+		ScrapedOnChainVotes,
+	},
+	AccountId, AuthorityDiscoveryId, Balance, Block, BlockNumber, CandidateCommitments,
+	CandidateHash, DisputeState, ExecutorParams, GroupRotationInfo, Hash, Id as ParaId,
+	InboundDownwardMessage, InboundHrmpMessage, Nonce, OccupiedCoreAssumption,
+	PersistedValidationData, PvfCheckStatement, SessionIndex, SessionInfo, ValidationCode,
+	ValidationCodeHash, ValidatorId, ValidatorIndex, ValidatorSignature,
 };
 use sp_consensus_beefy::ecdsa_crypto::{AuthorityId as BeefyId, Signature as BeefySignature};
 use sp_consensus_grandpa::AuthorityId as GrandpaId;

polkadot/node/subsystem-types/src/runtime_client.rs

@@ -380,7 +380,10 @@ where
 		&self,
 		at: Hash,
 	) -> Result<Vec<CoreState<Hash, BlockNumber>>, ApiError> {
-		self.client.runtime_api().availability_cores(at)
+		self.client
+			.runtime_api()
+			.availability_cores(at)
+			.map(|cores| cores.into_iter().map(|core| core.into()).collect::<Vec<_>>())
 	}
 
 	async fn persisted_validation_data(
@@ -433,19 +436,30 @@ where
 		at: Hash,
 		para_id: Id,
 	) -> Result<Option<CommittedCandidateReceipt<Hash>>, ApiError> {
-		self.client.runtime_api().candidate_pending_availability(at, para_id)
+		self.client
+			.runtime_api()
+			.candidate_pending_availability(at, para_id)
+			.map(|maybe_candidate| maybe_candidate.map(|candidate| candidate.into()))
 	}
 
 	async fn candidates_pending_availability(
 		&self,
 		at: Hash,
 		para_id: Id,
 	) -> Result<Vec<CommittedCandidateReceipt<Hash>>, ApiError> {
-		self.client.runtime_api().candidates_pending_availability(at, para_id)
+		self.client
+			.runtime_api()
+			.candidates_pending_availability(at, para_id)
+			.map(|candidates| {
+				candidates.into_iter().map(|candidate| candidate.into()).collect::<Vec<_>>()
+			})
 	}
 
 	async fn candidate_events(&self, at: Hash) -> Result<Vec<CandidateEvent<Hash>>, ApiError> {
-		self.client.runtime_api().candidate_events(at)
+		self.client
+			.runtime_api()
+			.candidate_events(at)
+			.map(|events| events.into_iter().map(|event| event.into()).collect::<Vec<_>>())
 	}
 
 	async fn dmq_contents(
@@ -476,7 +490,10 @@ where
 		&self,
 		at: Hash,
 	) -> Result<Option<ScrapedOnChainVotes<Hash>>, ApiError> {
-		self.client.runtime_api().on_chain_votes(at)
+		self.client
+			.runtime_api()
+			.on_chain_votes(at)
+			.map(|maybe_votes| maybe_votes.map(|votes| votes.into()))
 	}
 
 	async fn session_executor_params(
@@ -588,7 +605,12 @@ where
 		at: Hash,
 		para_id: Id,
 	) -> Result<Option<async_backing::BackingState>, ApiError> {
-		self.client.runtime_api().para_backing_state(at, para_id)
+		self.client
+			.runtime_api()
+			.para_backing_state(at, para_id)
+			.map(|maybe_backing_state| {
+				maybe_backing_state.map(|backing_state| backing_state.into())
+			})
 	}
 
 	async fn async_backing_params(

polkadot/node/test/client/src/block_builder.rs

@@ -16,7 +16,7 @@
 
 use crate::Client;
 use codec::{Decode, Encode};
-use polkadot_primitives::{Block, InherentData as ParachainsInherentData};
+use polkadot_primitives::{vstaging::InherentData as ParachainsInherentData, Block};
 use polkadot_test_runtime::UncheckedExtrinsic;
 use polkadot_test_service::GetLastTimestamp;
 use sc_block_builder::{BlockBuilder, BlockBuilderBuilder};

polkadot/primitives/Cargo.toml

@@ -28,10 +28,14 @@ sp-consensus-slots = { features = ["serde"], workspace = true }
 sp-io = { workspace = true }
 sp-keystore = { optional = true, workspace = true }
 sp-staking = { features = ["serde"], workspace = true }
+sp-std = { workspace = true, optional = true }
 
 polkadot-core-primitives = { workspace = true }
 polkadot-parachain-primitives = { workspace = true }
 
+[dev-dependencies]
+polkadot-primitives-test-helpers = { workspace = true }
+
 [features]
 default = ["std"]
 std = [
@@ -54,9 +58,11 @@ std = [
 	"sp-keystore?/std",
 	"sp-runtime/std",
 	"sp-staking/std",
+	"sp-std/std",
 ]
 runtime-benchmarks = [
 	"polkadot-parachain-primitives/runtime-benchmarks",
 	"sp-runtime/runtime-benchmarks",
 	"sp-staking/runtime-benchmarks",
 ]
+test = []

polkadot/primitives/src/runtime_api.rs

@@ -114,11 +114,15 @@
 //! separated from the stable primitives.
 
 use crate::{
-	async_backing, slashing, ApprovalVotingParams, AsyncBackingParams, BlockNumber,
-	CandidateCommitments, CandidateEvent, CandidateHash, CommittedCandidateReceipt, CoreIndex,
-	CoreState, DisputeState, ExecutorParams, GroupRotationInfo, Hash, NodeFeatures,
-	OccupiedCoreAssumption, PersistedValidationData, PvfCheckStatement, ScrapedOnChainVotes,
-	SessionIndex, SessionInfo, ValidatorId, ValidatorIndex, ValidatorSignature,
+	slashing,
+	vstaging::{
+		self, CandidateEvent, CommittedCandidateReceiptV2 as CommittedCandidateReceipt, CoreState,
+		ScrapedOnChainVotes,
+	},
+	ApprovalVotingParams, AsyncBackingParams, BlockNumber, CandidateCommitments, CandidateHash,
+	CoreIndex, DisputeState, ExecutorParams, GroupRotationInfo, Hash, NodeFeatures,
+	OccupiedCoreAssumption, PersistedValidationData, PvfCheckStatement, SessionIndex, SessionInfo,
+	ValidatorId, ValidatorIndex, ValidatorSignature,
 };
 
 use alloc::{
@@ -260,7 +264,7 @@ sp_api::decl_runtime_apis! {
 
 		/// Returns the state of parachain backing for a given para.
 		#[api_version(7)]
-		fn para_backing_state(_: ppp::Id) -> Option<async_backing::BackingState<Hash, BlockNumber>>;
+		fn para_backing_state(_: ppp::Id) -> Option<vstaging::async_backing::BackingState<Hash, BlockNumber>>;
 
 		/// Returns candidate's acceptance limitations for asynchronous backing for a relay parent.
 		#[api_version(7)]

polkadot/primitives/src/v7/mod.rs

@@ -15,7 +15,6 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 //! `V7` Primitives.
-
 use alloc::{
 	vec,
 	vec::{IntoIter, Vec},
@@ -1154,7 +1153,7 @@ pub enum OccupiedCoreAssumption {
 	Free,
 }
 
-/// An even concerning a candidate.
+/// An event concerning a candidate.
 #[derive(Clone, Encode, Decode, TypeInfo, RuntimeDebug)]
 #[cfg_attr(feature = "std", derive(PartialEq))]
 pub enum CandidateEvent<H = Hash> {
@@ -2052,7 +2051,7 @@ pub mod node_features {
 }
 
 #[cfg(test)]
-mod tests {
+pub mod tests {
 	use super::*;
 	use bitvec::bitvec;
 	use sp_core::sr25519;

polkadot/primitives/src/vstaging/async_backing.rs

@@ -0,0 +1,76 @@
+// 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/>.
+
+use super::*;
+
+use alloc::vec::Vec;
+use codec::{Decode, Encode};
+use scale_info::TypeInfo;
+use sp_core::RuntimeDebug;
+
+/// A candidate pending availability.
+#[derive(RuntimeDebug, Clone, PartialEq, Encode, Decode, TypeInfo)]
+pub struct CandidatePendingAvailability<H = Hash, N = BlockNumber> {
+	/// The hash of the candidate.
+	pub candidate_hash: CandidateHash,
+	/// The candidate's descriptor.
+	pub descriptor: CandidateDescriptorV2<H>,
+	/// The commitments of the candidate.
+	pub commitments: CandidateCommitments,
+	/// The candidate's relay parent's number.
+	pub relay_parent_number: N,
+	/// The maximum Proof-of-Validity size allowed, in bytes.
+	pub max_pov_size: u32,
+}
+
+impl<H: Copy> From<CandidatePendingAvailability<H>>
+	for crate::v7::async_backing::CandidatePendingAvailability<H>
+{
+	fn from(value: CandidatePendingAvailability<H>) -> Self {
+		Self {
+			candidate_hash: value.candidate_hash,
+			descriptor: value.descriptor.into(),
+			commitments: value.commitments,
+			relay_parent_number: value.relay_parent_number,
+			max_pov_size: value.max_pov_size,
+		}
+	}
+}
+
+/// The per-parachain state of the backing system, including
+/// state-machine constraints and candidates pending availability.
+#[derive(RuntimeDebug, Clone, PartialEq, Encode, Decode, TypeInfo)]
+pub struct BackingState<H = Hash, N = BlockNumber> {
+	/// The state-machine constraints of the parachain.
+	pub constraints: Constraints<N>,
+	/// The candidates pending availability. These should be ordered, i.e. they should form
+	/// a sub-chain, where the first candidate builds on top of the required parent of the
+	/// constraints and each subsequent builds on top of the previous head-data.
+	pub pending_availability: Vec<CandidatePendingAvailability<H, N>>,
+}
+
+impl<H: Copy> From<BackingState<H>> for crate::v7::async_backing::BackingState<H> {
+	fn from(value: BackingState<H>) -> Self {
+		Self {
+			constraints: value.constraints,
+			pending_availability: value
+				.pending_availability
+				.into_iter()
+				.map(|candidate| candidate.into())
+				.collect::<Vec<_>>(),
+		}
+	}
+}