fix: remove NativeElseWasmExecutor and use wasm executor exclusively (#978)

Author: 1xstj

Cargo.lock

@@ -1,5 +1,5 @@
 [workspace.package]
-version = "1.3.0"
+version = "1.3.1"
 authors = ["Tangle Foundation."]
 edition = "2021"
 license = "Unlicense"

Cargo.toml

@@ -235,8 +235,7 @@ pub fn run() -> sc_cli::Result<()> {
 							);
 						}
 
-						cmd.run_with_spec::<sp_runtime::traits::HashingFor<Block>,
-						<crate::service::tangle::ExecutorDispatch as sc_executor::NativeExecutionDispatch>::ExtendHostFunctions>(Some(
+						cmd.run_with_spec::<sp_runtime::traits::HashingFor<Block>, sp_io::SubstrateHostFunctions>(Some(
 							config.chain_spec,
 						))
 					},

node/src/command.rs

@@ -19,7 +19,7 @@ use std::{
 	time::Duration,
 };
 
-use futures::{future, prelude::*};
+use futures::StreamExt;
 // Substrate
 pub use fc_storage::{StorageOverride, StorageOverrideHandler};
 use sc_client_api::BlockchainEvents;
@@ -215,34 +215,41 @@ pub async fn spawn_frontier_tasks(
 	// Spawn main mapping sync worker background task.
 	match &*frontier_backend {
 		fc_db::Backend::KeyValue(b) => {
+			// Create a MappingSyncWorker and spawn it using StreamExt::for_each
+			let import_notifications = client.import_notification_stream();
+
+			let worker = fc_mapping_sync::kv::MappingSyncWorker::new(
+				import_notifications,
+				Duration::new(6, 0),
+				client.clone(),
+				backend,
+				storage_override.clone(),
+				b.clone(),
+				3,
+				0,
+				fc_mapping_sync::SyncStrategy::Normal,
+				sync,
+				pubsub_notification_sinks,
+			);
+
 			task_manager.spawn_essential_handle().spawn(
 				"frontier-mapping-sync-worker",
 				Some("frontier"),
-				fc_mapping_sync::kv::MappingSyncWorker::new(
-					client.import_notification_stream(),
-					Duration::new(6, 0),
-					client.clone(),
-					backend,
-					storage_override.clone(),
-					b.clone(),
-					3,
-					0,
-					fc_mapping_sync::SyncStrategy::Normal,
-					sync,
-					pubsub_notification_sinks,
-				)
-				.for_each(|()| future::ready(())),
+				worker.for_each(|_| futures::future::ready(())),
 			);
 		},
 		fc_db::Backend::Sql(b) => {
+			// Create a SyncWorker with blockchain notifications
+			let import_notifications = client.import_notification_stream();
+
 			task_manager.spawn_essential_handle().spawn_blocking(
 				"frontier-mapping-sync-worker",
 				Some("frontier"),
 				fc_mapping_sync::sql::SyncWorker::run(
 					client.clone(),
 					backend,
 					b.clone(),
-					client.import_notification_stream(),
+					import_notifications,
 					fc_mapping_sync::sql::SyncWorkerConfig {
 						read_notification_timeout: Duration::from_secs(10),
 						check_indexed_blocks_interval: Duration::from_secs(60),

node/src/eth.rs

@@ -23,13 +23,13 @@ use crate::{
 		StorageOverrideHandler,
 	},
 };
-use futures::{future, prelude::*, FutureExt};
+use futures::{future, FutureExt};
 use sc_client_api::{Backend, BlockBackend};
 use sc_consensus::BasicQueue;
 use sc_consensus_babe::BabeWorkerHandle;
 use sc_consensus_grandpa::SharedVoterState;
 #[allow(deprecated)]
-pub use sc_executor::NativeElseWasmExecutor;
+pub use sc_executor::WasmExecutor;
 use sc_service::{error::Error as ServiceError, Configuration, TaskManager};
 use sc_telemetry::{Telemetry, TelemetryHandle, TelemetryWorker};
 use sc_transaction_pool_api::OffchainTransactionPoolFactory;
@@ -48,63 +48,13 @@ use tangle_testnet_runtime::{self, RuntimeApi, TransactionConverter};
 /// imported and generated.
 const GRANDPA_JUSTIFICATION_PERIOD: u32 = 512;
 
-#[cfg(not(feature = "testnet"))]
-pub mod tangle {
-	// Our native executor instance.
-	pub struct ExecutorDispatch;
-
-	impl sc_executor::NativeExecutionDispatch for ExecutorDispatch {
-		/// Only enable the benchmarking host functions when we actually want to benchmark.
-		#[cfg(feature = "runtime-benchmarks")]
-		type ExtendHostFunctions =
-			(frame_benchmarking::benchmarking::HostFunctions, primitives_ext::ext::HostFunctions);
-		/// Otherwise we only use the default Substrate host functions.
-		#[cfg(not(feature = "runtime-benchmarks"))]
-		type ExtendHostFunctions = primitives_ext::ext::HostFunctions;
-
-		fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>> {
-			tangle_runtime::api::dispatch(method, data)
-		}
-
-		fn native_version() -> sc_executor::NativeVersion {
-			tangle_runtime::native_version()
-		}
-	}
-}
-
-#[cfg(feature = "testnet")]
-pub mod testnet {
-	// Our native executor instance.
-	pub struct ExecutorDispatch;
-
-	impl sc_executor::NativeExecutionDispatch for ExecutorDispatch {
-		/// Only enable the benchmarking host functions when we actually want to benchmark.
-		#[cfg(feature = "runtime-benchmarks")]
-		type ExtendHostFunctions =
-			(frame_benchmarking::benchmarking::HostFunctions, primitives_ext::ext::HostFunctions);
-		/// Otherwise we only use the default Substrate host functions.
-		#[cfg(not(feature = "runtime-benchmarks"))]
-		type ExtendHostFunctions = primitives_ext::ext::HostFunctions;
-
-		fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>> {
-			tangle_testnet_runtime::api::dispatch(method, data)
-		}
-
-		fn native_version() -> sc_executor::NativeVersion {
-			tangle_testnet_runtime::native_version()
-		}
-	}
-}
-
 #[cfg(not(feature = "testnet"))]
 #[allow(deprecated)]
-pub(crate) type FullClient =
-	sc_service::TFullClient<Block, RuntimeApi, NativeElseWasmExecutor<tangle::ExecutorDispatch>>;
+pub(crate) type FullClient = sc_service::TFullClient<Block, RuntimeApi, WasmExecutor>;
 
 #[cfg(feature = "testnet")]
 #[allow(deprecated)]
-pub(crate) type FullClient =
-	sc_service::TFullClient<Block, RuntimeApi, NativeElseWasmExecutor<testnet::ExecutorDispatch>>;
+pub(crate) type FullClient = sc_service::TFullClient<Block, RuntimeApi, WasmExecutor>;
 
 pub(crate) type FullBackend = sc_service::TFullBackend<Block>;
 type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;
@@ -174,8 +124,12 @@ where
 		})
 		.transpose()?;
 
-	#[allow(deprecated)]
-	let executor = sc_service::new_native_or_wasm_executor(config);
+	// Create the WasmExecutor with allow_missing_host_functions flag set to true
+	let executor = WasmExecutor::builder()
+		.with_max_runtime_instances(config.max_runtime_instances)
+		.with_runtime_cache_size(config.runtime_cache_size)
+		.with_allow_missing_host_functions(true)
+		.build();
 
 	let (client, backend, keystore_container, task_manager) =
 		sc_service::new_full_parts::<Block, RuntimeApi, _>(