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-12 10:01:17 +00:00 · 2022-05-10 10:52:19 +02:00
parent e45d53552d
commit 29c0c6a4a8
93 changed files with 3813 additions and 5094 deletions
@@ -23,26 +23,27 @@ mod tests;

 use std::sync::Arc;

-use sp_blockchain::HeaderBackend;
+use crate::SubscriptionTaskExecutor;

 use codec::{Decode, Encode};
-use futures::{
-	future::{FutureExt, TryFutureExt},
-	SinkExt, StreamExt as _,
+use futures::{FutureExt, TryFutureExt};
+use jsonrpsee::{
+	core::{async_trait, Error as JsonRpseeError, RpcResult},
+	PendingSubscription,
 };
-use jsonrpc_pubsub::{manager::SubscriptionManager, typed::Subscriber, SubscriptionId};
 use sc_rpc_api::DenyUnsafe;
 use sc_transaction_pool_api::{
 	error::IntoPoolError, BlockHash, InPoolTransaction, TransactionFor, TransactionPool,
-	TransactionSource, TransactionStatus, TxHash,
+	TransactionSource, TxHash,
 };
 use sp_api::ProvideRuntimeApi;
+use sp_blockchain::HeaderBackend;
 use sp_core::Bytes;
 use sp_keystore::{SyncCryptoStore, SyncCryptoStorePtr};
 use sp_runtime::{generic, traits::Block as BlockT};
 use sp_session::SessionKeys;

-use self::error::{Error, FutureResult, Result};
+use self::error::{Error, Result};
 /// Re-export the API for backward compatibility.
 pub use sc_rpc_api::author::*;

@@ -52,12 +53,12 @@ pub struct Author<P, Client> {
 	client: Arc<Client>,
 	/// Transactions pool
 	pool: Arc<P>,
-	/// Subscriptions manager
-	subscriptions: SubscriptionManager,
 	/// The key store.
 	keystore: SyncCryptoStorePtr,
 	/// Whether to deny unsafe calls
 	deny_unsafe: DenyUnsafe,
+	/// Executor to spawn subscriptions.
+	executor: SubscriptionTaskExecutor,
 }

 impl<P, Client> Author<P, Client> {
@@ -65,11 +66,11 @@ impl<P, Client> Author<P, Client> {
 	pub fn new(
 		client: Arc<Client>,
 		pool: Arc<P>,
-		subscriptions: SubscriptionManager,
 		keystore: SyncCryptoStorePtr,
 		deny_unsafe: DenyUnsafe,
+		executor: SubscriptionTaskExecutor,
 	) -> Self {
-		Author { client, pool, subscriptions, keystore, deny_unsafe }
+		Author { client, pool, keystore, deny_unsafe, executor }
 	}
 }

@@ -80,7 +81,8 @@ impl<P, Client> Author<P, Client> {
 /// some unique transactions via RPC and have them included in the pool.
 const TX_SOURCE: TransactionSource = TransactionSource::External;

-impl<P, Client> AuthorApi<TxHash<P>, BlockHash<P>> for Author<P, Client>
+#[async_trait]
+impl<P, Client> AuthorApiServer<TxHash<P>, BlockHash<P>> for Author<P, Client>
 where
 	P: TransactionPool + Sync + Send + 'static,
 	Client: HeaderBackend<P::Block> + ProvideRuntimeApi<P::Block> + Send + Sync + 'static,
@@ -88,9 +90,24 @@ where
 	P::Hash: Unpin,
 	<P::Block as BlockT>::Hash: Unpin,
 {
-	type Metadata = crate::Metadata;
+	async fn submit_extrinsic(&self, ext: Bytes) -> RpcResult<TxHash<P>> {
+		let xt = match Decode::decode(&mut &ext[..]) {
+			Ok(xt) => xt,
+			Err(err) => return Err(Error::Client(Box::new(err)).into()),
+		};
+		let best_block_hash = self.client.info().best_hash;
+		self.pool
+			.submit_one(&generic::BlockId::hash(best_block_hash), TX_SOURCE, xt)
+			.await
+			.map_err(|e| {
+				e.into_pool_error()
+					.map(|e| Error::Pool(e))
+					.unwrap_or_else(|e| Error::Verification(Box::new(e)))
+					.into()
+			})
+	}

-	fn insert_key(&self, key_type: String, suri: String, public: Bytes) -> Result<()> {
+	fn insert_key(&self, key_type: String, suri: String, public: Bytes) -> RpcResult<()> {
 		self.deny_unsafe.check_if_safe()?;

 		let key_type = key_type.as_str().try_into().map_err(|_| Error::BadKeyType)?;
@@ -99,7 +116,7 @@ where
 		Ok(())
 	}

-	fn rotate_keys(&self) -> Result<Bytes> {
+	fn rotate_keys(&self) -> RpcResult<Bytes> {
 		self.deny_unsafe.check_if_safe()?;

 		let best_block_hash = self.client.info().best_hash;
@@ -107,10 +124,10 @@ where
 			.runtime_api()
 			.generate_session_keys(&generic::BlockId::Hash(best_block_hash), None)
 			.map(Into::into)
-			.map_err(|e| Error::Client(Box::new(e)))
+			.map_err(|api_err| Error::Client(Box::new(api_err)).into())
 	}

-	fn has_session_keys(&self, session_keys: Bytes) -> Result<bool> {
+	fn has_session_keys(&self, session_keys: Bytes) -> RpcResult<bool> {
 		self.deny_unsafe.check_if_safe()?;

 		let best_block_hash = self.client.info().best_hash;
@@ -124,40 +141,22 @@ where
 		Ok(SyncCryptoStore::has_keys(&*self.keystore, &keys))
 	}

-	fn has_key(&self, public_key: Bytes, key_type: String) -> Result<bool> {
+	fn has_key(&self, public_key: Bytes, key_type: String) -> RpcResult<bool> {
 		self.deny_unsafe.check_if_safe()?;

 		let key_type = key_type.as_str().try_into().map_err(|_| Error::BadKeyType)?;
 		Ok(SyncCryptoStore::has_keys(&*self.keystore, &[(public_key.to_vec(), key_type)]))
 	}

-	fn submit_extrinsic(&self, ext: Bytes) -> FutureResult<TxHash<P>> {
-		let xt = match Decode::decode(&mut &ext[..]) {
-			Ok(xt) => xt,
-			Err(err) => return async move { Err(err.into()) }.boxed(),
-		};
-		let best_block_hash = self.client.info().best_hash;
-
-		self.pool
-			.submit_one(&generic::BlockId::hash(best_block_hash), TX_SOURCE, xt)
-			.map_err(|e| {
-				e.into_pool_error()
-					.map(Into::into)
-					.unwrap_or_else(|e| error::Error::Verification(Box::new(e)))
-			})
-			.boxed()
-	}
-
-	fn pending_extrinsics(&self) -> Result<Vec<Bytes>> {
+	fn pending_extrinsics(&self) -> RpcResult<Vec<Bytes>> {
 		Ok(self.pool.ready().map(|tx| tx.data().encode().into()).collect())
 	}

 	fn remove_extrinsic(
 		&self,
 		bytes_or_hash: Vec<hash::ExtrinsicOrHash<TxHash<P>>>,
-	) -> Result<Vec<TxHash<P>>> {
+	) -> RpcResult<Vec<TxHash<P>>> {
 		self.deny_unsafe.check_if_safe()?;
-
 		let hashes = bytes_or_hash
 			.into_iter()
 			.map(|x| match x {
@@ -177,20 +176,12 @@ where
 			.collect())
 	}

-	fn watch_extrinsic(
-		&self,
-		_metadata: Self::Metadata,
-		subscriber: Subscriber<TransactionStatus<TxHash<P>, BlockHash<P>>>,
-		xt: Bytes,
-	) {
+	fn watch_extrinsic(&self, pending: PendingSubscription, xt: Bytes) {
 		let best_block_hash = self.client.info().best_hash;
-		let dxt = match TransactionFor::<P>::decode(&mut &xt[..]).map_err(error::Error::from) {
-			Ok(tx) => tx,
-			Err(err) => {
-				log::debug!("Failed to submit extrinsic: {}", err);
-				// reject the subscriber (ignore errors - we don't care if subscriber is no longer
-				// there).
-				let _ = subscriber.reject(err.into());
+		let dxt = match TransactionFor::<P>::decode(&mut &xt[..]).map_err(|e| Error::from(e)) {
+			Ok(dxt) => dxt,
+			Err(e) => {
+				pending.reject(JsonRpseeError::from(e));
 				return
 			},
 		};
@@ -204,41 +195,25 @@ where
 					.unwrap_or_else(|e| error::Error::Verification(Box::new(e)))
 			});

-		let subscriptions = self.subscriptions.clone();
-
-		let future = async move {
-			let tx_stream = match submit.await {
-				Ok(s) => s,
+		let fut = async move {
+			let stream = match submit.await {
+				Ok(stream) => stream,
 				Err(err) => {
-					log::debug!("Failed to submit extrinsic: {}", err);
-					// reject the subscriber (ignore errors - we don't care if subscriber is no
-					// longer there).
-					let _ = subscriber.reject(err.into());
+					pending.reject(JsonRpseeError::from(err));
 					return
 				},
 			};

-			subscriptions.add(subscriber, move |sink| {
-				tx_stream
-					.map(|v| Ok(Ok(v)))
-					.forward(
-						sink.sink_map_err(|e| log::debug!("Error sending notifications: {:?}", e)),
-					)
-					.map(drop)
-			});
-		};
+			let mut sink = match pending.accept() {
+				Some(sink) => sink,
+				_ => return,
+			};

-		let res = self.subscriptions.executor().spawn_obj(future.boxed().into());
-		if res.is_err() {
-			log::warn!("Error spawning subscription RPC task.");
+			sink.pipe_from_stream(stream).await;
 		}
-	}
+		.boxed();

-	fn unwatch_extrinsic(
-		&self,
-		_metadata: Option<Self::Metadata>,
-		id: SubscriptionId,
-	) -> Result<bool> {
-		Ok(self.subscriptions.cancel(id))
+		self.executor
+			.spawn("substrate-rpc-subscription", Some("rpc"), fut.map(drop).boxed());
 	}
 }
@@ -18,21 +18,26 @@

 use super::*;

+use crate::testing::{test_executor, timeout_secs};
 use assert_matches::assert_matches;
 use codec::Encode;
-use futures::executor;
+use jsonrpsee::{
+	core::Error as RpcError,
+	types::{error::CallError, EmptyParams},
+	RpcModule,
+};
 use sc_transaction_pool::{BasicPool, FullChainApi};
+use sc_transaction_pool_api::TransactionStatus;
 use sp_core::{
 	blake2_256,
+	bytes::to_hex,
 	crypto::{ByteArray, CryptoTypePublicPair, Pair},
-	ed25519,
-	hexdisplay::HexDisplay,
-	sr25519,
+	ed25519, sr25519,
 	testing::{ED25519, SR25519},
 	H256,
 };
 use sp_keystore::testing::KeyStore;
-use std::{mem, sync::Arc};
+use std::sync::Arc;
 use substrate_test_runtime_client::{
 	self,
 	runtime::{Block, Extrinsic, SessionKeys, Transfer},
@@ -75,240 +80,253 @@ impl TestSetup {
 		Author {
 			client: self.client.clone(),
 			pool: self.pool.clone(),
-			subscriptions: SubscriptionManager::new(Arc::new(crate::testing::TaskExecutor)),
 			keystore: self.keystore.clone(),
 			deny_unsafe: DenyUnsafe::No,
+			executor: test_executor(),
 		}
 	}
+
+	fn into_rpc() -> RpcModule<Author<FullTransactionPool, Client<Backend>>> {
+		Self::default().author().into_rpc()
+	}
 }

-#[test]
-fn submit_transaction_should_not_cause_error() {
-	let p = TestSetup::default().author();
-	let xt = uxt(AccountKeyring::Alice, 1).encode();
-	let h: H256 = blake2_256(&xt).into();
+#[tokio::test]
+async fn author_submit_transaction_should_not_cause_error() {
+	let _ = env_logger::try_init();
+	let author = TestSetup::default().author();
+	let api = author.into_rpc();
+	let xt: Bytes = uxt(AccountKeyring::Alice, 1).encode().into();
+	let extrinsic_hash: H256 = blake2_256(&xt).into();
+	let response: H256 = api.call("author_submitExtrinsic", [xt.clone()]).await.unwrap();
+
+	assert_eq!(response, extrinsic_hash);

 	assert_matches!(
-		executor::block_on(AuthorApi::submit_extrinsic(&p, xt.clone().into())),
-		Ok(h2) if h == h2
+		api.call::<_, H256>("author_submitExtrinsic", [xt]).await,
+		Err(RpcError::Call(CallError::Custom(err))) if err.message().contains("Already Imported") && err.code() == 1013
 	);
-	assert!(executor::block_on(AuthorApi::submit_extrinsic(&p, xt.into())).is_err());
 }

-#[test]
-fn submit_rich_transaction_should_not_cause_error() {
-	let p = TestSetup::default().author();
-	let xt = uxt(AccountKeyring::Alice, 0).encode();
-	let h: H256 = blake2_256(&xt).into();
+#[tokio::test]
+async fn author_should_watch_extrinsic() {
+	let api = TestSetup::into_rpc();
+	let xt = to_hex(&uxt(AccountKeyring::Alice, 0).encode(), true);

-	assert_matches!(
-		executor::block_on(AuthorApi::submit_extrinsic(&p, xt.clone().into())),
-		Ok(h2) if h == h2
-	);
-	assert!(executor::block_on(AuthorApi::submit_extrinsic(&p, xt.into())).is_err());
-}
+	let mut sub = api.subscribe("author_submitAndWatchExtrinsic", [xt]).await.unwrap();
+	let (tx, sub_id) = timeout_secs(10, sub.next::<TransactionStatus<H256, Block>>())
+		.await
+		.unwrap()
+		.unwrap()
+		.unwrap();

-#[test]
-fn should_watch_extrinsic() {
-	// given
-	let setup = TestSetup::default();
-	let p = setup.author();
+	assert_matches!(tx, TransactionStatus::Ready);
+	assert_eq!(&sub_id, sub.subscription_id());

-	let (subscriber, id_rx, data) = jsonrpc_pubsub::typed::Subscriber::new_test("test");
-
-	// when
-	p.watch_extrinsic(
-		Default::default(),
-		subscriber,
-		uxt(AccountKeyring::Alice, 0).encode().into(),
-	);
-
-	let id = executor::block_on(id_rx).unwrap().unwrap();
-	assert_matches!(id, SubscriptionId::String(_));
-
-	let id = match id {
-		SubscriptionId::String(id) => id,
-		_ => unreachable!(),
-	};
-
-	// check notifications
-	let replacement = {
+	// Replace the extrinsic and observe the subscription is notified.
+	let (xt_replacement, xt_hash) = {
 		let tx = Transfer {
 			amount: 5,
 			nonce: 0,
 			from: AccountKeyring::Alice.into(),
 			to: AccountKeyring::Bob.into(),
 		};
-		tx.into_signed_tx()
+		let tx = tx.into_signed_tx().encode();
+		let hash = blake2_256(&tx);
+
+		(to_hex(&tx, true), hash)
 	};
-	executor::block_on(AuthorApi::submit_extrinsic(&p, replacement.encode().into())).unwrap();
-	let (res, data) = executor::block_on(data.into_future());

-	let expected = Some(format!(
-		r#"{{"jsonrpc":"2.0","method":"test","params":{{"result":"ready","subscription":"{}"}}}}"#,
-		id,
-	));
-	assert_eq!(res, expected);
+	let _ = api.call::<_, H256>("author_submitExtrinsic", [xt_replacement]).await.unwrap();

-	let h = blake2_256(&replacement.encode());
-	let expected = Some(format!(
-		r#"{{"jsonrpc":"2.0","method":"test","params":{{"result":{{"usurped":"0x{}"}},"subscription":"{}"}}}}"#,
-		HexDisplay::from(&h),
-		id,
-	));
-
-	let res = executor::block_on(data.into_future()).0;
-	assert_eq!(res, expected);
+	let (tx, sub_id) = timeout_secs(10, sub.next::<TransactionStatus<H256, Block>>())
+		.await
+		.unwrap()
+		.unwrap()
+		.unwrap();
+	assert_eq!(tx, TransactionStatus::Usurped(xt_hash.into()));
+	assert_eq!(&sub_id, sub.subscription_id());
 }

-#[test]
-fn should_return_watch_validation_error() {
-	// given
-	let setup = TestSetup::default();
-	let p = setup.author();
+#[tokio::test]
+async fn author_should_return_watch_validation_error() {
+	const METHOD: &'static str = "author_submitAndWatchExtrinsic";

-	let (subscriber, id_rx, _data) = jsonrpc_pubsub::typed::Subscriber::new_test("test");
+	let api = TestSetup::into_rpc();
+	let failed_sub = api
+		.subscribe(METHOD, [to_hex(&uxt(AccountKeyring::Alice, 179).encode(), true)])
+		.await;

-	// when
-	p.watch_extrinsic(
-		Default::default(),
-		subscriber,
-		uxt(AccountKeyring::Alice, 179).encode().into(),
-	);
-
-	// then
-	let res = executor::block_on(id_rx).unwrap();
-	assert!(res.is_err(), "Expected the transaction to be rejected as invalid.");
-}
-
-#[test]
-fn should_return_pending_extrinsics() {
-	let p = TestSetup::default().author();
-
-	let ex = uxt(AccountKeyring::Alice, 0);
-	executor::block_on(AuthorApi::submit_extrinsic(&p, ex.encode().into())).unwrap();
 	assert_matches!(
-		p.pending_extrinsics(),
-		Ok(ref expected) if *expected == vec![Bytes(ex.encode())]
+		failed_sub,
+		Err(RpcError::Call(CallError::Custom(err))) if err.message().contains("Invalid Transaction") && err.code() == 1010
 	);
 }

-#[test]
-fn should_remove_extrinsics() {
-	let setup = TestSetup::default();
-	let p = setup.author();
+#[tokio::test]
+async fn author_should_return_pending_extrinsics() {
+	let api = TestSetup::into_rpc();

-	let ex1 = uxt(AccountKeyring::Alice, 0);
-	executor::block_on(p.submit_extrinsic(ex1.encode().into())).unwrap();
-	let ex2 = uxt(AccountKeyring::Alice, 1);
-	executor::block_on(p.submit_extrinsic(ex2.encode().into())).unwrap();
-	let ex3 = uxt(AccountKeyring::Bob, 0);
-	let hash3 = executor::block_on(p.submit_extrinsic(ex3.encode().into())).unwrap();
-	assert_eq!(setup.pool.status().ready, 3);
-
-	// now remove all 3
-	let removed = p
-		.remove_extrinsic(vec![
-			hash::ExtrinsicOrHash::Hash(hash3),
-			// Removing this one will also remove ex2
-			hash::ExtrinsicOrHash::Extrinsic(ex1.encode().into()),
-		])
+	let xt_bytes: Bytes = uxt(AccountKeyring::Alice, 0).encode().into();
+	api.call::<_, H256>("author_submitExtrinsic", [to_hex(&xt_bytes, true)])
+		.await
 		.unwrap();

-	assert_eq!(removed.len(), 3);
+	let pending: Vec<Bytes> =
+		api.call("author_pendingExtrinsics", EmptyParams::new()).await.unwrap();
+	assert_eq!(pending, vec![xt_bytes]);
 }

-#[test]
-fn should_insert_key() {
+#[tokio::test]
+async fn author_should_remove_extrinsics() {
+	const METHOD: &'static str = "author_removeExtrinsic";
 	let setup = TestSetup::default();
-	let p = setup.author();
+	let api = setup.author().into_rpc();

+	// Submit three extrinsics, then remove two of them (will cause the third to be removed as well,
+	// having a higher nonce)
+	let xt1_bytes = uxt(AccountKeyring::Alice, 0).encode();
+	let xt1 = to_hex(&xt1_bytes, true);
+	let xt1_hash: H256 = api.call("author_submitExtrinsic", [xt1]).await.unwrap();
+
+	let xt2 = to_hex(&uxt(AccountKeyring::Alice, 1).encode(), true);
+	let xt2_hash: H256 = api.call("author_submitExtrinsic", [xt2]).await.unwrap();
+
+	let xt3 = to_hex(&uxt(AccountKeyring::Bob, 0).encode(), true);
+	let xt3_hash: H256 = api.call("author_submitExtrinsic", [xt3]).await.unwrap();
+	assert_eq!(setup.pool.status().ready, 3);
+
+	// Now remove all three.
+	// Notice how we need an extra `Vec` wrapping the `Vec` we want to submit as params.
+	let removed: Vec<H256> = api
+		.call(
+			METHOD,
+			vec![vec![
+				hash::ExtrinsicOrHash::Hash(xt3_hash),
+				// Removing this one will also remove xt2
+				hash::ExtrinsicOrHash::Extrinsic(xt1_bytes.into()),
+			]],
+		)
+		.await
+		.unwrap();
+
+	assert_eq!(removed, vec![xt1_hash, xt2_hash, xt3_hash]);
+}
+
+#[tokio::test]
+async fn author_should_insert_key() {
+	let setup = TestSetup::default();
+	let api = setup.author().into_rpc();
 	let suri = "//Alice";
-	let key_pair = ed25519::Pair::from_string(suri, None).expect("Generates keypair");
-	p.insert_key(
+	let keypair = ed25519::Pair::from_string(suri, None).expect("generates keypair");
+	let params: (String, String, Bytes) = (
 		String::from_utf8(ED25519.0.to_vec()).expect("Keytype is a valid string"),
 		suri.to_string(),
-		key_pair.public().0.to_vec().into(),
-	)
-	.expect("Insert key");
+		keypair.public().0.to_vec().into(),
+	);
+	api.call::<_, ()>("author_insertKey", params).await.unwrap();
+	let pubkeys = SyncCryptoStore::keys(&*setup.keystore, ED25519).unwrap();

-	let public_keys = SyncCryptoStore::keys(&*setup.keystore, ED25519).unwrap();
-
-	assert!(public_keys
-		.contains(&CryptoTypePublicPair(ed25519::CRYPTO_ID, key_pair.public().to_raw_vec())));
+	assert!(
+		pubkeys.contains(&CryptoTypePublicPair(ed25519::CRYPTO_ID, keypair.public().to_raw_vec()))
+	);
 }

-#[test]
-fn should_rotate_keys() {
+#[tokio::test]
+async fn author_should_rotate_keys() {
 	let setup = TestSetup::default();
-	let p = setup.author();
-
-	let new_public_keys = p.rotate_keys().expect("Rotates the keys");
+	let api = setup.author().into_rpc();

+	let new_pubkeys: Bytes = api.call("author_rotateKeys", EmptyParams::new()).await.unwrap();
 	let session_keys =
-		SessionKeys::decode(&mut &new_public_keys[..]).expect("SessionKeys decode successfully");
-
-	let ed25519_public_keys = SyncCryptoStore::keys(&*setup.keystore, ED25519).unwrap();
-	let sr25519_public_keys = SyncCryptoStore::keys(&*setup.keystore, SR25519).unwrap();
-
-	assert!(ed25519_public_keys
+		SessionKeys::decode(&mut &new_pubkeys[..]).expect("SessionKeys decode successfully");
+	let ed25519_pubkeys = SyncCryptoStore::keys(&*setup.keystore, ED25519).unwrap();
+	let sr25519_pubkeys = SyncCryptoStore::keys(&*setup.keystore, SR25519).unwrap();
+	assert!(ed25519_pubkeys
 		.contains(&CryptoTypePublicPair(ed25519::CRYPTO_ID, session_keys.ed25519.to_raw_vec())));
-	assert!(sr25519_public_keys
+	assert!(sr25519_pubkeys
 		.contains(&CryptoTypePublicPair(sr25519::CRYPTO_ID, session_keys.sr25519.to_raw_vec())));
 }

-#[test]
-fn test_has_session_keys() {
-	let setup = TestSetup::default();
-	let p = setup.author();
+#[tokio::test]
+async fn author_has_session_keys() {
+	// Setup
+	let api = TestSetup::into_rpc();

-	let non_existent_public_keys =
-		TestSetup::default().author().rotate_keys().expect("Rotates the keys");
+	// Add a valid session key
+	let pubkeys: Bytes = api
+		.call("author_rotateKeys", EmptyParams::new())
+		.await
+		.expect("Rotates the keys");

-	let public_keys = p.rotate_keys().expect("Rotates the keys");
-	let test_vectors = vec![
-		(public_keys, Ok(true)),
-		(vec![1, 2, 3].into(), Err(Error::InvalidSessionKeys)),
-		(non_existent_public_keys, Ok(false)),
-	];
+	// Add a session key in a different keystore
+	let non_existent_pubkeys: Bytes = {
+		let api2 = TestSetup::default().author().into_rpc();
+		api2.call("author_rotateKeys", EmptyParams::new())
+			.await
+			.expect("Rotates the keys")
+	};

-	for (keys, result) in test_vectors {
-		assert_eq!(
-			result.map_err(|e| mem::discriminant(&e)),
-			p.has_session_keys(keys).map_err(|e| mem::discriminant(&e)),
-		);
-	}
+	// Then…
+	let existing = api.call::<_, bool>("author_hasSessionKeys", vec![pubkeys]).await.unwrap();
+	assert!(existing, "Existing key is in the session keys");
+
+	let inexistent = api
+		.call::<_, bool>("author_hasSessionKeys", vec![non_existent_pubkeys])
+		.await
+		.unwrap();
+	assert_eq!(inexistent, false, "Inexistent key is not in the session keys");
+
+	assert_matches!(
+		api.call::<_, bool>("author_hasSessionKeys", vec![Bytes::from(vec![1, 2, 3])]).await,
+		Err(RpcError::Call(CallError::Custom(err))) if err.message().contains("Session keys are not encoded correctly")
+	);
 }

-#[test]
-fn test_has_key() {
-	let setup = TestSetup::default();
-	let p = setup.author();
+#[tokio::test]
+async fn author_has_key() {
+	let _ = env_logger::try_init();

+	let api = TestSetup::into_rpc();
 	let suri = "//Alice";
-	let alice_key_pair = ed25519::Pair::from_string(suri, None).expect("Generates keypair");
-	p.insert_key(
+	let alice_keypair = ed25519::Pair::from_string(suri, None).expect("Generates keypair");
+	let params = (
 		String::from_utf8(ED25519.0.to_vec()).expect("Keytype is a valid string"),
 		suri.to_string(),
-		alice_key_pair.public().0.to_vec().into(),
-	)
-	.expect("Insert key");
-	let bob_key_pair = ed25519::Pair::from_string("//Bob", None).expect("Generates keypair");
+		Bytes::from(alice_keypair.public().0.to_vec()),
+	);

-	let test_vectors = vec![
-		(alice_key_pair.public().to_raw_vec().into(), ED25519, Ok(true)),
-		(alice_key_pair.public().to_raw_vec().into(), SR25519, Ok(false)),
-		(bob_key_pair.public().to_raw_vec().into(), ED25519, Ok(false)),
-	];
+	api.call::<_, ()>("author_insertKey", params).await.expect("insertKey works");

-	for (key, key_type, result) in test_vectors {
-		assert_eq!(
-			result.map_err(|e| mem::discriminant(&e)),
-			p.has_key(
-				key,
-				String::from_utf8(key_type.0.to_vec()).expect("Keytype is a valid string"),
-			)
-			.map_err(|e| mem::discriminant(&e)),
+	let bob_keypair = ed25519::Pair::from_string("//Bob", None).expect("Generates keypair");
+
+	// Alice's ED25519 key is there
+	let has_alice_ed: bool = {
+		let params = (
+			Bytes::from(alice_keypair.public().to_raw_vec()),
+			String::from_utf8(ED25519.0.to_vec()).expect("Keytype is a valid string"),
 		);
-	}
+		api.call("author_hasKey", params).await.unwrap()
+	};
+	assert!(has_alice_ed);
+
+	// Alice's SR25519 key is not there
+	let has_alice_sr: bool = {
+		let params = (
+			Bytes::from(alice_keypair.public().to_raw_vec()),
+			String::from_utf8(SR25519.0.to_vec()).expect("Keytype is a valid string"),
+		);
+		api.call("author_hasKey", params).await.unwrap()
+	};
+	assert!(!has_alice_sr);
+
+	// Bob's ED25519 key is not there
+	let has_bob_ed: bool = {
+		let params = (
+			Bytes::from(bob_keypair.public().to_raw_vec()),
+			String::from_utf8(ED25519.0.to_vec()).expect("Keytype is a valid string"),
+		);
+		api.call("author_hasKey", params).await.unwrap()
+	};
+	assert!(!has_bob_ed);
 }
@@ -18,34 +18,40 @@

 //! Blockchain API backend for full nodes.

-use super::{client_err, error::FutureResult, ChainBackend};
-use futures::FutureExt;
-use jsonrpc_pubsub::manager::SubscriptionManager;
+use super::{client_err, ChainBackend, Error};
+use crate::SubscriptionTaskExecutor;
+use std::{marker::PhantomData, sync::Arc};
+
+use futures::{
+	future::{self, FutureExt},
+	stream::{self, Stream, StreamExt},
+};
+use jsonrpsee::{core::async_trait, PendingSubscription};
 use sc_client_api::{BlockBackend, BlockchainEvents};
 use sp_blockchain::HeaderBackend;
 use sp_runtime::{
 	generic::{BlockId, SignedBlock},
 	traits::Block as BlockT,
 };
-use std::{marker::PhantomData, sync::Arc};

 /// Blockchain API backend for full nodes. Reads all the data from local database.
 pub struct FullChain<Block: BlockT, Client> {
 	/// Substrate client.
 	client: Arc<Client>,
-	/// Current subscriptions.
-	subscriptions: SubscriptionManager,
 	/// phantom member to pin the block type
 	_phantom: PhantomData<Block>,
+	/// Subscription executor.
+	executor: SubscriptionTaskExecutor,
 }

 impl<Block: BlockT, Client> FullChain<Block, Client> {
 	/// Create new Chain API RPC handler.
-	pub fn new(client: Arc<Client>, subscriptions: SubscriptionManager) -> Self {
-		Self { client, subscriptions, _phantom: PhantomData }
+	pub fn new(client: Arc<Client>, executor: SubscriptionTaskExecutor) -> Self {
+		Self { client, executor, _phantom: PhantomData }
 	}
 }

+#[async_trait]
 impl<Block, Client> ChainBackend<Client, Block> for FullChain<Block, Client>
 where
 	Block: BlockT + 'static,
@@ -56,17 +62,93 @@ where
 		&self.client
 	}

-	fn subscriptions(&self) -> &SubscriptionManager {
-		&self.subscriptions
+	async fn header(&self, hash: Option<Block::Hash>) -> Result<Option<Block::Header>, Error> {
+		self.client.header(BlockId::Hash(self.unwrap_or_best(hash))).map_err(client_err)
 	}

-	fn header(&self, hash: Option<Block::Hash>) -> FutureResult<Option<Block::Header>> {
-		let res = self.client.header(BlockId::Hash(self.unwrap_or_best(hash))).map_err(client_err);
-		async move { res }.boxed()
+	async fn block(&self, hash: Option<Block::Hash>) -> Result<Option<SignedBlock<Block>>, Error> {
+		self.client.block(&BlockId::Hash(self.unwrap_or_best(hash))).map_err(client_err)
 	}

-	fn block(&self, hash: Option<Block::Hash>) -> FutureResult<Option<SignedBlock<Block>>> {
-		let res = self.client.block(&BlockId::Hash(self.unwrap_or_best(hash))).map_err(client_err);
-		async move { res }.boxed()
+	fn subscribe_all_heads(&self, sink: PendingSubscription) {
+		subscribe_headers(
+			&self.client,
+			&self.executor,
+			sink,
+			|| self.client().info().best_hash,
+			|| {
+				self.client()
+					.import_notification_stream()
+					.map(|notification| notification.header)
+			},
+		)
+	}
+
+	fn subscribe_new_heads(&self, sink: PendingSubscription) {
+		subscribe_headers(
+			&self.client,
+			&self.executor,
+			sink,
+			|| self.client().info().best_hash,
+			|| {
+				self.client()
+					.import_notification_stream()
+					.filter(|notification| future::ready(notification.is_new_best))
+					.map(|notification| notification.header)
+			},
+		)
+	}
+
+	fn subscribe_finalized_heads(&self, sink: PendingSubscription) {
+		subscribe_headers(
+			&self.client,
+			&self.executor,
+			sink,
+			|| self.client().info().finalized_hash,
+			|| {
+				self.client()
+					.finality_notification_stream()
+					.map(|notification| notification.header)
+			},
+		)
 	}
 }
+
+/// Subscribe to new headers.
+fn subscribe_headers<Block, Client, F, G, S>(
+	client: &Arc<Client>,
+	executor: &SubscriptionTaskExecutor,
+	pending: PendingSubscription,
+	best_block_hash: G,
+	stream: F,
+) where
+	Block: BlockT + 'static,
+	Block::Header: Unpin,
+	Client: HeaderBackend<Block> + 'static,
+	F: FnOnce() -> S,
+	G: FnOnce() -> Block::Hash,
+	S: Stream<Item = Block::Header> + Send + Unpin + 'static,
+{
+	// send current head right at the start.
+	let maybe_header = client
+		.header(BlockId::Hash(best_block_hash()))
+		.map_err(client_err)
+		.and_then(|header| header.ok_or_else(|| Error::Other("Best header missing.".into())))
+		.map_err(|e| log::warn!("Best header error {:?}", e))
+		.ok();
+
+	// NOTE: by the time we set up the stream there might be a new best block and so there is a risk
+	// that the stream has a hole in it. The alternative would be to look up the best block *after*
+	// we set up the stream and chain it to the stream. Consuming code would need to handle
+	// duplicates at the beginning of the stream though.
+	let stream = stream::iter(maybe_header).chain(stream());
+
+	let fut = async move {
+		if let Some(mut sink) = pending.accept() {
+			sink.pipe_from_stream(stream).await;
+		}
+	}
+	.boxed();
+
+	executor.spawn("substrate-rpc-subscription", Some("rpc"), fut.map(drop).boxed());
+}
@@ -23,15 +23,14 @@ mod chain_full;
 #[cfg(test)]
 mod tests;

-use futures::{future, StreamExt, TryStreamExt};
-use log::warn;
-use rpc::{
-	futures::{stream, FutureExt, SinkExt, Stream},
-	Result as RpcResult,
-};
 use std::sync::Arc;

-use jsonrpc_pubsub::{manager::SubscriptionManager, typed::Subscriber, SubscriptionId};
+use crate::SubscriptionTaskExecutor;
+
+use jsonrpsee::{
+	core::{async_trait, RpcResult},
+	PendingSubscription,
+};
 use sc_client_api::BlockchainEvents;
 use sp_rpc::{list::ListOrValue, number::NumberOrHex};
 use sp_runtime::{
@@ -39,13 +38,14 @@ use sp_runtime::{
 	traits::{Block as BlockT, Header, NumberFor},
 };

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

 use sc_client_api::BlockBackend;
 pub use sc_rpc_api::chain::*;
 use sp_blockchain::HeaderBackend;

 /// Blockchain backend API
+#[async_trait]
 trait ChainBackend<Client, Block: BlockT>: Send + Sync + 'static
 where
 	Block: BlockT + 'static,
@@ -55,9 +55,6 @@ where
 	/// Get client reference.
 	fn client(&self) -> &Arc<Client>;

-	/// Get subscriptions reference.
-	fn subscriptions(&self) -> &SubscriptionManager;
-
 	/// Tries to unwrap passed block hash, or uses best block hash otherwise.
 	fn unwrap_or_best(&self, hash: Option<Block::Hash>) -> Block::Hash {
 		match hash {
@@ -67,15 +64,15 @@ where
 	}

 	/// Get header of a relay chain block.
-	fn header(&self, hash: Option<Block::Hash>) -> FutureResult<Option<Block::Header>>;
+	async fn header(&self, hash: Option<Block::Hash>) -> Result<Option<Block::Header>, Error>;

 	/// Get header and body of a relay chain block.
-	fn block(&self, hash: Option<Block::Hash>) -> FutureResult<Option<SignedBlock<Block>>>;
+	async fn block(&self, hash: Option<Block::Hash>) -> Result<Option<SignedBlock<Block>>, Error>;

 	/// Get hash of the n-th block in the canon chain.
 	///
 	/// By default returns latest block hash.
-	fn block_hash(&self, number: Option<NumberOrHex>) -> Result<Option<Block::Hash>> {
+	fn block_hash(&self, number: Option<NumberOrHex>) -> Result<Option<Block::Hash>, Error> {
 		match number {
 			None => Ok(Some(self.client().info().best_hash)),
 			Some(num_or_hex) => {
@@ -97,107 +94,31 @@ where
 	}

 	/// Get hash of the last finalized block in the canon chain.
-	fn finalized_head(&self) -> Result<Block::Hash> {
+	fn finalized_head(&self) -> Result<Block::Hash, Error> {
 		Ok(self.client().info().finalized_hash)
 	}

 	/// All new head subscription
-	fn subscribe_all_heads(
-		&self,
-		_metadata: crate::Metadata,
-		subscriber: Subscriber<Block::Header>,
-	) {
-		subscribe_headers(
-			self.client(),
-			self.subscriptions(),
-			subscriber,
-			|| self.client().info().best_hash,
-			|| {
-				self.client()
-					.import_notification_stream()
-					.map(|notification| Ok::<_, rpc::Error>(notification.header))
-			},
-		)
-	}
-
-	/// Unsubscribe from all head subscription.
-	fn unsubscribe_all_heads(
-		&self,
-		_metadata: Option<crate::Metadata>,
-		id: SubscriptionId,
-	) -> RpcResult<bool> {
-		Ok(self.subscriptions().cancel(id))
-	}
+	fn subscribe_all_heads(&self, sink: PendingSubscription);

 	/// New best head subscription
-	fn subscribe_new_heads(
-		&self,
-		_metadata: crate::Metadata,
-		subscriber: Subscriber<Block::Header>,
-	) {
-		subscribe_headers(
-			self.client(),
-			self.subscriptions(),
-			subscriber,
-			|| self.client().info().best_hash,
-			|| {
-				self.client()
-					.import_notification_stream()
-					.filter(|notification| future::ready(notification.is_new_best))
-					.map(|notification| Ok::<_, rpc::Error>(notification.header))
-			},
-		)
-	}
-
-	/// Unsubscribe from new best head subscription.
-	fn unsubscribe_new_heads(
-		&self,
-		_metadata: Option<crate::Metadata>,
-		id: SubscriptionId,
-	) -> RpcResult<bool> {
-		Ok(self.subscriptions().cancel(id))
-	}
+	fn subscribe_new_heads(&self, sink: PendingSubscription);

 	/// Finalized head subscription
-	fn subscribe_finalized_heads(
-		&self,
-		_metadata: crate::Metadata,
-		subscriber: Subscriber<Block::Header>,
-	) {
-		subscribe_headers(
-			self.client(),
-			self.subscriptions(),
-			subscriber,
-			|| self.client().info().finalized_hash,
-			|| {
-				self.client()
-					.finality_notification_stream()
-					.map(|notification| Ok::<_, rpc::Error>(notification.header))
-			},
-		)
-	}
-
-	/// Unsubscribe from finalized head subscription.
-	fn unsubscribe_finalized_heads(
-		&self,
-		_metadata: Option<crate::Metadata>,
-		id: SubscriptionId,
-	) -> RpcResult<bool> {
-		Ok(self.subscriptions().cancel(id))
-	}
+	fn subscribe_finalized_heads(&self, sink: PendingSubscription);
 }

 /// Create new state API that works on full node.
 pub fn new_full<Block: BlockT, Client>(
 	client: Arc<Client>,
-	subscriptions: SubscriptionManager,
+	executor: SubscriptionTaskExecutor,
 ) -> Chain<Block, Client>
 where
 	Block: BlockT + 'static,
 	Block::Header: Unpin,
 	Client: BlockBackend<Block> + HeaderBackend<Block> + BlockchainEvents<Block> + 'static,
 {
-	Chain { backend: Box::new(self::chain_full::FullChain::new(client, subscriptions)) }
+	Chain { backend: Box::new(self::chain_full::FullChain::new(client, executor)) }
 }

 /// Chain API with subscriptions support.
@@ -205,120 +126,56 @@ pub struct Chain<Block: BlockT, Client> {
 	backend: Box<dyn ChainBackend<Client, Block>>,
 }

-impl<Block, Client> ChainApi<NumberFor<Block>, Block::Hash, Block::Header, SignedBlock<Block>>
+#[async_trait]
+impl<Block, Client> ChainApiServer<NumberFor<Block>, Block::Hash, Block::Header, SignedBlock<Block>>
 	for Chain<Block, Client>
 where
 	Block: BlockT + 'static,
 	Block::Header: Unpin,
 	Client: HeaderBackend<Block> + BlockchainEvents<Block> + 'static,
 {
-	type Metadata = crate::Metadata;
-
-	fn header(&self, hash: Option<Block::Hash>) -> FutureResult<Option<Block::Header>> {
-		self.backend.header(hash)
+	async fn header(&self, hash: Option<Block::Hash>) -> RpcResult<Option<Block::Header>> {
+		self.backend.header(hash).await.map_err(Into::into)
 	}

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

 	fn block_hash(
 		&self,
 		number: Option<ListOrValue<NumberOrHex>>,
-	) -> Result<ListOrValue<Option<Block::Hash>>> {
+	) -> RpcResult<ListOrValue<Option<Block::Hash>>> {
 		match number {
-			None => self.backend.block_hash(None).map(ListOrValue::Value),
-			Some(ListOrValue::Value(number)) =>
-				self.backend.block_hash(Some(number)).map(ListOrValue::Value),
+			None => self.backend.block_hash(None).map(ListOrValue::Value).map_err(Into::into),
+			Some(ListOrValue::Value(number)) => self
+				.backend
+				.block_hash(Some(number))
+				.map(ListOrValue::Value)
+				.map_err(Into::into),
 			Some(ListOrValue::List(list)) => Ok(ListOrValue::List(
 				list.into_iter()
 					.map(|number| self.backend.block_hash(Some(number)))
-					.collect::<Result<_>>()?,
+					.collect::<Result<_, _>>()?,
 			)),
 		}
 	}

-	fn finalized_head(&self) -> Result<Block::Hash> {
-		self.backend.finalized_head()
+	fn finalized_head(&self) -> RpcResult<Block::Hash> {
+		self.backend.finalized_head().map_err(Into::into)
 	}

-	fn subscribe_all_heads(&self, metadata: Self::Metadata, subscriber: Subscriber<Block::Header>) {
-		self.backend.subscribe_all_heads(metadata, subscriber)
+	fn subscribe_all_heads(&self, sink: PendingSubscription) {
+		self.backend.subscribe_all_heads(sink)
 	}

-	fn unsubscribe_all_heads(
-		&self,
-		metadata: Option<Self::Metadata>,
-		id: SubscriptionId,
-	) -> RpcResult<bool> {
-		self.backend.unsubscribe_all_heads(metadata, id)
+	fn subscribe_new_heads(&self, sink: PendingSubscription) {
+		self.backend.subscribe_new_heads(sink)
 	}

-	fn subscribe_new_heads(&self, metadata: Self::Metadata, subscriber: Subscriber<Block::Header>) {
-		self.backend.subscribe_new_heads(metadata, subscriber)
+	fn subscribe_finalized_heads(&self, sink: PendingSubscription) {
+		self.backend.subscribe_finalized_heads(sink)
 	}
-
-	fn unsubscribe_new_heads(
-		&self,
-		metadata: Option<Self::Metadata>,
-		id: SubscriptionId,
-	) -> RpcResult<bool> {
-		self.backend.unsubscribe_new_heads(metadata, id)
-	}
-
-	fn subscribe_finalized_heads(
-		&self,
-		metadata: Self::Metadata,
-		subscriber: Subscriber<Block::Header>,
-	) {
-		self.backend.subscribe_finalized_heads(metadata, subscriber)
-	}
-
-	fn unsubscribe_finalized_heads(
-		&self,
-		metadata: Option<Self::Metadata>,
-		id: SubscriptionId,
-	) -> RpcResult<bool> {
-		self.backend.unsubscribe_finalized_heads(metadata, id)
-	}
-}
-
-/// Subscribe to new headers.
-fn subscribe_headers<Block, Client, F, G, S>(
-	client: &Arc<Client>,
-	subscriptions: &SubscriptionManager,
-	subscriber: Subscriber<Block::Header>,
-	best_block_hash: G,
-	stream: F,
-) where
-	Block: BlockT + 'static,
-	Block::Header: Unpin,
-	Client: HeaderBackend<Block> + 'static,
-	F: FnOnce() -> S,
-	G: FnOnce() -> Block::Hash,
-	S: Stream<Item = std::result::Result<Block::Header, rpc::Error>> + Send + 'static,
-{
-	subscriptions.add(subscriber, |sink| {
-		// send current head right at the start.
-		let header = client
-			.header(BlockId::Hash(best_block_hash()))
-			.map_err(client_err)
-			.and_then(|header| {
-				header.ok_or_else(|| Error::Other("Best header missing.".to_string()))
-			})
-			.map_err(Into::into);
-
-		// send further subscriptions
-		let stream = stream()
-			.inspect_err(|e| warn!("Block notification stream error: {:?}", e))
-			.map(Ok);
-
-		stream::iter(vec![Ok(header)])
-			.chain(stream)
-			.forward(sink.sink_map_err(|e| warn!("Error sending notifications: {:?}", e)))
-			// we ignore the resulting Stream (if the first stream is over we are unsubscribed)
-			.map(|_| ())
-	});
 }

 fn client_err(err: sp_blockchain::Error) -> Error {
@@ -17,9 +17,9 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.

 use super::*;
-use crate::testing::TaskExecutor;
+use crate::testing::{test_executor, timeout_secs};
 use assert_matches::assert_matches;
-use futures::executor;
+use jsonrpsee::types::EmptyParams;
 use sc_block_builder::BlockBuilderProvider;
 use sp_consensus::BlockOrigin;
 use sp_rpc::list::ListOrValue;
@@ -28,65 +28,92 @@ use substrate_test_runtime_client::{
 	runtime::{Block, Header, H256},
 };

-#[test]
-fn should_return_header() {
+#[tokio::test]
+async fn should_return_header() {
 	let client = Arc::new(substrate_test_runtime_client::new());
-	let api = new_full(client.clone(), SubscriptionManager::new(Arc::new(TaskExecutor)));
+	let api = new_full(client.clone(), test_executor()).into_rpc();

-	assert_matches!(
-		executor::block_on(api.header(Some(client.genesis_hash()).into())),
-		Ok(Some(ref x)) if x == &Header {
+	let res: Header =
+		api.call("chain_getHeader", [H256::from(client.genesis_hash())]).await.unwrap();
+	assert_eq!(
+		res,
+		Header {
 			parent_hash: H256::from_low_u64_be(0),
 			number: 0,
-			state_root: x.state_root.clone(),
-			extrinsics_root:
-				"03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314".parse().unwrap(),
+			state_root: res.state_root.clone(),
+			extrinsics_root: "03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314"
+				.parse()
+				.unwrap(),
+			digest: Default::default(),
+		}
+	);
+
+	let res: Header = api.call("chain_getHeader", EmptyParams::new()).await.unwrap();
+	assert_eq!(
+		res,
+		Header {
+			parent_hash: H256::from_low_u64_be(0),
+			number: 0,
+			state_root: res.state_root.clone(),
+			extrinsics_root: "03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314"
+				.parse()
+				.unwrap(),
 			digest: Default::default(),
 		}
 	);

 	assert_matches!(
-		executor::block_on(api.header(None.into())),
-		Ok(Some(ref x)) if x == &Header {
-			parent_hash: H256::from_low_u64_be(0),
-			number: 0,
-			state_root: x.state_root.clone(),
-			extrinsics_root:
-				"03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314".parse().unwrap(),
-			digest: Default::default(),
-		}
-	);
-
-	assert_matches!(
-		executor::block_on(api.header(Some(H256::from_low_u64_be(5)).into())),
-		Ok(None)
+		api.call::<_, Option<Header>>("chain_getHeader", [H256::from_low_u64_be(5)])
+			.await
+			.unwrap(),
+		None
 	);
 }

-#[test]
-fn should_return_a_block() {
+#[tokio::test]
+async fn should_return_a_block() {
 	let mut client = Arc::new(substrate_test_runtime_client::new());
-	let api = new_full(client.clone(), SubscriptionManager::new(Arc::new(TaskExecutor)));
+	let api = new_full(client.clone(), test_executor()).into_rpc();

 	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
 	let block_hash = block.hash();
-	executor::block_on(client.import(BlockOrigin::Own, block)).unwrap();
+	client.import(BlockOrigin::Own, block).await.unwrap();
+
+	let res: SignedBlock<Block> =
+		api.call("chain_getBlock", [H256::from(client.genesis_hash())]).await.unwrap();

 	// Genesis block is not justified
-	assert_matches!(
-		executor::block_on(api.block(Some(client.genesis_hash()).into())),
-		Ok(Some(SignedBlock { justifications: None, .. }))
-	);
+	assert!(res.justifications.is_none());

-	assert_matches!(
-		executor::block_on(api.block(Some(block_hash).into())),
-		Ok(Some(ref x)) if x.block == Block {
+	let res: SignedBlock<Block> =
+		api.call("chain_getBlock", [H256::from(block_hash)]).await.unwrap();
+	assert_eq!(
+		res.block,
+		Block {
 			header: Header {
 				parent_hash: client.genesis_hash(),
 				number: 1,
-				state_root: x.block.header.state_root.clone(),
-				extrinsics_root:
-					"03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314".parse().unwrap(),
+				state_root: res.block.header.state_root.clone(),
+				extrinsics_root: "03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314"
+					.parse()
+					.unwrap(),
+				digest: Default::default(),
+			},
+			extrinsics: vec![],
+		}
+	);
+
+	let res: SignedBlock<Block> = api.call("chain_getBlock", Vec::<H256>::new()).await.unwrap();
+	assert_eq!(
+		res.block,
+		Block {
+			header: Header {
+				parent_hash: client.genesis_hash(),
+				number: 1,
+				state_root: res.block.header.state_root.clone(),
+				extrinsics_root: "03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314"
+					.parse()
+					.unwrap(),
 				digest: Default::default(),
 			},
 			extrinsics: vec![],
@@ -94,155 +121,125 @@ fn should_return_a_block() {
 	);

 	assert_matches!(
-		executor::block_on(api.block(None.into())),
-		Ok(Some(ref x)) if x.block == Block {
-			header: Header {
-				parent_hash: client.genesis_hash(),
-				number: 1,
-				state_root: x.block.header.state_root.clone(),
-				extrinsics_root:
-					"03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314".parse().unwrap(),
-				digest: Default::default(),
-			},
-			extrinsics: vec![],
-		}
+		api.call::<_, Option<Header>>("chain_getBlock", [H256::from_low_u64_be(5)])
+			.await
+			.unwrap(),
+		None
 	);
-
-	assert_matches!(executor::block_on(api.block(Some(H256::from_low_u64_be(5)).into())), Ok(None));
 }

-#[test]
-fn should_return_block_hash() {
+#[tokio::test]
+async fn should_return_block_hash() {
 	let mut client = Arc::new(substrate_test_runtime_client::new());
-	let api = new_full(client.clone(), SubscriptionManager::new(Arc::new(TaskExecutor)));
+	let api = new_full(client.clone(), test_executor()).into_rpc();
+
+	let res: ListOrValue<Option<H256>> =
+		api.call("chain_getBlockHash", EmptyParams::new()).await.unwrap();

 	assert_matches!(
-		api.block_hash(None.into()),
-		Ok(ListOrValue::Value(Some(ref x))) if x == &client.genesis_hash()
+		res,
+		ListOrValue::Value(Some(ref x)) if x == &client.genesis_hash()
 	);

+	let res: ListOrValue<Option<H256>> =
+		api.call("chain_getBlockHash", [ListOrValue::from(0_u64)]).await.unwrap();
 	assert_matches!(
-		api.block_hash(Some(ListOrValue::Value(0u64.into())).into()),
-		Ok(ListOrValue::Value(Some(ref x))) if x == &client.genesis_hash()
+		res,
+		ListOrValue::Value(Some(ref x)) if x == &client.genesis_hash()
 	);

-	assert_matches!(
-		api.block_hash(Some(ListOrValue::Value(1u64.into())).into()),
-		Ok(ListOrValue::Value(None))
-	);
+	let res: Option<ListOrValue<Option<H256>>> =
+		api.call("chain_getBlockHash", [ListOrValue::from(1_u64)]).await.unwrap();
+	assert_matches!(res, None);

 	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
-	executor::block_on(client.import(BlockOrigin::Own, block.clone())).unwrap();
+	client.import(BlockOrigin::Own, block.clone()).await.unwrap();

+	let res: ListOrValue<Option<H256>> =
+		api.call("chain_getBlockHash", [ListOrValue::from(0_u64)]).await.unwrap();
 	assert_matches!(
-		api.block_hash(Some(ListOrValue::Value(0u64.into())).into()),
-		Ok(ListOrValue::Value(Some(ref x))) if x == &client.genesis_hash()
-	);
-	assert_matches!(
-		api.block_hash(Some(ListOrValue::Value(1u64.into())).into()),
-		Ok(ListOrValue::Value(Some(ref x))) if x == &block.hash()
-	);
-	assert_matches!(
-		api.block_hash(Some(ListOrValue::Value(sp_core::U256::from(1u64).into())).into()),
-		Ok(ListOrValue::Value(Some(ref x))) if x == &block.hash()
+		res,
+		ListOrValue::Value(Some(ref x)) if x == &client.genesis_hash()
 	);

+	let res: ListOrValue<Option<H256>> =
+		api.call("chain_getBlockHash", [ListOrValue::from(1_u64)]).await.unwrap();
 	assert_matches!(
-		api.block_hash(Some(vec![0u64.into(), 1u64.into(), 2u64.into()].into())),
-		Ok(ListOrValue::List(list)) if list == &[client.genesis_hash().into(), block.hash().into(), None]
+		res,
+		ListOrValue::Value(Some(ref x)) if x == &block.hash()
+	);
+
+	let res: ListOrValue<Option<H256>> = api
+		.call("chain_getBlockHash", [ListOrValue::Value(sp_core::U256::from(1_u64))])
+		.await
+		.unwrap();
+	assert_matches!(
+		res,
+		ListOrValue::Value(Some(ref x)) if x == &block.hash()
+	);
+
+	let res: ListOrValue<Option<H256>> = api
+		.call("chain_getBlockHash", [ListOrValue::List(vec![0_u64, 1_u64, 2_u64])])
+		.await
+		.unwrap();
+	assert_matches!(
+		res,
+		ListOrValue::List(list) if list == &[client.genesis_hash().into(), block.hash().into(), None]
 	);
 }

-#[test]
-fn should_return_finalized_hash() {
+#[tokio::test]
+async fn should_return_finalized_hash() {
 	let mut client = Arc::new(substrate_test_runtime_client::new());
-	let api = new_full(client.clone(), SubscriptionManager::new(Arc::new(TaskExecutor)));
+	let api = new_full(client.clone(), test_executor()).into_rpc();

-	assert_matches!(
-		api.finalized_head(),
-		Ok(ref x) if x == &client.genesis_hash()
-	);
+	let res: H256 = api.call("chain_getFinalizedHead", EmptyParams::new()).await.unwrap();
+	assert_eq!(res, client.genesis_hash());

 	// import new block
 	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
-	executor::block_on(client.import(BlockOrigin::Own, block)).unwrap();
+	client.import(BlockOrigin::Own, block).await.unwrap();
+
 	// no finalization yet
-	assert_matches!(
-		api.finalized_head(),
-		Ok(ref x) if x == &client.genesis_hash()
-	);
+	let res: H256 = api.call("chain_getFinalizedHead", EmptyParams::new()).await.unwrap();
+	assert_eq!(res, client.genesis_hash());

 	// finalize
 	client.finalize_block(BlockId::number(1), None).unwrap();
-	assert_matches!(
-		api.finalized_head(),
-		Ok(ref x) if x == &client.block_hash(1).unwrap().unwrap()
-	);
+	let res: H256 = api.call("chain_getFinalizedHead", EmptyParams::new()).await.unwrap();
+	assert_eq!(res, client.block_hash(1).unwrap().unwrap());
 }

-#[test]
-fn should_notify_about_latest_block() {
-	let (subscriber, id, mut transport) = Subscriber::new_test("test");
-
-	{
-		let mut client = Arc::new(substrate_test_runtime_client::new());
-		let api = new_full(client.clone(), SubscriptionManager::new(Arc::new(TaskExecutor)));
-
-		api.subscribe_all_heads(Default::default(), subscriber);
-
-		// assert id assigned
-		assert!(matches!(executor::block_on(id), Ok(Ok(SubscriptionId::String(_)))));
-
-		let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
-		executor::block_on(client.import(BlockOrigin::Own, block)).unwrap();
-	}
-
-	// Check for the correct number of notifications
-	executor::block_on((&mut transport).take(2).collect::<Vec<_>>());
-	assert!(executor::block_on(transport.next()).is_none());
+#[tokio::test]
+async fn should_notify_about_latest_block() {
+	test_head_subscription("chain_subscribeAllHeads").await;
 }

-#[test]
-fn should_notify_about_best_block() {
-	let (subscriber, id, mut transport) = Subscriber::new_test("test");
-
-	{
-		let mut client = Arc::new(substrate_test_runtime_client::new());
-		let api = new_full(client.clone(), SubscriptionManager::new(Arc::new(TaskExecutor)));
-
-		api.subscribe_new_heads(Default::default(), subscriber);
-
-		// assert id assigned
-		assert!(matches!(executor::block_on(id), Ok(Ok(SubscriptionId::String(_)))));
-
-		let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
-		executor::block_on(client.import(BlockOrigin::Own, block)).unwrap();
-	}
-
-	// Assert that the correct number of notifications have been sent.
-	executor::block_on((&mut transport).take(2).collect::<Vec<_>>());
-	assert!(executor::block_on(transport.next()).is_none());
+#[tokio::test]
+async fn should_notify_about_best_block() {
+	test_head_subscription("chain_subscribeNewHeads").await;
 }

-#[test]
-fn should_notify_about_finalized_block() {
-	let (subscriber, id, mut transport) = Subscriber::new_test("test");
+#[tokio::test]
+async fn should_notify_about_finalized_block() {
+	test_head_subscription("chain_subscribeFinalizedHeads").await;
+}

-	{
-		let mut client = Arc::new(substrate_test_runtime_client::new());
-		let api = new_full(client.clone(), SubscriptionManager::new(Arc::new(TaskExecutor)));
-
-		api.subscribe_finalized_heads(Default::default(), subscriber);
-
-		// assert id assigned
-		assert!(matches!(executor::block_on(id), Ok(Ok(SubscriptionId::String(_)))));
+async fn test_head_subscription(method: &str) {
+	let mut client = Arc::new(substrate_test_runtime_client::new());

+	let mut sub = {
+		let api = new_full(client.clone(), test_executor()).into_rpc();
+		let sub = api.subscribe(method, EmptyParams::new()).await.unwrap();
 		let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
-		executor::block_on(client.import(BlockOrigin::Own, block)).unwrap();
+		client.import(BlockOrigin::Own, block).await.unwrap();
 		client.finalize_block(BlockId::number(1), None).unwrap();
-	}
+		sub
+	};

-	// Assert that the correct number of notifications have been sent.
-	executor::block_on((&mut transport).take(2).collect::<Vec<_>>());
-	assert!(executor::block_on(transport.next()).is_none());
+	assert_matches!(timeout_secs(10, sub.next::<Header>()).await, Ok(Some(_)));
+	assert_matches!(timeout_secs(10, sub.next::<Header>()).await, Ok(Some(_)));
+
+	sub.close();
+	assert_matches!(timeout_secs(10, sub.next::<Header>()).await, Ok(None));
 }
@@ -16,19 +16,15 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.

-//! Implementation of the [`DevApi`] trait providing debug utilities for Substrate based
+//! Implementation of the [`DevApiServer`] trait providing debug utilities for Substrate based
 //! blockchains.

 #[cfg(test)]
 mod tests;

-pub use sc_rpc_api::dev::{BlockStats, DevApi};
-
+use jsonrpsee::core::RpcResult;
 use sc_client_api::{BlockBackend, HeaderBackend};
-use sc_rpc_api::{
-	dev::error::{Error, Result},
-	DenyUnsafe,
-};
+use sc_rpc_api::{dev::error::Error, DenyUnsafe};
 use sp_api::{ApiExt, Core, ProvideRuntimeApi};
 use sp_core::Encode;
 use sp_runtime::{
@@ -40,6 +36,8 @@ use std::{
 	sync::Arc,
 };

+pub use sc_rpc_api::dev::{BlockStats, DevApiServer};
+
 type HasherOf<Block> = <<Block as BlockT>::Header as Header>::Hashing;

 /// The Dev API. All methods are unsafe.
@@ -56,7 +54,7 @@ impl<Block: BlockT, Client> Dev<Block, Client> {
 	}
 }

-impl<Block, Client> DevApi<Block::Hash> for Dev<Block, Client>
+impl<Block, Client> DevApiServer<Block::Hash> for Dev<Block, Client>
 where
 	Block: BlockT + 'static,
 	Client: BlockBackend<Block>
@@ -67,7 +65,7 @@ where
 		+ 'static,
 	Client::Api: Core<Block>,
 {
-	fn block_stats(&self, hash: Block::Hash) -> Result<Option<BlockStats>> {
+	fn block_stats(&self, hash: Block::Hash) -> RpcResult<Option<BlockStats>> {
 		self.deny_unsafe.check_if_safe()?;

 		let block = {
@@ -18,25 +18,32 @@

 use super::*;
 use assert_matches::assert_matches;
-use futures::executor;
+use jsonrpsee::{core::Error as JsonRpseeError, types::error::CallError};
 use sc_block_builder::BlockBuilderProvider;
 use sp_blockchain::HeaderBackend;
 use sp_consensus::BlockOrigin;
 use substrate_test_runtime_client::{prelude::*, runtime::Block};

-#[test]
-fn block_stats_work() {
+#[tokio::test]
+async fn block_stats_work() {
 	let mut client = Arc::new(substrate_test_runtime_client::new());
-	let api = <Dev<Block, _>>::new(client.clone(), DenyUnsafe::No);
+	let api = <Dev<Block, _>>::new(client.clone(), DenyUnsafe::No).into_rpc();

 	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
-	executor::block_on(client.import(BlockOrigin::Own, block)).unwrap();
+	client.import(BlockOrigin::Own, block).await.unwrap();

 	// Can't gather stats for a block without a parent.
-	assert_eq!(api.block_stats(client.genesis_hash()).unwrap(), None);
+	assert_eq!(
+		api.call::<_, Option<BlockStats>>("dev_getBlockStats", [client.genesis_hash()])
+			.await
+			.unwrap(),
+		None
+	);

 	assert_eq!(
-		api.block_stats(client.info().best_hash).unwrap(),
+		api.call::<_, Option<BlockStats>>("dev_getBlockStats", [client.info().best_hash])
+			.await
+			.unwrap(),
 		Some(BlockStats {
 			witness_len: 597,
 			witness_compact_len: 500,
@@ -46,13 +53,17 @@ fn block_stats_work() {
 	);
 }

-#[test]
-fn deny_unsafe_works() {
+#[tokio::test]
+async fn deny_unsafe_works() {
 	let mut client = Arc::new(substrate_test_runtime_client::new());
-	let api = <Dev<Block, _>>::new(client.clone(), DenyUnsafe::Yes);
+	let api = <Dev<Block, _>>::new(client.clone(), DenyUnsafe::Yes).into_rpc();

 	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
-	executor::block_on(client.import(BlockOrigin::Own, block)).unwrap();
+	client.import(BlockOrigin::Own, block).await.unwrap();

-	assert_matches!(api.block_stats(client.info().best_hash), Err(Error::UnsafeRpcCalled(_)));
+	assert_matches!(
+		api.call::<_, Option<BlockStats>>("dev_getBlockStats", [client.info().best_hash])
+			.await,
+		Err(JsonRpseeError::Call(CallError::Custom(err))) if err.message().contains("RPC call is unsafe to be called externally")
+	);
 }
@@ -22,15 +22,14 @@

 #![warn(missing_docs)]

-use futures::{
-	task::{FutureObj, Spawn, SpawnError},
-	FutureExt,
+pub use jsonrpsee::core::{
+	id_providers::{
+		RandomIntegerIdProvider as RandomIntegerSubscriptionId,
+		RandomStringIdProvider as RandomStringSubscriptionId,
+	},
+	traits::IdProvider as RpcSubscriptionIdProvider,
 };
-use sp_core::traits::SpawnNamed;
-use std::sync::Arc;
-
-pub use rpc::IoHandlerExtension as RpcExtension;
-pub use sc_rpc_api::{DenyUnsafe, Metadata};
+pub use sc_rpc_api::DenyUnsafe;

 pub mod author;
 pub mod chain;
@@ -43,24 +42,4 @@ pub mod system;
 pub mod testing;

 /// Task executor that is being used by RPC subscriptions.
-#[derive(Clone)]
-pub struct SubscriptionTaskExecutor(Arc<dyn SpawnNamed>);
-
-impl SubscriptionTaskExecutor {
-	/// Create a new `Self` with the given spawner.
-	pub fn new(spawn: impl SpawnNamed + 'static) -> Self {
-		Self(Arc::new(spawn))
-	}
-}
-
-impl Spawn for SubscriptionTaskExecutor {
-	fn spawn_obj(&self, future: FutureObj<'static, ()>) -> Result<(), SpawnError> {
-		self.0
-			.spawn("substrate-rpc-subscription", Some("rpc"), future.map(drop).boxed());
-		Ok(())
-	}
-
-	fn status(&self) -> Result<(), SpawnError> {
-		Ok(())
-	}
-}
+pub type SubscriptionTaskExecutor = std::sync::Arc<dyn sp_core::traits::SpawnNamed>;
@@ -21,7 +21,8 @@
 #[cfg(test)]
 mod tests;

-use self::error::{Error, Result};
+use self::error::Error;
+use jsonrpsee::core::{async_trait, Error as JsonRpseeError, RpcResult};
 use parking_lot::RwLock;
 /// Re-export the API for backward compatibility.
 pub use sc_rpc_api::offchain::*;
@@ -47,27 +48,27 @@ impl<T: OffchainStorage> Offchain<T> {
 	}
 }

-impl<T: OffchainStorage + 'static> OffchainApi for Offchain<T> {
-	/// Set offchain local storage under given key and prefix.
-	fn set_local_storage(&self, kind: StorageKind, key: Bytes, value: Bytes) -> Result<()> {
+#[async_trait]
+impl<T: OffchainStorage + 'static> OffchainApiServer for Offchain<T> {
+	fn set_local_storage(&self, kind: StorageKind, key: Bytes, value: Bytes) -> RpcResult<()> {
 		self.deny_unsafe.check_if_safe()?;

 		let prefix = match kind {
 			StorageKind::PERSISTENT => sp_offchain::STORAGE_PREFIX,
-			StorageKind::LOCAL => return Err(Error::UnavailableStorageKind),
+			StorageKind::LOCAL => return Err(JsonRpseeError::from(Error::UnavailableStorageKind)),
 		};
 		self.storage.write().set(prefix, &*key, &*value);
 		Ok(())
 	}

-	/// Get offchain local storage under given key and prefix.
-	fn get_local_storage(&self, kind: StorageKind, key: Bytes) -> Result<Option<Bytes>> {
+	fn get_local_storage(&self, kind: StorageKind, key: Bytes) -> RpcResult<Option<Bytes>> {
 		self.deny_unsafe.check_if_safe()?;

 		let prefix = match kind {
 			StorageKind::PERSISTENT => sp_offchain::STORAGE_PREFIX,
-			StorageKind::LOCAL => return Err(Error::UnavailableStorageKind),
+			StorageKind::LOCAL => return Err(JsonRpseeError::from(Error::UnavailableStorageKind)),
 		};
+
 		Ok(self.storage.read().get(prefix, &*key).map(Into::into))
 	}
 }
@@ -39,6 +39,7 @@ fn local_storage_should_work() {

 #[test]
 fn offchain_calls_considered_unsafe() {
+	use jsonrpsee::types::error::CallError;
 	let storage = InMemOffchainStorage::default();
 	let offchain = Offchain::new(storage, DenyUnsafe::Yes);
 	let key = Bytes(b"offchain_storage".to_vec());
@@ -46,10 +47,14 @@ fn offchain_calls_considered_unsafe() {

 	assert_matches!(
 		offchain.set_local_storage(StorageKind::PERSISTENT, key.clone(), value.clone()),
-		Err(Error::UnsafeRpcCalled(_))
+		Err(JsonRpseeError::Call(CallError::Custom(err))) => {
+			assert_eq!(err.message(), "RPC call is unsafe to be called externally")
+		}
 	);
 	assert_matches!(
 		offchain.get_local_storage(StorageKind::PERSISTENT, key),
-		Err(Error::UnsafeRpcCalled(_))
+		Err(JsonRpseeError::Call(CallError::Custom(err))) => {
+			assert_eq!(err.message(), "RPC call is unsafe to be called externally")
+		}
 	);
 }
@@ -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)
 	}
 }

@@ -18,17 +18,26 @@

 //! State API backend for full nodes.

-use futures::{
-	future,
-	future::{err, try_join_all},
-	stream, FutureExt, SinkExt, StreamExt,
-};
-use jsonrpc_pubsub::{manager::SubscriptionManager, typed::Subscriber, SubscriptionId};
-use log::warn;
-use rpc::Result as RpcResult;
-use std::{collections::HashMap, sync::Arc};
+use std::{collections::HashMap, marker::PhantomData, sync::Arc};

+use super::{
+	client_err,
+	error::{Error, Result},
+	ChildStateBackend, StateBackend,
+};
+use crate::SubscriptionTaskExecutor;
+
+use futures::{future, stream, FutureExt, StreamExt};
+use jsonrpsee::{
+	core::{async_trait, Error as JsonRpseeError},
+	PendingSubscription,
+};
+use sc_client_api::{
+	Backend, BlockBackend, BlockchainEvents, CallExecutor, ExecutorProvider, ProofProvider,
+	StorageProvider,
+};
 use sc_rpc_api::state::ReadProof;
+use sp_api::{CallApiAt, Metadata, ProvideRuntimeApi};
 use sp_blockchain::{
 	CachedHeaderMetadata, Error as ClientError, HeaderBackend, HeaderMetadata,
 	Result as ClientResult,
@@ -42,19 +51,6 @@ use sp_core::{
 use sp_runtime::{generic::BlockId, traits::Block as BlockT};
 use sp_version::RuntimeVersion;

-use sp_api::{CallApiAt, Metadata, ProvideRuntimeApi};
-
-use super::{
-	client_err,
-	error::{Error, FutureResult, Result},
-	ChildStateBackend, StateBackend,
-};
-use sc_client_api::{
-	Backend, BlockBackend, BlockchainEvents, CallExecutor, ExecutorProvider, ProofProvider,
-	StorageNotification, StorageProvider,
-};
-use std::marker::PhantomData;
-
 /// Ranges to query in state_queryStorage.
 struct QueryStorageRange<Block: BlockT> {
 	/// Hashes of all the blocks in the range.
@@ -64,7 +60,7 @@ struct QueryStorageRange<Block: BlockT> {
 /// State API backend for full nodes.
 pub struct FullState<BE, Block: BlockT, Client> {
 	client: Arc<Client>,
-	subscriptions: SubscriptionManager,
+	executor: SubscriptionTaskExecutor,
 	_phantom: PhantomData<(BE, Block)>,
 	rpc_max_payload: Option<usize>,
 }
@@ -81,10 +77,10 @@ where
 	/// Create new state API backend for full nodes.
 	pub fn new(
 		client: Arc<Client>,
-		subscriptions: SubscriptionManager,
+		executor: SubscriptionTaskExecutor,
 		rpc_max_payload: Option<usize>,
 	) -> Self {
-		Self { client, subscriptions, _phantom: PhantomData, rpc_max_payload }
+		Self { client, executor, _phantom: PhantomData, rpc_max_payload }
 	}

 	/// Returns given block hash or best block hash if None is passed.
@@ -174,6 +170,7 @@ where
 	}
 }

+#[async_trait]
 impl<BE, Block, Client> StateBackend<Block, Client> for FullState<BE, Block, Client>
 where
 	Block: BlockT + 'static,
@@ -193,14 +190,13 @@ where
 		+ 'static,
 	Client::Api: Metadata<Block>,
 {
-	fn call(
+	async fn call(
 		&self,
 		block: Option<Block::Hash>,
 		method: String,
 		call_data: Bytes,
-	) -> FutureResult<Bytes> {
-		let r = self
-			.block_or_best(block)
+	) -> std::result::Result<Bytes, Error> {
+		self.block_or_best(block)
 			.and_then(|block| {
 				self.client
 					.executor()
@@ -213,43 +209,37 @@ where
 					)
 					.map(Into::into)
 			})
-			.map_err(client_err);
-		async move { r }.boxed()
+			.map_err(client_err)
 	}

-	fn storage_keys(
+	async fn storage_keys(
 		&self,
 		block: Option<Block::Hash>,
 		prefix: StorageKey,
-	) -> FutureResult<Vec<StorageKey>> {
-		let r = self
-			.block_or_best(block)
+	) -> std::result::Result<Vec<StorageKey>, Error> {
+		self.block_or_best(block)
 			.and_then(|block| self.client.storage_keys(&BlockId::Hash(block), &prefix))
-			.map_err(client_err);
-		async move { r }.boxed()
+			.map_err(client_err)
 	}

-	fn storage_pairs(
+	async fn storage_pairs(
 		&self,
 		block: Option<Block::Hash>,
 		prefix: StorageKey,
-	) -> FutureResult<Vec<(StorageKey, StorageData)>> {
-		let r = self
-			.block_or_best(block)
+	) -> std::result::Result<Vec<(StorageKey, StorageData)>, Error> {
+		self.block_or_best(block)
 			.and_then(|block| self.client.storage_pairs(&BlockId::Hash(block), &prefix))
-			.map_err(client_err);
-		async move { r }.boxed()
+			.map_err(client_err)
 	}

-	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>> {
-		let r = self
-			.block_or_best(block)
+	) -> std::result::Result<Vec<StorageKey>, Error> {
+		self.block_or_best(block)
 			.and_then(|block| {
 				self.client.storage_keys_iter(
 					&BlockId::Hash(block),
@@ -258,40 +248,36 @@ where
 				)
 			})
 			.map(|iter| iter.take(count as usize).collect())
-			.map_err(client_err);
-		async move { r }.boxed()
+			.map_err(client_err)
 	}

-	fn storage(
+	async fn storage(
 		&self,
 		block: Option<Block::Hash>,
 		key: StorageKey,
-	) -> FutureResult<Option<StorageData>> {
-		let r = self
-			.block_or_best(block)
+	) -> std::result::Result<Option<StorageData>, Error> {
+		self.block_or_best(block)
 			.and_then(|block| self.client.storage(&BlockId::Hash(block), &key))
-			.map_err(client_err);
-		async move { r }.boxed()
+			.map_err(client_err)
 	}

-	fn storage_size(
+	async fn storage_size(
 		&self,
 		block: Option<Block::Hash>,
 		key: StorageKey,
-	) -> FutureResult<Option<u64>> {
+	) -> std::result::Result<Option<u64>, Error> {
 		let block = match self.block_or_best(block) {
 			Ok(b) => b,
-			Err(e) => return async move { Err(client_err(e)) }.boxed(),
+			Err(e) => return Err(client_err(e)),
 		};

 		match self.client.storage(&BlockId::Hash(block), &key) {
-			Ok(Some(d)) => return async move { Ok(Some(d.0.len() as u64)) }.boxed(),
-			Err(e) => return async move { Err(client_err(e)) }.boxed(),
+			Ok(Some(d)) => return Ok(Some(d.0.len() as u64)),
+			Err(e) => return Err(client_err(e)),
 			Ok(None) => {},
 		}

-		let r = self
-			.client
+		self.client
 			.storage_pairs(&BlockId::Hash(block), &key)
 			.map(|kv| {
 				let item_sum = kv.iter().map(|(_, v)| v.0.len() as u64).sum::<u64>();
@@ -301,48 +287,46 @@ where
 					None
 				}
 			})
-			.map_err(client_err);
-		async move { r }.boxed()
+			.map_err(client_err)
 	}

-	fn storage_hash(
+	async fn storage_hash(
 		&self,
 		block: Option<Block::Hash>,
 		key: StorageKey,
-	) -> FutureResult<Option<Block::Hash>> {
-		let r = self
-			.block_or_best(block)
+	) -> std::result::Result<Option<Block::Hash>, Error> {
+		self.block_or_best(block)
 			.and_then(|block| self.client.storage_hash(&BlockId::Hash(block), &key))
-			.map_err(client_err);
-		async move { r }.boxed()
+			.map_err(client_err)
 	}

-	fn metadata(&self, block: Option<Block::Hash>) -> FutureResult<Bytes> {
-		let r = self.block_or_best(block).map_err(client_err).and_then(|block| {
+	async fn metadata(&self, block: Option<Block::Hash>) -> std::result::Result<Bytes, Error> {
+		self.block_or_best(block).map_err(client_err).and_then(|block| {
 			self.client
 				.runtime_api()
 				.metadata(&BlockId::Hash(block))
 				.map(Into::into)
 				.map_err(|e| Error::Client(Box::new(e)))
-		});
-		async move { r }.boxed()
+		})
 	}

-	fn runtime_version(&self, block: Option<Block::Hash>) -> FutureResult<RuntimeVersion> {
-		let r = self.block_or_best(block).map_err(client_err).and_then(|block| {
+	async fn runtime_version(
+		&self,
+		block: Option<Block::Hash>,
+	) -> std::result::Result<RuntimeVersion, Error> {
+		self.block_or_best(block).map_err(client_err).and_then(|block| {
 			self.client
 				.runtime_version_at(&BlockId::Hash(block))
 				.map_err(|e| Error::Client(Box::new(e)))
-		});
-		async move { r }.boxed()
+		})
 	}

-	fn query_storage(
+	async fn query_storage(
 		&self,
 		from: Block::Hash,
 		to: Option<Block::Hash>,
 		keys: Vec<StorageKey>,
-	) -> FutureResult<Vec<StorageChangeSet<Block::Hash>>> {
+	) -> std::result::Result<Vec<StorageChangeSet<Block::Hash>>, Error> {
 		let call_fn = move || {
 			let range = self.query_storage_range(from, to)?;
 			let mut changes = Vec::new();
@@ -350,168 +334,151 @@ where
 			self.query_storage_unfiltered(&range, &keys, &mut last_values, &mut changes)?;
 			Ok(changes)
 		};
-
-		let r = call_fn();
-		async move { r }.boxed()
+		call_fn()
 	}

-	fn query_storage_at(
+	async fn query_storage_at(
 		&self,
 		keys: Vec<StorageKey>,
 		at: Option<Block::Hash>,
-	) -> FutureResult<Vec<StorageChangeSet<Block::Hash>>> {
+	) -> std::result::Result<Vec<StorageChangeSet<Block::Hash>>, Error> {
 		let at = at.unwrap_or_else(|| self.client.info().best_hash);
-		self.query_storage(at, Some(at), keys)
+		self.query_storage(at, Some(at), keys).await
 	}

-	fn read_proof(
+	async fn read_proof(
 		&self,
 		block: Option<Block::Hash>,
 		keys: Vec<StorageKey>,
-	) -> FutureResult<ReadProof<Block::Hash>> {
-		let r = self
-			.block_or_best(block)
+	) -> std::result::Result<ReadProof<Block::Hash>, Error> {
+		self.block_or_best(block)
 			.and_then(|block| {
 				self.client
 					.read_proof(&BlockId::Hash(block), &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);
-		async move { r }.boxed()
+			.map_err(client_err)
 	}

-	fn subscribe_runtime_version(
-		&self,
-		_meta: crate::Metadata,
-		subscriber: Subscriber<RuntimeVersion>,
-	) {
-		self.subscriptions.add(subscriber, |sink| {
-			let version = self
-				.block_or_best(None)
-				.and_then(|block| {
-					self.client.runtime_version_at(&BlockId::Hash(block)).map_err(Into::into)
-				})
-				.map_err(client_err)
-				.map_err(Into::into);
+	fn subscribe_runtime_version(&self, pending: PendingSubscription) {
+		let client = self.client.clone();

-			let client = self.client.clone();
-			let mut previous_version = version.clone();
+		let initial = match self
+			.block_or_best(None)
+			.and_then(|block| {
+				self.client.runtime_version_at(&BlockId::Hash(block)).map_err(Into::into)
+			})
+			.map_err(|e| Error::Client(Box::new(e)))
+		{
+			Ok(initial) => initial,
+			Err(e) => {
+				pending.reject(JsonRpseeError::from(e));
+				return
+			},
+		};

-			// A stream of all best blocks.
-			let stream =
-				client.import_notification_stream().filter(|n| future::ready(n.is_new_best));
+		let mut previous_version = initial.clone();

-			let stream = stream.filter_map(move |n| {
+		// A stream of new versions
+		let version_stream = client
+			.import_notification_stream()
+			.filter(|n| future::ready(n.is_new_best))
+			.filter_map(move |n| {
 				let version = client
 					.runtime_version_at(&BlockId::hash(n.hash))
-					.map_err(|e| Error::Client(Box::new(e)))
-					.map_err(Into::into);
+					.map_err(|e| Error::Client(Box::new(e)));

-				if previous_version != version {
-					previous_version = version.clone();
-					future::ready(Some(Ok::<_, ()>(version)))
-				} else {
-					future::ready(None)
+				match version {
+					Ok(version) if version != previous_version => {
+						previous_version = version.clone();
+						future::ready(Some(version))
+					},
+					_ => future::ready(None),
 				}
 			});

-			stream::iter(vec![Ok(version)])
-				.chain(stream)
-				.forward(sink.sink_map_err(|e| warn!("Error sending notifications: {:?}", e)))
-				// we ignore the resulting Stream (if the first stream is over we are unsubscribed)
-				.map(|_| ())
-		});
+		let stream = futures::stream::once(future::ready(initial)).chain(version_stream);
+
+		let fut = async move {
+			if let Some(mut sink) = pending.accept() {
+				sink.pipe_from_stream(stream).await;
+			}
+		}
+		.boxed();
+
+		self.executor
+			.spawn("substrate-rpc-subscription", Some("rpc"), fut.map(drop).boxed());
 	}

-	fn unsubscribe_runtime_version(
-		&self,
-		_meta: Option<crate::Metadata>,
-		id: SubscriptionId,
-	) -> RpcResult<bool> {
-		Ok(self.subscriptions.cancel(id))
-	}
-
-	fn subscribe_storage(
-		&self,
-		_meta: crate::Metadata,
-		subscriber: Subscriber<StorageChangeSet<Block::Hash>>,
-		keys: Option<Vec<StorageKey>>,
-	) {
-		let keys = Into::<Option<Vec<_>>>::into(keys);
+	fn subscribe_storage(&self, pending: PendingSubscription, keys: Option<Vec<StorageKey>>) {
 		let stream = match self.client.storage_changes_notification_stream(keys.as_deref(), None) {
 			Ok(stream) => stream,
-			Err(err) => {
-				let _ = subscriber.reject(client_err(err).into());
+			Err(blockchain_err) => {
+				pending.reject(JsonRpseeError::from(Error::Client(Box::new(blockchain_err))));
 				return
 			},
 		};

 		// initial values
-		let initial = stream::iter(
-			keys.map(|keys| {
-				let block = self.client.info().best_hash;
-				let changes = keys
-					.into_iter()
-					.map(|key| {
-						let v = self.client.storage(&BlockId::Hash(block), &key).ok().flatten();
-						(key, v)
-					})
-					.collect();
-				vec![Ok(Ok(StorageChangeSet { block, changes }))]
-			})
-			.unwrap_or_default(),
-		);
+		let initial = stream::iter(keys.map(|keys| {
+			let block = self.client.info().best_hash;
+			let changes = keys
+				.into_iter()
+				.map(|key| {
+					let v = self.client.storage(&BlockId::Hash(block), &key).ok().flatten();
+					(key, v)
+				})
+				.collect();
+			StorageChangeSet { block, changes }
+		}));

-		self.subscriptions.add(subscriber, |sink| {
-			let stream = stream.map(|StorageNotification { block, changes }| {
-				Ok(Ok::<_, rpc::Error>(StorageChangeSet {
-					block,
-					changes: changes
-						.iter()
-						.filter_map(|(o_sk, k, v)| o_sk.is_none().then(|| (k.clone(), v.cloned())))
-						.collect(),
-				}))
-			});
-
-			initial
-				.chain(stream)
-				.forward(sink.sink_map_err(|e| warn!("Error sending notifications: {:?}", e)))
-				// we ignore the resulting Stream (if the first stream is over we are unsubscribed)
-				.map(|_| ())
+		// let storage_stream = stream.map(|(block, changes)| StorageChangeSet {
+		let storage_stream = stream.map(|storage_notif| StorageChangeSet {
+			block: storage_notif.block,
+			changes: storage_notif
+				.changes
+				.iter()
+				.filter_map(|(o_sk, k, v)| o_sk.is_none().then(|| (k.clone(), v.cloned())))
+				.collect(),
 		});
+
+		let stream = initial
+			.chain(storage_stream)
+			.filter(|storage| future::ready(!storage.changes.is_empty()));
+
+		let fut = async move {
+			if let Some(mut sink) = pending.accept() {
+				sink.pipe_from_stream(stream).await;
+			}
+		}
+		.boxed();
+
+		self.executor
+			.spawn("substrate-rpc-subscription", Some("rpc"), fut.map(drop).boxed());
 	}

-	fn unsubscribe_storage(
-		&self,
-		_meta: Option<crate::Metadata>,
-		id: SubscriptionId,
-	) -> RpcResult<bool> {
-		Ok(self.subscriptions.cancel(id))
-	}
-
-	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> {
-		let block_executor = sc_tracing::block::BlockExecutor::new(
+	) -> std::result::Result<sp_rpc::tracing::TraceBlockResponse, Error> {
+		sc_tracing::block::BlockExecutor::new(
 			self.client.clone(),
 			block,
 			targets,
 			storage_keys,
 			methods,
 			self.rpc_max_payload,
-		);
-		let r = block_executor
-			.trace_block()
-			.map_err(|e| invalid_block::<Block>(block, None, e.to_string()));
-		async move { r }.boxed()
+		)
+		.trace_block()
+		.map_err(|e| invalid_block::<Block>(block, None, e.to_string()))
 	}
 }

+#[async_trait]
 impl<BE, Block, Client> ChildStateBackend<Block, Client> for FullState<BE, Block, Client>
 where
 	Block: BlockT + 'static,
@@ -530,14 +497,13 @@ where
 		+ 'static,
 	Client::Api: Metadata<Block>,
 {
-	fn read_child_proof(
+	async fn read_child_proof(
 		&self,
 		block: Option<Block::Hash>,
 		storage_key: PrefixedStorageKey,
 		keys: Vec<StorageKey>,
-	) -> FutureResult<ReadProof<Block::Hash>> {
-		let r = self
-			.block_or_best(block)
+	) -> std::result::Result<ReadProof<Block::Hash>, Error> {
+		self.block_or_best(block)
 			.and_then(|block| {
 				let child_info = match ChildType::from_prefixed_key(&storage_key) {
 					Some((ChildType::ParentKeyId, storage_key)) =>
@@ -553,19 +519,16 @@ where
 					.map(|proof| proof.iter_nodes().map(|node| node.into()).collect())
 					.map(|proof| ReadProof { at: block, proof })
 			})
-			.map_err(client_err);
-
-		async move { r }.boxed()
+			.map_err(client_err)
 	}

-	fn storage_keys(
+	async fn storage_keys(
 		&self,
 		block: Option<Block::Hash>,
 		storage_key: PrefixedStorageKey,
 		prefix: StorageKey,
-	) -> FutureResult<Vec<StorageKey>> {
-		let r = self
-			.block_or_best(block)
+	) -> std::result::Result<Vec<StorageKey>, Error> {
+		self.block_or_best(block)
 			.and_then(|block| {
 				let child_info = match ChildType::from_prefixed_key(&storage_key) {
 					Some((ChildType::ParentKeyId, storage_key)) =>
@@ -574,21 +537,18 @@ where
 				};
 				self.client.child_storage_keys(&BlockId::Hash(block), &child_info, &prefix)
 			})
-			.map_err(client_err);
-
-		async move { r }.boxed()
+			.map_err(client_err)
 	}

-	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>> {
-		let r = self
-			.block_or_best(block)
+	) -> std::result::Result<Vec<StorageKey>, Error> {
+		self.block_or_best(block)
 			.and_then(|block| {
 				let child_info = match ChildType::from_prefixed_key(&storage_key) {
 					Some((ChildType::ParentKeyId, storage_key)) =>
@@ -603,19 +563,16 @@ where
 				)
 			})
 			.map(|iter| iter.take(count as usize).collect())
-			.map_err(client_err);
-
-		async move { r }.boxed()
+			.map_err(client_err)
 	}

-	fn storage(
+	async fn storage(
 		&self,
 		block: Option<Block::Hash>,
 		storage_key: PrefixedStorageKey,
 		key: StorageKey,
-	) -> FutureResult<Option<StorageData>> {
-		let r = self
-			.block_or_best(block)
+	) -> std::result::Result<Option<StorageData>, Error> {
+		self.block_or_best(block)
 			.and_then(|block| {
 				let child_info = match ChildType::from_prefixed_key(&storage_key) {
 					Some((ChildType::ParentKeyId, storage_key)) =>
@@ -624,28 +581,25 @@ where
 				};
 				self.client.child_storage(&BlockId::Hash(block), &child_info, &key)
 			})
-			.map_err(client_err);
-
-		async move { r }.boxed()
+			.map_err(client_err)
 	}

-	fn storage_entries(
+	async fn storage_entries(
 		&self,
 		block: Option<Block::Hash>,
 		storage_key: PrefixedStorageKey,
 		keys: Vec<StorageKey>,
-	) -> FutureResult<Vec<Option<StorageData>>> {
-		let child_info = match ChildType::from_prefixed_key(&storage_key) {
-			Some((ChildType::ParentKeyId, storage_key)) =>
-				Arc::new(ChildInfo::new_default(storage_key)),
-			None => return err(client_err(sp_blockchain::Error::InvalidChildStorageKey)).boxed(),
-		};
-		let block = match self.block_or_best(block) {
-			Ok(b) => b,
-			Err(e) => return err(client_err(e)).boxed(),
+	) -> std::result::Result<Vec<Option<StorageData>>, Error> {
+		let child_info = if let Some((ChildType::ParentKeyId, storage_key)) =
+			ChildType::from_prefixed_key(&storage_key)
+		{
+			Arc::new(ChildInfo::new_default(storage_key))
+		} else {
+			return Err(client_err(sp_blockchain::Error::InvalidChildStorageKey))
 		};
+		let block = self.block_or_best(block).map_err(client_err)?;
 		let client = self.client.clone();
-		try_join_all(keys.into_iter().map(move |key| {
+		future::try_join_all(keys.into_iter().map(move |key| {
 			let res = client
 				.clone()
 				.child_storage(&BlockId::Hash(block), &child_info, &key)
@@ -653,17 +607,16 @@ where

 			async move { res }
 		}))
-		.boxed()
+		.await
 	}

-	fn storage_hash(
+	async fn storage_hash(
 		&self,
 		block: Option<Block::Hash>,
 		storage_key: PrefixedStorageKey,
 		key: StorageKey,
-	) -> FutureResult<Option<Block::Hash>> {
-		let r = self
-			.block_or_best(block)
+	) -> std::result::Result<Option<Block::Hash>, Error> {
+		self.block_or_best(block)
 			.and_then(|block| {
 				let child_info = match ChildType::from_prefixed_key(&storage_key) {
 					Some((ChildType::ParentKeyId, storage_key)) =>
@@ -672,9 +625,7 @@ where
 				};
 				self.client.child_storage_hash(&BlockId::Hash(block), &child_info, &key)
 			})
-			.map_err(client_err);
-
-		async move { r }.boxed()
+			.map_err(client_err)
 	}
 }

@@ -18,9 +18,13 @@

 use self::error::Error;
 use super::*;
-use crate::testing::TaskExecutor;
+use crate::testing::{test_executor, timeout_secs};
 use assert_matches::assert_matches;
-use futures::{executor, StreamExt};
+use futures::executor;
+use jsonrpsee::{
+	core::Error as RpcError,
+	types::{error::CallError as RpcCallError, EmptyParams, ErrorObject},
+};
 use sc_block_builder::BlockBuilderProvider;
 use sc_rpc_api::DenyUnsafe;
 use sp_consensus::BlockOrigin;
@@ -36,8 +40,8 @@ fn prefixed_storage_key() -> PrefixedStorageKey {
 	child_info.prefixed_storage_key()
 }

-#[test]
-fn should_return_storage() {
+#[tokio::test]
+async fn should_return_storage() {
 	const KEY: &[u8] = b":mock";
 	const VALUE: &[u8] = b"hello world";
 	const CHILD_VALUE: &[u8] = b"hello world !";
@@ -51,49 +55,46 @@ fn should_return_storage() {
 		.add_extra_storage(b":map:acc2".to_vec(), vec![1, 2, 3])
 		.build();
 	let genesis_hash = client.genesis_hash();
-	let (client, child) = new_full(
-		Arc::new(client),
-		SubscriptionManager::new(Arc::new(TaskExecutor)),
-		DenyUnsafe::No,
-		None,
-	);
+	let (client, child) = new_full(Arc::new(client), test_executor(), DenyUnsafe::No, None);
 	let key = StorageKey(KEY.to_vec());

 	assert_eq!(
-		executor::block_on(client.storage(key.clone(), Some(genesis_hash).into()))
+		client
+			.storage(key.clone(), Some(genesis_hash).into())
+			.await
 			.map(|x| x.map(|x| x.0.len()))
 			.unwrap()
 			.unwrap() as usize,
 		VALUE.len(),
 	);
 	assert_matches!(
-		executor::block_on(client.storage_hash(key.clone(), Some(genesis_hash).into()))
+		client
+			.storage_hash(key.clone(), Some(genesis_hash).into())
+			.await
 			.map(|x| x.is_some()),
 		Ok(true)
 	);
 	assert_eq!(
-		executor::block_on(client.storage_size(key.clone(), None)).unwrap().unwrap() as usize,
+		client.storage_size(key.clone(), None).await.unwrap().unwrap() as usize,
 		VALUE.len(),
 	);
 	assert_eq!(
-		executor::block_on(client.storage_size(StorageKey(b":map".to_vec()), None))
-			.unwrap()
-			.unwrap() as usize,
+		client.storage_size(StorageKey(b":map".to_vec()), None).await.unwrap().unwrap() as usize,
 		2 + 3,
 	);
 	assert_eq!(
-		executor::block_on(
-			child
-				.storage(prefixed_storage_key(), key, Some(genesis_hash).into())
-				.map(|x| x.map(|x| x.unwrap().0.len()))
-		)
-		.unwrap() as usize,
+		child
+			.storage(prefixed_storage_key(), key, Some(genesis_hash).into())
+			.await
+			.map(|x| x.map(|x| x.0.len()))
+			.unwrap()
+			.unwrap() as usize,
 		CHILD_VALUE.len(),
 	);
 }

-#[test]
-fn should_return_storage_entries() {
+#[tokio::test]
+async fn should_return_storage_entries() {
 	const KEY1: &[u8] = b":mock";
 	const KEY2: &[u8] = b":turtle";
 	const VALUE: &[u8] = b"hello world";
@@ -107,22 +108,15 @@ fn should_return_storage_entries() {
 		.add_extra_child_storage(&child_info, KEY2.to_vec(), CHILD_VALUE2.to_vec())
 		.build();
 	let genesis_hash = client.genesis_hash();
-	let (_client, child) = new_full(
-		Arc::new(client),
-		SubscriptionManager::new(Arc::new(TaskExecutor)),
-		DenyUnsafe::No,
-		None,
-	);
+	let (_client, child) = new_full(Arc::new(client), test_executor(), DenyUnsafe::No, None);

 	let keys = &[StorageKey(KEY1.to_vec()), StorageKey(KEY2.to_vec())];
 	assert_eq!(
-		executor::block_on(child.storage_entries(
-			prefixed_storage_key(),
-			keys.to_vec(),
-			Some(genesis_hash).into()
-		))
-		.map(|x| x.into_iter().map(|x| x.map(|x| x.0.len()).unwrap()).sum::<usize>())
-		.unwrap(),
+		child
+			.storage_entries(prefixed_storage_key(), keys.to_vec(), Some(genesis_hash).into())
+			.await
+			.map(|x| x.into_iter().map(|x| x.map(|x| x.0.len()).unwrap()).sum::<usize>())
+			.unwrap(),
 		CHILD_VALUE1.len() + CHILD_VALUE2.len()
 	);

@@ -130,18 +124,16 @@ fn should_return_storage_entries() {
 	let mut failing_keys = vec![StorageKey(b":soup".to_vec())];
 	failing_keys.extend_from_slice(keys);
 	assert_matches!(
-		executor::block_on(child.storage_entries(
-			prefixed_storage_key(),
-			failing_keys,
-			Some(genesis_hash).into()
-		))
-		.map(|x| x.iter().all(|x| x.is_some())),
+		child
+			.storage_entries(prefixed_storage_key(), failing_keys, Some(genesis_hash).into())
+			.await
+			.map(|x| x.iter().all(|x| x.is_some())),
 		Ok(false)
 	);
 }

-#[test]
-fn should_return_child_storage() {
+#[tokio::test]
+async fn should_return_child_storage() {
 	let child_info = ChildInfo::new_default(STORAGE_KEY);
 	let client = Arc::new(
 		substrate_test_runtime_client::TestClientBuilder::new()
@@ -149,49 +141,30 @@ fn should_return_child_storage() {
 			.build(),
 	);
 	let genesis_hash = client.genesis_hash();
-	let (_client, child) =
-		new_full(client, SubscriptionManager::new(Arc::new(TaskExecutor)), DenyUnsafe::No, None);
+	let (_client, child) = new_full(client, test_executor(), DenyUnsafe::No, None);
 	let child_key = prefixed_storage_key();
 	let key = StorageKey(b"key".to_vec());

 	assert_matches!(
-		executor::block_on(child.storage(
+		child.storage(
 			child_key.clone(),
 			key.clone(),
 			Some(genesis_hash).into(),
-		)),
+		).await,
 		Ok(Some(StorageData(ref d))) if d[0] == 42 && d.len() == 1
 	);
-
-	// should fail if key does not exist.
-	let failing_key = StorageKey(b":soup".to_vec());
 	assert_matches!(
-		executor::block_on(child.storage(
-			prefixed_storage_key(),
-			failing_key,
-			Some(genesis_hash).into()
-		))
-		.map(|x| x.is_some()),
-		Ok(false)
-	);
-
-	assert_matches!(
-		executor::block_on(child.storage_hash(
-			child_key.clone(),
-			key.clone(),
-			Some(genesis_hash).into(),
-		))
-		.map(|x| x.is_some()),
+		child
+			.storage_hash(child_key.clone(), key.clone(), Some(genesis_hash).into(),)
+			.await
+			.map(|x| x.is_some()),
 		Ok(true)
 	);
-	assert_matches!(
-		executor::block_on(child.storage_size(child_key.clone(), key.clone(), None)),
-		Ok(Some(1))
-	);
+	assert_matches!(child.storage_size(child_key.clone(), key.clone(), None).await, Ok(Some(1)));
 }

-#[test]
-fn should_return_child_storage_entries() {
+#[tokio::test]
+async fn should_return_child_storage_entries() {
 	let child_info = ChildInfo::new_default(STORAGE_KEY);
 	let client = Arc::new(
 		substrate_test_runtime_client::TestClientBuilder::new()
@@ -200,17 +173,14 @@ fn should_return_child_storage_entries() {
 			.build(),
 	);
 	let genesis_hash = client.genesis_hash();
-	let (_client, child) =
-		new_full(client, SubscriptionManager::new(Arc::new(TaskExecutor)), DenyUnsafe::No, None);
+	let (_client, child) = new_full(client, test_executor(), DenyUnsafe::No, None);
 	let child_key = prefixed_storage_key();
 	let keys = vec![StorageKey(b"key1".to_vec()), StorageKey(b"key2".to_vec())];

-	let res = executor::block_on(child.storage_entries(
-		child_key.clone(),
-		keys.clone(),
-		Some(genesis_hash).into(),
-	))
-	.unwrap();
+	let res = child
+		.storage_entries(child_key.clone(), keys.clone(), Some(genesis_hash).into())
+		.await
+		.unwrap();

 	assert_matches!(
 		res[0],
@@ -232,46 +202,37 @@ fn should_return_child_storage_entries() {
 		Ok(true)
 	);
 	assert_matches!(
-		executor::block_on(child.storage_size(child_key.clone(), keys[0].clone(), None)),
+		child.storage_size(child_key.clone(), keys[0].clone(), None).await,
 		Ok(Some(1))
 	);
 }

-#[test]
-fn should_call_contract() {
+#[tokio::test]
+async fn should_call_contract() {
 	let client = Arc::new(substrate_test_runtime_client::new());
 	let genesis_hash = client.genesis_hash();
-	let (client, _child) =
-		new_full(client, SubscriptionManager::new(Arc::new(TaskExecutor)), DenyUnsafe::No, None);
+	let (client, _child) = new_full(client, test_executor(), DenyUnsafe::No, None);
+
+	use jsonrpsee::{core::Error, types::error::CallError};

 	assert_matches!(
-		executor::block_on(client.call(
-			"balanceOf".into(),
-			Bytes(vec![1, 2, 3]),
-			Some(genesis_hash).into()
-		)),
-		Err(Error::Client(_))
+		client
+			.call("balanceOf".into(), Bytes(vec![1, 2, 3]), Some(genesis_hash).into())
+			.await,
+		Err(Error::Call(CallError::Failed(_)))
 	)
 }

-#[test]
-fn should_notify_about_storage_changes() {
-	let (subscriber, id, mut transport) = Subscriber::new_test("test");
-
-	{
+#[tokio::test]
+async fn should_notify_about_storage_changes() {
+	let mut sub = {
 		let mut client = Arc::new(substrate_test_runtime_client::new());
-		let (api, _child) = new_full(
-			client.clone(),
-			SubscriptionManager::new(Arc::new(TaskExecutor)),
-			DenyUnsafe::No,
-			None,
-		);
+		let (api, _child) = new_full(client.clone(), test_executor(), DenyUnsafe::No, None);

-		api.subscribe_storage(Default::default(), subscriber, None.into());
-
-		// assert id assigned
-		assert!(matches!(executor::block_on(id), Ok(Ok(SubscriptionId::String(_)))));
+		let api_rpc = api.into_rpc();
+		let sub = api_rpc.subscribe("state_subscribeStorage", EmptyParams::new()).await.unwrap();

+		// Cause a change:
 		let mut builder = client.new_block(Default::default()).unwrap();
 		builder
 			.push_transfer(runtime::Transfer {
@@ -282,38 +243,32 @@ fn should_notify_about_storage_changes() {
 			})
 			.unwrap();
 		let block = builder.build().unwrap().block;
-		executor::block_on(client.import(BlockOrigin::Own, block)).unwrap();
-	}
+		client.import(BlockOrigin::Own, block).await.unwrap();

-	// Check notification sent to transport
-	executor::block_on((&mut transport).take(2).collect::<Vec<_>>());
-	assert!(executor::block_on(transport.next()).is_none());
+		sub
+	};
+
+	// We should get a message back on our subscription about the storage change:
+	// NOTE: previous versions of the subscription code used to return an empty value for the
+	// "initial" storage change here
+	assert_matches!(timeout_secs(1, sub.next::<StorageChangeSet<H256>>()).await, Ok(Some(_)));
+	assert_matches!(timeout_secs(1, sub.next::<StorageChangeSet<H256>>()).await, Ok(None));
 }

-#[test]
-fn should_send_initial_storage_changes_and_notifications() {
-	let (subscriber, id, mut transport) = Subscriber::new_test("test");
-
-	{
+#[tokio::test]
+async fn should_send_initial_storage_changes_and_notifications() {
+	let mut sub = {
 		let mut client = Arc::new(substrate_test_runtime_client::new());
-		let (api, _child) = new_full(
-			client.clone(),
-			SubscriptionManager::new(Arc::new(TaskExecutor)),
-			DenyUnsafe::No,
-			None,
-		);
+		let (api, _child) = new_full(client.clone(), test_executor(), DenyUnsafe::No, None);

 		let alice_balance_key =
 			blake2_256(&runtime::system::balance_of_key(AccountKeyring::Alice.into()));

-		api.subscribe_storage(
-			Default::default(),
-			subscriber,
-			Some(vec![StorageKey(alice_balance_key.to_vec())]).into(),
-		);
-
-		// assert id assigned
-		assert!(matches!(executor::block_on(id), Ok(Ok(SubscriptionId::String(_)))));
+		let api_rpc = api.into_rpc();
+		let sub = api_rpc
+			.subscribe("state_subscribeStorage", [[StorageKey(alice_balance_key.to_vec())]])
+			.await
+			.unwrap();

 		let mut builder = client.new_block(Default::default()).unwrap();
 		builder
@@ -325,23 +280,22 @@ fn should_send_initial_storage_changes_and_notifications() {
 			})
 			.unwrap();
 		let block = builder.build().unwrap().block;
-		executor::block_on(client.import(BlockOrigin::Own, block)).unwrap();
-	}
+		client.import(BlockOrigin::Own, block).await.unwrap();

-	// Check for the correct number of notifications
-	executor::block_on((&mut transport).take(2).collect::<Vec<_>>());
-	assert!(executor::block_on(transport.next()).is_none());
+		sub
+	};
+
+	assert_matches!(timeout_secs(1, sub.next::<StorageChangeSet<H256>>()).await, Ok(Some(_)));
+	assert_matches!(timeout_secs(1, sub.next::<StorageChangeSet<H256>>()).await, Ok(Some(_)));
+
+	// No more messages to follow
+	assert_matches!(timeout_secs(1, sub.next::<StorageChangeSet<H256>>()).await, Ok(None));
 }

-#[test]
-fn should_query_storage() {
-	fn run_tests(mut client: Arc<TestClient>) {
-		let (api, _child) = new_full(
-			client.clone(),
-			SubscriptionManager::new(Arc::new(TaskExecutor)),
-			DenyUnsafe::No,
-			None,
-		);
+#[tokio::test]
+async fn should_query_storage() {
+	async fn run_tests(mut client: Arc<TestClient>) {
+		let (api, _child) = new_full(client.clone(), test_executor(), DenyUnsafe::No, None);

 		let mut add_block = |nonce| {
 			let mut builder = client.new_block(Default::default()).unwrap();
@@ -393,7 +347,7 @@ fn should_query_storage() {
 		let keys = (1..6).map(|k| StorageKey(vec![k])).collect::<Vec<_>>();
 		let result = api.query_storage(keys.clone(), genesis_hash, Some(block1_hash).into());

-		assert_eq!(executor::block_on(result).unwrap(), expected);
+		assert_eq!(result.await.unwrap(), expected);

 		// Query all changes
 		let result = api.query_storage(keys.clone(), genesis_hash, None.into());
@@ -406,23 +360,28 @@ fn should_query_storage() {
 				(StorageKey(vec![5]), Some(StorageData(vec![1]))),
 			],
 		});
-		assert_eq!(executor::block_on(result).unwrap(), expected);
+		assert_eq!(result.await.unwrap(), expected);

 		// Query changes up to block2.
 		let result = api.query_storage(keys.clone(), genesis_hash, Some(block2_hash));

-		assert_eq!(executor::block_on(result).unwrap(), expected);
+		assert_eq!(result.await.unwrap(), expected);

 		// Inverted range.
 		let result = api.query_storage(keys.clone(), block1_hash, Some(genesis_hash));

 		assert_eq!(
-			executor::block_on(result).map_err(|e| e.to_string()),
-			Err(Error::InvalidBlockRange {
-				from: format!("1 ({:?})", block1_hash),
-				to: format!("0 ({:?})", genesis_hash),
-				details: "from number > to number".to_owned(),
-			})
+			result.await.map_err(|e| e.to_string()),
+			Err(RpcError::Call(RpcCallError::Custom(ErrorObject::owned(
+				4001,
+				Error::InvalidBlockRange {
+					from: format!("1 ({:?})", block1_hash),
+					to: format!("0 ({:?})", genesis_hash),
+					details: "from number > to number".to_owned(),
+				}
+				.to_string(),
+				None::<()>,
+			))))
 			.map_err(|e| e.to_string())
 		);

@@ -433,15 +392,20 @@ fn should_query_storage() {
 		let result = api.query_storage(keys.clone(), genesis_hash, Some(random_hash1));

 		assert_eq!(
-			executor::block_on(result).map_err(|e| e.to_string()),
-			Err(Error::InvalidBlockRange {
-				from: format!("{:?}", genesis_hash),
-				to: format!("{:?}", Some(random_hash1)),
-				details: format!(
-					"UnknownBlock: Header was not found in the database: {:?}",
-					random_hash1
-				),
-			})
+			result.await.map_err(|e| e.to_string()),
+			Err(RpcError::Call(RpcCallError::Custom(ErrorObject::owned(
+				4001,
+				Error::InvalidBlockRange {
+					from: format!("{:?}", genesis_hash),
+					to: format!("{:?}", Some(random_hash1)),
+					details: format!(
+						"UnknownBlock: Header was not found in the database: {:?}",
+						random_hash1
+					),
+				}
+				.to_string(),
+				None::<()>,
+			))))
 			.map_err(|e| e.to_string())
 		);

@@ -449,15 +413,20 @@ fn should_query_storage() {
 		let result = api.query_storage(keys.clone(), random_hash1, Some(genesis_hash));

 		assert_eq!(
-			executor::block_on(result).map_err(|e| e.to_string()),
-			Err(Error::InvalidBlockRange {
-				from: format!("{:?}", random_hash1),
-				to: format!("{:?}", Some(genesis_hash)),
-				details: format!(
-					"UnknownBlock: Header was not found in the database: {:?}",
-					random_hash1
-				),
-			})
+			result.await.map_err(|e| e.to_string()),
+			Err(RpcError::Call(RpcCallError::Custom(ErrorObject::owned(
+				4001,
+				Error::InvalidBlockRange {
+					from: format!("{:?}", random_hash1),
+					to: format!("{:?}", Some(genesis_hash)),
+					details: format!(
+						"UnknownBlock: Header was not found in the database: {:?}",
+						random_hash1
+					),
+				}
+				.to_string(),
+				None::<()>,
+			))))
 			.map_err(|e| e.to_string()),
 		);

@@ -465,15 +434,20 @@ fn should_query_storage() {
 		let result = api.query_storage(keys.clone(), random_hash1, None);

 		assert_eq!(
-			executor::block_on(result).map_err(|e| e.to_string()),
-			Err(Error::InvalidBlockRange {
-				from: format!("{:?}", random_hash1),
-				to: format!("{:?}", Some(block2_hash)), // Best block hash.
-				details: format!(
-					"UnknownBlock: Header was not found in the database: {:?}",
-					random_hash1
-				),
-			})
+			result.await.map_err(|e| e.to_string()),
+			Err(RpcError::Call(RpcCallError::Custom(ErrorObject::owned(
+				4001,
+				Error::InvalidBlockRange {
+					from: format!("{:?}", random_hash1),
+					to: format!("{:?}", Some(block2_hash)), // Best block hash.
+					details: format!(
+						"UnknownBlock: Header was not found in the database: {:?}",
+						random_hash1
+					),
+				}
+				.to_string(),
+				None::<()>,
+			))))
 			.map_err(|e| e.to_string()),
 		);

@@ -481,15 +455,20 @@ fn should_query_storage() {
 		let result = api.query_storage(keys.clone(), random_hash1, Some(random_hash2));

 		assert_eq!(
-			executor::block_on(result).map_err(|e| e.to_string()),
-			Err(Error::InvalidBlockRange {
-				from: format!("{:?}", random_hash1), // First hash not found.
-				to: format!("{:?}", Some(random_hash2)),
-				details: format!(
-					"UnknownBlock: Header was not found in the database: {:?}",
-					random_hash1
-				),
-			})
+			result.await.map_err(|e| e.to_string()),
+			Err(RpcError::Call(RpcCallError::Custom(ErrorObject::owned(
+				4001,
+				Error::InvalidBlockRange {
+					from: format!("{:?}", random_hash1), // First hash not found.
+					to: format!("{:?}", Some(random_hash2)),
+					details: format!(
+						"UnknownBlock: Header was not found in the database: {:?}",
+						random_hash1
+					),
+				}
+				.to_string(),
+				None::<()>
+			))))
 			.map_err(|e| e.to_string()),
 		);

@@ -497,7 +476,7 @@ fn should_query_storage() {
 		let result = api.query_storage_at(keys.clone(), Some(block1_hash));

 		assert_eq!(
-			executor::block_on(result).unwrap(),
+			result.await.unwrap(),
 			vec![StorageChangeSet {
 				block: block1_hash,
 				changes: vec![
@@ -511,19 +490,14 @@ fn should_query_storage() {
 		);
 	}

-	run_tests(Arc::new(substrate_test_runtime_client::new()));
-	run_tests(Arc::new(TestClientBuilder::new().build()));
+	run_tests(Arc::new(substrate_test_runtime_client::new())).await;
+	run_tests(Arc::new(TestClientBuilder::new().build())).await;
 }

-#[test]
-fn should_return_runtime_version() {
+#[tokio::test]
+async fn should_return_runtime_version() {
 	let client = Arc::new(substrate_test_runtime_client::new());
-	let (api, _child) = new_full(
-		client.clone(),
-		SubscriptionManager::new(Arc::new(TaskExecutor)),
-		DenyUnsafe::No,
-		None,
-	);
+	let (api, _child) = new_full(client.clone(), test_executor(), DenyUnsafe::No, None);

 	let result = "{\"specName\":\"test\",\"implName\":\"parity-test\",\"authoringVersion\":1,\
 		\"specVersion\":2,\"implVersion\":2,\"apis\":[[\"0xdf6acb689907609b\",4],\
@@ -532,7 +506,7 @@ fn should_return_runtime_version() {
 		[\"0xf78b278be53f454c\",2],[\"0xab3c0572291feb8b\",1],[\"0xbc9d89904f5b923f\",1]],\
 		\"transactionVersion\":1,\"stateVersion\":1}";

-	let runtime_version = executor::block_on(api.runtime_version(None.into())).unwrap();
+	let runtime_version = api.runtime_version(None.into()).await.unwrap();
 	let serialized = serde_json::to_string(&runtime_version).unwrap();
 	assert_eq!(serialized, result);

@@ -540,28 +514,26 @@ fn should_return_runtime_version() {
 	assert_eq!(deserialized, runtime_version);
 }

-#[test]
-fn should_notify_on_runtime_version_initially() {
-	let (subscriber, id, mut transport) = Subscriber::new_test("test");
-
-	{
+#[tokio::test]
+async fn should_notify_on_runtime_version_initially() {
+	let mut sub = {
 		let client = Arc::new(substrate_test_runtime_client::new());
-		let (api, _child) = new_full(
-			client.clone(),
-			SubscriptionManager::new(Arc::new(TaskExecutor)),
-			DenyUnsafe::No,
-			None,
-		);
+		let (api, _child) = new_full(client, test_executor(), DenyUnsafe::No, None);

-		api.subscribe_runtime_version(Default::default(), subscriber);
+		let api_rpc = api.into_rpc();
+		let sub = api_rpc
+			.subscribe("state_subscribeRuntimeVersion", EmptyParams::new())
+			.await
+			.unwrap();

-		// assert id assigned
-		assert!(matches!(executor::block_on(id), Ok(Ok(SubscriptionId::String(_)))));
-	}
+		sub
+	};

 	// assert initial version sent.
-	executor::block_on((&mut transport).take(1).collect::<Vec<_>>());
-	assert!(executor::block_on(transport.next()).is_none());
+	assert_matches!(timeout_secs(10, sub.next::<RuntimeVersion>()).await, Ok(Some(_)));
+
+	sub.close();
+	assert_matches!(timeout_secs(10, sub.next::<RuntimeVersion>()).await, Ok(None));
 }

 #[test]
@@ -572,38 +544,24 @@ fn should_deserialize_storage_key() {
 	assert_eq!(k.0.len(), 32);
 }

-#[test]
-fn wildcard_storage_subscriptions_are_rpc_unsafe() {
-	let (subscriber, id, _) = Subscriber::new_test("test");
-
+#[tokio::test]
+async fn wildcard_storage_subscriptions_are_rpc_unsafe() {
 	let client = Arc::new(substrate_test_runtime_client::new());
-	let (api, _child) = new_full(
-		client.clone(),
-		SubscriptionManager::new(Arc::new(TaskExecutor)),
-		DenyUnsafe::Yes,
-		None,
-	);
+	let (api, _child) = new_full(client, test_executor(), DenyUnsafe::Yes, None);

-	api.subscribe_storage(Default::default(), subscriber, None.into());
-
-	let error = executor::block_on(id).unwrap().unwrap_err();
-	assert_eq!(error.to_string(), "Method not found: RPC call is unsafe to be called externally");
+	let api_rpc = api.into_rpc();
+	let err = api_rpc.subscribe("state_subscribeStorage", EmptyParams::new()).await;
+	assert_matches!(err, Err(RpcError::Call(RpcCallError::Custom(e))) if e.message() == "RPC call is unsafe to be called externally");
 }

-#[test]
-fn concrete_storage_subscriptions_are_rpc_safe() {
-	let (subscriber, id, _) = Subscriber::new_test("test");
-
+#[tokio::test]
+async fn concrete_storage_subscriptions_are_rpc_safe() {
 	let client = Arc::new(substrate_test_runtime_client::new());
-	let (api, _child) = new_full(
-		client.clone(),
-		SubscriptionManager::new(Arc::new(TaskExecutor)),
-		DenyUnsafe::Yes,
-		None,
-	);
+	let (api, _child) = new_full(client, test_executor(), DenyUnsafe::Yes, None);
+	let api_rpc = api.into_rpc();

 	let key = StorageKey(STORAGE_KEY.to_vec());
-	api.subscribe_storage(Default::default(), subscriber, Some(vec![key]));
+	let sub = api_rpc.subscribe("state_subscribeStorage", [[key]]).await;

-	assert!(matches!(executor::block_on(id), Ok(Ok(SubscriptionId::String(_)))));
+	assert!(sub.is_ok());
 }
@@ -18,31 +18,24 @@

 //! Substrate system API.

-use self::error::Result;
-use futures::{channel::oneshot, FutureExt};
-use sc_rpc_api::{DenyUnsafe, Receiver};
+#[cfg(test)]
+mod tests;
+
+use futures::channel::oneshot;
+use jsonrpsee::{
+	core::{async_trait, error::Error as JsonRpseeError, JsonValue, RpcResult},
+	types::error::{CallError, ErrorCode, ErrorObject},
+};
+use sc_rpc_api::DenyUnsafe;
 use sc_tracing::logging;
 use sc_utils::mpsc::TracingUnboundedSender;
 use sp_runtime::traits::{self, Header as HeaderT};

-pub use self::{
-	gen_client::Client as SystemClient,
-	helpers::{Health, NodeRole, PeerInfo, SyncState, SystemInfo},
-};
+use self::error::Result;
+
+pub use self::helpers::{Health, NodeRole, PeerInfo, SyncState, SystemInfo};
 pub use sc_rpc_api::system::*;

-#[cfg(test)]
-mod tests;
-
-/// Early exit for RPCs that require `--rpc-methods=Unsafe` to be enabled
-macro_rules! bail_if_unsafe {
-	($value: expr) => {
-		if let Err(err) = $value.check_if_safe() {
-			return async move { Err(err.into()) }.boxed()
-		}
-	};
-}
-
 /// System API implementation
 pub struct System<B: traits::Block> {
 	info: SystemInfo,
@@ -62,7 +55,7 @@ pub enum Request<B: traits::Block> {
 	/// Must return information about the peers we are connected to.
 	Peers(oneshot::Sender<Vec<PeerInfo<B::Hash, <B::Header as HeaderT>::Number>>>),
 	/// Must return the state of the network.
-	NetworkState(oneshot::Sender<rpc::Value>),
+	NetworkState(oneshot::Sender<serde_json::Value>),
 	/// Must return any potential parse error.
 	NetworkAddReservedPeer(String, oneshot::Sender<Result<()>>),
 	/// Must return any potential parse error.
@@ -89,121 +82,123 @@ impl<B: traits::Block> System<B> {
 	}
 }

-impl<B: traits::Block> SystemApi<B::Hash, <B::Header as HeaderT>::Number> for System<B> {
-	fn system_name(&self) -> Result<String> {
+#[async_trait]
+impl<B: traits::Block> SystemApiServer<B::Hash, <B::Header as HeaderT>::Number> for System<B> {
+	fn system_name(&self) -> RpcResult<String> {
 		Ok(self.info.impl_name.clone())
 	}

-	fn system_version(&self) -> Result<String> {
+	fn system_version(&self) -> RpcResult<String> {
 		Ok(self.info.impl_version.clone())
 	}

-	fn system_chain(&self) -> Result<String> {
+	fn system_chain(&self) -> RpcResult<String> {
 		Ok(self.info.chain_name.clone())
 	}

-	fn system_type(&self) -> Result<sc_chain_spec::ChainType> {
+	fn system_type(&self) -> RpcResult<sc_chain_spec::ChainType> {
 		Ok(self.info.chain_type.clone())
 	}

-	fn system_properties(&self) -> Result<sc_chain_spec::Properties> {
+	fn system_properties(&self) -> RpcResult<sc_chain_spec::Properties> {
 		Ok(self.info.properties.clone())
 	}

-	fn system_health(&self) -> Receiver<Health> {
+	async fn system_health(&self) -> RpcResult<Health> {
 		let (tx, rx) = oneshot::channel();
 		let _ = self.send_back.unbounded_send(Request::Health(tx));
-		Receiver(rx)
+		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
 	}

-	fn system_local_peer_id(&self) -> Receiver<String> {
+	async fn system_local_peer_id(&self) -> RpcResult<String> {
 		let (tx, rx) = oneshot::channel();
 		let _ = self.send_back.unbounded_send(Request::LocalPeerId(tx));
-		Receiver(rx)
+		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
 	}

-	fn system_local_listen_addresses(&self) -> Receiver<Vec<String>> {
+	async fn system_local_listen_addresses(&self) -> RpcResult<Vec<String>> {
 		let (tx, rx) = oneshot::channel();
 		let _ = self.send_back.unbounded_send(Request::LocalListenAddresses(tx));
-		Receiver(rx)
+		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
 	}

-	fn system_peers(
+	async fn system_peers(
 		&self,
-	) -> rpc::BoxFuture<rpc::Result<Vec<PeerInfo<B::Hash, <B::Header as HeaderT>::Number>>>> {
-		bail_if_unsafe!(self.deny_unsafe);
-
+	) -> RpcResult<Vec<PeerInfo<B::Hash, <B::Header as HeaderT>::Number>>> {
+		self.deny_unsafe.check_if_safe()?;
 		let (tx, rx) = oneshot::channel();
 		let _ = self.send_back.unbounded_send(Request::Peers(tx));
-
-		async move { rx.await.map_err(|_| rpc::Error::internal_error()) }.boxed()
+		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
 	}

-	fn system_network_state(&self) -> rpc::BoxFuture<rpc::Result<rpc::Value>> {
-		bail_if_unsafe!(self.deny_unsafe);
-
+	async fn system_network_state(&self) -> RpcResult<JsonValue> {
+		self.deny_unsafe.check_if_safe()?;
 		let (tx, rx) = oneshot::channel();
 		let _ = self.send_back.unbounded_send(Request::NetworkState(tx));
-
-		async move { rx.await.map_err(|_| rpc::Error::internal_error()) }.boxed()
+		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
 	}

-	fn system_add_reserved_peer(&self, peer: String) -> rpc::BoxFuture<rpc::Result<()>> {
-		bail_if_unsafe!(self.deny_unsafe);
-
+	async fn system_add_reserved_peer(&self, peer: String) -> RpcResult<()> {
+		self.deny_unsafe.check_if_safe()?;
 		let (tx, rx) = oneshot::channel();
 		let _ = self.send_back.unbounded_send(Request::NetworkAddReservedPeer(peer, tx));
-		async move {
-			match rx.await {
-				Ok(Ok(())) => Ok(()),
-				Ok(Err(e)) => Err(rpc::Error::from(e)),
-				Err(_) => Err(rpc::Error::internal_error()),
-			}
+		match rx.await {
+			Ok(Ok(())) => Ok(()),
+			Ok(Err(e)) => Err(JsonRpseeError::from(e)),
+			Err(e) => Err(JsonRpseeError::to_call_error(e)),
 		}
-		.boxed()
 	}

-	fn system_remove_reserved_peer(&self, peer: String) -> rpc::BoxFuture<rpc::Result<()>> {
-		bail_if_unsafe!(self.deny_unsafe);
-
+	async fn system_remove_reserved_peer(&self, peer: String) -> RpcResult<()> {
+		self.deny_unsafe.check_if_safe()?;
 		let (tx, rx) = oneshot::channel();
 		let _ = self.send_back.unbounded_send(Request::NetworkRemoveReservedPeer(peer, tx));
-		async move {
-			match rx.await {
-				Ok(Ok(())) => Ok(()),
-				Ok(Err(e)) => Err(rpc::Error::from(e)),
-				Err(_) => Err(rpc::Error::internal_error()),
-			}
+		match rx.await {
+			Ok(Ok(())) => Ok(()),
+			Ok(Err(e)) => Err(JsonRpseeError::from(e)),
+			Err(e) => Err(JsonRpseeError::to_call_error(e)),
 		}
-		.boxed()
 	}

-	fn system_reserved_peers(&self) -> Receiver<Vec<String>> {
+	async fn system_reserved_peers(&self) -> RpcResult<Vec<String>> {
 		let (tx, rx) = oneshot::channel();
 		let _ = self.send_back.unbounded_send(Request::NetworkReservedPeers(tx));
-		Receiver(rx)
+		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
 	}

-	fn system_node_roles(&self) -> Receiver<Vec<NodeRole>> {
+	async fn system_node_roles(&self) -> RpcResult<Vec<NodeRole>> {
 		let (tx, rx) = oneshot::channel();
 		let _ = self.send_back.unbounded_send(Request::NodeRoles(tx));
-		Receiver(rx)
+		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
 	}

-	fn system_sync_state(&self) -> Receiver<SyncState<<B::Header as HeaderT>::Number>> {
+	async fn system_sync_state(&self) -> RpcResult<SyncState<<B::Header as HeaderT>::Number>> {
 		let (tx, rx) = oneshot::channel();
 		let _ = self.send_back.unbounded_send(Request::SyncState(tx));
-		Receiver(rx)
+		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
 	}

-	fn system_add_log_filter(&self, directives: String) -> rpc::Result<()> {
+	fn system_add_log_filter(&self, directives: String) -> RpcResult<()> {
 		self.deny_unsafe.check_if_safe()?;
+
 		logging::add_directives(&directives);
-		logging::reload_filter().map_err(|_e| rpc::Error::internal_error())
+		logging::reload_filter().map_err(|e| {
+			JsonRpseeError::Call(CallError::Custom(ErrorObject::owned(
+				ErrorCode::InternalError.code(),
+				e,
+				None::<()>,
+			)))
+		})
 	}

-	fn system_reset_log_filter(&self) -> rpc::Result<()> {
+	fn system_reset_log_filter(&self) -> RpcResult<()> {
 		self.deny_unsafe.check_if_safe()?;
-		logging::reset_log_filter().map_err(|_e| rpc::Error::internal_error())
+		logging::reset_log_filter().map_err(|e| {
+			JsonRpseeError::Call(CallError::Custom(ErrorObject::owned(
+				ErrorCode::InternalError.code(),
+				e,
+				None::<()>,
+			)))
+		})
 	}
 }
@@ -16,12 +16,18 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.

-use super::*;
-
+use super::{helpers::SyncState, *};
 use assert_matches::assert_matches;
-use futures::{executor, prelude::*};
+use futures::prelude::*;
+use jsonrpsee::{
+	core::Error as RpcError,
+	types::{error::CallError, EmptyParams},
+	RpcModule,
+};
 use sc_network::{self, config::Role, PeerId};
+use sc_rpc_api::system::helpers::PeerInfo;
 use sc_utils::mpsc::tracing_unbounded;
+use sp_core::H256;
 use std::{
 	env,
 	io::{BufRead, BufReader, Write},
@@ -43,7 +49,7 @@ impl Default for Status {
 	}
 }

-fn api<T: Into<Option<Status>>>(sync: T) -> System<Block> {
+fn api<T: Into<Option<Status>>>(sync: T) -> RpcModule<System<Block>> {
 	let status = sync.into().unwrap_or_default();
 	let should_have_peers = !status.is_dev;
 	let (tx, rx) = tracing_unbounded("rpc_system_tests");
@@ -136,98 +142,122 @@ fn api<T: Into<Option<Status>>>(sync: T) -> System<Block> {
 		tx,
 		sc_rpc_api::DenyUnsafe::No,
 	)
+	.into_rpc()
 }

-fn wait_receiver<T>(rx: Receiver<T>) -> T {
-	futures::executor::block_on(rx).unwrap()
-}
-
-#[test]
-fn system_name_works() {
-	assert_eq!(api(None).system_name().unwrap(), "testclient".to_owned());
-}
-
-#[test]
-fn system_version_works() {
-	assert_eq!(api(None).system_version().unwrap(), "0.2.0".to_owned());
-}
-
-#[test]
-fn system_chain_works() {
-	assert_eq!(api(None).system_chain().unwrap(), "testchain".to_owned());
-}
-
-#[test]
-fn system_properties_works() {
-	assert_eq!(api(None).system_properties().unwrap(), serde_json::map::Map::new());
-}
-
-#[test]
-fn system_type_works() {
-	assert_eq!(api(None).system_type().unwrap(), Default::default());
-}
-
-#[test]
-fn system_health() {
-	assert_matches!(
-		wait_receiver(api(None).system_health()),
-		Health { peers: 0, is_syncing: false, should_have_peers: true }
+#[tokio::test]
+async fn system_name_works() {
+	assert_eq!(
+		api(None).call::<_, String>("system_name", EmptyParams::new()).await.unwrap(),
+		"testclient".to_string(),
 	);
+}

-	assert_matches!(
-		wait_receiver(
-			api(Status { peer_id: PeerId::random(), peers: 5, is_syncing: true, is_dev: true })
-				.system_health()
-		),
-		Health { peers: 5, is_syncing: true, should_have_peers: false }
+#[tokio::test]
+async fn system_version_works() {
+	assert_eq!(
+		api(None).call::<_, String>("system_version", EmptyParams::new()).await.unwrap(),
+		"0.2.0".to_string(),
+	);
+}
+
+#[tokio::test]
+async fn system_chain_works() {
+	assert_eq!(
+		api(None).call::<_, String>("system_chain", EmptyParams::new()).await.unwrap(),
+		"testchain".to_string(),
+	);
+}
+
+#[tokio::test]
+async fn system_properties_works() {
+	type Map = serde_json::map::Map<String, serde_json::Value>;
+
+	assert_eq!(
+		api(None).call::<_, Map>("system_properties", EmptyParams::new()).await.unwrap(),
+		Map::new()
+	);
+}
+
+#[tokio::test]
+async fn system_type_works() {
+	assert_eq!(
+		api(None)
+			.call::<_, String>("system_chainType", EmptyParams::new())
+			.await
+			.unwrap(),
+		"Live".to_owned(),
+	);
+}
+
+#[tokio::test]
+async fn system_health() {
+	assert_eq!(
+		api(None).call::<_, Health>("system_health", EmptyParams::new()).await.unwrap(),
+		Health { peers: 0, is_syncing: false, should_have_peers: true },
 	);

 	assert_eq!(
-		wait_receiver(
-			api(Status { peer_id: PeerId::random(), peers: 5, is_syncing: false, is_dev: false })
-				.system_health()
-		),
-		Health { peers: 5, is_syncing: false, should_have_peers: true }
+		api(Status { peer_id: PeerId::random(), peers: 5, is_syncing: true, is_dev: true })
+			.call::<_, Health>("system_health", EmptyParams::new())
+			.await
+			.unwrap(),
+		Health { peers: 5, is_syncing: true, should_have_peers: false },
 	);

 	assert_eq!(
-		wait_receiver(
-			api(Status { peer_id: PeerId::random(), peers: 0, is_syncing: false, is_dev: true })
-				.system_health()
-		),
-		Health { peers: 0, is_syncing: false, should_have_peers: false }
+		api(Status { peer_id: PeerId::random(), peers: 5, is_syncing: false, is_dev: false })
+			.call::<_, Health>("system_health", EmptyParams::new())
+			.await
+			.unwrap(),
+		Health { peers: 5, is_syncing: false, should_have_peers: true },
+	);
+
+	assert_eq!(
+		api(Status { peer_id: PeerId::random(), peers: 0, is_syncing: false, is_dev: true })
+			.call::<_, Health>("system_health", EmptyParams::new())
+			.await
+			.unwrap(),
+		Health { peers: 0, is_syncing: false, should_have_peers: false },
 	);
 }

-#[test]
-fn system_local_peer_id_works() {
+#[tokio::test]
+async fn system_local_peer_id_works() {
 	assert_eq!(
-		wait_receiver(api(None).system_local_peer_id()),
-		"QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".to_owned(),
+		api(None)
+			.call::<_, String>("system_localPeerId", EmptyParams::new())
+			.await
+			.unwrap(),
+		"QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".to_owned()
 	);
 }

-#[test]
-fn system_local_listen_addresses_works() {
+#[tokio::test]
+async fn system_local_listen_addresses_works() {
 	assert_eq!(
-		wait_receiver(api(None).system_local_listen_addresses()),
+		api(None)
+			.call::<_, Vec<String>>("system_localListenAddresses", EmptyParams::new())
+			.await
+			.unwrap(),
 		vec![
-			"/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV"
-				.to_string(),
+			"/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV",
 			"/ip4/127.0.0.1/tcp/30334/ws/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV"
-				.to_string(),
 		]
 	);
 }

-#[test]
-fn system_peers() {
+#[tokio::test]
+async fn system_peers() {
 	let peer_id = PeerId::random();
-	let req = api(Status { peer_id, peers: 1, is_syncing: false, is_dev: true }).system_peers();
-	let res = executor::block_on(req).unwrap();
+	let peer_info: Vec<PeerInfo<H256, u64>> =
+		api(Status { peer_id, peers: 1, is_syncing: false, is_dev: true })
+			.call("system_peers", EmptyParams::new())
+			.await
+			.unwrap();

 	assert_eq!(
-		res,
+		peer_info,
 		vec![PeerInfo {
 			peer_id: peer_id.to_base58(),
 			roles: "FULL".into(),
@@ -237,14 +267,16 @@ fn system_peers() {
 	);
 }

-#[test]
-fn system_network_state() {
-	let req = api(None).system_network_state();
-	let res = executor::block_on(req).unwrap();
-
+#[tokio::test]
+async fn system_network_state() {
+	use sc_network::network_state::NetworkState;
+	let network_state: NetworkState = api(None)
+		.call("system_unstable_networkState", EmptyParams::new())
+		.await
+		.unwrap();
 	assert_eq!(
-		serde_json::from_value::<sc_network::network_state::NetworkState>(res).unwrap(),
-		sc_network::network_state::NetworkState {
+		network_state,
+		NetworkState {
 			peer_id: String::new(),
 			listened_addresses: Default::default(),
 			external_addresses: Default::default(),
@@ -255,51 +287,60 @@ fn system_network_state() {
 	);
 }

-#[test]
-fn system_node_roles() {
-	assert_eq!(wait_receiver(api(None).system_node_roles()), vec![NodeRole::Authority]);
+#[tokio::test]
+async fn system_node_roles() {
+	let node_roles: Vec<NodeRole> =
+		api(None).call("system_nodeRoles", EmptyParams::new()).await.unwrap();
+	assert_eq!(node_roles, vec![NodeRole::Authority]);
 }
-
-#[test]
-fn system_sync_state() {
+#[tokio::test]
+async fn system_sync_state() {
+	let sync_state: SyncState<i32> =
+		api(None).call("system_syncState", EmptyParams::new()).await.unwrap();
 	assert_eq!(
-		wait_receiver(api(None).system_sync_state()),
+		sync_state,
 		SyncState { starting_block: 1, current_block: 2, highest_block: Some(3) }
 	);
 }

-#[test]
-fn system_network_add_reserved() {
+#[tokio::test]
+async fn system_network_add_reserved() {
 	let good_peer_id =
-		"/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV";
-	let bad_peer_id = "/ip4/198.51.100.19/tcp/30333";
+		["/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV"];
+	let _good: () = api(None)
+		.call("system_addReservedPeer", good_peer_id)
+		.await
+		.expect("good peer id works");

-	let good_fut = api(None).system_add_reserved_peer(good_peer_id.into());
-	let bad_fut = api(None).system_add_reserved_peer(bad_peer_id.into());
-	assert_eq!(executor::block_on(good_fut), Ok(()));
-	assert!(executor::block_on(bad_fut).is_err());
-}
-
-#[test]
-fn system_network_remove_reserved() {
-	let good_peer_id = "QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV";
-	let bad_peer_id =
-		"/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV";
-
-	let good_fut = api(None).system_remove_reserved_peer(good_peer_id.into());
-	let bad_fut = api(None).system_remove_reserved_peer(bad_peer_id.into());
-	assert_eq!(executor::block_on(good_fut), Ok(()));
-	assert!(executor::block_on(bad_fut).is_err());
-}
-
-#[test]
-fn system_network_reserved_peers() {
-	assert_eq!(
-		wait_receiver(api(None).system_reserved_peers()),
-		vec!["QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".to_string()]
+	let bad_peer_id = ["/ip4/198.51.100.19/tcp/30333"];
+	assert_matches!(
+		api(None).call::<_, ()>("system_addReservedPeer", bad_peer_id).await,
+		Err(RpcError::Call(CallError::Custom(err))) if err.message().contains("Peer id is missing from the address")
 	);
 }

+#[tokio::test]
+async fn system_network_remove_reserved() {
+	let _good_peer: () = api(None)
+		.call("system_removeReservedPeer", ["QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV"])
+		.await
+		.expect("call with good peer id works");
+
+	let bad_peer_id =
+		["/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV"];
+
+	assert_matches!(
+		api(None).call::<_, String>("system_removeReservedPeer", bad_peer_id).await,
+		Err(RpcError::Call(CallError::Custom(err))) if err.message().contains("base-58 decode error: provided string contained invalid character '/' at byte 0")
+	);
+}
+#[tokio::test]
+async fn system_network_reserved_peers() {
+	let reserved_peers: Vec<String> =
+		api(None).call("system_reservedPeers", EmptyParams::new()).await.unwrap();
+	assert_eq!(reserved_peers, vec!["QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".to_string()],);
+}
+
 #[test]
 fn test_add_reset_log_filter() {
 	const EXPECTED_BEFORE_ADD: &'static str = "EXPECTED_BEFORE_ADD";
@@ -315,15 +356,20 @@ fn test_add_reset_log_filter() {
 		for line in std::io::stdin().lock().lines() {
 			let line = line.expect("Failed to read bytes");
 			if line.contains("add_reload") {
-				api(None)
-					.system_add_log_filter("test_after_add".into())
-					.expect("`system_add_log_filter` failed");
+				let filter = "test_after_add";
+				let fut =
+					async move { api(None).call::<_, ()>("system_addLogFilter", [filter]).await };
+				futures::executor::block_on(fut).expect("`system_addLogFilter` failed");
 			} else if line.contains("add_trace") {
-				api(None)
-					.system_add_log_filter("test_before_add=trace".into())
-					.expect("`system_add_log_filter` failed");
+				let filter = "test_before_add=trace";
+				let fut =
+					async move { api(None).call::<_, ()>("system_addLogFilter", [filter]).await };
+				futures::executor::block_on(fut).expect("`system_addLogFilter (trace)` failed");
 			} else if line.contains("reset") {
-				api(None).system_reset_log_filter().expect("`system_reset_log_filter` failed");
+				let fut = async move {
+					api(None).call::<_, ()>("system_resetLogFilter", EmptyParams::new()).await
+				};
+				futures::executor::block_on(fut).expect("`system_resetLogFilter` failed");
 			} else if line.contains("exit") {
 				return
 			}
@@ -18,29 +18,16 @@

 //! Testing utils used by the RPC tests.

-use futures::{
-	executor,
-	task::{FutureObj, Spawn, SpawnError},
-};
+use std::{future::Future, sync::Arc};

-// Executor shared by all tests.
-//
-// This shared executor is used to prevent `Too many open files` errors
-// on systems with a lot of cores.
-lazy_static::lazy_static! {
-	static ref EXECUTOR: executor::ThreadPool = executor::ThreadPool::new()
-		.expect("Failed to create thread pool executor for tests");
+use sp_core::testing::TaskExecutor;
+
+/// Executor for testing.
+pub fn test_executor() -> Arc<sp_core::testing::TaskExecutor> {
+	Arc::new(TaskExecutor::default())
 }

-/// Executor for use in testing
-pub struct TaskExecutor;
-impl Spawn for TaskExecutor {
-	fn spawn_obj(&self, future: FutureObj<'static, ()>) -> Result<(), SpawnError> {
-		EXECUTOR.spawn_ok(future);
-		Ok(())
-	}
-
-	fn status(&self) -> Result<(), SpawnError> {
-		Ok(())
-	}
+/// Wrap a future in a timeout a little more concisely
+pub fn timeout_secs<I, F: Future<Output = I>>(s: u64, f: F) -> tokio::time::Timeout<F> {
+	tokio::time::timeout(std::time::Duration::from_secs(s), f)
 }