feat: switch to WASM-only executor (#841)

Required for the `CheckMetadata` extension to work properly. Fixes
KILTprotocol/ticket#3744. Changes "inspired"
from this PR: paritytech/cumulus#1054.

## How to test

We can re-test this and other related scenarios during our deployment to
staging. I already included the step in the [next release
ticket](KILTprotocol/ticket#3524).

## Checklist

- [x] Check block production for standalone (binary)
- [x] Check if SDK metadata-related tests pass
- [x] Check that the other commands (e.g., benchmarks) work fine
- [x] Check block production for kilt-parachain (locally built Docker
image + Zombienet)

Author: ntn-x2

nodes/parachain/src/command.rs

@@ -47,19 +47,19 @@ macro_rules! construct_async_run {
 		match runtime {
 			ParachainRuntime::Spiritnet(_) => {
 				runner.async_run(|$config| {
-					let $components = new_partial::<spiritnet_runtime::RuntimeApi, SpiritnetRuntimeExecutor, _>(
+					let $components = new_partial::<spiritnet_runtime::RuntimeApi, _>(
 						&$config,
-						crate::service::build_import_queue::<SpiritnetRuntimeExecutor, spiritnet_runtime::RuntimeApi>,
+						crate::service::build_import_queue::<spiritnet_runtime::RuntimeApi>,
 					)?;
 					let task_manager = $components.task_manager;
 					{ $( $code )* }.map(|v| (v, task_manager))
 				})
 			},
 			ParachainRuntime::Peregrine(_) => {
 				runner.async_run(|$config| {
-					let $components = new_partial::<peregrine_runtime::RuntimeApi, PeregrineRuntimeExecutor, _>(
+					let $components = new_partial::<peregrine_runtime::RuntimeApi, _>(
 						&$config,
-						crate::service::build_import_queue::<PeregrineRuntimeExecutor, peregrine_runtime::RuntimeApi>,
+						crate::service::build_import_queue::<peregrine_runtime::RuntimeApi>,
 					)?;
 					let task_manager = $components.task_manager;
 					{ $( $code )* }.map(|v| (v, task_manager))
@@ -123,15 +123,15 @@ pub(crate) fn run() -> sc_cli::Result<()> {
 
 			match runtime {
 				ParachainRuntime::Spiritnet(_) => runner.sync_run(|config| {
-					let partials = new_partial::<spiritnet_runtime::RuntimeApi, SpiritnetRuntimeExecutor, _>(
+					let partials = new_partial::<spiritnet_runtime::RuntimeApi, _>(
 						&config,
 						crate::service::build_import_queue,
 					)?;
 
 					cmd.run(partials.client)
 				}),
 				ParachainRuntime::Peregrine(_) => runner.sync_run(|config| {
-					let partials = new_partial::<peregrine_runtime::RuntimeApi, PeregrineRuntimeExecutor, _>(
+					let partials = new_partial::<peregrine_runtime::RuntimeApi, _>(
 						&config,
 						crate::service::build_import_queue,
 					)?;
@@ -187,14 +187,14 @@ pub(crate) fn run() -> sc_cli::Result<()> {
 					}
 				}
 				(BenchmarkCmd::Block(cmd), ParachainRuntime::Spiritnet(_)) => runner.sync_run(|config| {
-					let partials = new_partial::<spiritnet_runtime::RuntimeApi, SpiritnetRuntimeExecutor, _>(
+					let partials = new_partial::<spiritnet_runtime::RuntimeApi, _>(
 						&config,
 						crate::service::build_import_queue,
 					)?;
 					cmd.run(partials.client)
 				}),
 				(BenchmarkCmd::Block(cmd), ParachainRuntime::Peregrine(_)) => runner.sync_run(|config| {
-					let partials = new_partial::<peregrine_runtime::RuntimeApi, PeregrineRuntimeExecutor, _>(
+					let partials = new_partial::<peregrine_runtime::RuntimeApi, _>(
 						&config,
 						crate::service::build_import_queue,
 					)?;
@@ -208,7 +208,7 @@ pub(crate) fn run() -> sc_cli::Result<()> {
 				)),
 				#[cfg(feature = "runtime-benchmarks")]
 				(BenchmarkCmd::Storage(cmd), ParachainRuntime::Spiritnet(_)) => runner.sync_run(|config| {
-					let partials = new_partial::<spiritnet_runtime::RuntimeApi, SpiritnetRuntimeExecutor, _>(
+					let partials = new_partial::<spiritnet_runtime::RuntimeApi, _>(
 						&config,
 						crate::service::build_import_queue,
 					)?;
@@ -220,7 +220,7 @@ pub(crate) fn run() -> sc_cli::Result<()> {
 				}),
 				#[cfg(feature = "runtime-benchmarks")]
 				(BenchmarkCmd::Storage(cmd), ParachainRuntime::Peregrine(_)) => runner.sync_run(|config| {
-					let partials = new_partial::<peregrine_runtime::RuntimeApi, PeregrineRuntimeExecutor, _>(
+					let partials = new_partial::<peregrine_runtime::RuntimeApi, _>(
 						&config,
 						crate::service::build_import_queue,
 					)?;
@@ -284,7 +284,7 @@ pub(crate) fn run() -> sc_cli::Result<()> {
 
 				match runtime {
 					ParachainRuntime::Peregrine(_) => {
-						crate::service::start_node::<PeregrineRuntimeExecutor, peregrine_runtime::RuntimeApi>(
+						crate::service::start_node::<peregrine_runtime::RuntimeApi>(
 							config,
 							polkadot_config,
 							collator_options,
@@ -296,7 +296,7 @@ pub(crate) fn run() -> sc_cli::Result<()> {
 						.map_err(Into::into)
 					},
 					ParachainRuntime::Spiritnet(_) => {
-						crate::service::start_node::<SpiritnetRuntimeExecutor, spiritnet_runtime::RuntimeApi>(
+						crate::service::start_node::<spiritnet_runtime::RuntimeApi>(
 							config,
 							polkadot_config,
 							collator_options,

nodes/parachain/src/service.rs

@@ -32,14 +32,14 @@ use cumulus_primitives_core::{
 	ParaId,
 };
 use cumulus_relay_chain_interface::{OverseerHandle, RelayChainInterface};
-use polkadot_service::NativeExecutionDispatch;
 use sc_consensus::ImportQueue;
-use sc_executor::NativeElseWasmExecutor;
+use sc_executor::WasmExecutor;
 use sc_network::NetworkBlock;
 use sc_network_sync::SyncingService;
 use sc_service::{Configuration, TFullBackend, TFullClient, TaskManager};
 use sc_telemetry::{Telemetry, TelemetryHandle, TelemetryWorker, TelemetryWorkerHandle};
 use sp_api::ConstructRuntimeApi;
+use sp_io::SubstrateHostFunctions;
 use sp_keystore::KeystorePtr;
 use sp_runtime::traits::BlakeTwo256;
 use std::{sync::Arc, time::Duration};
@@ -54,26 +54,31 @@ type Header = sp_runtime::generic::Header<BlockNumber, sp_runtime::traits::Blake
 
 pub(crate) type Block = sp_runtime::generic::Block<Header, sp_runtime::OpaqueExtrinsic>;
 
-type ParachainExecutor<Executor> = NativeElseWasmExecutor<Executor>;
+#[cfg(not(feature = "runtime-benchmarks"))]
+type HostFunctions = SubstrateHostFunctions;
+#[cfg(feature = "runtime-benchmarks")]
+type HostFunctions = (SubstrateHostFunctions, frame_benchmarking::benchmarking::HostFunctions);
 
-type ParachainClient<RuntimeApi, Executor> = TFullClient<Block, RuntimeApi, ParachainExecutor<Executor>>;
+type ParachainExecutor = WasmExecutor<HostFunctions>;
+
+type ParachainClient<RuntimeApi> = TFullClient<Block, RuntimeApi, ParachainExecutor>;
 
 type ParachainBackend = TFullBackend<Block>;
 
-type ParachainBlockImport<RuntimeApi, Executor> =
-	TParachainBlockImport<Block, Arc<ParachainClient<RuntimeApi, Executor>>, ParachainBackend>;
+type ParachainBlockImport<RuntimeApi> =
+	TParachainBlockImport<Block, Arc<ParachainClient<RuntimeApi>>, ParachainBackend>;
 
-pub(crate) type TransactionPool<Block, RuntimeApi, Executor> =
-	sc_transaction_pool::FullPool<Block, TFullClient<Block, RuntimeApi, Executor>>;
+pub(crate) type TransactionPool<Block, RuntimeApi> =
+	sc_transaction_pool::FullPool<Block, TFullClient<Block, RuntimeApi, WasmExecutor<HostFunctions>>>;
 
-type PartialComponents<Block, RuntimeApi, Executor, Telemetry, TelemetryWorkerHandle> = sc_service::PartialComponents<
-	TFullClient<Block, RuntimeApi, NativeElseWasmExecutor<Executor>>,
+type PartialComponents<Block, RuntimeApi, Telemetry, TelemetryWorkerHandle> = sc_service::PartialComponents<
+	TFullClient<Block, RuntimeApi, WasmExecutor<HostFunctions>>,
 	TFullBackend<Block>,
 	(),
 	sc_consensus::DefaultImportQueue<Block>,
-	TransactionPool<Block, RuntimeApi, NativeElseWasmExecutor<Executor>>,
+	TransactionPool<Block, RuntimeApi>,
 	(
-		ParachainBlockImport<RuntimeApi, Executor>,
+		ParachainBlockImport<RuntimeApi>,
 		Option<Telemetry>,
 		Option<TelemetryWorkerHandle>,
 	),
@@ -113,26 +118,23 @@ impl sc_executor::NativeExecutionDispatch for PeregrineRuntimeExecutor {
 ///
 /// Use this macro if you don't actually need the full service, but just the
 /// builder in order to be able to perform chain operations.
-pub(crate) fn new_partial<RuntimeApi, Executor, BIQ>(
+pub(crate) fn new_partial<RuntimeApi, BIQ>(
 	config: &Configuration,
 	build_import_queue: BIQ,
-) -> Result<PartialComponents<Block, RuntimeApi, Executor, Telemetry, TelemetryWorkerHandle>, sc_service::Error>
+) -> Result<PartialComponents<Block, RuntimeApi, Telemetry, TelemetryWorkerHandle>, sc_service::Error>
 where
-	RuntimeApi: ConstructRuntimeApi<Block, TFullClient<Block, RuntimeApi, NativeElseWasmExecutor<Executor>>>
-		+ Send
-		+ Sync
-		+ 'static,
+	RuntimeApi:
+		ConstructRuntimeApi<Block, TFullClient<Block, RuntimeApi, WasmExecutor<HostFunctions>>> + Send + Sync + 'static,
 	RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>
 		+ sp_api::Metadata<Block>
 		+ sp_session::SessionKeys<Block>
 		+ sp_api::ApiExt<Block>
 		+ sp_offchain::OffchainWorkerApi<Block>
 		+ sp_block_builder::BlockBuilder<Block>,
 	sc_client_api::StateBackendFor<TFullBackend<Block>, Block>: sp_state_machine::Backend<BlakeTwo256>,
-	Executor: NativeExecutionDispatch + 'static,
 	BIQ: FnOnce(
-		Arc<TFullClient<Block, RuntimeApi, NativeElseWasmExecutor<Executor>>>,
-		ParachainBlockImport<RuntimeApi, Executor>,
+		Arc<TFullClient<Block, RuntimeApi, WasmExecutor<HostFunctions>>>,
+		ParachainBlockImport<RuntimeApi>,
 		&Configuration,
 		Option<TelemetryHandle>,
 		&TaskManager,
@@ -149,7 +151,14 @@ where
 		})
 		.transpose()?;
 
-	let executor = sc_service::new_native_or_wasm_executor(config);
+	#[allow(deprecated)]
+	let executor = ParachainExecutor::new(
+		config.wasm_method,
+		config.default_heap_pages,
+		config.max_runtime_instances,
+		None,
+		config.runtime_cache_size,
+	);
 
 	let (client, backend, keystore_container, task_manager) = sc_service::new_full_parts::<Block, RuntimeApi, _>(
 		config,
@@ -173,7 +182,7 @@ where
 		Arc::clone(&client),
 	);
 
-	let block_import = ParachainBlockImport::<RuntimeApi, Executor>::new(Arc::clone(&client), Arc::clone(&backend));
+	let block_import = ParachainBlockImport::<RuntimeApi>::new(Arc::clone(&client), Arc::clone(&backend));
 
 	let import_queue = build_import_queue(
 		Arc::clone(&client),
@@ -202,7 +211,7 @@ where
 /// runtime api.
 #[allow(clippy::too_many_arguments)]
 #[sc_tracing::logging::prefix_logs_with("Parachain")]
-async fn start_node_impl<RuntimeApi, Executor, RB, BIQ>(
+async fn start_node_impl<RuntimeApi, RB, BIQ>(
 	parachain_config: Configuration,
 	polkadot_config: Configuration,
 	collator_options: CollatorOptions,
@@ -212,13 +221,11 @@ async fn start_node_impl<RuntimeApi, Executor, RB, BIQ>(
 	hwbench: Option<sc_sysinfo::HwBench>,
 ) -> sc_service::error::Result<(
 	TaskManager,
-	Arc<TFullClient<Block, RuntimeApi, NativeElseWasmExecutor<Executor>>>,
+	Arc<TFullClient<Block, RuntimeApi, WasmExecutor<HostFunctions>>>,
 )>
 where
-	RuntimeApi: ConstructRuntimeApi<Block, TFullClient<Block, RuntimeApi, NativeElseWasmExecutor<Executor>>>
-		+ Send
-		+ Sync
-		+ 'static,
+	RuntimeApi:
+		ConstructRuntimeApi<Block, TFullClient<Block, RuntimeApi, WasmExecutor<HostFunctions>>> + Send + Sync + 'static,
 	RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>
 		+ sp_api::Metadata<Block>
 		+ sp_session::SessionKeys<Block>
@@ -231,23 +238,22 @@ where
 		+ sp_consensus_aura::AuraApi<Block, AuthorityId>
 		+ cumulus_primitives_aura::AuraUnincludedSegmentApi<Block>,
 	sc_client_api::StateBackendFor<TFullBackend<Block>, Block>: sp_state_machine::Backend<BlakeTwo256>,
-	Executor: sc_executor::NativeExecutionDispatch + 'static,
 	RB: FnOnce(
-			Arc<TFullClient<Block, RuntimeApi, NativeElseWasmExecutor<Executor>>>,
+			Arc<TFullClient<Block, RuntimeApi, WasmExecutor<HostFunctions>>>,
 		) -> Result<RpcModule<()>, sc_service::Error>
 		+ Send
 		+ 'static,
 	BIQ: FnOnce(
-		Arc<TFullClient<Block, RuntimeApi, NativeElseWasmExecutor<Executor>>>,
-		ParachainBlockImport<RuntimeApi, Executor>,
+		Arc<TFullClient<Block, RuntimeApi, WasmExecutor<HostFunctions>>>,
+		ParachainBlockImport<RuntimeApi>,
 		&Configuration,
 		Option<TelemetryHandle>,
 		&TaskManager,
 	) -> Result<sc_consensus::DefaultImportQueue<Block>, sc_service::Error>,
 {
 	let parachain_config = prepare_node_config(parachain_config);
 
-	let params = new_partial::<RuntimeApi, Executor, BIQ>(&parachain_config, build_import_queue)?;
+	let params = new_partial::<RuntimeApi, BIQ>(&parachain_config, build_import_queue)?;
 	let (block_import, mut telemetry, telemetry_worker_handle) = params.other;
 
 	let client = Arc::clone(&params.client);
@@ -357,7 +363,7 @@ where
 	})?;
 
 	if validator {
-		start_consensus::<RuntimeApi, Executor>(
+		start_consensus::<RuntimeApi>(
 			Arc::clone(&client),
 			Arc::clone(&backend),
 			block_import,
@@ -383,16 +389,15 @@ where
 
 #[allow(clippy::type_complexity)]
 /// Build the import queue for THE runtime.
-pub(crate) fn build_import_queue<RE, API>(
-	client: Arc<TFullClient<Block, API, NativeElseWasmExecutor<RE>>>,
-	block_import: ParachainBlockImport<API, RE>,
+pub(crate) fn build_import_queue<API>(
+	client: Arc<TFullClient<Block, API, WasmExecutor<HostFunctions>>>,
+	block_import: ParachainBlockImport<API>,
 	config: &Configuration,
 	telemetry: Option<TelemetryHandle>,
 	task_manager: &TaskManager,
 ) -> Result<sc_consensus::DefaultImportQueue<Block>, sc_service::Error>
 where
-	RE: sc_executor::NativeExecutionDispatch + 'static,
-	API: ConstructRuntimeApi<Block, TFullClient<Block, API, NativeElseWasmExecutor<RE>>> + Send + Sync + 'static,
+	API: ConstructRuntimeApi<Block, TFullClient<Block, API, WasmExecutor<HostFunctions>>> + Send + Sync + 'static,
 	API::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>
 		+ sp_api::Metadata<Block>
 		+ sp_session::SessionKeys<Block>
@@ -430,16 +435,15 @@ where
 }
 
 /// Start a parachain node.
-pub(crate) async fn start_node<RE, API>(
+pub(crate) async fn start_node<API>(
 	parachain_config: Configuration,
 	polkadot_config: Configuration,
 	collator_options: CollatorOptions,
 	id: ParaId,
 	hwbench: Option<sc_sysinfo::HwBench>,
-) -> sc_service::error::Result<(TaskManager, Arc<TFullClient<Block, API, NativeElseWasmExecutor<RE>>>)>
+) -> sc_service::error::Result<(TaskManager, Arc<TFullClient<Block, API, WasmExecutor<HostFunctions>>>)>
 where
-	RE: sc_executor::NativeExecutionDispatch + 'static,
-	API: ConstructRuntimeApi<Block, TFullClient<Block, API, NativeElseWasmExecutor<RE>>> + Send + Sync + 'static,
+	API: ConstructRuntimeApi<Block, TFullClient<Block, API, WasmExecutor<HostFunctions>>> + Send + Sync + 'static,
 	API::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>
 		+ sp_api::Metadata<Block>
 		+ sp_session::SessionKeys<Block>
@@ -453,28 +457,28 @@ where
 		+ cumulus_primitives_aura::AuraUnincludedSegmentApi<Block>,
 	sc_client_api::StateBackendFor<TFullBackend<Block>, Block>: sp_state_machine::Backend<BlakeTwo256>,
 {
-	start_node_impl::<API, RE, _, _>(
+	start_node_impl::<API, _, _>(
 		parachain_config,
 		polkadot_config,
 		collator_options,
 		id,
 		|_| Ok(RpcModule::new(())),
-		build_import_queue::<RE, API>,
+		build_import_queue::<API>,
 		hwbench,
 	)
 	.await
 }
 
 #[allow(clippy::too_many_arguments)]
-fn start_consensus<RuntimeApi, Executor>(
-	client: Arc<ParachainClient<RuntimeApi, Executor>>,
+fn start_consensus<RuntimeApi>(
+	client: Arc<ParachainClient<RuntimeApi>>,
 	backend: Arc<ParachainBackend>,
-	block_import: ParachainBlockImport<RuntimeApi, Executor>,
+	block_import: ParachainBlockImport<RuntimeApi>,
 	prometheus_registry: Option<&Registry>,
 	telemetry: Option<TelemetryHandle>,
 	task_manager: &TaskManager,
 	relay_chain_interface: Arc<dyn RelayChainInterface>,
-	transaction_pool: Arc<sc_transaction_pool::FullPool<Block, ParachainClient<RuntimeApi, Executor>>>,
+	transaction_pool: Arc<sc_transaction_pool::FullPool<Block, ParachainClient<RuntimeApi>>>,
 	sync_oracle: Arc<SyncingService<Block>>,
 	keystore: KeystorePtr,
 	relay_chain_slot_duration: Duration,
@@ -484,10 +488,8 @@ fn start_consensus<RuntimeApi, Executor>(
 	announce_block: Arc<dyn Fn(Hash, Option<Vec<u8>>) + Send + Sync>,
 ) -> Result<(), sc_service::Error>
 where
-	RuntimeApi: ConstructRuntimeApi<Block, TFullClient<Block, RuntimeApi, NativeElseWasmExecutor<Executor>>>
-		+ Send
-		+ Sync
-		+ 'static,
+	RuntimeApi:
+		ConstructRuntimeApi<Block, TFullClient<Block, RuntimeApi, WasmExecutor<HostFunctions>>> + Send + Sync + 'static,
 	RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>
 		+ sp_api::Metadata<Block>
 		+ sp_session::SessionKeys<Block>
@@ -499,7 +501,6 @@ where
 		+ substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>
 		+ sp_consensus_aura::AuraApi<Block, AuthorityId>
 		+ cumulus_primitives_aura::AuraUnincludedSegmentApi<Block>,
-	Executor: sc_executor::NativeExecutionDispatch + 'static,
 {
 	use cumulus_client_consensus_aura::collators::lookahead::{self as aura, Params as AuraParams};