remove old rpc

client/rpc-api/src/state/mod.rs

@@ -72,54 +72,6 @@ pub trait StateApi<Hash> {
 	#[rpc(name = "state_getStorageSize", alias("state_getStorageSizeAt"))]
 	fn storage_size(&self, key: StorageKey, hash: Option<Hash>) -> FutureResult<Option<u64>>;
 
-	/// Returns the keys with prefix from a child storage, leave empty to get all the keys
-	/// This method is deprecated in favor of `childstate_getChildKeys`.
-	#[rpc(name = "state_getChildKeys")]
-	fn child_storage_keys(
-		&self,
-		child_storage_key: StorageKey,
-		child_info: StorageKey,
-		child_type: u32,
-		prefix: StorageKey,
-		hash: Option<Hash>
-	) -> FutureResult<Vec<StorageKey>>;
-
-	/// Returns a child storage entry at a specific block's state.
-	/// This method is deprecated in favor of `childstate_getChildStorage`.
-	#[rpc(name = "state_getChildStorage")]
-	fn child_storage(
-		&self,
-		child_storage_key: StorageKey,
-		child_info: StorageKey,
-		child_type: u32,
-		key: StorageKey,
-		hash: Option<Hash>
-	) -> FutureResult<Option<StorageData>>;
-
-	/// Returns the hash of a child storage entry at a block's state.
-	/// This method is deprecated in favor of `childstate_getChildStorageHash`.
-	#[rpc(name = "state_getChildStorageHash")]
-	fn child_storage_hash(
-		&self,
-		child_storage_key: StorageKey,
-		child_info: StorageKey,
-		child_type: u32,
-		key: StorageKey,
-		hash: Option<Hash>
-	) -> FutureResult<Option<Hash>>;
-
-	/// Returns the size of a child storage entry at a block's state.
-	/// This method is deprecated in favor of `childstate_getChildStorageSize`.
-	#[rpc(name = "state_getChildStorageSize")]
-	fn child_storage_size(
-		&self,
-		child_storage_key: StorageKey,
-		child_info: StorageKey,
-		child_type: u32,
-		key: StorageKey,
-		hash: Option<Hash>
-	) -> FutureResult<Option<u64>>;
-
 	/// Returns the runtime metadata as an opaque blob.
 	#[rpc(name = "state_getMetadata")]
 	fn metadata(&self, hash: Option<Hash>) -> FutureResult<Bytes>;

client/rpc/src/state/mod.rs

@@ -104,49 +104,6 @@ pub trait StateBackend<Block: BlockT, Client>: Send + Sync + 'static
 			.map(|x| x.map(|x| x.0.len() as u64)))
 	}
 
-	/// Returns the keys with prefix from a child storage, leave empty to get all the keys
-	fn child_storage_keys(
-		&self,
-		block: Option<Block::Hash>,
-		child_storage_key: StorageKey,
-		child_info: StorageKey,
-		child_type: u32,
-		prefix: StorageKey,
-	) -> FutureResult<Vec<StorageKey>>;
-
-	/// Returns a child storage entry at a specific block's state.
-	fn child_storage(
-		&self,
-		block: Option<Block::Hash>,
-		child_storage_key: StorageKey,
-		child_info: StorageKey,
-		child_type: u32,
-		key: StorageKey,
-	) -> FutureResult<Option<StorageData>>;
-
-	/// Returns the hash of a child storage entry at a block's state.
-	fn child_storage_hash(
-		&self,
-		block: Option<Block::Hash>,
-		child_storage_key: StorageKey,
-		child_info: StorageKey,
-		child_type: u32,
-		key: StorageKey,
-	) -> FutureResult<Option<Block::Hash>>;
-
-	/// Returns the size of a child storage entry at a block's state.
-	fn child_storage_size(
-		&self,
-		block: Option<Block::Hash>,
-		child_storage_key: StorageKey,
-		child_info: StorageKey,
-		child_type: u32,
-		key: StorageKey,
-	) -> FutureResult<Option<u64>> {
-		Box::new(self.child_storage(block, child_storage_key, child_info, child_type, key)
-			.map(|x| x.map(|x| x.0.len() as u64)))
-	}
-
 	/// Returns the runtime metadata as an opaque blob.
 	fn metadata(&self, block: Option<Block::Hash>) -> FutureResult<Bytes>;
 
@@ -309,50 +266,6 @@ impl<Block, Client> StateApi<Block::Hash> for State<Block, Client>
 		self.backend.storage_size(block, key)
 	}
 
-	fn child_storage(
-		&self,
-		child_storage_key: StorageKey,
-		child_info: StorageKey,
-		child_type: u32,
-		key: StorageKey,
-		block: Option<Block::Hash>
-	) -> FutureResult<Option<StorageData>> {
-		self.backend.child_storage(block, child_storage_key, child_info, child_type, key)
-	}
-
-	fn child_storage_keys(
-		&self,
-		child_storage_key: StorageKey,
-		child_info: StorageKey,
-		child_type: u32,
-		key_prefix: StorageKey,
-		block: Option<Block::Hash>
-	) -> FutureResult<Vec<StorageKey>> {
-		self.backend.child_storage_keys(block, child_storage_key, child_info, child_type, key_prefix)
-	}
-
-	fn child_storage_hash(
-		&self,
-		child_storage_key: StorageKey,
-		child_info: StorageKey,
-		child_type: u32,
-		key: StorageKey,
-		block: Option<Block::Hash>
-	) -> FutureResult<Option<Block::Hash>> {
-		self.backend.child_storage_hash(block, child_storage_key, child_info, child_type, key)
-	}
-
-	fn child_storage_size(
-		&self,
-		child_storage_key: StorageKey,
-		child_info: StorageKey,
-		child_type: u32,
-		key: StorageKey,
-		block: Option<Block::Hash>
-	) -> FutureResult<Option<u64>> {
-		self.backend.child_storage_size(block, child_storage_key, child_info, child_type, key)
-	}
-
 	fn metadata(&self, block: Option<Block::Hash>) -> FutureResult<Bytes> {
 		self.backend.metadata(block)
 	}
