cumulus: ParachainBlockData support multiple blocks

.github/workflows/zombienet-reusable-preflight.yml

@@ -245,7 +245,7 @@ jobs:
               echo "::warning::No CI workflow runs found for this commit"
               exit 1
             fi
-            sleep 10
+            sleep 60
           done
 
           #check if the build succeeded

cumulus/client/collator/src/lib.rs

@@ -32,7 +32,7 @@ use polkadot_node_subsystem::messages::{CollationGenerationMessage, CollatorProt
 use polkadot_overseer::Handle as OverseerHandle;
 use polkadot_primitives::{CollatorPair, Id as ParaId};
 
-use codec::{Decode, Encode};
+use codec::Decode;
 use futures::prelude::*;
 use std::sync::Arc;
 
@@ -121,13 +121,7 @@ where
 
 		let (collation, b) = self.service.build_collation(&last_head, block_hash, candidate)?;
 
-		tracing::info!(
-			target: LOG_TARGET,
-			"PoV size {{ header: {}kb, extrinsics: {}kb, storage_proof: {}kb }}",
-			b.header().encode().len() as f64 / 1024f64,
-			b.extrinsics().encode().len() as f64 / 1024f64,
-			b.storage_proof().encode().len() as f64 / 1024f64,
-		);
+		b.log_size_info();
 
 		if let MaybeCompressedPoV::Compressed(ref pov) = collation.proof_of_validity {
 			tracing::info!(
@@ -337,6 +331,7 @@ pub fn start_collator_sync<Block, RA, BS, Spawner>(
 mod tests {
 	use super::*;
 	use async_trait::async_trait;
+	use codec::Encode;
 	use cumulus_client_consensus_common::ParachainCandidate;
 	use cumulus_primitives_core::ParachainBlockData;
 	use cumulus_test_client::{
@@ -459,10 +454,10 @@ mod tests {
 		let block =
 			ParachainBlockData::<Block>::decode(&mut &decompressed[..]).expect("Is a valid block");
 
-		assert_eq!(1, *block.header().number());
+		assert_eq!(1, *block.blocks()[0].header().number());
 
 		// Ensure that we did not include `:code` in the proof.
-		let proof = block.storage_proof();
+		let proof = block.proof().clone();
 
 		let backend = sp_state_machine::create_proof_check_backend::<BlakeTwo256>(
 			*header.state_root(),

cumulus/client/collator/src/service.rs

@@ -176,13 +176,14 @@ where
 
 	/// Fetch the collation info from the runtime.
 	///
-	/// Returns `Ok(Some(_))` on success, `Err(_)` on error or `Ok(None)` if the runtime api isn't
-	/// implemented by the runtime.
+	/// Returns `Ok(Some((CollationInfo, ApiVersion)))` on success, `Err(_)` on error or `Ok(None)`
+	/// if the runtime api isn't implemented by the runtime. `ApiVersion` being the version of the
+	/// [`CollectCollationInfo`] runtime api.
 	pub fn fetch_collation_info(
 		&self,
 		block_hash: Block::Hash,
 		header: &Block::Header,
-	) -> Result<Option<CollationInfo>, sp_api::ApiError> {
+	) -> Result<Option<(CollationInfo, u32)>, sp_api::ApiError> {
 		let runtime_api = self.runtime_api.runtime_api();
 
 		let api_version =
@@ -206,7 +207,7 @@ where
 			runtime_api.collect_collation_info(block_hash, header)?
 		};
 
-		Ok(Some(collation_info))
+		Ok(Some((collation_info, api_version)))
 	}
 
 	/// Build a full [`Collation`] from a given [`ParachainCandidate`]. This requires
@@ -220,7 +221,7 @@ where
 		block_hash: Block::Hash,
 		candidate: ParachainCandidate<Block>,
 	) -> Option<(Collation, ParachainBlockData<Block>)> {
-		let (header, extrinsics) = candidate.block.deconstruct();
+		let block = candidate.block;
 
 		let compact_proof = match candidate
 			.proof
@@ -234,8 +235,8 @@ where
 		};
 
 		// Create the parachain block data for the validators.
-		let collation_info = self
-			.fetch_collation_info(block_hash, &header)
+		let (collation_info, api_version) = self
+			.fetch_collation_info(block_hash, block.header())
 			.map_err(|e| {
 				tracing::error!(
 					target: LOG_TARGET,
@@ -246,10 +247,23 @@ where
 			.ok()
 			.flatten()?;
 
-		let block_data = ParachainBlockData::<Block>::new(header, extrinsics, compact_proof);
+		let block_data = ParachainBlockData::<Block>::new(vec![block], compact_proof);
 
 		let pov = polkadot_node_primitives::maybe_compress_pov(PoV {
-			block_data: BlockData(block_data.encode()),
+			block_data: BlockData(if api_version >= 3 {
+				block_data.encode()
+			} else {
+				let block_data = block_data.as_v0();
+
+				if block_data.is_none() {
+					tracing::error!(
+						target: LOG_TARGET,
+						"Trying to submit a collation with multiple blocks is not supported by the current runtime."
+					);
+				}
+
+				block_data?.encode()
+			}),
 		});
 
 		let upward_messages = collation_info

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

@@ -25,7 +25,7 @@
 //! This module also exposes some standalone functions for common operations when building
 //! aura-based collators.
 
-use codec::{Codec, Encode};
+use codec::Codec;
 use cumulus_client_collator::service::ServiceInterface as CollatorServiceInterface;
 use cumulus_client_consensus_common::{
 	self as consensus_common, ParachainBlockImportMarker, ParachainCandidate,
@@ -229,10 +229,7 @@ where
 		inherent_data: (ParachainInherentData, InherentData),
 		proposal_duration: Duration,
 		max_pov_size: usize,
-	) -> Result<
-		Option<(Collation, ParachainBlockData<Block>, Block::Hash)>,
-		Box<dyn Error + Send + 'static>,
-	> {
+	) -> Result<Option<(Collation, ParachainBlockData<Block>)>, Box<dyn Error + Send + 'static>> {
 		let maybe_candidate = self
 			.build_block_and_import(
 				parent_header,
@@ -250,13 +247,7 @@ where
 		if let Some((collation, block_data)) =
 			self.collator_service.build_collation(parent_header, hash, candidate)
 		{
-			tracing::info!(
-				target: crate::LOG_TARGET,
-				"PoV size {{ header: {}kb, extrinsics: {}kb, storage_proof: {}kb }}",
-				block_data.header().encode().len() as f64 / 1024f64,
-				block_data.extrinsics().encode().len() as f64 / 1024f64,
-				block_data.storage_proof().encode().len() as f64 / 1024f64,
-			);
+			block_data.log_size_info();
 
 			if let MaybeCompressedPoV::Compressed(ref pov) = collation.proof_of_validity {
 				tracing::info!(
@@ -266,10 +257,9 @@ where
 				);
 			}
 
-			Ok(Some((collation, block_data, hash)))
+			Ok(Some((collation, block_data)))
 		} else {
-			Err(Box::<dyn Error + Send + Sync>::from("Unable to produce collation")
-				as Box<dyn Error + Send>)
+			Err(Box::<dyn Error + Send + Sync>::from("Unable to produce collation"))
 		}
 	}
 

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

@@ -253,9 +253,12 @@ where
 					.await
 			);
 
-			if let Some((collation, _, post_hash)) = maybe_collation {
+			if let Some((collation, block_data)) = maybe_collation {
+				let Some(block_hash) = block_data.blocks().first().map(|b| b.hash()) else {
+					continue
+				};
 				let result_sender =
-					Some(collator.collator_service().announce_with_barrier(post_hash));
+					Some(collator.collator_service().announce_with_barrier(block_hash));
 				request.complete(Some(CollationResult { collation, result_sender }));
 			} else {
 				request.complete(None);

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

@@ -399,7 +399,16 @@ where
 					)
 					.await
 				{
-					Ok(Some((collation, block_data, new_block_hash))) => {
+					Ok(Some((collation, block_data))) => {
+						let Some(new_block_header) =
+							block_data.blocks().first().map(|b| b.header().clone())
+						else {
+							tracing::error!(target: crate::LOG_TARGET,  "Produced PoV doesn't contain any blocks");
+							break
+						};
+
+						let new_block_hash = new_block_header.hash();
+
 						// Here we are assuming that the import logic protects against equivocations
 						// and provides sybil-resistance, as it should.
 						collator.collator_service().announce_block(new_block_hash, None);
@@ -409,7 +418,7 @@ where
 								export_pov.clone(),
 								collation.proof_of_validity.clone().into_compressed(),
 								new_block_hash,
-								*block_data.header().number(),
+								*new_block_header.number(),
 								parent_header.clone(),
 								*relay_parent_header.state_root(),
 								*relay_parent_header.number(),
@@ -439,7 +448,7 @@ where
 							.await;
 
 						parent_hash = new_block_hash;
-						parent_header = block_data.into_header();
+						parent_header = new_block_header;
 					},
 					Ok(None) => {
 						tracing::debug!(target: crate::LOG_TARGET, "No block proposal");

cumulus/client/consensus/aura/src/collators/slot_based/collation_task.rs

@@ -140,29 +140,25 @@ async fn handle_collation_message<Block: BlockT, RClient: RelayChainInterface +
 			},
 		};
 
-	tracing::info!(
-		target: LOG_TARGET,
-		"PoV size {{ header: {:.2}kB, extrinsics: {:.2}kB, storage_proof: {:.2}kB }}",
-		block_data.header().encoded_size() as f64 / 1024f64,
-		block_data.extrinsics().encoded_size() as f64 / 1024f64,
-		block_data.storage_proof().encoded_size() as f64 / 1024f64,
-	);
+	block_data.log_size_info();
 
 	if let MaybeCompressedPoV::Compressed(ref pov) = collation.proof_of_validity {
 		if let Some(pov_path) = export_pov {
 			if let Ok(Some(relay_parent_header)) =
 				relay_client.header(BlockId::Hash(relay_parent)).await
 			{
-				export_pov_to_path::<Block>(
-					pov_path.clone(),
-					pov.clone(),
-					block_data.header().hash(),
-					*block_data.header().number(),
-					parent_header.clone(),
-					relay_parent_header.state_root,
-					relay_parent_header.number,
-					max_pov_size,
-				);
+				if let Some(header) = block_data.blocks().first().map(|b| b.header()) {
+					export_pov_to_path::<Block>(
+						pov_path.clone(),
+						pov.clone(),
+						header.hash(),
+						*header.number(),
+						parent_header.clone(),
+						relay_parent_header.state_root,
+						relay_parent_header.number,
+						max_pov_size,
+					);
+				}
 			} else {
 				tracing::error!(target: LOG_TARGET, "Failed to get relay parent header from hash: {relay_parent:?}");
 			}