diff --git a/Cargo.lock b/Cargo.lock
index a424738685e7..3b4a5aa4a443 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -262,9 +262,9 @@ dependencies = [
[[package]]
name = "anyhow"
-version = "1.0.81"
+version = "1.0.86"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0952808a6c2afd1aa8947271f3a60f1a6763c7b912d210184c5149b5cf147247"
+checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da"
[[package]]
name = "approx"
@@ -4149,6 +4149,24 @@ dependencies = [
"staging-xcm",
]
+[[package]]
+name = "cumulus-pov-validator"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "clap 4.5.9",
+ "parity-scale-codec",
+ "polkadot-node-primitives",
+ "polkadot-parachain-primitives",
+ "polkadot-primitives",
+ "sc-executor",
+ "sp-core",
+ "sp-io",
+ "sp-maybe-compressed-blob",
+ "tracing",
+ "tracing-subscriber 0.3.18",
+]
+
[[package]]
name = "cumulus-primitives-aura"
version = "0.7.0"
diff --git a/Cargo.toml b/Cargo.toml
index 759780ce4a4c..8d1beb8d33db 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -61,6 +61,7 @@ members = [
"bridges/snowbridge/primitives/router",
"bridges/snowbridge/runtime/runtime-common",
"bridges/snowbridge/runtime/test-common",
+ "cumulus/bin/pov-validator",
"cumulus/client/cli",
"cumulus/client/collator",
"cumulus/client/consensus/aura",
diff --git a/cumulus/bin/pov-validator/Cargo.toml b/cumulus/bin/pov-validator/Cargo.toml
new file mode 100644
index 000000000000..9be92960ad77
--- /dev/null
+++ b/cumulus/bin/pov-validator/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "cumulus-pov-validator"
+version = "0.1.0"
+authors.workspace = true
+edition.workspace = true
+repository.workspace = true
+license.workspace = true
+homepage.workspace = true
+description = "A tool for validating PoVs locally"
+
+[dependencies]
+codec.workspace = true
+clap = { workspace = true, features = ["derive"] }
+sc-executor.workspace = true
+sp-io.workspace = true
+sp-core.workspace = true
+sp-maybe-compressed-blob.workspace = true
+polkadot-node-primitives.workspace = true
+polkadot-parachain-primitives.workspace = true
+polkadot-primitives.workspace = true
+anyhow.workspace = true
+tracing.workspace = true
+tracing-subscriber.workspace = true
+
+[lints]
+workspace = true
diff --git a/cumulus/bin/pov-validator/src/main.rs b/cumulus/bin/pov-validator/src/main.rs
new file mode 100644
index 000000000000..1c08f218f6b8
--- /dev/null
+++ b/cumulus/bin/pov-validator/src/main.rs
@@ -0,0 +1,154 @@
+// This file is part of Cumulus.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+// This program 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.
+
+// This program 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 this program. If not, see .
+
+use clap::Parser;
+use codec::{Decode, Encode};
+use polkadot_node_primitives::{BlockData, PoV, POV_BOMB_LIMIT, VALIDATION_CODE_BOMB_LIMIT};
+use polkadot_parachain_primitives::primitives::ValidationParams;
+use polkadot_primitives::{BlockNumber as RBlockNumber, Hash as RHash, HeadData};
+use sc_executor::WasmExecutor;
+use sp_core::traits::{CallContext, CodeExecutor, RuntimeCode, WrappedRuntimeCode};
+use std::{fs, path::PathBuf, time::Instant};
+use tracing::level_filters::LevelFilter;
+
+/// Tool for validating a `PoV` locally.
+#[derive(Parser)]
+struct Cli {
+ /// The path to the validation code that should be used to validate the `PoV`.
+ ///
+ /// The validation code can either be downloaded from the relay chain that the parachain is
+ /// connected to or by building the runtime manually to obtain the WASM binary.
+ #[arg(long)]
+ validation_code: PathBuf,
+
+ /// The path to the `PoV` to validate.
+ ///
+ /// The `PoV`'s can be obtained by running `polkadot-parachains --collator --chain YOUR_CHAIN
+ /// --export-pov-to-path PATH_TO_EXPORT` and then choose one of the exported `PoV`'s.
+ #[arg(long)]
+ pov: PathBuf,
+}
+
+fn main() -> anyhow::Result<()> {
+ let _ = tracing_subscriber::fmt()
+ .with_env_filter(
+ tracing_subscriber::EnvFilter::from_default_env()
+ .add_directive(LevelFilter::INFO.into()),
+ )
+ .with_writer(std::io::stderr)
+ .try_init();
+
+ let cli = Cli::parse();
+
+ let validation_code = fs::read(&cli.validation_code).map_err(|error| {
+ tracing::error!(%error, path = %cli.validation_code.display(), "Failed to read validation code");
+ anyhow::anyhow!("Failed to read validation code")
+ })?;
+
+ let validation_code =
+ sp_maybe_compressed_blob::decompress(&validation_code, VALIDATION_CODE_BOMB_LIMIT)
+ .map_err(|error| {
+ tracing::error!(%error, "Failed to decompress validation code");
+ anyhow::anyhow!("Failed to decompress validation code")
+ })?;
+
+ let pov_file = fs::read(&cli.pov).map_err(|error| {
+ tracing::error!(%error, path = %cli.pov.display(), "Failed to read PoV");
+ anyhow::anyhow!("Failed to read PoV")
+ })?;
+
+ let executor = WasmExecutor::::builder()
+ .with_allow_missing_host_functions(true)
+ .build();
+
+ let runtime_code = RuntimeCode {
+ code_fetcher: &WrappedRuntimeCode(validation_code.into()),
+ heap_pages: None,
+ // The hash is used for caching, which we need here, but we only use one wasm file. So, the
+ // actual hash is not that important.
+ hash: vec![1, 2, 3],
+ };
+
+ // We are calling `Core_version` to get the wasm file compiled. We don't care about the result.
+ let _ = executor
+ .call(
+ &mut sp_io::TestExternalities::default().ext(),
+ &runtime_code,
+ "Core_version",
+ &[],
+ CallContext::Offchain,
+ )
+ .0;
+
+ let pov_file_ptr = &mut &pov_file[..];
+ let pov = PoV::decode(pov_file_ptr).map_err(|error| {
+ tracing::error!(%error, "Failed to decode `PoV`");
+ anyhow::anyhow!("Failed to decode `PoV`")
+ })?;
+ let head_data = HeadData::decode(pov_file_ptr).map_err(|error| {
+ tracing::error!(%error, "Failed to `HeadData`");
+ anyhow::anyhow!("Failed to decode `HeadData`")
+ })?;
+ let relay_parent_storage_root = RHash::decode(pov_file_ptr).map_err(|error| {
+ tracing::error!(%error, "Failed to relay storage root");
+ anyhow::anyhow!("Failed to decode relay storage root")
+ })?;
+ let relay_parent_number = RBlockNumber::decode(pov_file_ptr).map_err(|error| {
+ tracing::error!(%error, "Failed to relay block number");
+ anyhow::anyhow!("Failed to decode relay block number")
+ })?;
+
+ let pov = sp_maybe_compressed_blob::decompress(&pov.block_data.0, POV_BOMB_LIMIT).map_err(
+ |error| {
+ tracing::error!(%error, "Failed to decompress `PoV`");
+ anyhow::anyhow!("Failed to decompress `PoV`")
+ },
+ )?;
+
+ let validation_params = ValidationParams {
+ relay_parent_number,
+ relay_parent_storage_root,
+ parent_head: head_data,
+ block_data: BlockData(pov.into()),
+ };
+
+ tracing::info!("Starting validation");
+
+ let start = Instant::now();
+
+ let res = executor
+ .call(
+ &mut sp_io::TestExternalities::default().ext(),
+ &runtime_code,
+ "validate_block",
+ &validation_params.encode(),
+ CallContext::Offchain,
+ )
+ .0;
+
+ let duration = start.elapsed();
+
+ match res {
+ Ok(_) => tracing::info!("Validation was successful"),
+ Err(error) => tracing::error!(%error, "Validation failed"),
+ }
+
+ tracing::info!("Validation took {}ms", duration.as_millis());
+
+ Ok(())
+}
diff --git a/cumulus/client/consensus/aura/src/collators/lookahead.rs b/cumulus/client/consensus/aura/src/collators/lookahead.rs
index 749b13112394..02d60538a732 100644
--- a/cumulus/client/consensus/aura/src/collators/lookahead.rs
+++ b/cumulus/client/consensus/aura/src/collators/lookahead.rs
@@ -39,10 +39,13 @@ use cumulus_primitives_aura::AuraUnincludedSegmentApi;
use cumulus_primitives_core::{CollectCollationInfo, PersistedValidationData};
use cumulus_relay_chain_interface::RelayChainInterface;
-use polkadot_node_primitives::SubmitCollationParams;
+use polkadot_node_primitives::{PoV, SubmitCollationParams};
use polkadot_node_subsystem::messages::CollationGenerationMessage;
use polkadot_overseer::Handle as OverseerHandle;
-use polkadot_primitives::{CollatorPair, Id as ParaId, OccupiedCoreAssumption};
+use polkadot_primitives::{
+ BlockNumber as RBlockNumber, CollatorPair, Hash as RHash, HeadData, Id as ParaId,
+ OccupiedCoreAssumption,
+};
use futures::prelude::*;
use sc_client_api::{backend::AuxStore, BlockBackend, BlockOf};
@@ -54,10 +57,49 @@ use sp_consensus_aura::{AuraApi, Slot};
use sp_core::crypto::Pair;
use sp_inherents::CreateInherentDataProviders;
use sp_keystore::KeystorePtr;
-use sp_runtime::traits::{Block as BlockT, Header as HeaderT, Member};
-use std::{sync::Arc, time::Duration};
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT, Member, NumberFor};
+use std::{
+ fs::{self, File},
+ path::PathBuf,
+ sync::Arc,
+ time::Duration,
+};
-use crate::collator::{self as collator_util};
+use crate::{collator as collator_util, LOG_TARGET};
+
+/// Export the given `pov` to the file system at `path`.
+///
+/// The file will be named `block_hash_block_number.pov`.
+///
+/// The `parent_header`, `relay_parent_storage_root` and `relay_parent_number` will also be
+/// stored in the file alongside the `pov`. This enables stateless validation of the `pov`.
+fn export_pov_to_path(
+ path: PathBuf,
+ pov: PoV,
+ block_hash: Block::Hash,
+ block_number: NumberFor,
+ parent_header: Block::Header,
+ relay_parent_storage_root: RHash,
+ relay_parent_number: RBlockNumber,
+) {
+ if let Err(error) = fs::create_dir_all(&path) {
+ tracing::error!(target: LOG_TARGET, %error, path = %path.display(), "Failed to create PoV export directory");
+ return
+ }
+
+ let mut file = match File::create(path.join(format!("{block_hash:?}_{block_number}.pov"))) {
+ Ok(f) => f,
+ Err(error) => {
+ tracing::error!(target: LOG_TARGET, %error, "Failed to export PoV.");
+ return
+ },
+ };
+
+ pov.encode_to(&mut file);
+ HeadData(parent_header.encode()).encode_to(&mut file);
+ relay_parent_storage_root.encode_to(&mut file);
+ relay_parent_number.encode_to(&mut file);
+}
/// Parameters for [`run`].
pub struct Params {
@@ -97,7 +139,58 @@ pub struct Params {
/// Run async-backing-friendly Aura.
pub fn run(
- mut params: Params,
+ params: Params,
+) -> impl Future