cumulus: add SignedSchedulingInfo PVF verification

.github/zombienet-tests/zombienet_polkadot_tests.yml

@@ -229,6 +229,18 @@
   runner-type: "default"
   use-zombienet-sdk: true
 
+- job-name: "zombienet-polkadot-scheduling-v2-and-v3-collator-with-v3-validators"
+  test-filter: "functional::scheduling_v3::scheduling_v2_and_v3_collator_with_v3_validators"
+  runner-type: "default"
+  use-zombienet-sdk: true
+  cumulus-image: "test-parachain"
+
+- job-name: "zombienet-polkadot-scheduling-v3-es-collator-with-v3-validators"
+  test-filter: "functional::scheduling_v3::scheduling_v3_es_collator_with_v3_validators"
+  runner-type: "large"
+  use-zombienet-sdk: true
+  cumulus-image: "test-parachain"
+
 - job-name: "zombienet-polkadot-scheduling-v3-dynamic-enablement"
   test-filter: "functional::v3_dynamic_enablement::v3_dynamic_enablement_test"
   runner-type: "default"

cumulus/client/collator/src/service.rs

@@ -19,7 +19,9 @@
 //! operations used in parachain consensus/authoring.
 
 use cumulus_client_network::WaitToAnnounce;
-use cumulus_primitives_core::{CollationInfo, CollectCollationInfo, ParachainBlockData};
+use cumulus_primitives_core::{
+	CollationInfo, CollectCollationInfo, ParachainBlockData, SchedulingProof,
+};
 
 use polkadot_primitives::UMP_SEPARATOR;
 use sc_client_api::BlockBackend;
@@ -51,23 +53,31 @@ pub trait ServiceInterface<Block: BlockT> {
 	/// that the underlying block has been fully imported into the underlying client,
 	/// as implementations will fetch underlying runtime API data.
 	///
+	/// `scheduling_proof` is `Some` for V3 candidates (produces [`ParachainBlockData::V2`])
+	/// and `None` for legacy candidates (produces [`ParachainBlockData::V1`]).
+	///
 	/// This also returns the unencoded parachain block data, in case that is desired.
 	fn build_collation(
 		&self,
 		parent_header: &Block::Header,
 		block_hash: Block::Hash,
 		candidate: ParachainCandidate<Block>,
+		scheduling_proof: Option<SchedulingProof>,
 	) -> Option<(Collation, ParachainBlockData<Block>)>;
 
 	/// Build a multi-block collation.
 	///
 	/// Does the same as [`Self::build_collation`], but includes multiple blocks into one collation.
 	/// The given `parent_header` should be the header from the parent of the first block.
+	///
+	/// `scheduling_proof` is `Some` for V3 candidates (produces [`ParachainBlockData::V2`])
+	/// and `None` for legacy candidates (produces [`ParachainBlockData::V1`]).
 	fn build_multi_block_collation(
 		&self,
 		parent_header: &Block::Header,
 		blocks: Vec<Block>,
 		proof: StorageProof,
+		scheduling_proof: Option<SchedulingProof>,
 	) -> Option<(Collation, ParachainBlockData<Block>)>;
 
 	/// Inform networking systems that the block should be announced after a signal has
@@ -236,6 +246,7 @@ where
 		parent_header: &Block::Header,
 		blocks: Vec<Block>,
 		proof: StorageProof,
+		scheduling_proof: Option<SchedulingProof>,
 	) -> Option<(Collation, ParachainBlockData<Block>)> {
 		let compact_proof =
 			match proof.into_compact_proof::<HashingFor<Block>>(*parent_header.state_root()) {
@@ -246,7 +257,17 @@ where
 				},
 			};
 
-		let mut api_version = 0;
+		// We are always using the `api_version` of the parent block. The `api_version` can only
+		// change with a runtime upgrade and this is when we want to observe the old
+		// `api_version`. Because this old `api_version` is the one used to validate this
+		// block. Otherwise, we already assume the `api_version` is higher than what the relay
+		// chain will use and this will lead to validation errors.
+		let api_version = self
+			.runtime_api
+			.runtime_api()
+			.api_version::<dyn CollectCollationInfo<Block>>(parent_header.hash())
+			.ok()
+			.flatten()?;
 		let mut upward_messages = Vec::new();
 		let mut upward_message_signals = Vec::<Vec<u8>>::with_capacity(4);
 		let mut horizontal_messages = Vec::new();
@@ -269,18 +290,6 @@ where
 				.ok()
 				.flatten()?;
 
