refactor builder

bin/node/executor/benches/bench.rs

@@ -192,13 +192,12 @@ fn bench_execute_block(c: &mut Criterion) {
 		group.bench_function(format!("{:?}", strategy), |b| {
 			let genesis_config = node_testing::genesis::config(Some(compact_code_unwrap()));
 			let (use_native, wasm_method) = match strategy {
-				ExecutionMethod::Native => (true, WasmExecutionMethod::Interpreted),
+				ExecutionMethod::Native => (true),
 				ExecutionMethod::Wasm(wasm_method) => (false, wasm_method),
 			};
 
-			let executor = NativeElseWasmExecutor::new_with_wasm_executor(
-				WasmExecutor::builder(WasmExecutionMethod::Interpreted).build(),
-			);
+			let executor =
+				NativeElseWasmExecutor::new_with_wasm_executor(WasmExecutor::builder().build());
 			let runtime_code = RuntimeCode {
 				code_fetcher: &sp_core::traits::WrappedRuntimeCode(compact_code_unwrap().into()),
 				hash: vec![1, 2, 3],

bin/node/executor/tests/common.rs

@@ -98,9 +98,7 @@ pub fn from_block_number(n: u32) -> Header {
 }
 
 pub fn executor() -> NativeElseWasmExecutor<ExecutorDispatch> {
-	NativeElseWasmExecutor::new_with_wasm_executor(
-		WasmExecutor::builder(WasmExecutionMethod::Interpreted).build(),
-	)
+	NativeElseWasmExecutor::new_with_wasm_executor(WasmExecutor::builder().build())
 }
 
 pub fn executor_call(

bin/node/testing/src/bench.rs

@@ -393,10 +393,11 @@ impl BenchDb {
 
 		let backend = sc_service::new_db_backend(db_config).expect("Should not fail");
 		let executor = NativeElseWasmExecutor::new_with_wasm_executor(
-			sc_executor::WasmExecutor::builder(WasmExecutionMethod::Compiled {
-				instantiation_strategy: WasmtimeInstantiationStrategy::PoolingCopyOnWrite,
-			})
-			.build(),
+			sc_executor::WasmExecutor::builder()
+				.with_execution_method(WasmExecutionMethod::Compiled {
+					instantiation_strategy: WasmtimeInstantiationStrategy::PoolingCopyOnWrite,
+				})
+				.build(),
 		);
 
 		let client_config = sc_service::ClientConfig::default();

client/executor/src/executor.rs

@@ -98,10 +98,10 @@ impl<H> WasmExecutorBuilder<H> {
 	/// Create a new instance of `Self`
 	///
 	/// - `method`: The wasm execution method that should be used by the executor.
-	pub fn new(method: WasmExecutionMethod) -> Self {
+	pub fn new() -> Self {
 		Self {
 			_phantom: PhantomData,
-			method,
+			method: WasmExecutionMethod::default(),
 			onchain_heap_alloc_strategy: None,
 			offchain_heap_alloc_strategy: None,
 			max_runtime_instances: 2,
@@ -111,6 +111,12 @@ impl<H> WasmExecutorBuilder<H> {
 		}
 	}
 
+	/// Create the wasm executor with execution method that should be used by the executor.
+	pub fn with_execution_method(mut self, method: WasmExecutionMethod) -> Self {
+		self.method = method;
+		self
+	}
+
 	/// Create the wasm executor with the given number of `heap_alloc_strategy` for onchain runtime
 	/// calls.
 	pub fn with_onchain_heap_alloc_strategy(
@@ -282,8 +288,8 @@ where
 	}
 
 	/// Instantiate a builder for creating an instance of `Self`.
-	pub fn builder(method: WasmExecutionMethod) -> WasmExecutorBuilder<H> {
-		WasmExecutorBuilder::new(method)
+	pub fn builder() -> WasmExecutorBuilder<H> {
+		WasmExecutorBuilder::new()
 	}
 
 	/// Ignore missing function imports if set true.
@@ -561,13 +567,16 @@ impl<D: NativeExecutionDispatch> NativeElseWasmExecutor<D> {
 		max_runtime_instances: usize,
 		runtime_cache_size: u8,
 	) -> Self {
-		let wasm = WasmExecutor::new(
-			fallback_method,
-			default_heap_pages,
-			max_runtime_instances,
-			None,
-			runtime_cache_size,
-		);
+		let heap_pages = default_heap_pages.map_or(DEFAULT_HEAP_ALLOC_STRATEGY, |h| {
+			HeapAllocStrategy::Static { extra_pages: h as _ }
+		});
+		let wasm = WasmExecutor::builder()
+			.with_execution_method(fallback_method)
+			.with_onchain_heap_alloc_strategy(heap_pages)
+			.with_offchain_heap_alloc_strategy(heap_pages)
+			.with_max_runtime_instances(max_runtime_instances)
+			.with_runtime_cache_size(runtime_cache_size)
+			.build();
 
 		NativeElseWasmExecutor { native_version: D::native_version(), wasm }
 	}
@@ -718,7 +727,7 @@ mod tests {
 	#[test]
 	fn native_executor_registers_custom_interface() {
 		let executor = NativeElseWasmExecutor::<MyExecutorDispatch>::new_with_wasm_executor(
-			WasmExecutor::builder(WasmExecutionMethod::Interpreted).build(),
+			WasmExecutor::builder().build(),
 		);
 
 		fn extract_host_functions<H>(

client/executor/src/integration_tests/mod.rs

@@ -114,7 +114,9 @@ fn call_in_wasm<E: Externalities>(
 	execution_method: WasmExecutionMethod,
 	ext: &mut E,
 ) -> Result<Vec<u8>, Error> {
-	let executor = crate::WasmExecutor::<HostFunctions>::builder(execution_method).build();
+	let executor = crate::WasmExecutor::<HostFunctions>::builder()
+		.with_execution_method(execution_method)
+		.build();
 
 	executor.uncached_call(
 		RuntimeBlob::uncompress_if_needed(wasm_binary_unwrap()).unwrap(),
@@ -446,7 +448,8 @@ test_wasm_execution!(should_trap_when_heap_exhausted);
 fn should_trap_when_heap_exhausted(wasm_method: WasmExecutionMethod) {
 	let mut ext = TestExternalities::default();
 
-	let executor = crate::WasmExecutor::<HostFunctions>::builder(wasm_method)
+	let executor = crate::WasmExecutor::<HostFunctions>::builder()
+		.with_execution_method(wasm_method)
 		// `17` is the initial number of pages compiled into the binary.
 		.with_onchain_heap_alloc_strategy(HeapAllocStrategy::Static { extra_pages: 17 })
 		.build();
@@ -576,7 +579,11 @@ fn heap_is_reset_between_calls(wasm_method: WasmExecutionMethod) {
 
 test_wasm_execution!(parallel_execution);
 fn parallel_execution(wasm_method: WasmExecutionMethod) {
-	let executor = Arc::new(crate::WasmExecutor::<HostFunctions>::builder(wasm_method).build());
+	let executor = Arc::new(
+		crate::WasmExecutor::<HostFunctions>::builder()
+			.with_execution_method(wasm_method)
+			.build(),
+	);
 	let threads: Vec<_> = (0..8)
 		.map(|_| {
 			let executor = executor.clone();

client/executor/src/lib.rs

@@ -79,10 +79,7 @@ mod tests {
 		let mut ext = TestExternalities::default();
 		let mut ext = ext.ext();
 
-		let executor = WasmExecutor::<sp_io::SubstrateHostFunctions>::builder(
-			WasmExecutionMethod::Interpreted,
-		)
-		.build();
+		let executor = WasmExecutor::<sp_io::SubstrateHostFunctions>::builder().build();
 		let res = executor
 			.uncached_call(
 				RuntimeBlob::uncompress_if_needed(wasm_binary_unwrap()).unwrap(),

client/executor/wasmtime/src/tests.rs

@@ -20,9 +20,7 @@ use codec::{Decode as _, Encode as _};
 use sc_executor_common::{
 	error::Error,
 	runtime_blob::RuntimeBlob,
-	wasm_runtime::{
-		HeapAllocStrategy, WasmModule, DEFAULT_HEAP_ALLOC_PAGES, DEFAULT_HEAP_ALLOC_STRATEGY,
-	},
+	wasm_runtime::{HeapAllocStrategy, WasmModule, DEFAULT_HEAP_ALLOC_STRATEGY},
 };
 use sc_runtime_test::wasm_binary_unwrap;
 

client/service/src/builder.rs

@@ -38,7 +38,7 @@ use sc_client_db::{Backend, DatabaseSettings};
 use sc_consensus::import_queue::ImportQueue;
 use sc_executor::{
 	sp_wasm_interface::HostFunctions, HeapAllocStrategy, NativeElseWasmExecutor,
-	NativeExecutionDispatch, RuntimeVersionOf, WasmExecutor, DEFAULT_HEAP_ALLOC_PAGES,
+	NativeExecutionDispatch, RuntimeVersionOf, WasmExecutor, DEFAULT_HEAP_ALLOC_STRATEGY,
 };
 use sc_keystore::LocalKeystore;
 use sc_network::{
@@ -241,10 +241,11 @@ pub fn new_native_executor<D: NativeExecutionDispatch>(
 
 /// Creates a [`WasmExecutor`] according to [`Configuration`].
 pub fn new_wasm_executor<H: HostFunctions>(config: &Configuration) -> WasmExecutor<H> {
-	let extra_pages =
-		config.default_heap_pages.map(|p| p as u32).unwrap_or(DEFAULT_HEAP_ALLOC_PAGES);
-	let strategy = HeapAllocStrategy::Static { extra_pages };
-	WasmExecutor::<H>::builder(config.wasm_method)
+	let strategy = config
+		.default_heap_pages
+		.map_or(DEFAULT_HEAP_ALLOC_STRATEGY, |p| HeapAllocStrategy::Static { extra_pages: p as _ });
+	WasmExecutor::<H>::builder()
+		.with_execution_method(config.wasm_method)
 		.with_onchain_heap_alloc_strategy(strategy)
 		.with_onchain_heap_alloc_strategy(strategy)
 		.with_max_runtime_instances(config.max_runtime_instances)

client/service/src/client/call_executor.rs

@@ -368,7 +368,7 @@ mod tests {
 	use super::*;
 	use backend::Backend;
 	use sc_client_api::in_mem;
-	use sc_executor::{NativeElseWasmExecutor, WasmExecutionMethod, WasmExecutor};
+	use sc_executor::{NativeElseWasmExecutor, WasmExecutor};
 	use sp_core::{
 		testing::TaskExecutor,
 		traits::{FetchRuntimeCode, WrappedRuntimeCode},
@@ -378,7 +378,7 @@ mod tests {
 
 	fn executor() -> NativeElseWasmExecutor<LocalExecutorDispatch> {
 		NativeElseWasmExecutor::new_with_wasm_executor(
-			WasmExecutor::builder(WasmExecutionMethod::Interpreted)
+			WasmExecutor::builder()
 				.with_max_runtime_instances(1)
 				.with_runtime_cache_size(2)
 				.build(),

client/service/src/client/wasm_override.rs

@@ -264,15 +264,13 @@ pub fn dummy_overrides() -> WasmOverride {
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use sc_executor::{
-		HeapAllocStrategy, NativeElseWasmExecutor, WasmExecutionMethod, WasmExecutor,
-	};
+	use sc_executor::{HeapAllocStrategy, NativeElseWasmExecutor, WasmExecutor};
 	use std::fs::{self, File};
 	use substrate_test_runtime_client::LocalExecutorDispatch;
 
 	fn executor() -> NativeElseWasmExecutor<substrate_test_runtime_client::LocalExecutorDispatch> {
 		NativeElseWasmExecutor::<substrate_test_runtime_client::LocalExecutorDispatch>::new_with_wasm_executor(
-			WasmExecutor::builder(WasmExecutionMethod::Interpreted)
+			WasmExecutor::builder()
 				.with_onchain_heap_alloc_strategy(HeapAllocStrategy::Static {extra_pages: 128})
 				.with_offchain_heap_alloc_strategy(HeapAllocStrategy::Static {extra_pages: 128})
 				.with_max_runtime_instances(1)

primitives/api/test/tests/runtime_calls.rs

@@ -180,7 +180,7 @@ fn record_proof_works() {
 	// Use the proof backend to execute `execute_block`.
 	let mut overlay = Default::default();
 	let executor = NativeElseWasmExecutor::<LocalExecutorDispatch>::new_with_wasm_executor(
-		WasmExecutor::builder(WasmExecutionMethod::Interpreted).build(),
+		WasmExecutor::builder().build(),
 	);
 	execution_proof_check_on_trie_backend(
 		&backend,

test-utils/client/src/lib.rs

@@ -286,9 +286,7 @@ impl<Block: BlockT, D, Backend, G: GenesisInit>
 		Backend: sc_client_api::backend::Backend<Block> + 'static,
 	{
 		let executor = executor.into().unwrap_or_else(|| {
-			NativeElseWasmExecutor::new_with_wasm_executor(
-				WasmExecutor::builder(WasmExecutionMethod::Interpreted).build(),
-			)
+			NativeElseWasmExecutor::new_with_wasm_executor(WasmExecutor::builder().build())
 		});
 		let executor = LocalCallExecutor::new(
 			self.backend.clone(),

test-utils/runtime/client/src/lib.rs

@@ -292,7 +292,5 @@ pub fn new() -> Client<Backend> {
 
 /// Create a new native executor.
 pub fn new_native_executor() -> NativeElseWasmExecutor<LocalExecutorDispatch> {
-	NativeElseWasmExecutor::new_with_wasm_executor(
-		WasmExecutor::builder(WasmExecutionMethod::Interpreted).build(),
-	)
+	NativeElseWasmExecutor::new_with_wasm_executor(WasmExecutor::builder().build())
 }

test-utils/runtime/src/system.rs

@@ -350,7 +350,7 @@ mod tests {
 	use super::*;
 
 	use crate::{wasm_binary_unwrap, Header, Transfer};
-	use sc_executor::{NativeElseWasmExecutor, WasmExecutionMethod, WasmExecutor};
+	use sc_executor::{NativeElseWasmExecutor, WasmExecutor};
 	use sp_core::{
 		map,
 		traits::{CallContext, CodeExecutor, RuntimeCode},
@@ -374,9 +374,7 @@ mod tests {
 	}
 
 	fn executor() -> NativeElseWasmExecutor<NativeDispatch> {
-		NativeElseWasmExecutor::new_with_wasm_executor(
-			WasmExecutor::builder(WasmExecutionMethod::Interpreted).build(),
-		)
+		NativeElseWasmExecutor::new_with_wasm_executor(WasmExecutor::builder().build())
 	}
 
 	fn new_test_ext() -> TestExternalities {

utils/frame/benchmarking-cli/src/pallet/command.rs

@@ -214,7 +214,8 @@ impl PalletCmd {
 			execution_method_from_cli(self.wasm_method, self.wasmtime_instantiation_strategy);
 
 		let executor = NativeElseWasmExecutor::<ExecDispatch>::new_with_wasm_executor(
-			WasmExecutor::builder(method)
+			WasmExecutor::builder()
+				.with_execution_method(method)
 				.with_max_runtime_instances(2)
 				.with_runtime_cache_size(2)
 				.build(),

utils/frame/try-runtime/cli/src/lib.rs

@@ -368,9 +368,8 @@ use sc_cli::{
 	WasmtimeInstantiationStrategy, DEFAULT_WASMTIME_INSTANTIATION_STRATEGY,
 	DEFAULT_WASM_EXECUTION_METHOD,
 };
-use sc_executor::{
-	sp_wasm_interface::HostFunctions, HeapAllocStrategy, WasmExecutor, DEFAULT_HEAP_ALLOC_PAGES,
-};
+use sc_executor::{sp_wasm_interface::HostFunctions, HeapAllocStrategy, WasmExecutor};
+use sc_executor_common::wasm_runtime::DEFAULT_HEAP_ALLOC_STRATEGY;
 use sp_api::HashT;
 use sp_core::{
 	hexdisplay::HexDisplay,
@@ -829,17 +828,18 @@ pub(crate) fn full_extensions() -> Extensions {
 
 /// Build wasm executor by default config.
 pub(crate) fn build_executor<H: HostFunctions>(shared: &SharedParams) -> WasmExecutor<H> {
-	let heap_pages = HeapAllocStrategy::Static {
-		extra_pages: shared.heap_pages.map(|p| p as u32).unwrap_or(DEFAULT_HEAP_ALLOC_PAGES),
-	};
-
-	WasmExecutor::builder(execution_method_from_cli(
-		shared.wasm_method,
-		shared.wasmtime_instantiation_strategy,
-	))
-	.with_onchain_heap_alloc_strategy(heap_pages)
-	.with_offchain_heap_alloc_strategy(heap_pages)
-	.build()
+	let heap_pages = shared
+		.heap_pages
+		.map_or(DEFAULT_HEAP_ALLOC_STRATEGY, |p| HeapAllocStrategy::Static { extra_pages: p as _ });
+
+	WasmExecutor::builder()
+		.with_execution_method(execution_method_from_cli(
+			shared.wasm_method,
+			shared.wasmtime_instantiation_strategy,
+		))
+		.with_onchain_heap_alloc_strategy(heap_pages)
+		.with_offchain_heap_alloc_strategy(heap_pages)
+		.build()
 }
 
 /// Ensure that the given `ext` is compiled with `try-runtime`