jsonrpsee integration (#8783)

* Add tokio * No need to map CallError to CallError * jsonrpsee proc macros (#9673) * port error types to `JsonRpseeError` * migrate chain module to proc macro api * make it compile with proc macros * update branch * update branch * update to jsonrpsee master * port system rpc * port state rpc * port childstate & offchain * frame system rpc * frame transaction payment * bring back CORS hack to work with polkadot UI * port babe rpc * port manual seal rpc * port frame mmr rpc * port frame contracts rpc * port finality grandpa rpc * port sync state rpc * resolve a few TODO + no jsonrpc deps * Update bin/node/rpc-client/src/main.rs * Update bin/node/rpc-client/src/main.rs * Update bin/node/rpc-client/src/main.rs * Update bin/node/rpc-client/src/main.rs * Port over system_ rpc tests * Make it compile * Use prost 0.8 * Use prost 0.8 * Make it compile * Ignore more failing tests * Comment out WIP tests * fix nit in frame system api * Update lockfile * No more juggling tokio versions * No more wait_for_stop ? * Remove browser-testing * Arguments must be arrays * Use same argument names * Resolve todo: no wait_for_stop for WS server Add todo: is parse_rpc_result used? Cleanup imports * fmt * log * One test passes * update jsonrpsee * update jsonrpsee * cleanup rpc-servers crate * jsonrpsee: add host and origin filtering (#9787) * add access control in the jsonrpsee servers * use master * fix nits * rpc runtime_version safe * fix nits * fix grumbles * remove unused files * resolve some todos * jsonrpsee more cleanup (#9803) * more cleanup * resolve TODOs * fix some unwraps * remove type hints * update jsonrpsee * downgrade zeroize * pin jsonrpsee rev * remove unwrap nit * Comment out more tests that aren't ported * Comment out more tests * Fix tests after merge * Subscription test * Invalid nonce test * Pending exts * WIP removeExtrinsic test * Test remove_extrinsic * Make state test: should_return_storage work * Uncomment/fix the other non-subscription related state tests * test: author_insertKey * test: author_rotateKeys * Get rest of state tests passing * asyncify a little more * Add todo to note #msg change * Crashing test for has_session_keys * Fix error conversion to avoid stack overflows Port author_hasSessionKeys test fmt * test author_hasKey * Add two missing tests Add a check on the return type Add todos for James's concerns * RPC tests for state, author and system (#9859) * Fix test runner * Impl Default for SubscriptionTaskExecutor * Keep the minimul amount of code needed to compile tests * Re-instate `RpcSession` (for now) * cleanup * Port over RPC tests * Add tokio * No need to map CallError to CallError * Port over system_ rpc tests * Make it compile * Use prost 0.8 * Use prost 0.8 * Make it compile * Ignore more failing tests * Comment out WIP tests * Update lockfile * No more juggling tokio versions * No more wait_for_stop ? * Remove browser-testing * Arguments must be arrays * Use same argument names * Resolve todo: no wait_for_stop for WS server Add todo: is parse_rpc_result used? Cleanup imports * fmt * log * One test passes * Comment out more tests that aren't ported * Comment out more tests * Fix tests after merge * Subscription test * Invalid nonce test * Pending exts * WIP removeExtrinsic test * Test remove_extrinsic * Make state test: should_return_storage work * Uncomment/fix the other non-subscription related state tests * test: author_insertKey * test: author_rotateKeys * Get rest of state tests passing * asyncify a little more * Add todo to note #msg change * Crashing test for has_session_keys * Fix error conversion to avoid stack overflows Port author_hasSessionKeys test fmt * test author_hasKey * Add two missing tests Add a check on the return type Add todos for James's concerns * offchain rpc tests * Address todos * fmt Co-authored-by: James Wilson <james@jsdw.me> * fix drop in state test * update jsonrpsee * fix ignored system test * fix chain tests * remove some boiler plate * Port BEEFY RPC (#9883) * Merge master * Port beefy RPC (ty @niklas!) * trivial changes left over from merge * Remove unused code * Update jsonrpsee * fix build * make tests compile again * beefy update jsonrpsee * fix: respect rpc methods policy * update cargo.lock * update jsonrpsee * update jsonrpsee * downgrade error logs * update jsonrpsee * Fix typo * remove unused file * Better name * Port Babe RPC tests * Put docs back * Resolve todo * Port tests for System RPCs * Resolve todo * fix build * Updated jsonrpsee to current master * fix: port finality grandpa rpc tests * Move .into() outside of the match * more review grumbles * jsonrpsee: add `rpc handlers` back (#10245) * add back RpcHandlers * cargo fmt * fix docs * fix grumble: remove needless alloc * resolve TODO * fmt * Fix typo * grumble: Use constants based on BASE_ERROR * grumble: DRY whitelisted listening addresses grumble: s/JSONRPC/JSON-RPC/ * cleanup * grumbles: Making readers aware of the possibility of gaps * review grumbles * grumbles * remove notes from niklasad1 * Update `jsonrpsee` * fix: jsonrpsee features * jsonrpsee: fallback to random port in case the specified port failed (#10304) * jsonrpsee: fallback to random port * better comment * Update client/rpc-servers/src/lib.rs Co-authored-by: Maciej Hirsz <1096222+maciejhirsz@users.noreply.github.com> * Update client/rpc-servers/src/lib.rs Co-authored-by: Maciej Hirsz <1096222+maciejhirsz@users.noreply.github.com> * address grumbles * cargo fmt * addrs already slice Co-authored-by: Maciej Hirsz <1096222+maciejhirsz@users.noreply.github.com> * Update jsonrpsee to 092081a0a2b8904c6ebd2cd99e16c7bc13ffc3ae * lockfile * update jsonrpsee * fix warning * Don't fetch jsonrpsee from crates * make tests compile again * fix rpc tests * remove unused deps * update tokio * fix rpc tests again * fix: test runner `HttpServerBuilder::builder` fails unless it's called within tokio runtime * cargo fmt * grumbles: fix subscription aliases * make clippy happy * update remaining subscriptions alias * cleanup * cleanup * fix chain subscription: less boiler plate (#10285) * fix chain subscription: less boiler plate * fix bad merge * cargo fmt * Switch to jsonrpsee 0.5 * fix build * add missing features * fix nit: remove needless Box::pin * Integrate jsonrpsee metrics (#10395) * draft metrics impl * Use latest api * Add missing file * Http server metrics * cleanup * bump jsonrpsee * Remove `ServerMetrics` and use a single middleware for both connection counting (aka sessions) and call metrics. * fix build * remove needless Arc::clone * Update to jsonrpsee 0.6 * lolz * fix metrics * Revert "lolz" This reverts commit eed6c6a56e78d8e307b4950f4c52a1c3a2322ba1. * fix: in-memory rpc support subscriptions * commit Cargo.lock * Update tests to 0.7 * fix TODOs * ws server: generate subscriptionIDs as Strings Some libraries seems to expect the subscription IDs to be Strings, let's not break this in this PR. * Increase timeout * Port over tests * cleanup * Using error codes from the spec * fix clippy * cargo fmt * update jsonrpsee * fix nits * fix: rpc_query * enable custom subid gen through spawn_tasks * remove unsed deps * unify tokio deps * Revert "enable custom subid gen through spawn_tasks" This reverts commit 5c5eb70328fe39d154fdb55c56e637b4548cf470. * fix bad merge of `test-utils` * fix more nits * downgrade wasm-instrument to 0.1.0 * [jsonrpsee]: enable custom RPC subscription ID generatation (#10731) * enable custom subid gen through spawn_tasks * fix nits * Update client/service/src/builder.rs Co-authored-by: David <dvdplm@gmail.com> * add Poc; needs jsonrpsee pr * update jsonrpsee * add re-exports * add docs Co-authored-by: David <dvdplm@gmail.com> * cargo fmt * fmt * port RPC-API dev * Remove unused file * fix nit: remove async trait * fix doc links * fix merge nit: remove jsonrpc deps * kill namespace on rpc apis * companion for jsonrpsee v0.10 (#11158) * companion for jsonrpsee v0.10 * update versions v0.10.0 * add some fixes * spelling * fix spaces Co-authored-by: Niklas Adolfsson <niklasadolfsson1@gmail.com> * send error before subs are closed * fix unsubscribe method names: chain * fix tests * jsonrpc server: print binded local address * grumbles: kill SubscriptionTaskExecutor * Update client/sync-state-rpc/src/lib.rs Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com> * Update client/rpc/src/chain/chain_full.rs Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com> * Update client/rpc/src/chain/chain_full.rs Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com> * sync-state-rpc: kill anyhow * no more anyhow * remove todo * jsonrpsee: fix bad params in subscriptions. (#11251) * update jsonrpsee * fix error responses * revert error codes * dont do weird stuff in drop impl * rpc servers: remove needless clone * Remove silly constants * chore: update jsonrpsee v0.12 * commit Cargo.lock * deps: downgrade git2 * feat: CLI flag max subscriptions per connection * metrics: use old logging format * fix: read WS address from substrate output (#11379) Co-authored-by: Niklas Adolfsson <niklasadolfsson1@gmail.com> Co-authored-by: James Wilson <james@jsdw.me> Co-authored-by: Maciej Hirsz <hello@maciej.codes> Co-authored-by: Maciej Hirsz <1096222+maciejhirsz@users.noreply.github.com> Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>
2026-06-13 05:51:02 +00:00 · 2022-05-10 10:52:19 +02:00
parent e45d53552d
commit 29c0c6a4a8
93 changed files with 3813 additions and 5094 deletions
@@ -23,11 +23,15 @@ mod state_full;
 #[cfg(test)]
 mod tests;

-use futures::FutureExt;
-use jsonrpc_pubsub::{manager::SubscriptionManager, typed::Subscriber, SubscriptionId};
-use rpc::Result as RpcResult;
 use std::sync::Arc;

+use crate::SubscriptionTaskExecutor;
+
+use jsonrpsee::{
+	core::{async_trait, Error as JsonRpseeError, RpcResult},
+	ws_server::PendingSubscription,
+};
+
 use sc_rpc_api::{state::ReadProof, DenyUnsafe};
 use sp_core::{
 	storage::{PrefixedStorageKey, StorageChangeSet, StorageData, StorageKey},
@@ -38,7 +42,7 @@ use sp_version::RuntimeVersion;

 use sp_api::{CallApiAt, Metadata, ProvideRuntimeApi};

-use self::error::{Error, FutureResult};
+use self::error::Error;

 use sc_client_api::{
 	Backend, BlockBackend, BlockchainEvents, ExecutorProvider, ProofProvider, StorageProvider,
@@ -49,144 +53,122 @@ use sp_blockchain::{HeaderBackend, HeaderMetadata};
 const STORAGE_KEYS_PAGED_MAX_COUNT: u32 = 1000;

 /// State backend API.
+#[async_trait]
 pub trait StateBackend<Block: BlockT, Client>: Send + Sync + 'static
 where
 	Block: BlockT + 'static,
 	Client: Send + Sync + 'static,
 {
 	/// Call runtime method at given block.
-	fn call(
+	async fn call(
 		&self,
 		block: Option<Block::Hash>,
 		method: String,
 		call_data: Bytes,
-	) -> FutureResult<Bytes>;
+	) -> Result<Bytes, Error>;

 	/// Returns the keys with prefix, leave empty to get all the keys.
-	fn storage_keys(
+	async fn storage_keys(
 		&self,
 		block: Option<Block::Hash>,
 		prefix: StorageKey,
-	) -> FutureResult<Vec<StorageKey>>;
+	) -> Result<Vec<StorageKey>, Error>;

 	/// Returns the keys with prefix along with their values, leave empty to get all the pairs.
-	fn storage_pairs(
+	async fn storage_pairs(
 		&self,
 		block: Option<Block::Hash>,
 		prefix: StorageKey,
-	) -> FutureResult<Vec<(StorageKey, StorageData)>>;
+	) -> Result<Vec<(StorageKey, StorageData)>, Error>;

 	/// Returns the keys with prefix with pagination support.
-	fn storage_keys_paged(
+	async fn storage_keys_paged(
 		&self,
 		block: Option<Block::Hash>,
 		prefix: Option<StorageKey>,
 		count: u32,
 		start_key: Option<StorageKey>,
-	) -> FutureResult<Vec<StorageKey>>;
+	) -> Result<Vec<StorageKey>, Error>;

 	/// Returns a storage entry at a specific block's state.
-	fn storage(
+	async fn storage(
 		&self,
 		block: Option<Block::Hash>,
 		key: StorageKey,
-	) -> FutureResult<Option<StorageData>>;
+	) -> Result<Option<StorageData>, Error>;

 	/// Returns the hash of a storage entry at a block's state.
-	fn storage_hash(
+	async fn storage_hash(
 		&self,
 		block: Option<Block::Hash>,
 		key: StorageKey,
-	) -> FutureResult<Option<Block::Hash>>;
+	) -> Result<Option<Block::Hash>, Error>;

 	/// Returns the size of a storage entry at a block's state.
 	///
 	/// If data is available at `key`, it is returned. Else, the sum of values who's key has `key`
 	/// prefix is returned, i.e. all the storage (double) maps that have this prefix.
-	fn storage_size(
+	async fn storage_size(
 		&self,
 		block: Option<Block::Hash>,
 		key: StorageKey,
-	) -> FutureResult<Option<u64>>;
+	) -> Result<Option<u64>, Error>;

 	/// Returns the runtime metadata as an opaque blob.
-	fn metadata(&self, block: Option<Block::Hash>) -> FutureResult<Bytes>;
+	async fn metadata(&self, block: Option<Block::Hash>) -> Result<Bytes, Error>;

 	/// Get the runtime version.
-	fn runtime_version(&self, block: Option<Block::Hash>) -> FutureResult<RuntimeVersion>;
+	async fn runtime_version(&self, block: Option<Block::Hash>) -> Result<RuntimeVersion, Error>;

 	/// Query historical storage entries (by key) starting from a block given as the second
 	/// parameter.
 	///
 	/// NOTE This first returned result contains the initial state of storage for all keys.
 	/// Subsequent values in the vector represent changes to the previous state (diffs).
-	fn query_storage(
+	async fn query_storage(
 		&self,
 		from: Block::Hash,
 		to: Option<Block::Hash>,
 		keys: Vec<StorageKey>,
-	) -> FutureResult<Vec<StorageChangeSet<Block::Hash>>>;
+	) -> Result<Vec<StorageChangeSet<Block::Hash>>, Error>;

 	/// Query storage entries (by key) starting at block hash given as the second parameter.
-	fn query_storage_at(
+	async fn query_storage_at(
 		&self,
 		keys: Vec<StorageKey>,
 		at: Option<Block::Hash>,
-	) -> FutureResult<Vec<StorageChangeSet<Block::Hash>>>;
+	) -> Result<Vec<StorageChangeSet<Block::Hash>>, Error>;

 	/// Returns proof of storage entries at a specific block's state.
-	fn read_proof(
+	async fn read_proof(
 		&self,
 		block: Option<Block::Hash>,
 		keys: Vec<StorageKey>,
-	) -> FutureResult<ReadProof<Block::Hash>>;
-
-	/// New runtime version subscription
-	fn subscribe_runtime_version(
-		&self,
-		_meta: crate::Metadata,
-		subscriber: Subscriber<RuntimeVersion>,
-	);
-
-	/// Unsubscribe from runtime version subscription
-	fn unsubscribe_runtime_version(
-		&self,
-		_meta: Option<crate::Metadata>,
-		id: SubscriptionId,
-	) -> RpcResult<bool>;
-
-	/// New storage subscription
-	fn subscribe_storage(
-		&self,
-		_meta: crate::Metadata,
-		subscriber: Subscriber<StorageChangeSet<Block::Hash>>,
-		keys: Option<Vec<StorageKey>>,
-	);
-
-	/// Unsubscribe from storage subscription
-	fn unsubscribe_storage(
-		&self,
-		_meta: Option<crate::Metadata>,
-		id: SubscriptionId,
-	) -> RpcResult<bool>;
+	) -> Result<ReadProof<Block::Hash>, Error>;

 	/// Trace storage changes for block
-	fn trace_block(
+	async fn trace_block(
 		&self,
 		block: Block::Hash,
 		targets: Option<String>,
 		storage_keys: Option<String>,
 		methods: Option<String>,
-	) -> FutureResult<sp_rpc::tracing::TraceBlockResponse>;
+	) -> Result<sp_rpc::tracing::TraceBlockResponse, Error>;
+
+	/// New runtime version subscription
+	fn subscribe_runtime_version(&self, sink: PendingSubscription);
+
+	/// New storage subscription
+	fn subscribe_storage(&self, sink: PendingSubscription, keys: Option<Vec<StorageKey>>);
 }

 /// Create new state API that works on full node.
 pub fn new_full<BE, Block: BlockT, Client>(
 	client: Arc<Client>,
-	subscriptions: SubscriptionManager,
+	executor: SubscriptionTaskExecutor,
 	deny_unsafe: DenyUnsafe,
 	rpc_max_payload: Option<usize>,
-) -> (State<Block, Client>, ChildState<Block, Client>)
+) -> (StateApi<Block, Client>, ChildState<Block, Client>)
 where
 	Block: BlockT + 'static,
 	Block::Hash: Unpin,
@@ -207,168 +189,127 @@ where
 {
 	let child_backend = Box::new(self::state_full::FullState::new(
 		client.clone(),
-		subscriptions.clone(),
+		executor.clone(),
 		rpc_max_payload,
 	));
-	let backend =
-		Box::new(self::state_full::FullState::new(client, subscriptions, rpc_max_payload));
-	(State { backend, deny_unsafe }, ChildState { backend: child_backend })
+	let backend = Box::new(self::state_full::FullState::new(client, executor, rpc_max_payload));
+	(StateApi { backend, deny_unsafe }, ChildState { backend: child_backend })
 }

 /// State API with subscriptions support.
-pub struct State<Block, Client> {
+pub struct StateApi<Block, Client> {
 	backend: Box<dyn StateBackend<Block, Client>>,
 	/// Whether to deny unsafe calls
 	deny_unsafe: DenyUnsafe,
 }

-impl<Block, Client> StateApi<Block::Hash> for State<Block, Client>
+#[async_trait]
+impl<Block, Client> StateApiServer<Block::Hash> for StateApi<Block, Client>
 where
 	Block: BlockT + 'static,
 	Client: Send + Sync + 'static,
 {
-	type Metadata = crate::Metadata;
-
-	fn call(&self, method: String, data: Bytes, block: Option<Block::Hash>) -> FutureResult<Bytes> {
-		self.backend.call(block, method, data)
+	async fn call(
+		&self,
+		method: String,
+		data: Bytes,
+		block: Option<Block::Hash>,
+	) -> RpcResult<Bytes> {
+		self.backend.call(block, method, data).await.map_err(Into::into)
 	}

-	fn storage_keys(
+	async fn storage_keys(
 		&self,
 		key_prefix: StorageKey,
 		block: Option<Block::Hash>,
-	) -> FutureResult<Vec<StorageKey>> {
-		self.backend.storage_keys(block, key_prefix)
+	) -> RpcResult<Vec<StorageKey>> {
+		self.backend.storage_keys(block, key_prefix).await.map_err(Into::into)
 	}

-	fn storage_pairs(
+	async fn storage_pairs(
 		&self,
 		key_prefix: StorageKey,
 		block: Option<Block::Hash>,
-	) -> FutureResult<Vec<(StorageKey, StorageData)>> {
-		if let Err(err) = self.deny_unsafe.check_if_safe() {
-			return async move { Err(err.into()) }.boxed()
-		}
-
-		self.backend.storage_pairs(block, key_prefix)
+	) -> RpcResult<Vec<(StorageKey, StorageData)>> {
+		self.deny_unsafe.check_if_safe()?;
+		self.backend.storage_pairs(block, key_prefix).await.map_err(Into::into)
 	}

-	fn storage_keys_paged(
+	async fn storage_keys_paged(
 		&self,
 		prefix: Option<StorageKey>,
 		count: u32,
 		start_key: Option<StorageKey>,
 		block: Option<Block::Hash>,
-	) -> FutureResult<Vec<StorageKey>> {
+	) -> RpcResult<Vec<StorageKey>> {
 		if count > STORAGE_KEYS_PAGED_MAX_COUNT {
-			return async move {
-				Err(Error::InvalidCount { value: count, max: STORAGE_KEYS_PAGED_MAX_COUNT })
-			}
-			.boxed()
+			return Err(JsonRpseeError::from(Error::InvalidCount {
+				value: count,
+				max: STORAGE_KEYS_PAGED_MAX_COUNT,
+			}))
 		}
-		self.backend.storage_keys_paged(block, prefix, count, start_key)
+		self.backend
+			.storage_keys_paged(block, prefix, count, start_key)
+			.await
+			.map_err(Into::into)
 	}

-	fn storage(
+	async fn storage(
 		&self,
 		key: StorageKey,
 		block: Option<Block::Hash>,
-	) -> FutureResult<Option<StorageData>> {
-		self.backend.storage(block, key)
+	) -> RpcResult<Option<StorageData>> {
+		self.backend.storage(block, key).await.map_err(Into::into)
 	}

-	fn storage_hash(
+	async fn storage_hash(
 		&self,
 		key: StorageKey,
 		block: Option<Block::Hash>,
-	) -> FutureResult<Option<Block::Hash>> {
-		self.backend.storage_hash(block, key)
+	) -> RpcResult<Option<Block::Hash>> {
+		self.backend.storage_hash(block, key).await.map_err(Into::into)
 	}

-	fn storage_size(
+	async fn storage_size(
 		&self,
 		key: StorageKey,
 		block: Option<Block::Hash>,
-	) -> FutureResult<Option<u64>> {
-		self.backend.storage_size(block, key)
+	) -> RpcResult<Option<u64>> {
+		self.backend.storage_size(block, key).await.map_err(Into::into)
 	}

-	fn metadata(&self, block: Option<Block::Hash>) -> FutureResult<Bytes> {
-		self.backend.metadata(block)
+	async fn metadata(&self, block: Option<Block::Hash>) -> RpcResult<Bytes> {
+		self.backend.metadata(block).await.map_err(Into::into)
 	}

-	fn query_storage(
+	async fn runtime_version(&self, at: Option<Block::Hash>) -> RpcResult<RuntimeVersion> {
+		self.backend.runtime_version(at).await.map_err(Into::into)
+	}
+
+	async fn query_storage(
 		&self,
 		keys: Vec<StorageKey>,
 		from: Block::Hash,
 		to: Option<Block::Hash>,
-	) -> FutureResult<Vec<StorageChangeSet<Block::Hash>>> {
-		if let Err(err) = self.deny_unsafe.check_if_safe() {
-			return async move { Err(err.into()) }.boxed()
-		}
-
-		self.backend.query_storage(from, to, keys)
+	) -> RpcResult<Vec<StorageChangeSet<Block::Hash>>> {
+		self.deny_unsafe.check_if_safe()?;
+		self.backend.query_storage(from, to, keys).await.map_err(Into::into)
 	}

-	fn query_storage_at(
+	async fn query_storage_at(
 		&self,
 		keys: Vec<StorageKey>,
 		at: Option<Block::Hash>,
-	) -> FutureResult<Vec<StorageChangeSet<Block::Hash>>> {
-		self.backend.query_storage_at(keys, at)
+	) -> RpcResult<Vec<StorageChangeSet<Block::Hash>>> {
+		self.backend.query_storage_at(keys, at).await.map_err(Into::into)
 	}

-	fn read_proof(
+	async fn read_proof(
 		&self,
 		keys: Vec<StorageKey>,
 		block: Option<Block::Hash>,
-	) -> FutureResult<ReadProof<Block::Hash>> {
-		self.backend.read_proof(block, keys)
-	}
-
-	fn subscribe_storage(
-		&self,
-		meta: Self::Metadata,
-		subscriber: Subscriber<StorageChangeSet<Block::Hash>>,
-		keys: Option<Vec<StorageKey>>,
-	) {
-		if keys.is_none() {
-			if let Err(err) = self.deny_unsafe.check_if_safe() {
-				subscriber.reject(err.into())
-				    .expect("subscription rejection can only fail if it's been already rejected, and we're rejecting it for the first time; qed");
-				return
-			}
-		}
-
-		self.backend.subscribe_storage(meta, subscriber, keys)
-	}
-
-	fn unsubscribe_storage(
-		&self,
-		meta: Option<Self::Metadata>,
-		id: SubscriptionId,
-	) -> RpcResult<bool> {
-		self.backend.unsubscribe_storage(meta, id)
-	}
-
-	fn runtime_version(&self, at: Option<Block::Hash>) -> FutureResult<RuntimeVersion> {
-		self.backend.runtime_version(at)
-	}
-
-	fn subscribe_runtime_version(
-		&self,
-		meta: Self::Metadata,
-		subscriber: Subscriber<RuntimeVersion>,
-	) {
-		self.backend.subscribe_runtime_version(meta, subscriber);
-	}
-
-	fn unsubscribe_runtime_version(
-		&self,
-		meta: Option<Self::Metadata>,
-		id: SubscriptionId,
-	) -> RpcResult<bool> {
-		self.backend.unsubscribe_runtime_version(meta, id)
+	) -> RpcResult<ReadProof<Block::Hash>> {
+		self.backend.read_proof(block, keys).await.map_err(Into::into)
 	}

 	/// Re-execute the given block with the tracing targets given in `targets`
@@ -376,88 +317,102 @@ where
 	///
 	/// Note: requires the node to run with `--rpc-methods=Unsafe`.
 	/// Note: requires runtimes compiled with wasm tracing support, `--features with-tracing`.
-	fn trace_block(
+	async fn trace_block(
 		&self,
 		block: Block::Hash,
 		targets: Option<String>,
 		storage_keys: Option<String>,
 		methods: Option<String>,
-	) -> FutureResult<sp_rpc::tracing::TraceBlockResponse> {
-		if let Err(err) = self.deny_unsafe.check_if_safe() {
-			return async move { Err(err.into()) }.boxed()
+	) -> RpcResult<sp_rpc::tracing::TraceBlockResponse> {
+		self.deny_unsafe.check_if_safe()?;
+		self.backend
+			.trace_block(block, targets, storage_keys, methods)
+			.await
+			.map_err(Into::into)
+	}
+
+	fn subscribe_runtime_version(&self, sink: PendingSubscription) {
+		self.backend.subscribe_runtime_version(sink)
+	}
+
+	fn subscribe_storage(&self, sink: PendingSubscription, keys: Option<Vec<StorageKey>>) {
+		if keys.is_none() {
+			if let Err(err) = self.deny_unsafe.check_if_safe() {
+				let _ = sink.reject(JsonRpseeError::from(err));
+				return
+			}
 		}

-		self.backend.trace_block(block, targets, storage_keys, methods)
+		self.backend.subscribe_storage(sink, keys)
 	}
 }

 /// Child state backend API.
+#[async_trait]
 pub trait ChildStateBackend<Block: BlockT, Client>: Send + Sync + 'static
 where
 	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(
+	async fn read_child_proof(
 		&self,
 		block: Option<Block::Hash>,
 		storage_key: PrefixedStorageKey,
 		keys: Vec<StorageKey>,
-	) -> FutureResult<ReadProof<Block::Hash>>;
+	) -> Result<ReadProof<Block::Hash>, Error>;

 	/// Returns the keys with prefix from a child storage,
 	/// leave prefix empty to get all the keys.
-	fn storage_keys(
+	async fn storage_keys(
 		&self,
 		block: Option<Block::Hash>,
 		storage_key: PrefixedStorageKey,
 		prefix: StorageKey,
-	) -> FutureResult<Vec<StorageKey>>;
+	) -> Result<Vec<StorageKey>, Error>;

 	/// Returns the keys with prefix from a child storage with pagination support.
-	fn storage_keys_paged(
+	async fn storage_keys_paged(
 		&self,
 		block: Option<Block::Hash>,
 		storage_key: PrefixedStorageKey,
 		prefix: Option<StorageKey>,
 		count: u32,
 		start_key: Option<StorageKey>,
-	) -> FutureResult<Vec<StorageKey>>;
+	) -> Result<Vec<StorageKey>, Error>;

 	/// Returns a child storage entry at a specific block's state.
-	fn storage(
+	async fn storage(
 		&self,
 		block: Option<Block::Hash>,
 		storage_key: PrefixedStorageKey,
 		key: StorageKey,
-	) -> FutureResult<Option<StorageData>>;
+	) -> Result<Option<StorageData>, Error>;

 	/// Returns child storage entries at a specific block's state.
-	fn storage_entries(
+	async fn storage_entries(
 		&self,
 		block: Option<Block::Hash>,
 		storage_key: PrefixedStorageKey,
 		keys: Vec<StorageKey>,
-	) -> FutureResult<Vec<Option<StorageData>>>;
+	) -> Result<Vec<Option<StorageData>>, Error>;

 	/// Returns the hash of a child storage entry at a block's state.
-	fn storage_hash(
+	async fn storage_hash(
 		&self,
 		block: Option<Block::Hash>,
 		storage_key: PrefixedStorageKey,
 		key: StorageKey,
-	) -> FutureResult<Option<Block::Hash>>;
+	) -> Result<Option<Block::Hash>, Error>;

 	/// Returns the size of a child storage entry at a block's state.
-	fn storage_size(
+	async fn storage_size(
 		&self,
 		block: Option<Block::Hash>,
 		storage_key: PrefixedStorageKey,
 		key: StorageKey,
-	) -> FutureResult<Option<u64>> {
-		self.storage(block, storage_key, key)
-			.map(|x| x.map(|r| r.map(|v| v.0.len() as u64)))
-			.boxed()
+	) -> Result<Option<u64>, Error> {
+		self.storage(block, storage_key, key).await.map(|x| x.map(|x| x.0.len() as u64))
 	}
 }

@@ -466,76 +421,84 @@ pub struct ChildState<Block, Client> {
 	backend: Box<dyn ChildStateBackend<Block, Client>>,
 }

-impl<Block, Client> ChildStateApi<Block::Hash> for ChildState<Block, Client>
+#[async_trait]
+impl<Block, Client> ChildStateApiServer<Block::Hash> for ChildState<Block, Client>
 where
 	Block: BlockT + 'static,
 	Client: Send + Sync + 'static,
 {
-	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,
-		key: StorageKey,
-		block: Option<Block::Hash>,
-	) -> FutureResult<Option<StorageData>> {
-		self.backend.storage(block, storage_key, key)
-	}
-
-	fn storage_entries(
-		&self,
-		storage_key: PrefixedStorageKey,
-		keys: Vec<StorageKey>,
-		block: Option<Block::Hash>,
-	) -> FutureResult<Vec<Option<StorageData>>> {
-		self.backend.storage_entries(block, storage_key, keys)
-	}
-
-	fn storage_keys(
+	async fn storage_keys(
 		&self,
 		storage_key: PrefixedStorageKey,
 		key_prefix: StorageKey,
 		block: Option<Block::Hash>,
-	) -> FutureResult<Vec<StorageKey>> {
-		self.backend.storage_keys(block, storage_key, key_prefix)
+	) -> RpcResult<Vec<StorageKey>> {
+		self.backend
+			.storage_keys(block, storage_key, key_prefix)
+			.await
+			.map_err(Into::into)
 	}

-	fn storage_keys_paged(
+	async fn storage_keys_paged(
 		&self,
 		storage_key: PrefixedStorageKey,
 		prefix: Option<StorageKey>,
 		count: u32,
 		start_key: Option<StorageKey>,
 		block: Option<Block::Hash>,
-	) -> FutureResult<Vec<StorageKey>> {
-		self.backend.storage_keys_paged(block, storage_key, prefix, count, start_key)
+	) -> RpcResult<Vec<StorageKey>> {
+		self.backend
+			.storage_keys_paged(block, storage_key, prefix, count, start_key)
+			.await
+			.map_err(Into::into)
 	}

-	fn storage_hash(
+	async fn storage(
 		&self,
 		storage_key: PrefixedStorageKey,
 		key: StorageKey,
 		block: Option<Block::Hash>,
-	) -> FutureResult<Option<Block::Hash>> {
-		self.backend.storage_hash(block, storage_key, key)
+	) -> RpcResult<Option<StorageData>> {
+		self.backend.storage(block, storage_key, key).await.map_err(Into::into)
 	}

-	fn storage_size(
+	async fn storage_entries(
+		&self,
+		storage_key: PrefixedStorageKey,
+		keys: Vec<StorageKey>,
+		block: Option<Block::Hash>,
+	) -> RpcResult<Vec<Option<StorageData>>> {
+		self.backend.storage_entries(block, storage_key, keys).await.map_err(Into::into)
+	}
+
+	async fn storage_hash(
 		&self,
 		storage_key: PrefixedStorageKey,
 		key: StorageKey,
 		block: Option<Block::Hash>,
-	) -> FutureResult<Option<u64>> {
-		self.backend.storage_size(block, storage_key, key)
+	) -> RpcResult<Option<Block::Hash>> {
+		self.backend.storage_hash(block, storage_key, key).await.map_err(Into::into)
+	}
+
+	async fn storage_size(
+		&self,
+		storage_key: PrefixedStorageKey,
+		key: StorageKey,
+		block: Option<Block::Hash>,
+	) -> RpcResult<Option<u64>> {
+		self.backend.storage_size(block, storage_key, key).await.map_err(Into::into)
+	}
+
+	async fn read_child_proof(
+		&self,
+		child_storage_key: PrefixedStorageKey,
+		keys: Vec<StorageKey>,
+		block: Option<Block::Hash>,
+	) -> RpcResult<ReadProof<Block::Hash>> {
+		self.backend
+			.read_child_proof(block, child_storage_key, keys)
+			.await
+			.map_err(Into::into)
 	}
 }