Companion PR for `Move subcommands from sc-cli to nodes #6948 ` (#1635)

* Companion PR

* Implement traits for Client

* "Update Substrate"

Co-authored-by: parity-processbot <>

cli/src/cli.rs

@@ -21,9 +21,26 @@ use structopt::StructOpt;
 #[allow(missing_docs)]
 #[derive(Debug, StructOpt)]
 pub enum Subcommand {
-	#[allow(missing_docs)]
-	#[structopt(flatten)]
-	Base(sc_cli::Subcommand),
+	/// Build a chain specification.
+	BuildSpec(sc_cli::BuildSpecCmd),
+
+	/// Validate blocks.
+	CheckBlock(sc_cli::CheckBlockCmd),
+
+	/// Export blocks.
+	ExportBlocks(sc_cli::ExportBlocksCmd),
+
+	/// Export the state of a given block into a chain spec.
+	ExportState(sc_cli::ExportStateCmd),
+
+	/// Import blocks.
+	ImportBlocks(sc_cli::ImportBlocksCmd),
+
+	/// Remove the whole chain.
+	PurgeChain(sc_cli::PurgeChainCmd),
+
+	/// Revert the chain to a previous state.
+	Revert(sc_cli::RevertCmd),
 
 	#[allow(missing_docs)]
 	#[structopt(name = "validation-worker", setting = structopt::clap::AppSettings::Hidden)]

cli/src/command.rs

@@ -96,24 +96,24 @@ impl SubstrateCli for Cli {
 	}
 }
 
+fn set_default_ss58_version(spec: &Box<dyn service::ChainSpec>) {
+	use sp_core::crypto::Ss58AddressFormat;
+
+	let ss58_version = if spec.is_kusama() {
+		Ss58AddressFormat::KusamaAccount
+	} else if spec.is_westend() {
+		Ss58AddressFormat::SubstrateAccount
+	} else {
+		Ss58AddressFormat::PolkadotAccount
+	};
+
+	sp_core::crypto::set_default_ss58_version(ss58_version);
+}
+
 /// Parses polkadot specific CLI arguments and run the service.
 pub fn run() -> Result<()> {
 	let cli = Cli::from_args();
 
-	fn set_default_ss58_version(spec: &Box<dyn service::ChainSpec>) {
-		use sp_core::crypto::Ss58AddressFormat;
-
-		let ss58_version = if spec.is_kusama() {
-			Ss58AddressFormat::KusamaAccount
-		} else if spec.is_westend() {
-			Ss58AddressFormat::SubstrateAccount
-		} else {
-			Ss58AddressFormat::PolkadotAccount
-		};
-
-		sp_core::crypto::set_default_ss58_version(ss58_version);
-	};
-
 	match &cli.subcommand {
 		None => {
 			let runner = cli.create_runner(&cli.run.base)?;
@@ -150,34 +150,68 @@ pub fn run() -> Result<()> {
 				}
 			})
 		},
-		Some(Subcommand::Base(subcommand)) => {
-			let runner = cli.create_runner(subcommand)?;
+		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)?;
+			let chain_spec = &runner.config().chain_spec;
+
+			set_default_ss58_version(chain_spec);
+
+			runner.async_run(|mut config| {
+				let (client, _, import_queue, task_manager) = service::new_chain_ops(&mut config)?;
+				Ok((cmd.run(client, import_queue), task_manager))
+			})
+		},
+		Some(Subcommand::ExportBlocks(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
 			let chain_spec = &runner.config().chain_spec;
 
 			set_default_ss58_version(chain_spec);
 
-			if chain_spec.is_kusama() {
-				runner.run_subcommand(subcommand, |config|
-					service::new_chain_ops::<
-						service::kusama_runtime::RuntimeApi,
-						service::KusamaExecutor,
-					>(config)
-				)
-			} else if chain_spec.is_westend() {
-				runner.run_subcommand(subcommand, |config|
-					service::new_chain_ops::<
-						service::westend_runtime::RuntimeApi,
-						service::WestendExecutor,
-					>(config)
-				)
-			} else {
-				runner.run_subcommand(subcommand, |config|
-					service::new_chain_ops::<
-						service::polkadot_runtime::RuntimeApi,
-						service::PolkadotExecutor,
-					>(config)
-				)
-			}
+			runner.async_run(|mut config| {
+				let (client, _, _, task_manager) = service::new_chain_ops(&mut config)?;
+				Ok((cmd.run(client, config.database), task_manager))
+			})
+		},
+		Some(Subcommand::ExportState(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			let chain_spec = &runner.config().chain_spec;
+
+			set_default_ss58_version(chain_spec);
+
+			runner.async_run(|mut config| {
+				let (client, _, _, task_manager) = service::new_chain_ops(&mut config)?;
+				Ok((cmd.run(client, config.chain_spec), task_manager))
+			})
+		},
+		Some(Subcommand::ImportBlocks(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			let chain_spec = &runner.config().chain_spec;
+
+			set_default_ss58_version(chain_spec);
+
+			runner.async_run(|mut config| {
+				let (client, _, import_queue, task_manager) = service::new_chain_ops(&mut config)?;
+				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))
+		},
+		Some(Subcommand::Revert(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			let chain_spec = &runner.config().chain_spec;
+
+			set_default_ss58_version(chain_spec);
+
+			runner.async_run(|mut config| {
+				let (client, backend, _, task_manager) = service::new_chain_ops(&mut config)?;
+				Ok((cmd.run(client, backend), task_manager))
+			})
 		},
 		Some(Subcommand::ValidationWorker(cmd)) => {
 			sc_cli::init_logger("");
@@ -196,19 +230,9 @@ pub fn run() -> Result<()> {
 
 			set_default_ss58_version(chain_spec);
 
-			if chain_spec.is_kusama() {
-				runner.sync_run(|config| {
-					cmd.run::<service::kusama_runtime::Block, service::KusamaExecutor>(config)
-				})
-			} else if chain_spec.is_westend() {
-				runner.sync_run(|config| {
-					cmd.run::<service::westend_runtime::Block, service::WestendExecutor>(config)
-				})
-			} else {
-				runner.sync_run(|config| {
-					cmd.run::<service::polkadot_runtime::Block, service::PolkadotExecutor>(config)
-				})
-			}
+			runner.sync_run(|config| {
+				cmd.run::<service::kusama_runtime::Block, service::KusamaExecutor>(config)
+			})
 		},
 	}
 }

node/service/src/lib.rs

@@ -631,7 +631,7 @@ fn new_light<Runtime, Dispatch>(mut config: Configuration) -> Result<TaskManager
 
 /// Builds a new object suitable for chain operations.
 #[cfg(feature = "full-node")]
-pub fn new_chain_ops<Runtime, Dispatch>(mut config: Configuration) -> Result<
+pub fn new_chain_ops<Runtime, Dispatch>(mut config: &mut Configuration) -> Result<
 	(
 		Arc<FullClient<Runtime, Dispatch>>,
 		Arc<FullBackend>,
@@ -648,7 +648,7 @@ where
 {
 	config.keystore = service::config::KeystoreConfig::InMemory;
 	let service::PartialComponents { client, backend, import_queue, task_manager, .. }
-		= new_partial::<Runtime, Dispatch>(&mut config)?;
+		= new_partial::<Runtime, Dispatch>(config)?;
 	Ok((client, backend, import_queue, task_manager))
 }
 

service/Cargo.toml

@@ -55,6 +55,7 @@ sp-session = { git = "https://github.com/paritytech/substrate", branch = "master
 sp-offchain = { package = "sp-offchain", git = "https://github.com/paritytech/substrate", branch = "master" }
 prometheus-endpoint = { package = "substrate-prometheus-endpoint", git = "https://github.com/paritytech/substrate", branch = "master" }
 frame-benchmarking = { git = "https://github.com/paritytech/substrate", branch = "master" }
+sp-storage = { git = "https://github.com/paritytech/substrate", branch = "master" }
 
 [dev-dependencies]
 polkadot-test-runtime-client = { path = "../runtime/test-runtime/client" }

service/src/client.rs

@@ -17,10 +17,14 @@
 //! Polkadot Client abstractions.
 
 use std::sync::Arc;
-use sp_api::{ProvideRuntimeApi, CallApiAt};
+use sp_api::{ProvideRuntimeApi, CallApiAt, NumberFor};
 use sp_blockchain::HeaderBackend;
 use sp_runtime::traits::{Block as BlockT, BlakeTwo256};
-use sc_client_api::{Backend as BackendT, BlockchainEvents};
+use sp_runtime::generic::{BlockId, SignedBlock};
+use consensus_common::BlockStatus;
+use sp_runtime::Justification;
+use sp_storage::{StorageData, StorageKey, ChildInfo, PrefixedStorageKey};
+use sc_client_api::{Backend as BackendT, BlockchainEvents, KeyIterator};
 use polkadot_primitives::v0::{Block, ParachainHost, AccountId, Nonce, Balance};
 
 /// A set of APIs that polkadot-like runtimes must implement.
@@ -156,3 +160,192 @@ impl ClientHandle for Client {
 		}
 	}
 }
+
+impl sc_client_api::UsageProvider<Block> for Client {
+	fn usage_info(&self) -> sc_client_api::ClientInfo<Block> {
+		match self {
+			Self::Polkadot(client) => client.usage_info(),
+			Self::Westend(client) => client.usage_info(),
+			Self::Kusama(client) => client.usage_info(),
+		}
+	}
+}
+
+impl sc_client_api::BlockBackend<Block> for Client {
+	fn block_body(
+		&self, 
+		id: &BlockId<Block>
+	) -> sp_blockchain::Result<Option<Vec<<Block as BlockT>::Extrinsic>>> {
+		match self {
+			Self::Polkadot(client) => client.block_body(id),
+			Self::Westend(client) => client.block_body(id),
+			Self::Kusama(client) => client.block_body(id),
+		}
+	}
+
+	fn block(&self, id: &BlockId<Block>) -> sp_blockchain::Result<Option<SignedBlock<Block>>> {
+		match self {
+			Self::Polkadot(client) => client.block(id),
+			Self::Westend(client) => client.block(id),
+			Self::Kusama(client) => client.block(id),
+		}
+	}
+
+	fn block_status(&self, id: &BlockId<Block>) -> sp_blockchain::Result<BlockStatus> {
+		match self {
+			Self::Polkadot(client) => client.block_status(id),
+			Self::Westend(client) => client.block_status(id),
+			Self::Kusama(client) => client.block_status(id),
+		}
+	}
+
+	fn justification(
+		&self, 
+		id: &BlockId<Block>
+	) -> sp_blockchain::Result<Option<Justification>> {
+		match self {
+			Self::Polkadot(client) => client.justification(id),
+			Self::Westend(client) => client.justification(id),
+			Self::Kusama(client) => client.justification(id),
+		}
+	}
+
+	fn block_hash(
+		&self, 
+		number: NumberFor<Block>
+	) -> sp_blockchain::Result<Option<<Block as BlockT>::Hash>> {
+		match self {
+			Self::Polkadot(client) => client.block_hash(number),
+			Self::Westend(client) => client.block_hash(number),
+			Self::Kusama(client) => client.block_hash(number),
+		}
+	}
+}
+
+impl sc_client_api::StorageProvider<Block, crate::FullBackend> for Client {
+	fn storage(
+		&self, 
+		id: &BlockId<Block>, 
+		key: &StorageKey
+	) -> sp_blockchain::Result<Option<StorageData>> {
+		match self {
+			Self::Polkadot(client) => client.storage(id, key),
+			Self::Westend(client) => client.storage(id, key),
+			Self::Kusama(client) => client.storage(id, key),
+		}
+	}
+
+	fn storage_keys(
+		&self, 
+		id: &BlockId<Block>, 
+		key_prefix: &StorageKey
+	) -> sp_blockchain::Result<Vec<StorageKey>> {
+		match self {
+			Self::Polkadot(client) => client.storage_keys(id, key_prefix),
+			Self::Westend(client) => client.storage_keys(id, key_prefix),
+			Self::Kusama(client) => client.storage_keys(id, key_prefix),
+		}
+	}
+	
+	fn storage_hash(
+		&self, 
+		id: &BlockId<Block>, 
+		key: &StorageKey
+	) -> sp_blockchain::Result<Option<<Block as BlockT>::Hash>> {
+		match self {
+			Self::Polkadot(client) => client.storage_hash(id, key),
+			Self::Westend(client) => client.storage_hash(id, key),
+			Self::Kusama(client) => client.storage_hash(id, key),
+		}
+	}
+
+	fn storage_pairs(
+		&self, 
+		id: &BlockId<Block>, 
+		key_prefix: &StorageKey
+	) -> sp_blockchain::Result<Vec<(StorageKey, StorageData)>> {
+		match self {
+			Self::Polkadot(client) => client.storage_pairs(id, key_prefix),
+			Self::Westend(client) => client.storage_pairs(id, key_prefix),
+			Self::Kusama(client) => client.storage_pairs(id, key_prefix),
+		}
+	}
+
+	fn storage_keys_iter<'a>(
+		&self, 
+		id: &BlockId<Block>, 
+		prefix: Option<&'a StorageKey>, 
+		start_key: Option<&StorageKey>
+	) -> sp_blockchain::Result<KeyIterator<'a, <crate::FullBackend as sc_client_api::Backend<Block>>::State, Block>> {
+		match self {
+			Self::Polkadot(client) => client.storage_keys_iter(id, prefix, start_key),
+			Self::Westend(client) => client.storage_keys_iter(id, prefix, start_key),
+			Self::Kusama(client) => client.storage_keys_iter(id, prefix, start_key),
+		}
+	}
+
+	fn child_storage(
+		&self, 
+		id: &BlockId<Block>, 
+		child_info: &ChildInfo, 
+		key: &StorageKey
+	) -> sp_blockchain::Result<Option<StorageData>> {
+		match self {
+			Self::Polkadot(client) => client.child_storage(id, child_info, key),
+			Self::Westend(client) => client.child_storage(id, child_info, key),
+			Self::Kusama(client) => client.child_storage(id, child_info, key),
+		}
+	}
+
+	fn child_storage_keys(
+		&self, 
+		id: &BlockId<Block>, 
+		child_info: &ChildInfo, 
+		key_prefix: &StorageKey
+	) -> sp_blockchain::Result<Vec<StorageKey>> {
+		match self {
+			Self::Polkadot(client) => client.child_storage_keys(id, child_info, key_prefix),
+			Self::Westend(client) => client.child_storage_keys(id, child_info, key_prefix),
+			Self::Kusama(client) => client.child_storage_keys(id, child_info, key_prefix),
+		}
+	}
+
+	fn child_storage_hash(
+		&self, 
+		id: &BlockId<Block>, 
+		child_info: &ChildInfo, 
+		key: &StorageKey
+	) -> sp_blockchain::Result<Option<<Block as BlockT>::Hash>> {
+		match self {
+			Self::Polkadot(client) => client.child_storage_hash(id, child_info, key),
+			Self::Westend(client) => client.child_storage_hash(id, child_info, key),
+			Self::Kusama(client) => client.child_storage_hash(id, child_info, key),
+		}
+	}
+
+	fn max_key_changes_range(
+		&self, 
+		first: NumberFor<Block>, 
+		last: BlockId<Block>
+	) -> sp_blockchain::Result<Option<(NumberFor<Block>, BlockId<Block>)>> {
+		match self {
+			Self::Polkadot(client) => client.max_key_changes_range(first, last),
+			Self::Westend(client) => client.max_key_changes_range(first, last),
+			Self::Kusama(client) => client.max_key_changes_range(first, last),
+		}
+	}
+
+	fn key_changes(
+		&self, 
+		first: NumberFor<Block>, 
+		last: BlockId<Block>, 
+		storage_key: Option<&PrefixedStorageKey>, 
+		key: &StorageKey
+	) -> sp_blockchain::Result<Vec<(NumberFor<Block>, u32)>> {
+		match self {
+			Self::Polkadot(client) => client.key_changes(first, last, storage_key, key),
+			Self::Westend(client) => client.key_changes(first, last, storage_key, key),
+			Self::Kusama(client) => client.key_changes(first, last, storage_key, key),
+		}
+	}
+}

service/src/lib.rs

@@ -567,25 +567,30 @@ fn new_light<Runtime, Dispatch>(mut config: Configuration) -> Result<(TaskManage
 
 /// Builds a new object suitable for chain operations.
 #[cfg(feature = "full-node")]
-pub fn new_chain_ops<Runtime, Dispatch>(mut config: Configuration) -> Result<
+pub fn new_chain_ops(mut config: &mut Configuration) -> Result<
 	(
-		Arc<FullClient<Runtime, Dispatch>>,
+		Arc<crate::Client>,
 		Arc<FullBackend>,
 		consensus_common::import_queue::BasicQueue<Block, PrefixedMemoryDB<BlakeTwo256>>,
 		TaskManager,
 	),
 	ServiceError
->
-where
-	Runtime: ConstructRuntimeApi<Block, FullClient<Runtime, Dispatch>> + Send + Sync + 'static,
-	Runtime::RuntimeApi:
-	RuntimeApiCollection<StateBackend = sc_client_api::StateBackendFor<FullBackend, Block>>,
-	Dispatch: NativeExecutionDispatch + 'static,
-{
+> {
 	config.keystore = service::config::KeystoreConfig::InMemory;
-	let service::PartialComponents { client, backend, import_queue, task_manager, .. }
-		= new_partial::<Runtime, Dispatch>(&mut config, false)?;
-	Ok((client, backend, import_queue, task_manager))
+
+	if config.chain_spec.is_kusama() {
+		let service::PartialComponents { client, backend, import_queue, task_manager, .. }
+			= new_partial::<kusama_runtime::RuntimeApi, KusamaExecutor>(config, false)?;
+		Ok((Arc::new(Client::Kusama(client)), backend, import_queue, task_manager))
+	} else if config.chain_spec.is_westend() {
+		let service::PartialComponents { client, backend, import_queue, task_manager, .. }
+			= new_partial::<westend_runtime::RuntimeApi, WestendExecutor>(config, false)?;
+		Ok((Arc::new(Client::Westend(client)), backend, import_queue, task_manager))
+	} else {
+		let service::PartialComponents { client, backend, import_queue, task_manager, .. }
+			= new_partial::<polkadot_runtime::RuntimeApi, PolkadotExecutor>(config, false)?;
+		Ok((Arc::new(Client::Polkadot(client)), backend, import_queue, task_manager))
+	}
 }
 
 /// Create a new Polkadot service for a full node.