-			// We are always using the `api_version` of the parent block. The `api_version` can only
-			// change with a runtime upgrade and this is when we want to observe the old
-			// `api_version`. Because this old `api_version` is the one used to validate this
-			// block. Otherwise, we already assume the `api_version` is higher than what the relay
-			// chain will use and this will lead to validation errors.
-			api_version = self
-				.runtime_api
-				.runtime_api()
-				.api_version::<dyn CollectCollationInfo<Block>>(parent_header.hash())
-				.ok()
-				.flatten()?;
-
 			let (messages, signals) = Self::split_at_separator(collation_info.upward_messages);
 
 			upward_messages.extend(messages);
@@ -304,7 +313,7 @@ where
 		// Sort by recipient as required by the relay chain rules.
 		horizontal_messages.sort_by(|a, b| a.recipient.cmp(&b.recipient));
 
-		let block_data = ParachainBlockData::<Block>::new(blocks, compact_proof);
+		let block_data = ParachainBlockData::<Block>::new(blocks, compact_proof, scheduling_proof);
 
 		let pov = polkadot_node_primitives::maybe_compress_pov(PoV {
 			block_data: BlockData(if api_version >= 3 {
@@ -392,12 +401,14 @@ where
 		parent_header: &Block::Header,
 		_: Block::Hash,
 		candidate: ParachainCandidate<Block>,
+		scheduling_proof: Option<SchedulingProof>,
 	) -> Option<(Collation, ParachainBlockData<Block>)> {
 		CollatorService::build_multi_block_collation(
 			self,
 			parent_header,
 			vec![candidate.block],
 			candidate.proof,
+			scheduling_proof,
 		)
 	}
 
@@ -417,7 +428,14 @@ where
 		parent_header: &<Block as BlockT>::Header,
 		blocks: Vec<Block>,
 		proof: StorageProof,
+		scheduling_proof: Option<SchedulingProof>,
 	) -> Option<(Collation, ParachainBlockData<Block>)> {
-		CollatorService::build_multi_block_collation(self, parent_header, blocks, proof)
+		CollatorService::build_multi_block_collation(
+			self,
+			parent_header,
+			blocks,
+			proof,
+			scheduling_proof,
+		)
 	}
 }

cumulus/client/consensus/aura/src/collator.rs

@@ -371,6 +371,7 @@ where
 		inherent_data: (ParachainInherentData, InherentData),
 		proposal_duration: Duration,
 		max_pov_size: usize,
+		scheduling_proof: Option<cumulus_primitives_core::SchedulingProof>,
 	) -> Result<Option<(Collation, ParachainBlockData<Block>)>, Box<dyn Error + Send + 'static>> {
 		let maybe_candidate = self
 			.build_block_and_import(BuildBlockAndImportParams {
@@ -389,9 +390,12 @@ where
 		let Some(candidate) = maybe_candidate else { return Ok(None) };
 
 		let hash = candidate.block.header().hash();
-		if let Some((collation, block_data)) =
-			self.collator_service.build_collation(parent_header, hash, candidate.into())
-		{
+		if let Some((collation, block_data)) = self.collator_service.build_collation(
+			parent_header,
+			hash,
+			candidate.into(),
+			scheduling_proof,
+		) {
 			block_data.log_size_info();
 
 			if let MaybeCompressedPoV::Compressed(ref pov) = collation.proof_of_validity {
@@ -480,7 +484,7 @@ where
 	let authorities = runtime_api.authorities(parent_hash).map_err(Box::new)?;
 
 	// Determine the current slot and timestamp based on the relay-parent's.
-	let (slot_now, timestamp) = match consensus_common::relay_slot_and_timestamp(
+	let (slot_now, timestamp) = match consensus_common::get_relay_slot_and_timestamp(
 		relay_parent_header,
 		relay_chain_slot_duration,
 	) {

cumulus/client/consensus/aura/src/collators/basic.rs

@@ -264,6 +264,7 @@ where
 						(parachain_inherent_data, other_inherent_data),
 						params.authoring_duration,
 						allowed_pov_size,
+						None,
 					)
 					.await
 			);

cumulus/client/consensus/aura/src/collators/lookahead.rs

@@ -137,8 +137,10 @@ where
 
 	tracing::debug!(target: crate::LOG_TARGET, ?slot_duration, ?block_hash, "Parachain slot duration acquired");
 
-	let (relay_slot, timestamp) =
-		consensus_common::relay_slot_and_timestamp(relay_parent_header, relay_chain_slot_duration)?;
+	let (relay_slot, timestamp) = consensus_common::get_relay_slot_and_timestamp(
+		relay_parent_header,
+		relay_chain_slot_duration,
+	)?;
 
 	let slot_now = Slot::from_timestamp(timestamp, slot_duration);
 
@@ -476,17 +478,19 @@ where
 					validation_data.max_pov_size * 85 / 100
 				} as usize;
 
-				match collator
+				let collation_result = collator
 					.collate(
 						&parent_header,
 						&slot_claim,
 						None,
 						(parachain_inherent_data, other_inherent_data),
 						params.authoring_duration,
 						allowed_pov_size,
+						None,
 					)
-					.await
-				{
+					.await;
+
+				match collation_result {
 					Ok(Some((collation, block_data))) => {
 						let Some(new_block_header) =
 							block_data.blocks().first().map(|b| b.header().clone())

cumulus/client/consensus/aura/src/collators/mod.rs

@@ -29,15 +29,15 @@ use cumulus_primitives_core::{
 	relay_chain::Header as RelayHeader, BlockT, KeyToIncludeInRelayProof, RelayProofRequest,
 };
 use cumulus_relay_chain_interface::{OverseerHandle, RelayChainInterface};
-use polkadot_node_subsystem::messages::{CollatorProtocolMessage, RuntimeApiRequest};
+use polkadot_node_subsystem::messages::CollatorProtocolMessage;
 use polkadot_node_subsystem_util::runtime::ClaimQueueSnapshot;
 use polkadot_primitives::{
 	Hash as RelayHash, Id as ParaId, OccupiedCoreAssumption, ValidationCodeHash,
 	DEFAULT_SCHEDULING_LOOKAHEAD,
 };
 use sc_client_api::HeaderBackend;
 use sc_consensus_aura::{standalone as aura_internal, AuraApi};
-use sp_api::{ApiExt, ProvideRuntimeApi, RuntimeApiInfo};
+use sp_api::{ApiExt, ProvideRuntimeApi};
 use sp_core::Pair;
 use sp_keystore::KeystorePtr;
 use sp_runtime::traits::Header;
@@ -152,49 +152,6 @@ async fn check_validation_code_or_log(
 	}
 }
 
-/// Fetch scheduling lookahead at given relay parent.
-async fn scheduling_lookahead(
-	relay_parent: RelayHash,
-	relay_client: &impl RelayChainInterface,
-) -> Option<u32> {
-	let runtime_api_version = relay_client
-		.version(relay_parent)
-		.await
-		.map_err(|e| {
-			tracing::error!(
-				target: super::LOG_TARGET,
-				error = ?e,
-				"Failed to fetch relay chain runtime version.",
-			)
-		})
-		.ok()?;
-
-	let parachain_host_runtime_api_version = runtime_api_version
-		.api_version(
-			&<dyn polkadot_primitives::runtime_api::ParachainHost<polkadot_primitives::Block>>::ID,
-		)
-		.unwrap_or_default();
-
-	if parachain_host_runtime_api_version <
-		RuntimeApiRequest::SCHEDULING_LOOKAHEAD_RUNTIME_REQUIREMENT
-	{
-		return None;
-	}
-
-	match relay_client.scheduling_lookahead(relay_parent).await {
-		Ok(scheduling_lookahead) => Some(scheduling_lookahead),
-		Err(err) => {
-			tracing::error!(
-				target: crate::LOG_TARGET,
-				?err,
-				?relay_parent,
-				"Failed to fetch scheduling lookahead from relay chain",
-			);
-			None
-		},
-	}
-}
-
 // Returns the claim queue at the given relay parent.
 async fn claim_queue_at(
 	relay_parent: RelayHash,
@@ -290,14 +247,12 @@ async fn find_parent<Block>(
 where
 	Block: BlockT,
 {
-	let parent_search_params = ParentSearchParams {
-		relay_parent,
-		para_id,
-		ancestry_lookback: scheduling_lookahead(relay_parent, relay_client)
-			.await
-			.unwrap_or(DEFAULT_SCHEDULING_LOOKAHEAD)
-			.saturating_sub(1) as usize,
-	};
+	let ancestry_lookback = relay_client
+		.scheduling_lookahead(relay_parent)
+		.await
+		.unwrap_or(DEFAULT_SCHEDULING_LOOKAHEAD)
+		.saturating_sub(1) as usize;
+	let parent_search_params = ParentSearchParams { relay_parent, para_id, ancestry_lookback };
 
 	let mut result = match cumulus_client_consensus_common::find_parent_for_building::<Block>(
 		parent_search_params,
@@ -743,6 +698,13 @@ impl RelayParentData {
 		&self.relay_parent
 	}
 
+	/// Returns a reference to the descendants list.
+	///
+	/// List is ordered from oldest to newest.
+	pub fn descendants(&self) -> &[RelayHeader] {
+		&self.descendants
+	}
+
 	/// Returns the number of descendants.
 	#[cfg(test)]
 	pub fn descendants_len(&self) -> usize {