Feat/evm devnet ready

node/Cargo.toml

@@ -20,6 +20,7 @@ targets = ["x86_64-unknown-linux-gnu"]
 name = "node-subtensor"
 
 [dependencies]
+async-trait = { workspace = true }
 clap = { workspace = true, features = ["derive"] }
 futures = { workspace = true, features = ["thread-pool"] }
 serde = { workspace = true, features = ["derive"] }
@@ -74,6 +75,22 @@ pallet-transaction-payment-rpc = { workspace = true }
 frame-benchmarking = { workspace = true }
 frame-benchmarking-cli = { workspace = true }
 
+# Needed for Frontier
+sc-consensus-manual-seal = { workspace = true }
+sc-network-sync = { workspace = true }
+substrate-prometheus-endpoint = { workspace = true }
+
+# Frontier
+fc-storage = { workspace = true }
+fc-db = { workspace = true }
+fc-consensus = { workspace = true }
+fp-dynamic-fee = { workspace = true }
+fc-api = { workspace = true }
+fc-rpc = { workspace = true }
+fc-rpc-core = { workspace = true }
+fp-rpc = { workspace = true }
+fc-mapping-sync = { workspace = true }
+
 # Local Dependencies
 node-subtensor-runtime = { path = "../runtime" }
 subtensor-custom-rpc = { path = "../pallets/subtensor/rpc" }
@@ -83,7 +100,22 @@ subtensor-custom-rpc-runtime-api = { path = "../pallets/subtensor/runtime-api" }
 substrate-build-script-utils = { workspace = true }
 
 [features]
