Allow separate max-heap-pages for offchain (non-consensus) execution context.

bin/node/executor/tests/common.rs

@@ -97,7 +97,7 @@ pub fn from_block_number(n: u32) -> Header {
 }
 
 pub fn executor() -> NativeExecutor<Executor> {
-	NativeExecutor::new(WasmExecutionMethod::Interpreted, None, 8)
+	NativeExecutor::new(WasmExecutionMethod::Interpreted, 8)
 }
 
 pub fn executor_call<
@@ -117,6 +117,7 @@ pub fn executor_call<
 	let heap_pages = t.storage(sp_core::storage::well_known_keys::HEAP_PAGES);
 	let runtime_code = RuntimeCode {
 		code_fetcher: &sp_core::traits::WrappedRuntimeCode(code.as_slice().into()),
+		context: sp_core::traits::CodeContext::Consensus,
 		hash: sp_core::blake2_256(&code).to_vec(),
 		heap_pages: heap_pages.and_then(|hp| Decode::decode(&mut &hp[..]).ok()),
 	};

bin/node/testing/src/bench.rs

@@ -41,7 +41,7 @@ use node_runtime::{
 };
 use sc_block_builder::BlockBuilderProvider;
 use sc_client_api::{
-	execution_extensions::{ExecutionExtensions, ExecutionStrategies},
+	execution_extensions::{ExecutionConfig, ExecutionConfigs, ExecutionExtensions},
 	BlockBackend, ExecutionStrategy,
 };
 use sc_client_db::PruningMode;
