Move things around in subspace-node to not expose unnecessary things via library API

Author: nazar-pc

crates/subspace-node/src/bin/subspace-node.rs

@@ -16,9 +16,198 @@
 
 //! Subspace node implementation.
 
-#![warn(missing_docs)]
+use futures::future::TryFutureExt;
+use sc_cli::{ChainSpec, SubstrateCli};
+use sc_executor::NativeExecutionDispatch;
+use sp_core::crypto::Ss58AddressFormat;
+use subspace_node::{Cli, Subcommand};
+use subspace_runtime::RuntimeApi;
+
+/// Subspace node error.
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    /// Subspace service error.
+    #[error(transparent)]
+    SubspaceService(#[from] subspace_service::Error),
+
+    /// CLI error.
+    #[error(transparent)]
+    SubstrateCli(#[from] sc_cli::Error),
+
+    /// Substrate service error.
+    #[error(transparent)]
+    SubstrateService(#[from] sc_service::Error),
+
+    /// Other kind of error.
+    #[error("Other: {0}")]
+    Other(String),
+}
+
+impl From<String> for Error {
+    fn from(s: String) -> Self {
+        Self::Other(s)
+    }
+}
+
+struct ExecutorDispatch;
+
+impl 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;
+    /// Otherwise we only use the default Substrate host functions.
+    #[cfg(not(feature = "runtime-benchmarks"))]
+    type ExtendHostFunctions = ();
+
+    fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>> {
+        subspace_runtime::api::dispatch(method, data)
+    }
+
+    fn native_version() -> sc_executor::NativeVersion {
+        subspace_runtime::native_version()
+    }
+}
+
+fn set_default_ss58_version<C: AsRef<dyn ChainSpec>>(chain_spec: C) {
+    let maybe_ss58_address_format = chain_spec
+        .as_ref()
+        .properties()
+        .get("ss58Format")
+        .map(|v| {
+            v.as_u64()
+                .expect("ss58Format must always be an unsigned number; qed")
+        })
+        .map(|v| {
+            v.try_into()
+                .expect("ss58Format must always be within u16 range; qed")
+        })
+        .map(Ss58AddressFormat::custom);
+
+    if let Some(ss58_address_format) = maybe_ss58_address_format {
+        sp_core::crypto::set_default_ss58_version(ss58_address_format);
+    }
+}
+
+fn main() -> std::result::Result<(), Error> {
+    let cli = Cli::from_args();
+
+    match &cli.subcommand {
+        Some(Subcommand::Key(cmd)) => cmd.run(&cli)?,
+        Some(Subcommand::BuildSpec(cmd)) => {
+            let runner = cli.create_runner(cmd)?;
+            runner.sync_run(|config| cmd.run(config.chain_spec, config.network))?
+        }
+        Some(Subcommand::CheckBlock(cmd)) => {
+            let runner = cli.create_runner(cmd)?;
+            set_default_ss58_version(&runner.config().chain_spec);
+            runner.async_run(|config| {
+                let sc_service::PartialComponents {
+                    client,
+                    import_queue,
+                    task_manager,
+                    ..
+                } = subspace_service::new_partial::<RuntimeApi, ExecutorDispatch>(&config)?;
+                Ok((
+                    cmd.run(client, import_queue).map_err(Error::SubstrateCli),
+                    task_manager,
+                ))
+            })?;
+        }
+        Some(Subcommand::ExportBlocks(cmd)) => {
+            let runner = cli.create_runner(cmd)?;
+            set_default_ss58_version(&runner.config().chain_spec);
+            runner.async_run(|config| {
+                let sc_service::PartialComponents {
+                    client,
+                    task_manager,
+                    ..
+                } = subspace_service::new_partial::<RuntimeApi, ExecutorDispatch>(&config)?;
+                Ok((
+                    cmd.run(client, config.database)
+                        .map_err(Error::SubstrateCli),
+                    task_manager,
+                ))
+            })?;
+        }
+        Some(Subcommand::ExportState(cmd)) => {
+            let runner = cli.create_runner(cmd)?;
+            set_default_ss58_version(&runner.config().chain_spec);
+            runner.async_run(|config| {
+                let sc_service::PartialComponents {
+                    client,
+                    task_manager,
+                    ..
+                } = subspace_service::new_partial::<RuntimeApi, ExecutorDispatch>(&config)?;
+                Ok((
+                    cmd.run(client, config.chain_spec)
+                        .map_err(Error::SubstrateCli),
+                    task_manager,
+                ))
+            })?;
+        }
+        Some(Subcommand::ImportBlocks(cmd)) => {
+            let runner = cli.create_runner(cmd)?;
+            set_default_ss58_version(&runner.config().chain_spec);
+            runner.async_run(|config| {
+                let sc_service::PartialComponents {
+                    client,
+                    import_queue,
+                    task_manager,
+                    ..
+                } = subspace_service::new_partial::<RuntimeApi, ExecutorDispatch>(&config)?;
+                Ok((
+                    cmd.run(client, import_queue).map_err(Error::SubstrateCli),
+                    task_manager,
+                ))
+            })?;
+        }
+        Some(Subcommand::PurgeChain(cmd)) => {
+            let runner = cli.create_runner(cmd)?;
+            runner.sync_run(|config| cmd.run(config.database))?
+        }
+        Some(Subcommand::Revert(cmd)) => {
+            let runner = cli.create_runner(cmd)?;
+            set_default_ss58_version(&runner.config().chain_spec);
+            runner.async_run(|config| {
+                let sc_service::PartialComponents {
+                    client,
+                    backend,
+                    task_manager,
+                    ..
+                } = subspace_service::new_partial::<RuntimeApi, ExecutorDispatch>(&config)?;
+                Ok((
+                    cmd.run(client, backend).map_err(Error::SubstrateCli),
+                    task_manager,
+                ))
+            })?;
+        }
+        Some(Subcommand::Benchmark(cmd)) => {
+            if cfg!(feature = "runtime-benchmarks") {
+                let runner = cli.create_runner(cmd)?;
+                set_default_ss58_version(&runner.config().chain_spec);
+                runner.sync_run(|config| {
+                    cmd.run::<subspace_runtime::Block, ExecutorDispatch>(config)
+                })?;
+            } else {
+                return Err(Error::Other(
+                    "Benchmarking wasn't enabled when building the node. You can enable it with \
+                    `--features runtime-benchmarks`."
+                        .into(),
+                ));
+            }
+        }
+        None => {
+            let runner = cli.create_runner(&cli.run.base)?;
+            set_default_ss58_version(&runner.config().chain_spec);
+            runner.run_node_until_exit(|config| async move {
+                subspace_service::new_full::<subspace_runtime::RuntimeApi, ExecutorDispatch>(
+                    config, true,
+                )
+                .await
+                .map(|full| full.task_manager)
+            })?;
+        }
+    }
 
-fn main() -> std::result::Result<(), subspace_node::Error> {
-    subspace_node::run()?;
     Ok(())
 }