-default = []
+default = [
+	"rocksdb",
+	"sql",
+	"txpool",
+]
+sql = [
+	"fc-db/sql",
+	"fc-mapping-sync/sql",
+]
+rocksdb = [
+	"sc-service/rocksdb",
+	"fc-db/rocksdb",
+	"fc-mapping-sync/rocksdb",
+]
+txpool = ["fc-rpc/txpool"]
+
 # Dependencies that are only required if runtime benchmarking should be build.
 runtime-benchmarks = [
 	"node-subtensor-runtime/runtime-benchmarks",

node/src/cli.rs

@@ -1,3 +1,4 @@
+use crate::ethereum::EthConfiguration;
 use sc_cli::RunCmd;
 
 #[derive(Debug, clap::Parser)]
@@ -7,6 +8,13 @@ pub struct Cli {
 
     #[clap(flatten)]
     pub run: RunCmd,
+
+    /// Choose sealing method.
+    #[arg(long, value_enum, ignore_case = true)]
+    pub sealing: Option<Sealing>,
+
+    #[command(flatten)]
+    pub eth: EthConfiguration,
 }
 
 #[allow(clippy::large_enum_variant)]
@@ -45,3 +53,13 @@ pub enum Subcommand {
     // Db meta columns information.
     ChainInfo(sc_cli::ChainInfoCmd),
 }
+
+/// Available Sealing methods.
+#[derive(Copy, Clone, Debug, Default, clap::ValueEnum)]
+pub enum Sealing {
+    /// Seal using rpc method.
+    #[default]
+    Manual,
+    /// Seal when transaction is executed.
+    Instant,
+}

node/src/command.rs

@@ -1,8 +1,10 @@
 use crate::{
     chain_spec,
     cli::{Cli, Subcommand},
+    ethereum::db_config_dir,
     service,
 };
+use fc_db::{kv::frontier_database_dir, DatabaseSource};
 
 #[cfg(feature = "runtime-benchmarks")]
 pub use crate::benchmarking::{inherent_benchmark_data, RemarkBuilder, TransferKeepAliveBuilder};
@@ -15,9 +17,10 @@ pub use sp_keyring::Sr25519Keyring;
 #[cfg(feature = "runtime-benchmarks")]
 use sp_runtime::traits::HashingFor;
 
+use futures::TryFutureExt;
 use node_subtensor_runtime::Block;
 use sc_cli::SubstrateCli;
-use sc_service::{Configuration, PartialComponents};
+use sc_service::Configuration;
 
 impl SubstrateCli for Cli {
     fn impl_name() -> String {
@@ -68,64 +71,89 @@ pub fn run() -> sc_cli::Result<()> {
         }
         Some(Subcommand::CheckBlock(cmd)) => {
             let runner = cli.create_runner(cmd)?;
-            runner.async_run(|config| {
-                let PartialComponents {
-                    client,
-                    task_manager,
-                    import_queue,
-                    ..
-                } = service::new_partial(&config)?;
+            runner.async_run(|mut config| {
+                let (client, _, import_queue, task_manager, _) =
+                    service::new_chain_ops(&mut config, &cli.eth)?;
                 Ok((cmd.run(client, import_queue), task_manager))
             })
         }
         Some(Subcommand::ExportBlocks(cmd)) => {
             let runner = cli.create_runner(cmd)?;
-            runner.async_run(|config| {
-                let PartialComponents {
-                    client,
-                    task_manager,
-                    ..
-                } = service::new_partial(&config)?;
+            runner.async_run(|mut config| {
+                let (client, _, _, task_manager, _) =
+                    service::new_chain_ops(&mut config, &cli.eth)?;
                 Ok((cmd.run(client, config.database), task_manager))
             })
         }
         Some(Subcommand::ExportState(cmd)) => {
             let runner = cli.create_runner(cmd)?;
-            runner.async_run(|config| {
-                let PartialComponents {
-                    client,
-                    task_manager,
-                    ..
-                } = service::new_partial(&config)?;
+            runner.async_run(|mut config| {
+                let (client, _, _, task_manager, _) =
+                    service::new_chain_ops(&mut config, &cli.eth)?;
                 Ok((cmd.run(client, config.chain_spec), task_manager))
             })
         }
         Some(Subcommand::ImportBlocks(cmd)) => {
             let runner = cli.create_runner(cmd)?;
-            runner.async_run(|config| {
-                let PartialComponents {
-                    client,
-                    task_manager,
-                    import_queue,
-                    ..
-                } = service::new_partial(&config)?;
+            runner.async_run(|mut config| {
+                let (client, _, import_queue, task_manager, _) =
+                    service::new_chain_ops(&mut config, &cli.eth)?;
                 Ok((cmd.run(client, import_queue), task_manager))
             })
         }
         Some(Subcommand::PurgeChain(cmd)) => {
             let runner = cli.create_runner(cmd)?;
-            runner.sync_run(|config| cmd.run(config.database))
+            runner.sync_run(|config| {
+                // Remove Frontier offchain db
+                let db_config_dir = db_config_dir(&config);
+                match cli.eth.frontier_backend_type {
+                    crate::ethereum::BackendType::KeyValue => {
+                        let frontier_database_config = match config.database {
+                            DatabaseSource::RocksDb { .. } => DatabaseSource::RocksDb {
+                                path: frontier_database_dir(&db_config_dir, "db"),
+                                cache_size: 0,
+                            },
+                            DatabaseSource::ParityDb { .. } => DatabaseSource::ParityDb {
+                                path: frontier_database_dir(&db_config_dir, "paritydb"),
+                            },
+                            _ => {
+                                return Err(format!(
+                                    "Cannot purge `{:?}` database",
+                                    config.database
+                                )
+                                .into())
+                            }
+                        };
+                        cmd.run(frontier_database_config)?;
+                    }
+                    crate::ethereum::BackendType::Sql => {
+                        let db_path = db_config_dir.join("sql");
+                        match std::fs::remove_dir_all(&db_path) {
+                            Ok(_) => {
+                                println!("{:?} removed.", &db_path);
+                            }
+                            Err(ref err) if err.kind() == std::io::ErrorKind::NotFound => {
+                                eprintln!("{:?} did not exist.", &db_path);
+                            }
+                            Err(err) => {
+                                return Err(format!(
+                                    "Cannot purge `{:?}` database: {:?}",
+                                    db_path, err,
+                                )
+                                .into())
+                            }
+                        };
+                    }
+                };
+                cmd.run(config.database)
+            })
         }
         Some(Subcommand::Revert(cmd)) => {
             let runner = cli.create_runner(cmd)?;
-            runner.async_run(|config| {
-                let PartialComponents {
-                    client,
-                    task_manager,
-                    backend,
-                    ..
-                } = service::new_partial(&config)?;
-                let aux_revert = Box::new(|client, _, blocks| {
+            runner.async_run(|mut config| {
+                let (client, backend, _, task_manager, _) =
+                    service::new_chain_ops(&mut config, &cli.eth)?;
+                let aux_revert = Box::new(move |client, _, blocks| {
                     sc_consensus_grandpa::revert(client, blocks)?;
                     Ok(())
                 });
@@ -137,6 +165,14 @@ pub fn run() -> sc_cli::Result<()> {
             let runner = cli.create_runner(cmd)?;
 
             runner.sync_run(|config| {
+                let sc_service::PartialComponents {
+                    client, backend, ..
+                } = crate::service::new_partial(
+                    &config,
+                    &cli.eth,
+                    crate::service::build_manual_seal_import_queue,
+                )?;
+
                 // This switch needs to be in the client, since the client decides
                 // which sub-commands it wants to support.
                 match cmd {
@@ -149,29 +185,24 @@ pub fn run() -> sc_cli::Result<()> {
                             );
                         }
 
-                        cmd.run::<HashingFor<Block>, service::ExecutorDispatch>(config)
-                    }
-                    BenchmarkCmd::Block(cmd) => {
-                        let PartialComponents { client, .. } = service::new_partial(&config)?;
-                        cmd.run(client)
+                        cmd.run_with_spec::<HashingFor<Block>, service::ExecutorDispatch>(Some(
+                            config.chain_spec,
+                        ))
                     }
+                    BenchmarkCmd::Block(cmd) => cmd.run(client),
                     #[cfg(not(feature = "runtime-benchmarks"))]
                     BenchmarkCmd::Storage(_) => Err(
                         "Storage benchmarking can be enabled with `--features runtime-benchmarks`."
                             .into(),
                     ),
                     #[cfg(feature = "runtime-benchmarks")]
                     BenchmarkCmd::Storage(cmd) => {
-                        let PartialComponents {
-                            client, backend, ..
-                        } = service::new_partial(&config)?;
                         let db = backend.expose_db();
                         let storage = backend.expose_storage();
 
                         cmd.run(config, client, db, storage)
                     }
                     BenchmarkCmd::Overhead(cmd) => {
-                        let PartialComponents { client, .. } = service::new_partial(&config)?;
                         let ext_builder = RemarkBuilder::new(client.clone());
 
                         cmd.run(
@@ -183,7 +214,6 @@ pub fn run() -> sc_cli::Result<()> {
                         )
                     }
                     BenchmarkCmd::Extrinsic(cmd) => {
-                        let PartialComponents { client, .. } = service::new_partial(&config)?;
                         // Register the *Remark* and *TKA* builders.
                         let ext_factory = ExtrinsicFactory(vec![
                             Box::new(RemarkBuilder::new(client.clone())),
@@ -210,7 +240,9 @@ pub fn run() -> sc_cli::Result<()> {
             let runner = cli.create_runner(&cli.run)?;
             runner.run_node_until_exit(|config| async move {
                 let config = override_default_heap_pages(config, 60_000);
-                service::new_full(config).map_err(sc_cli::Error::Service)
+                service::new_full::<sc_network::Litep2pNetworkBackend>(config, cli.eth, cli.sealing)
+                    .map_err(Into::into)
+                    .await
             })
         }
     }