bifrost-platform
diff --git a/‎Cargo.lock
Lines changed: 2866 additions & 2224 deletions b/‎Cargo.lock
Lines changed: 2866 additions & 2224 deletions
diff --git a/‎Cargo.toml
Lines changed: 111 additions & 122 deletions b/‎Cargo.toml
Lines changed: 111 additions & 122 deletions
diff --git a/‎node/common/Cargo.toml
Lines changed: 1 addition & 0 deletions b/‎node/common/Cargo.toml
Lines changed: 1 addition & 0 deletions
diff --git a/‎node/common/src/rpc.rs
Lines changed: 8 additions & 44 deletions b/‎node/common/src/rpc.rs
Lines changed: 8 additions & 44 deletions
diff --git a/‎node/common/src/service.rs
Lines changed: 34 additions & 26 deletions b/‎node/common/src/service.rs
Lines changed: 34 additions & 26 deletions
diff --git a/‎node/common/src/tracing.rs
Lines changed: 5 additions & 5 deletions b/‎node/common/src/tracing.rs
Lines changed: 5 additions & 5 deletions
diff --git a/‎node/core/Cargo.toml
Lines changed: 4 additions & 1 deletion b/‎node/core/Cargo.toml
Lines changed: 4 additions & 1 deletion
diff --git a/‎node/core/src/command.rs
Lines changed: 6 additions & 4 deletions b/‎node/core/src/command.rs
Lines changed: 6 additions & 4 deletions
@@ -34,6 +34,7 @@ frame-benchmarking = { workspace = true, features = ["std"] }
 sp-core = { workspace = true, features = ["std"] }
 sp-runtime = { workspace = true, features = ["std"] }
 sp-api = { workspace = true, features = ["std"] }
+sp-io = { workspace = true, features = ["std"] }
 sp-blockchain = { workspace = true }
 sp-block-builder = { workspace = true, features = ["std"] }
 
 
@@ -2,28 +2,21 @@ use crate::cli_opt::EthApi as EthApiCmd;
 
 use std::{collections::BTreeMap, sync::Arc};
 
-use fc_rpc::{
-	EthBlockDataCacheTask, OverrideHandle, RuntimeApiStorageOverride, SchemaV1Override,
-	SchemaV2Override, SchemaV3Override, StorageOverride,
-};
+use fc_rpc::{EthBlockDataCacheTask, StorageOverride};
 use fc_rpc_core::types::{FeeHistoryCache, FilterPool};
 use sc_client_api::{backend::Backend, StorageProvider};
 use sc_consensus_grandpa::{
 	FinalityProofProvider, GrandpaJustificationStream, SharedAuthoritySet, SharedVoterState,
 };
 use sc_consensus_manual_seal::EngineCommand;
-use sc_network::NetworkService;
+use sc_network::service::traits::NetworkService;
 use sc_network_sync::SyncingService;
 use sc_rpc::SubscriptionTaskExecutor;
 use sc_rpc_api::DenyUnsafe;
 use sc_service::TaskManager;
 use sc_transaction_pool::{ChainApi, Pool};
 
 use bp_core::{BlockNumber, Hash, Header};
-use fp_rpc::{self, EthereumRuntimeRPCApi};
-use fp_storage::EthereumStorageSchema;
-use sp_api::ProvideRuntimeApi;
-use sp_blockchain::HeaderBackend;
 use sp_core::H256;
 use sp_runtime::{generic, traits::Block as BlockT, OpaqueExtrinsic as UncheckedExtrinsic};
 
@@ -41,35 +34,6 @@ where
 		fc_rpc::frontier_backend_client::SystemAccountId20StorageOverride<Block, C, BE>;
 }
 