@@ -390,11 +390,11 @@ impl BenchDb {
 		let backend = sc_service::new_db_backend(db_config).expect("Should not fail");
 		let client = sc_service::new_client(
 			backend.clone(),
-			NativeExecutor::new(WasmExecutionMethod::Compiled, None, 8),
+			NativeExecutor::new(WasmExecutionMethod::Compiled, 8),
 			&keyring.generate_genesis(),
 			None,
 			None,
-			ExecutionExtensions::new(profile.into_execution_strategies(), None, None),
+			ExecutionExtensions::new(profile.into_execution_configs(), None, None),
 			Box::new(task_executor.clone()),
 			None,
 			None,
@@ -588,7 +588,7 @@ impl BenchKeyring {
 	}
 }
 
-/// Profile for exetion strategies.
+/// Profile for execution configurations.
 #[derive(Clone, Copy, Debug)]
 pub enum Profile {
 	/// As native as possible.
@@ -598,21 +598,23 @@ pub enum Profile {
 }
 
 impl Profile {
-	fn into_execution_strategies(self) -> ExecutionStrategies {
+	fn into_execution_configs(self) -> ExecutionConfigs {
 		match self {
-			Profile::Wasm => ExecutionStrategies {
-				syncing: ExecutionStrategy::AlwaysWasm,
-				importing: ExecutionStrategy::AlwaysWasm,
-				block_construction: ExecutionStrategy::AlwaysWasm,
-				offchain_worker: ExecutionStrategy::AlwaysWasm,
-				other: ExecutionStrategy::AlwaysWasm,
+			Profile::Wasm => ExecutionConfigs {
+				syncing: ExecutionConfig::new_offchain(ExecutionStrategy::AlwaysWasm),
+				importing: ExecutionConfig::new_offchain(ExecutionStrategy::AlwaysWasm),
+				block_construction: ExecutionConfig::new_offchain(ExecutionStrategy::AlwaysWasm),
+				offchain_worker: ExecutionConfig::new_offchain(ExecutionStrategy::AlwaysWasm),
+				other: ExecutionConfig::new_offchain(ExecutionStrategy::AlwaysWasm),
 			},
-			Profile::Native => ExecutionStrategies {
-				syncing: ExecutionStrategy::NativeElseWasm,
-				importing: ExecutionStrategy::NativeElseWasm,
-				block_construction: ExecutionStrategy::NativeElseWasm,
-				offchain_worker: ExecutionStrategy::NativeElseWasm,
-				other: ExecutionStrategy::NativeElseWasm,
+			Profile::Native => ExecutionConfigs {
+				syncing: ExecutionConfig::new_offchain(ExecutionStrategy::NativeElseWasm),
+				importing: ExecutionConfig::new_offchain(ExecutionStrategy::NativeElseWasm),
+				block_construction: ExecutionConfig::new_offchain(
+					ExecutionStrategy::NativeElseWasm,
+				),
+				offchain_worker: ExecutionConfig::new_offchain(ExecutionStrategy::NativeElseWasm),
+				other: ExecutionConfig::new_offchain(ExecutionStrategy::NativeElseWasm),
 			},
 		}
 	}

client/api/src/call_executor.rs

@@ -23,7 +23,7 @@ use sc_executor::{NativeVersion, RuntimeVersion};
 use sp_core::NativeOrEncoded;
 use sp_externalities::Extensions;
 use sp_runtime::{generic::BlockId, traits::Block as BlockT};
-use sp_state_machine::{ExecutionManager, ExecutionStrategy, OverlayedChanges, StorageProof};
+use sp_state_machine::{ExecutionConfig, ExecutionManager, OverlayedChanges, StorageProof};
 use std::{cell::RefCell, panic::UnwindSafe, result};
 
 use crate::execution_extensions::ExecutionExtensions;
@@ -57,7 +57,7 @@ pub trait CallExecutor<B: BlockT> {
 		id: &BlockId<B>,
 		method: &str,
 		call_data: &[u8],
-		strategy: ExecutionStrategy,
+		config: ExecutionConfig,
 		extensions: Option<Extensions>,
 	) -> Result<Vec<u8>, sp_blockchain::Error>;
 

client/api/src/execution_extensions.rs

@@ -32,33 +32,33 @@ use sp_core::{
 use sp_externalities::Extensions;
 use sp_keystore::{KeystoreExt, SyncCryptoStorePtr};
 use sp_runtime::{generic::BlockId, traits};
-pub use sp_state_machine::ExecutionStrategy;
 use sp_state_machine::{DefaultHandler, ExecutionManager};
+pub use sp_state_machine::{ExecutionConfig, ExecutionStrategy};
 use std::sync::{Arc, Weak};
 
-/// Execution strategies settings.
+/// Execution configurations, per operation type.
 #[derive(Debug, Clone)]
-pub struct ExecutionStrategies {
-	/// Execution strategy used when syncing.
-	pub syncing: ExecutionStrategy,
-	/// Execution strategy used when importing blocks.
-	pub importing: ExecutionStrategy,
-	/// Execution strategy used when constructing blocks.
-	pub block_construction: ExecutionStrategy,
-	/// Execution strategy used for offchain workers.
-	pub offchain_worker: ExecutionStrategy,
-	/// Execution strategy used in other cases.
-	pub other: ExecutionStrategy,
+pub struct ExecutionConfigs {
+	/// Execution config used when syncing.
+	pub syncing: ExecutionConfig,
+	/// Execution config used when importing blocks.
+	pub importing: ExecutionConfig,
+	/// Execution config used when constructing blocks.
+	pub block_construction: ExecutionConfig,
+	/// Execution config used for offchain workers.
+	pub offchain_worker: ExecutionConfig,
+	/// Execution config used in other cases.
+	pub other: ExecutionConfig,
 }
 
-impl Default for ExecutionStrategies {
-	fn default() -> ExecutionStrategies {
-		ExecutionStrategies {
-			syncing: ExecutionStrategy::NativeElseWasm,
-			importing: ExecutionStrategy::NativeElseWasm,
-			block_construction: ExecutionStrategy::AlwaysWasm,
-			offchain_worker: ExecutionStrategy::NativeWhenPossible,
-			other: ExecutionStrategy::NativeElseWasm,
+impl Default for ExecutionConfigs {
+	fn default() -> ExecutionConfigs {
+		ExecutionConfigs {
+			syncing: ExecutionStrategy::NativeElseWasm.in_consensus(),
+			importing: ExecutionStrategy::NativeElseWasm.in_consensus(),
+			block_construction: ExecutionStrategy::AlwaysWasm.in_consensus(),
+			offchain_worker: ExecutionStrategy::NativeWhenPossible.in_offchain(),
+			other: ExecutionStrategy::NativeElseWasm.in_consensus(),
 		}
 	}
 }
@@ -93,7 +93,7 @@ impl<T: offchain::DbExternalities + Clone + Sync + Send + 'static> DbExternaliti
 /// and is responsible for producing a correct `Extensions` object.
 /// for each call, based on required `Capabilities`.
 pub struct ExecutionExtensions<Block: traits::Block> {
-	strategies: ExecutionStrategies,
+	configs: ExecutionConfigs,
 	keystore: Option<SyncCryptoStorePtr>,
 	offchain_db: Option<Box<dyn DbExternalitiesFactory>>,
 	// FIXME: these two are only RwLock because of https://github.com/paritytech/substrate/issues/4587
@@ -109,7 +109,7 @@ pub struct ExecutionExtensions<Block: traits::Block> {
 impl<Block: traits::Block> Default for ExecutionExtensions<Block> {
 	fn default() -> Self {
 		Self {
-			strategies: Default::default(),
+			configs: Default::default(),
 			keystore: None,
 			offchain_db: None,
 			transaction_pool: RwLock::new(None),
@@ -119,26 +119,26 @@ impl<Block: traits::Block> Default for ExecutionExtensions<Block> {
 }
 
 impl<Block: traits::Block> ExecutionExtensions<Block> {
-	/// Create new `ExecutionExtensions` given a `keystore` and `ExecutionStrategies`.
+	/// Create new `ExecutionExtensions` given a `keystore` and `ExecutionConfigs`.
 	pub fn new(
-		strategies: ExecutionStrategies,
+		configs: ExecutionConfigs,
 		keystore: Option<SyncCryptoStorePtr>,
 		offchain_db: Option<Box<dyn DbExternalitiesFactory>>,
 	) -> Self {
 		let transaction_pool = RwLock::new(None);
 		let extensions_factory = Box::new(());
 		Self {
-			strategies,
+			configs,
 			keystore,
 			offchain_db,
 			extensions_factory: RwLock::new(extensions_factory),
 			transaction_pool,
 		}
 	}
 
-	/// Get a reference to the execution strategies.
-	pub fn strategies(&self) -> &ExecutionStrategies {
-		&self.strategies
+	/// Get a reference to the execution configs.
+	pub fn configs(&self) -> &ExecutionConfigs {
+		&self.configs
 	}
 
 	/// Set the new extensions_factory
@@ -207,12 +207,12 @@ impl<Block: traits::Block> ExecutionExtensions<Block> {
 		context: ExecutionContext,
 	) -> (ExecutionManager<DefaultHandler<R, E>>, Extensions) {
 		let manager = match context {
-			ExecutionContext::BlockConstruction => self.strategies.block_construction.get_manager(),
-			ExecutionContext::Syncing => self.strategies.syncing.get_manager(),
-			ExecutionContext::Importing => self.strategies.importing.get_manager(),
+			ExecutionContext::BlockConstruction => self.configs.block_construction.get_manager(),
+			ExecutionContext::Syncing => self.configs.syncing.get_manager(),
+			ExecutionContext::Importing => self.configs.importing.get_manager(),
 			ExecutionContext::OffchainCall(Some((_, capabilities))) if capabilities.has_all() =>
-				self.strategies.offchain_worker.get_manager(),
-			ExecutionContext::OffchainCall(_) => self.strategies.other.get_manager(),
+				self.configs.offchain_worker.get_manager(),
+			ExecutionContext::OffchainCall(_) => self.configs.other.get_manager(),
 		};
 
 		(manager, self.extensions(at, context))

client/api/src/lib.rs

@@ -39,7 +39,7 @@ pub use proof_provider::*;
 pub use sp_blockchain as blockchain;
 pub use sp_blockchain::HeaderBackend;
 
-pub use sp_state_machine::{ExecutionStrategy, StorageProof};
+pub use sp_state_machine::{ExecutionConfig, ExecutionStrategy, StorageProof};
 pub use sp_storage::{ChildInfo, PrefixedStorageKey, StorageData, StorageKey};
 
 /// Usage Information Provider interface

client/cli/Cargo.toml

@@ -43,6 +43,7 @@ sc-tracing = { version = "4.0.0-dev", path = "../tracing" }
 chrono = "0.4.10"
 serde = "1.0.126"
 thiserror = "1.0.21"
+paste = "1.0.5"
 
 [target.'cfg(not(target_os = "unknown"))'.dependencies]
 rpassword = "5.0.0"

client/cli/src/arg_enums.rs

@@ -18,6 +18,7 @@
 // NOTE: we allow missing docs here because arg_enum! creates the function variants without doc
 #![allow(missing_docs)]
 
+use sp_core::traits::CodeContext;
 use structopt::clap::arg_enum;
 
 /// How to execute Wasm runtime code.
@@ -260,15 +261,24 @@ impl Into<sc_network::config::SyncMode> for SyncMode {
 	}
 }
 
-/// Default value for the `--execution-syncing` parameter.
-pub const DEFAULT_EXECUTION_SYNCING: ExecutionStrategy = ExecutionStrategy::NativeElseWasm;
-/// Default value for the `--execution-import-block` parameter.
-pub const DEFAULT_EXECUTION_IMPORT_BLOCK: ExecutionStrategy = ExecutionStrategy::NativeElseWasm;
-/// Default value for the `--execution-import-block` parameter when the node is a validator.
-pub const DEFAULT_EXECUTION_IMPORT_BLOCK_VALIDATOR: ExecutionStrategy = ExecutionStrategy::Wasm;
-/// Default value for the `--execution-block-construction` parameter.
-pub const DEFAULT_EXECUTION_BLOCK_CONSTRUCTION: ExecutionStrategy = ExecutionStrategy::Wasm;
-/// Default value for the `--execution-offchain-worker` parameter.
-pub const DEFAULT_EXECUTION_OFFCHAIN_WORKER: ExecutionStrategy = ExecutionStrategy::Native;
-/// Default value for the `--execution-other` parameter.
-pub const DEFAULT_EXECUTION_OTHER: ExecutionStrategy = ExecutionStrategy::Native;
+macro_rules! generate_config_const {
+	($( $role:ident => $strategy:ident, $context:ident ),*) => {
+		paste::paste! {
+			$(
+				pub const [<DEFAULT_STRATEGY_ $role:snake:upper>]: ExecutionStrategy
+					= ExecutionStrategy::$strategy;
+				pub const [<DEFAULT_CODE_CONTEXT_ $role:snake:upper>]: CodeContext
+					= CodeContext::$context;
+			)*
+		}
+	};
+}
+
+generate_config_const!(
+	syncing => NativeElseWasm, Consensus,
+	import_block => NativeElseWasm, Consensus,
+	import_block_validator => Wasm, Consensus,
+	block_construction => Wasm, Consensus,
+	offchain_worker => Native, Offchain,
+	other => Native, Consensus
+);