Extends ChildStateBackend and ChildStateAPI with ReadProofs (#8812)

* Extends ChildStateBackend and ChildStateAPI with ReadProofs

The following changes integrate the existing `read_child_proof`
from the `ProofProvider` into the ChildStateBackend, so that a
read proof can be generated from a full client via an rpc call.

* Cleanup formatting

substrate/client/rpc-api/src/child_state/mod.rs

@@ -23,6 +23,7 @@ use sp_core::storage::{StorageKey, PrefixedStorageKey, StorageData};
 use crate::state::error::FutureResult;
 
 pub use self::gen_client::Client as ChildStateClient;
+use crate::state::ReadProof;
 
 /// Substrate child state API
 ///
@@ -68,4 +69,13 @@ pub trait ChildStateApi<Hash> {
 		key: StorageKey,
 		hash: Option<Hash>
 	) -> FutureResult<Option<u64>>;
+
+	/// Returns proof of storage for child key entries at a specific block's state.
+	#[rpc(name = "state_getChildReadProof")]
+	fn read_child_proof(
+		&self,
+		child_storage_key: PrefixedStorageKey,
+		keys: Vec<StorageKey>,
+		hash: Option<Hash>,
+	) -> FutureResult<ReadProof<Hash>>;
 }

substrate/client/rpc/src/state/mod.rs

@@ -382,6 +382,14 @@ pub trait ChildStateBackend<Block: BlockT, Client>: Send + Sync + 'static
 		Block: BlockT + 'static,
 		Client: Send + Sync + 'static,
 {
+	/// Returns proof of storage for a child key entries at a specific block's state.
+	fn read_child_proof(
+		&self,
+		block: Option<Block::Hash>,
+		storage_key: PrefixedStorageKey,
+		keys: Vec<StorageKey>,
+	) -> FutureResult<ReadProof<Block::Hash>>;
+
 	/// Returns the keys with prefix from a child storage,
 	/// leave prefix empty to get all the keys.
 	fn storage_keys(
@@ -431,6 +439,15 @@ impl<Block, Client> ChildStateApi<Block::Hash> for ChildState<Block, Client>
 {
 	type Metadata = crate::Metadata;
 
+	fn read_child_proof(
+		&self,
+		child_storage_key: PrefixedStorageKey,
+		keys: Vec<StorageKey>,
+		block: Option<Block::Hash>,
+	) -> FutureResult<ReadProof<Block::Hash>> {
+		self.backend.read_child_proof(block, child_storage_key, keys)
+	}
+
 	fn storage(
 		&self,
 		storage_key: PrefixedStorageKey,
@@ -466,6 +483,7 @@ impl<Block, Client> ChildStateApi<Block::Hash> for ChildState<Block, Client>
 	) -> FutureResult<Option<u64>> {
 		self.backend.storage_size(block, storage_key, key)
 	}
+
 }
 
 fn client_err(err: sp_blockchain::Error) -> Error {

substrate/client/rpc/src/state/state_full.rs

@@ -552,12 +552,39 @@ impl<BE, Block, Client> ChildStateBackend<Block, Client> for FullState<BE, Block
 	Block: BlockT + 'static,
 	BE: Backend<Block> + 'static,
 	Client: ExecutorProvider<Block> + StorageProvider<Block, BE>
+		+ ProofProvider<Block>
 		+ HeaderBackend<Block> + BlockBackend<Block>
 		+ HeaderMetadata<Block, Error = sp_blockchain::Error> + BlockchainEvents<Block>
 		+ CallApiAt<Block> + ProvideRuntimeApi<Block>
 		+ Send + Sync + 'static,
 	Client::Api: Metadata<Block>,
 {
+	fn read_child_proof(
+		&self,
+		block: Option<Block::Hash>,
+		storage_key: PrefixedStorageKey,
+		keys: Vec<StorageKey>,
+	) -> FutureResult<ReadProof<Block::Hash>> {
+		Box::new(result(
+			self.block_or_best(block)
+				.and_then(|block| {
+					let child_info = match ChildType::from_prefixed_key(&storage_key) {
+						Some((ChildType::ParentKeyId, storage_key)) => ChildInfo::new_default(storage_key),
+						None => return Err(sp_blockchain::Error::InvalidChildStorageKey),
+					};
+					self.client
+						.read_child_proof(
+							&BlockId::Hash(block),
+							&child_info,
+							&mut keys.iter().map(|key| key.0.as_ref()),
+						)
+						.map(|proof| proof.iter_nodes().map(|node| node.into()).collect())
+						.map(|proof| ReadProof { at: block, proof })
+				})
+				.map_err(client_err),
+		))
+	}
+
 	fn storage_keys(
 		&self,
 		block: Option<Block::Hash>,

substrate/client/rpc/src/state/state_light.rs

@@ -491,6 +491,15 @@ impl<Block, F, Client> ChildStateBackend<Block, Client> for LightState<Block, F,
 		Client: BlockchainEvents<Block> + HeaderBackend<Block> + Send + Sync + 'static,
 		F: Fetcher<Block> + 'static
 {
+	fn read_child_proof(
+		&self,
+		_block: Option<Block::Hash>,
+		_storage_key: PrefixedStorageKey,
+		_keys: Vec<StorageKey>,
+	) -> FutureResult<ReadProof<Block::Hash>> {
+		Box::new(result(Err(client_err(ClientError::NotAvailableOnLightClient))))
+	}
+
 	fn storage_keys(
 		&self,
 		_block: Option<Block::Hash>,