-/// Override storage
-pub fn overrides_handle<B, C, BE>(client: Arc<C>) -> Arc<OverrideHandle<B>>
-where
-	B: BlockT,
-	C: ProvideRuntimeApi<B>,
-	C::Api: EthereumRuntimeRPCApi<B>,
-	C: HeaderBackend<B> + StorageProvider<B, BE> + 'static,
-	BE: Backend<B> + 'static,
-{
-	let mut overrides_map = BTreeMap::new();
-	overrides_map.insert(
-		EthereumStorageSchema::V1,
-		Box::new(SchemaV1Override::new(client.clone())) as Box<dyn StorageOverride<_>>,
-	);
-	overrides_map.insert(
-		EthereumStorageSchema::V2,
-		Box::new(SchemaV2Override::new(client.clone())) as Box<dyn StorageOverride<_>>,
-	);
-	overrides_map.insert(
-		EthereumStorageSchema::V3,
-		Box::new(SchemaV3Override::new(client.clone())) as Box<dyn StorageOverride<_>>,
-	);
-
-	Arc::new(OverrideHandle {
-		schemas: overrides_map,
-		fallback: Box::new(RuntimeApiStorageOverride::new(client.clone())),
-	})
-}
-
 /// Extra dependencies for GRANDPA
 pub struct GrandpaDeps<B> {
 	/// Voting round info.
@@ -105,7 +69,7 @@ pub struct FullDevDeps<C, P, BE, SC, A: ChainApi, CIDP> {
 	/// The Node authority flag
 	pub is_authority: bool,
 	/// Network service
-	pub network: Arc<NetworkService<Block, Hash>>,
+	pub network: Arc<dyn NetworkService>,
 	/// EthFilterApi pool.
 	pub filter_pool: FilterPool,
 	/// List of optional RPC extensions.
@@ -119,7 +83,7 @@ pub struct FullDevDeps<C, P, BE, SC, A: ChainApi, CIDP> {
 	/// Fee history cache.
 	pub fee_history_cache: FeeHistoryCache,
 	/// Ethereum data access overrides.
-	pub overrides: Arc<OverrideHandle<Block>>,
+	pub overrides: Arc<dyn StorageOverride<Block>>,
 	/// Cache for Ethereum block data.
 	pub block_data_cache: Arc<EthBlockDataCacheTask<Block>>,
 	/// Manual seal command sink
@@ -157,7 +121,7 @@ pub struct FullDeps<C, P, BE, SC, A: ChainApi, CIDP> {
 	/// The Node authority flag
 	pub is_authority: bool,
 	/// Network service
-	pub network: Arc<NetworkService<Block, Hash>>,
+	pub network: Arc<dyn NetworkService>,
 	/// EthFilterApi pool.
 	pub filter_pool: FilterPool,
 	/// List of optional RPC extensions.
@@ -171,7 +135,7 @@ pub struct FullDeps<C, P, BE, SC, A: ChainApi, CIDP> {
 	/// Fee history cache.
 	pub fee_history_cache: FeeHistoryCache,
 	/// Ethereum data access overrides.
-	pub overrides: Arc<OverrideHandle<Block>>,
+	pub overrides: Arc<dyn StorageOverride<Block>>,
 	/// Cache for Ethereum block data.
 	pub block_data_cache: Arc<EthBlockDataCacheTask<Block>>,
 	/// Maximum number of logs in one query.
@@ -190,9 +154,9 @@ pub struct SpawnTasksParams<'a, B: BlockT, C, BE> {
 	pub task_manager: &'a TaskManager,
 	pub client: Arc<C>,
 	pub substrate_backend: Arc<BE>,
-	pub frontier_backend: fc_db::Backend<B>,
+	pub frontier_backend: Arc<fc_db::Backend<B, C>>,
 	pub filter_pool: Option<FilterPool>,
-	pub overrides: Arc<OverrideHandle<B>>,
+	pub overrides: Arc<dyn StorageOverride<B>>,
 	pub fee_history_limit: u64,
 	pub fee_history_cache: FeeHistoryCache,
 }
 
@@ -3,6 +3,7 @@ use crate::cli_opt::{BackendTypeConfig, RpcConfig};
 use std::{path::Path, sync::Arc};
 
 use fc_db::DatabaseSource;
+use fc_rpc::StorageOverrideHandler;
 use sc_client_api::{
 	backend::{Backend, StateBackend},
 	AuxStore, StorageProvider,
@@ -14,8 +15,13 @@ use sp_api::ProvideRuntimeApi;
 use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata};
 use sp_runtime::traits::BlakeTwo256;
 
+/// Only enable the benchmarking host functions when we actually want to benchmark.
+#[cfg(feature = "runtime-benchmarks")]
 pub type HostFunctions =
-	(frame_benchmarking::benchmarking::HostFunctions, fp_ext::bifrost_ext::HostFunctions);
+	(sp_io::SubstrateHostFunctions, frame_benchmarking::benchmarking::HostFunctions);
+/// Otherwise we use empty host functions for ext host functions.
+#[cfg(not(feature = "runtime-benchmarks"))]
+pub type HostFunctions = (sp_io::SubstrateHostFunctions, fp_ext::bifrost_ext::HostFunctions);
 
 /// Configure frontier database.
 pub fn frontier_database_dir(config: &Configuration, path: &str) -> std::path::PathBuf {
@@ -28,7 +34,7 @@ pub fn open_frontier_backend<C, BE>(
 	client: Arc<C>,
 	config: &Configuration,
 	rpc_config: &RpcConfig,
-) -> Result<fc_db::Backend<Block>, String>
+) -> Result<fc_db::Backend<Block, C>, String>
 where
 	C: ProvideRuntimeApi<Block> + StorageProvider<Block, BE> + AuxStore,
 	C: HeaderBackend<Block> + HeaderMetadata<Block, Error = BlockChainError>,
@@ -38,32 +44,34 @@ where
 	BE::State: StateBackend<BlakeTwo256>,
 {
 	let frontier_backend = match rpc_config.frontier_backend_type {
-		BackendTypeConfig::KeyValue => fc_db::Backend::KeyValue(fc_db::kv::Backend::<Block>::new(
-			client,
-			&fc_db::kv::DatabaseSettings {
-				source: match config.database {
-					DatabaseSource::RocksDb { .. } => DatabaseSource::RocksDb {
-						path: frontier_database_dir(config, "db"),
-						cache_size: 0,
-					},
-					DatabaseSource::ParityDb { .. } => {
-						DatabaseSource::ParityDb { path: frontier_database_dir(config, "paritydb") }
-					},
-					DatabaseSource::Auto { .. } => DatabaseSource::Auto {
-						rocksdb_path: frontier_database_dir(config, "db"),
-						paritydb_path: frontier_database_dir(config, "paritydb"),
-						cache_size: 0,
-					},
-					_ => {
-						return Err(
-							"Supported db sources: `rocksdb` | `paritydb` | `auto`".to_string()
-						)
+		BackendTypeConfig::KeyValue => {
+			fc_db::Backend::KeyValue(Arc::new(fc_db::kv::Backend::<Block, C>::new(
+				client,
+				&fc_db::kv::DatabaseSettings {
+					source: match config.database {
+						DatabaseSource::RocksDb { .. } => DatabaseSource::RocksDb {
+							path: frontier_database_dir(config, "db"),
+							cache_size: 0,
+						},
+						DatabaseSource::ParityDb { .. } => DatabaseSource::ParityDb {
+							path: frontier_database_dir(config, "paritydb"),
+						},
+						DatabaseSource::Auto { .. } => DatabaseSource::Auto {
+							rocksdb_path: frontier_database_dir(config, "db"),
+							paritydb_path: frontier_database_dir(config, "paritydb"),
+							cache_size: 0,
+						},
+						_ => {
+							return Err(
+								"Supported db sources: `rocksdb` | `paritydb` | `auto`".to_string()
+							)
+						},
 					},
 				},
-			},
-		)?),
+			)?))
+		},
 		BackendTypeConfig::Sql { pool_size, num_ops_timeout, thread_count, cache_size } => {
-			let overrides = crate::rpc::overrides_handle(client.clone());
+			let overrides = Arc::new(StorageOverrideHandler::<Block, _, _>::new(client.clone()));
 			let sqlite_db_path = frontier_database_dir(config, "sql");
 			std::fs::create_dir_all(&sqlite_db_path).expect("failed creating sql db directory");
 			let backend = futures::executor::block_on(fc_db::sql::Backend::new(
@@ -82,7 +90,7 @@ where
 				overrides.clone(),
 			))
 			.unwrap_or_else(|err| panic!("failed creating sql backend: {:?}", err));
-			fc_db::Backend::Sql(backend)
+			fc_db::Backend::Sql(Arc::new(backend))
 		},
 	};
 
 
@@ -12,11 +12,11 @@ use sc_client_api::{backend::Backend, BlockOf, BlockchainEvents, StateBackend, S
 use substrate_prometheus_endpoint::Registry as PrometheusRegistry;
 use tokio::sync::Semaphore;
 
-use sp_api::{BlockT, HeaderT, ProvideRuntimeApi};
+use sp_api::ProvideRuntimeApi;
 use sp_block_builder::BlockBuilder;
 use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata};
 use sp_core::H256;
-use sp_runtime::traits::BlakeTwo256;
+use sp_runtime::traits::{BlakeTwo256, Block as BlockT, Header as HeaderT};
 
 use std::{sync::Arc, time::Duration};
 
@@ -66,9 +66,9 @@ where
 		let (debug_task, debug_requester) = DebugHandler::task(
 			Arc::clone(&params.client),
 			Arc::clone(&params.substrate_backend),
-			match params.frontier_backend {
-				fc_db::Backend::KeyValue(b) => Arc::new(b),
-				fc_db::Backend::Sql(b) => Arc::new(b),
+			match &*params.frontier_backend {
+				fc_db::Backend::KeyValue(b) => b.clone(),
+				fc_db::Backend::Sql(b) => b.clone(),
 			},
 			Arc::clone(&permit_pool),
 			Arc::clone(&params.overrides),
 
@@ -1,6 +1,6 @@
 [package]
 name = "bifrost-node"
-version = "2.0.0"
+version = "2.0.1"
 description = "The node client implementation for Bifrost"
 authors = { workspace = true }
 homepage = { workspace = true }
@@ -19,6 +19,9 @@ name = "bifrost-node"
 # third-party dependencies
 clap = { workspace = true }
 
+# substrate primitive dependencies
+sp-runtime = { workspace = true, features = ["std"] }
+
 # substrate client dependencies
 sc-cli = { workspace = true }
 sc-service = { workspace = true }
 
@@ -64,12 +64,12 @@ impl SubstrateCli for Cli {
 
 	fn load_spec(&self, id: &str) -> Result<Box<dyn sc_service::ChainSpec>, String> {
 		Ok(match id {
-			"dev" => Box::new(bifrost_dev_node::chain_spec::development_config()?),
-			"testnet-local" => Box::new(bifrost_testnet_node::chain_spec::testnet_config()?),
+			"dev" => Box::new(bifrost_dev_node::chain_spec::development_config()),
+			"testnet-local" => Box::new(bifrost_testnet_node::chain_spec::testnet_config()),
 			"testnet" => Box::new(bifrost_testnet_node::chain_spec::ChainSpec::from_json_file(
 				std::path::PathBuf::from("./specs/bifrost-testnet.json"),
 			)?),
-			"mainnet-local" => Box::new(bifrost_mainnet_node::chain_spec::mainnet_config()?),
+			"mainnet-local" => Box::new(bifrost_mainnet_node::chain_spec::mainnet_config()),
 			"mainnet" => Box::new(bifrost_mainnet_node::chain_spec::ChainSpec::from_json_file(
 				std::path::PathBuf::from("./specs/bifrost-mainnet.json"),
 			)?),
@@ -294,7 +294,9 @@ pub fn run() -> sc_cli::Result<()> {
 							);
 						}
 
-						cmd.run::<Block, bifrost_common_node::service::HostFunctions>(config)
+						cmd.run_with_spec::<sp_runtime::traits::HashingFor<Block>, ()>(Some(
+							config.chain_spec,
+						))
 					},
 					BenchmarkCmd::Block(cmd) => {
 						let PartialComponents { client, .. } =