jsonrpsee integration (#8783)

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