@@ -488,12 +401,6 @@ impl<Block, Client> ChildStateApi<Block::Hash> for ChildState<Block, Client>
 	}
 }
 
-const CHILD_RESOLUTION_ERROR: &str = "Unexpected child info and type";
-
-fn child_resolution_error() -> Error {
-	client_err(sp_blockchain::Error::Msg(CHILD_RESOLUTION_ERROR.to_string()))
-}
-
 fn client_err(err: sp_blockchain::Error) -> Error {
 	Error::Client(Box::new(err))
 }

client/rpc/src/state/state_full.rs

@@ -39,8 +39,7 @@ use sp_runtime::{
 
 use sp_api::{Metadata, ProvideRuntimeApi, CallApiAt};
 
-use super::{StateBackend, ChildStateBackend, error::{FutureResult, Error, Result},
-	client_err, child_resolution_error};
+use super::{StateBackend, ChildStateBackend, error::{FutureResult, Error, Result}, client_err};
 use std::marker::PhantomData;
 use sc_client_api::{CallExecutor, StorageProvider, ExecutorProvider};
 
@@ -307,63 +306,6 @@ impl<BE, Block, Client> StateBackend<Block, Client> for FullState<BE, Block, Cli
 				.map_err(client_err)))
 	}
 
-	fn child_storage_keys(
-		&self,
-		block: Option<Block::Hash>,
-		child_storage_key: StorageKey,
-		_child_info: StorageKey,
-		child_type: u32,
-		prefix: StorageKey,
-	) -> FutureResult<Vec<StorageKey>> {
-		if child_type != 1 {
-			return Box::new(result(Err(child_resolution_error())));
-		}
-		ChildStateBackend::storage_keys(
-			self,
-			block,
-			child_storage_key,
-			prefix,
-		)
-	}
-
-	fn child_storage(
-		&self,
-		block: Option<Block::Hash>,
-		child_storage_key: StorageKey,
-		_child_info: StorageKey,
-		child_type: u32,
-		key: StorageKey,
-	) -> FutureResult<Option<StorageData>> {
-		if child_type != 1 {
-			return Box::new(result(Err(child_resolution_error())));
-		}
-		ChildStateBackend::storage(
-			self,
-			block,
-			child_storage_key,
-			key,
-		)
-	}
-
-	fn child_storage_hash(
-		&self,
-		block: Option<Block::Hash>,
-		child_storage_key: StorageKey,
-		_child_info: StorageKey,
-		child_type: u32,
-		key: StorageKey,
-	) -> FutureResult<Option<Block::Hash>> {
-		if child_type != 1 {
-			return Box::new(result(Err(child_resolution_error())));
-		}
-		ChildStateBackend::storage_hash(
-			self,
-			block,
-			child_storage_key,
-			key,
-		)
-	}
-
 	fn metadata(&self, block: Option<Block::Hash>) -> FutureResult<Bytes> {
 		Box::new(result(
 			self.block_or_best(block)

client/rpc/src/state/state_light.rs

@@ -53,8 +53,7 @@ use sp_core::{
 use sp_version::RuntimeVersion;
 use sp_runtime::{generic::BlockId, traits::{Block as BlockT, HashFor}};
 
-use super::{StateBackend, ChildStateBackend, error::{FutureResult, Error}, client_err,
-	child_resolution_error};
+use super::{StateBackend, ChildStateBackend, error::{FutureResult, Error}, client_err};
 
 /// Storage data map of storage keys => (optional) storage value.
 type StorageMap = HashMap<StorageKey, Option<StorageData>>;
@@ -242,55 +241,6 @@ impl<Block, F, Client> StateBackend<Block, Client> for LightState<Block, F, Clie
 		)
 	}
 
-	fn child_storage_keys(
-		&self,
-		_block: Option<Block::Hash>,
-		_child_storage_key: StorageKey,
-		_child_info: StorageKey,
-		_child_type: u32,
-		_prefix: StorageKey,
-	) -> FutureResult<Vec<StorageKey>> {
-		Box::new(result(Err(client_err(ClientError::NotAvailableOnLightClient))))
-	}
-
-	fn child_storage(
-		&self,
-		block: Option<Block::Hash>,
-		child_storage_key: StorageKey,
-		_child_info: StorageKey,
-		child_type: u32,
-		key: StorageKey,
-	) -> FutureResult<Option<StorageData>> {
-		if child_type != 1 {
-			return Box::new(result(Err(child_resolution_error())));
-		}
-		ChildStateBackend::storage(
-			self,
-			block,
-			child_storage_key,
-			key,
-		)
-	}
-
-	fn child_storage_hash(
-		&self,
-		block: Option<Block::Hash>,
-		child_storage_key: StorageKey,
-		_child_info: StorageKey,
-		child_type: u32,
-		key: StorageKey,
-	) -> FutureResult<Option<Block::Hash>> {
-		if child_type != 1 {
-			return Box::new(result(Err(child_resolution_error())));
-		}
-		ChildStateBackend::storage_hash(
-			self,
-			block,
-			child_storage_key,
-			key,
-		)
-	}
-
 	fn metadata(&self, block: Option<Block::Hash>) -> FutureResult<Bytes> {
 		let metadata = self.call(block, "Metadata_metadata".into(), Bytes(Vec::new()))
 			.and_then(|metadata| OpaqueMetadata::decode(&mut &metadata.0[..])