Adds export-state subcommand (#5842)

* Export state cli

* More work

* Fix tests

* Make it work

* Fix compilation

* Apply suggestions from code review

substrate/client/service/src/builder.rs

@@ -34,7 +34,7 @@ use futures::{
 	Future, FutureExt, StreamExt,
 	future::ready,
 };
-use sc_keystore::{Store as Keystore};
+use sc_keystore::Store as Keystore;
 use log::{info, warn, error};
 use sc_network::config::{Role, FinalityProofProvider, OnDemand, BoxFinalityProofRequestBuilder};
 use sc_network::{NetworkService, NetworkStateInfo};
@@ -59,6 +59,7 @@ use sc_client_db::{Backend, DatabaseSettings};
 use sp_core::traits::CodeExecutor;
 use sp_runtime::BuildStorage;
 use sc_client_api::execution_extensions::ExecutionExtensions;
+use sp_core::storage::Storage;
 
 pub type BackgroundTask = Pin<Box<dyn Future<Output=()> + Send>>;
 
@@ -771,6 +772,13 @@ pub trait ServiceBuilderCommand {
 		self,
 		block: BlockId<Self::Block>
 	) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send>>;
+
+	/// Export the raw state at the given `block`. If `block` is `None`, the
+	/// best block will be used.
+	fn export_raw_state(
+		&self,
+		block: Option<BlockId<Self::Block>>,
+	) -> Result<Storage, Error>;
 }
 
 impl<TBl, TRtApi, TBackend, TExec, TSc, TImpQu, TExPool, TRpc>

substrate/client/service/src/chain_ops.rs

@@ -33,13 +33,14 @@ use sp_consensus::{
 	import_queue::{IncomingBlock, Link, BlockImportError, BlockImportResult, ImportQueue},
 };
 use sc_executor::{NativeExecutor, NativeExecutionDispatch};
+use sp_core::storage::{StorageKey, well_known_keys, ChildInfo, Storage, StorageChild, StorageMap};
+use sc_client_api::{StorageProvider, BlockBackend, UsageProvider};
 
-use std::{io::{Read, Write, Seek}, pin::Pin};
-use sc_client_api::BlockBackend;
+use std::{io::{Read, Write, Seek}, pin::Pin, collections::HashMap};
 
 /// Build a chain spec json
 pub fn build_spec(spec: &dyn ChainSpec, raw: bool) -> error::Result<String> {
-	Ok(spec.as_json(raw)?)
+	spec.as_json(raw).map_err(Into::into)
 }
 
 impl<
@@ -298,4 +299,45 @@ impl<
 			Err(e) => Box::pin(future::err(format!("Error reading block: {:?}", e).into())),
 		}
 	}
+
+	fn export_raw_state(
+		&self,
+		block: Option<BlockId<Self::Block>>,
+	) -> Result<Storage, Error> {
+		let block = block.unwrap_or_else(
+			|| BlockId::Hash(self.client.usage_info().chain.best_hash)
+		);
+
+		let empty_key = StorageKey(Vec::new());
+		let mut top_storage = self.client.storage_pairs(&block, &empty_key)?;
+		let mut children_default = HashMap::new();
+
+		// Remove all default child storage roots from the top storage and collect the child storage
+		// pairs.
+		while let Some(pos) = top_storage
+			.iter()
+			.position(|(k, _)| k.0.starts_with(well_known_keys::DEFAULT_CHILD_STORAGE_KEY_PREFIX)) {
+			let (key, _) = top_storage.swap_remove(pos);
+
+			let key = StorageKey(
+				key.0[well_known_keys::DEFAULT_CHILD_STORAGE_KEY_PREFIX.len()..].to_vec(),
+			);
+			let child_info = ChildInfo::new_default(&key.0);
+
+			let keys = self.client.child_storage_keys(&block, &child_info, &empty_key)?;
+			let mut pairs = StorageMap::new();
+			keys.into_iter().try_for_each(|k| {
+				if let Some(value) = self.client.child_storage(&block, &child_info, &k)? {
+					pairs.insert(k.0, value.0);
+				}
+
+				Ok::<_, Error>(())
+			})?;
+
+			children_default.insert(key.0, StorageChild { child_info, data: pairs });
+		}
+
+		let top = top_storage.into_iter().map(|(k, v)| (k.0, v.0)).collect();
+		Ok(Storage { top, children_default })
+	}
 }

substrate/client/service/src/client/client.rs

@@ -1321,8 +1321,11 @@ impl<B, E, Block, RA> StorageProvider<Block, B> for Client<B, E, Block, RA> wher
 	}
 
 
-	fn storage(&self, id: &BlockId<Block>, key: &StorageKey) -> sp_blockchain::Result<Option<StorageData>>
-	{
+	fn storage(
+		&self,
+		id: &BlockId<Block>,
+		key: &StorageKey,
+	) -> sp_blockchain::Result<Option<StorageData>> {
 		Ok(self.state_at(id)?
 			.storage(&key.0).map_err(|e| sp_blockchain::Error::from_state(Box::new(e)))?
 			.map(StorageData)
@@ -1330,8 +1333,11 @@ impl<B, E, Block, RA> StorageProvider<Block, B> for Client<B, E, Block, RA> wher
 	}
 
 
-	fn storage_hash(&self, id: &BlockId<Block>, key: &StorageKey) -> sp_blockchain::Result<Option<Block::Hash>>
-	{
+	fn storage_hash(
+		&self,
+		id: &BlockId<Block>,
+		key: &StorageKey,
+	) -> sp_blockchain::Result<Option<Block::Hash>> {
 		Ok(self.state_at(id)?
 			.storage_hash(&key.0).map_err(|e| sp_blockchain::Error::from_state(Box::new(e)))?
 		)