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-05-31 20:21:03 +00:00 · 2022-05-10 10:52:19 +02:00
parent e45d53552d
commit 29c0c6a4a8
93 changed files with 3813 additions and 5094 deletions
@@ -12,10 +12,7 @@ homepage = "https://substrate.io"
 [dependencies]
 finality-grandpa = { version = "0.15.0", features = ["derive-codec"] }
 futures = "0.3.16"
-jsonrpc-core = "18.0.0"
-jsonrpc-core-client = "18.0.0"
-jsonrpc-derive = "18.0.0"
-jsonrpc-pubsub = "18.0.0"
+jsonrpsee = { version = "0.12.0", features = ["server", "macros"] }
 log = "0.4.8"
 parity-scale-codec = { version = "3.0.0", features = ["derive"] }
 serde = { version = "1.0.105", features = ["derive"] }
@@ -37,3 +34,4 @@ sp-core = { version = "6.0.0", path = "../../../primitives/core" }
 sp-finality-grandpa = { version = "4.0.0-dev", path = "../../../primitives/finality-grandpa" }
 sp-keyring = { version = "6.0.0", path = "../../../primitives/keyring" }
 substrate-test-runtime-client = { version = "2.0.0", path = "../../../test-utils/runtime/client" }
+tokio = { version = "1.17.0", features = ["macros"] }
@@ -16,6 +16,11 @@
 // 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 jsonrpsee::{
+	core::Error as JsonRpseeError,
+	types::error::{CallError, ErrorObject},
+};
+
 #[derive(Debug, thiserror::Error)]
 /// Top-level error type for the RPC handler
 pub enum Error {
@@ -56,15 +61,15 @@ impl From<Error> for ErrorCode {
 	}
 }

-impl From<Error> for jsonrpc_core::Error {
+impl From<Error> for JsonRpseeError {
 	fn from(error: Error) -> Self {
-		let message = format!("{}", error);
+		let message = error.to_string();
 		let code = ErrorCode::from(error);
-		jsonrpc_core::Error {
+		JsonRpseeError::Call(CallError::Custom(ErrorObject::owned(
+			code as i32,
 			message,
-			code: jsonrpc_core::ErrorCode::ServerError(code as i64),
-			data: None,
-		}
+			None::<()>,
+		)))
 	}
 }

@@ -19,167 +19,137 @@
 //! RPC API for GRANDPA.
 #![warn(missing_docs)]

-use futures::{task::Spawn, FutureExt, SinkExt, StreamExt, TryFutureExt};
-use jsonrpc_derive::rpc;
-use jsonrpc_pubsub::{manager::SubscriptionManager, typed::Subscriber, SubscriptionId};
+use futures::{FutureExt, StreamExt};
 use log::warn;
 use std::sync::Arc;

+use jsonrpsee::{
+	core::{async_trait, RpcResult},
+	proc_macros::rpc,
+	PendingSubscription,
+};
+
 mod error;
 mod finality;
 mod notification;
 mod report;

 use sc_finality_grandpa::GrandpaJustificationStream;
+use sc_rpc::SubscriptionTaskExecutor;
 use sp_runtime::traits::{Block as BlockT, NumberFor};

 use finality::{EncodedFinalityProof, RpcFinalityProofProvider};
 use notification::JustificationNotification;
 use report::{ReportAuthoritySet, ReportVoterState, ReportedRoundStates};

-type FutureResult<T> = jsonrpc_core::BoxFuture<Result<T, jsonrpc_core::Error>>;
-
 /// Provides RPC methods for interacting with GRANDPA.
-#[rpc]
+#[rpc(client, server)]
 pub trait GrandpaApi<Notification, Hash, Number> {
-	/// RPC Metadata
-	type Metadata;
-
 	/// Returns the state of the current best round state as well as the
 	/// ongoing background rounds.
-	#[rpc(name = "grandpa_roundState")]
-	fn round_state(&self) -> FutureResult<ReportedRoundStates>;
+	#[method(name = "grandpa_roundState")]
+	async fn round_state(&self) -> RpcResult<ReportedRoundStates>;

 	/// Returns the block most recently finalized by Grandpa, alongside
 	/// side its justification.
-	#[pubsub(
-		subscription = "grandpa_justifications",
-		subscribe,
-		name = "grandpa_subscribeJustifications"
+	#[subscription(
+		name = "grandpa_subscribeJustifications" => "grandpa_justifications",
+		unsubscribe = "grandpa_unsubscribeJustifications",
+		item = Notification
 	)]
-	fn subscribe_justifications(
-		&self,
-		metadata: Self::Metadata,
-		subscriber: Subscriber<Notification>,
-	);
-
-	/// Unsubscribe from receiving notifications about recently finalized blocks.
-	#[pubsub(
-		subscription = "grandpa_justifications",
-		unsubscribe,
-		name = "grandpa_unsubscribeJustifications"
-	)]
-	fn unsubscribe_justifications(
-		&self,
-		metadata: Option<Self::Metadata>,
-		id: SubscriptionId,
-	) -> jsonrpc_core::Result<bool>;
+	fn subscribe_justifications(&self);

 	/// Prove finality for the given block number by returning the Justification for the last block
 	/// in the set and all the intermediary headers to link them together.
-	#[rpc(name = "grandpa_proveFinality")]
-	fn prove_finality(&self, block: Number) -> FutureResult<Option<EncodedFinalityProof>>;
+	#[method(name = "grandpa_proveFinality")]
+	async fn prove_finality(&self, block: Number) -> RpcResult<Option<EncodedFinalityProof>>;
 }

-/// Implements the GrandpaApi RPC trait for interacting with GRANDPA.
-pub struct GrandpaRpcHandler<AuthoritySet, VoterState, Block: BlockT, ProofProvider> {
+/// Provides RPC methods for interacting with GRANDPA.
+pub struct GrandpaRpc<AuthoritySet, VoterState, Block: BlockT, ProofProvider> {
+	executor: SubscriptionTaskExecutor,
 	authority_set: AuthoritySet,
 	voter_state: VoterState,
 	justification_stream: GrandpaJustificationStream<Block>,
-	manager: SubscriptionManager,
 	finality_proof_provider: Arc<ProofProvider>,
 }
-
 impl<AuthoritySet, VoterState, Block: BlockT, ProofProvider>
-	GrandpaRpcHandler<AuthoritySet, VoterState, Block, ProofProvider>
+	GrandpaRpc<AuthoritySet, VoterState, Block, ProofProvider>
 {
-	/// Creates a new GrandpaRpcHandler instance.
-	pub fn new<E>(
+	/// Prepare a new [`GrandpaRpc`]
+	pub fn new(
+		executor: SubscriptionTaskExecutor,
 		authority_set: AuthoritySet,
 		voter_state: VoterState,
 		justification_stream: GrandpaJustificationStream<Block>,
-		executor: E,
 		finality_proof_provider: Arc<ProofProvider>,
-	) -> Self
-	where
-		E: Spawn + Sync + Send + 'static,
-	{
-		let manager = SubscriptionManager::new(Arc::new(executor));
-		Self { authority_set, voter_state, justification_stream, manager, finality_proof_provider }
+	) -> Self {
+		Self { executor, authority_set, voter_state, justification_stream, finality_proof_provider }
 	}
 }

+#[async_trait]
 impl<AuthoritySet, VoterState, Block, ProofProvider>
-	GrandpaApi<JustificationNotification, Block::Hash, NumberFor<Block>>
-	for GrandpaRpcHandler<AuthoritySet, VoterState, Block, ProofProvider>
+	GrandpaApiServer<JustificationNotification, Block::Hash, NumberFor<Block>>
+	for GrandpaRpc<AuthoritySet, VoterState, Block, ProofProvider>
 where
 	VoterState: ReportVoterState + Send + Sync + 'static,
 	AuthoritySet: ReportAuthoritySet + Send + Sync + 'static,
 	Block: BlockT,
 	ProofProvider: RpcFinalityProofProvider<Block> + Send + Sync + 'static,
 {
-	type Metadata = sc_rpc::Metadata;
-
-	fn round_state(&self) -> FutureResult<ReportedRoundStates> {
-		let round_states = ReportedRoundStates::from(&self.authority_set, &self.voter_state);
-		let future = async move { round_states }.boxed();
-		future.map_err(jsonrpc_core::Error::from).boxed()
+	async fn round_state(&self) -> RpcResult<ReportedRoundStates> {
+		ReportedRoundStates::from(&self.authority_set, &self.voter_state).map_err(Into::into)
 	}

-	fn subscribe_justifications(
-		&self,
-		_metadata: Self::Metadata,
-		subscriber: Subscriber<JustificationNotification>,
-	) {
-		let stream = self
-			.justification_stream
-			.subscribe()
-			.map(|x| Ok(Ok::<_, jsonrpc_core::Error>(JustificationNotification::from(x))));
+	fn subscribe_justifications(&self, pending: PendingSubscription) {
+		let stream = self.justification_stream.subscribe().map(
+			|x: sc_finality_grandpa::GrandpaJustification<Block>| {
+				JustificationNotification::from(x)
+			},
+		);

-		self.manager.add(subscriber, |sink| {
-			stream
-				.forward(sink.sink_map_err(|e| warn!("Error sending notifications: {:?}", e)))
-				.map(|_| ())
-		});
+		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_justifications(
-		&self,
-		_metadata: Option<Self::Metadata>,
-		id: SubscriptionId,
-	) -> jsonrpc_core::Result<bool> {
-		Ok(self.manager.cancel(id))
-	}
-
-	fn prove_finality(
+	async fn prove_finality(
 		&self,
 		block: NumberFor<Block>,
-	) -> FutureResult<Option<EncodedFinalityProof>> {
-		let result = self.finality_proof_provider.rpc_prove_finality(block);
-		let future = async move { result }.boxed();
-		future
+	) -> RpcResult<Option<EncodedFinalityProof>> {
+		self.finality_proof_provider
+			.rpc_prove_finality(block)
 			.map_err(|e| {
 				warn!("Error proving finality: {}", e);
 				error::Error::ProveFinalityFailed(e)
 			})
-			.map_err(jsonrpc_core::Error::from)
-			.boxed()
+			.map_err(Into::into)
 	}
 }

 #[cfg(test)]
 mod tests {
 	use super::*;
-	use jsonrpc_core::{types::Params, Notification, Output};
-	use std::{collections::HashSet, sync::Arc};
+	use std::{collections::HashSet, convert::TryInto, sync::Arc};

+	use jsonrpsee::{
+		types::{EmptyParams, SubscriptionId},
+		RpcModule,
+	};
 	use parity_scale_codec::{Decode, Encode};
 	use sc_block_builder::{BlockBuilder, RecordProof};
 	use sc_finality_grandpa::{
 		report, AuthorityId, FinalityProof, GrandpaJustification, GrandpaJustificationSender,
 	};
 	use sp_blockchain::HeaderBackend;
-	use sp_core::crypto::ByteArray;
+	use sp_core::{crypto::ByteArray, testing::TaskExecutor};
 	use sp_keyring::Ed25519Keyring;
 	use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
 	use substrate_test_runtime_client::{
@@ -274,7 +244,10 @@ mod tests {

 	fn setup_io_handler<VoterState>(
 		voter_state: VoterState,
-	) -> (jsonrpc_core::MetaIoHandler<sc_rpc::Metadata>, GrandpaJustificationSender<Block>)
+	) -> (
+		RpcModule<GrandpaRpc<TestAuthoritySet, VoterState, Block, TestFinalityProofProvider>>,
+		GrandpaJustificationSender<Block>,
+	)
 	where
 		VoterState: ReportVoterState + Send + Sync + 'static,
 	{
@@ -284,120 +257,107 @@ mod tests {
 	fn setup_io_handler_with_finality_proofs<VoterState>(
 		voter_state: VoterState,
 		finality_proof: Option<FinalityProof<Header>>,
-	) -> (jsonrpc_core::MetaIoHandler<sc_rpc::Metadata>, GrandpaJustificationSender<Block>)
+	) -> (
+		RpcModule<GrandpaRpc<TestAuthoritySet, VoterState, Block, TestFinalityProofProvider>>,
+		GrandpaJustificationSender<Block>,
+	)
 	where
 		VoterState: ReportVoterState + Send + Sync + 'static,
 	{
 		let (justification_sender, justification_stream) = GrandpaJustificationStream::channel();
 		let finality_proof_provider = Arc::new(TestFinalityProofProvider { finality_proof });
+		let executor = Arc::new(TaskExecutor::default());

-		let handler = GrandpaRpcHandler::new(
+		let rpc = GrandpaRpc::new(
+			executor,
 			TestAuthoritySet,
 			voter_state,
 			justification_stream,
-			sc_rpc::testing::TaskExecutor,
 			finality_proof_provider,
-		);
+		)
+		.into_rpc();

-		let mut io = jsonrpc_core::MetaIoHandler::default();
-		io.extend_with(GrandpaApi::to_delegate(handler));
-
-		(io, justification_sender)
+		(rpc, justification_sender)
 	}

-	#[test]
-	fn uninitialized_rpc_handler() {
-		let (io, _) = setup_io_handler(EmptyVoterState);
+	#[tokio::test]
+	async fn uninitialized_rpc_handler() {
+		let (rpc, _) = setup_io_handler(EmptyVoterState);
+		let expected_response = r#"{"jsonrpc":"2.0","error":{"code":1,"message":"GRANDPA RPC endpoint not ready"},"id":0}"#.to_string();
+		let request = r#"{"jsonrpc":"2.0","method":"grandpa_roundState","params":[],"id":0}"#;
+		let (result, _) = rpc.raw_json_request(&request).await.unwrap();

-		let request = r#"{"jsonrpc":"2.0","method":"grandpa_roundState","params":[],"id":1}"#;
-		let response = r#"{"jsonrpc":"2.0","error":{"code":1,"message":"GRANDPA RPC endpoint not ready"},"id":1}"#;
-
-		let meta = sc_rpc::Metadata::default();
-		assert_eq!(Some(response.into()), io.handle_request_sync(request, meta));
+		assert_eq!(expected_response, result,);
 	}

-	#[test]
-	fn working_rpc_handler() {
-		let (io, _) = setup_io_handler(TestVoterState);
-
-		let request = r#"{"jsonrpc":"2.0","method":"grandpa_roundState","params":[],"id":1}"#;
-		let response = "{\"jsonrpc\":\"2.0\",\"result\":{\
-			\"background\":[{\
-				\"precommits\":{\"currentWeight\":100,\"missing\":[]},\
-				\"prevotes\":{\"currentWeight\":100,\"missing\":[]},\
-				\"round\":1,\"thresholdWeight\":67,\"totalWeight\":100\
-			}],\
+	#[tokio::test]
+	async fn working_rpc_handler() {
+		let (rpc, _) = setup_io_handler(TestVoterState);
+		let expected_response = "{\"jsonrpc\":\"2.0\",\"result\":{\
+			\"setId\":1,\
 			\"best\":{\
-				\"precommits\":{\"currentWeight\":0,\"missing\":[\"5C62Ck4UrFPiBtoCmeSrgF7x9yv9mn38446dhCpsi2mLHiFT\",\"5C7LYpP2ZH3tpKbvVvwiVe54AapxErdPBbvkYhe6y9ZBkqWt\"]},\
+				\"round\":2,\"totalWeight\":100,\"thresholdWeight\":67,\
 				\"prevotes\":{\"currentWeight\":50,\"missing\":[\"5C7LYpP2ZH3tpKbvVvwiVe54AapxErdPBbvkYhe6y9ZBkqWt\"]},\
-				\"round\":2,\"thresholdWeight\":67,\"totalWeight\":100\
+				\"precommits\":{\"currentWeight\":0,\"missing\":[\"5C62Ck4UrFPiBtoCmeSrgF7x9yv9mn38446dhCpsi2mLHiFT\",\"5C7LYpP2ZH3tpKbvVvwiVe54AapxErdPBbvkYhe6y9ZBkqWt\"]}\
 			},\
-			\"setId\":1\
-		},\"id\":1}";
+				\"background\":[{\
+				\"round\":1,\"totalWeight\":100,\"thresholdWeight\":67,\
+				\"prevotes\":{\"currentWeight\":100,\"missing\":[]},\
+				\"precommits\":{\"currentWeight\":100,\"missing\":[]}\
+			}]\
+		},\"id\":0}".to_string();

-		let meta = sc_rpc::Metadata::default();
-		assert_eq!(io.handle_request_sync(request, meta), Some(response.into()));
+		let request = r#"{"jsonrpc":"2.0","method":"grandpa_roundState","params":[],"id":0}"#;
+		let (result, _) = rpc.raw_json_request(&request).await.unwrap();
+		assert_eq!(expected_response, result);
 	}

-	fn setup_session() -> (sc_rpc::Metadata, futures::channel::mpsc::UnboundedReceiver<String>) {
-		let (tx, rx) = futures::channel::mpsc::unbounded();
-		let meta = sc_rpc::Metadata::new(tx);
-		(meta, rx)
-	}
+	#[tokio::test]
+	async fn subscribe_and_unsubscribe_to_justifications() {
+		let (rpc, _) = setup_io_handler(TestVoterState);
+		// Subscribe call.
+		let sub = rpc
+			.subscribe("grandpa_subscribeJustifications", EmptyParams::new())
+			.await
+			.unwrap();

-	#[test]
-	fn subscribe_and_unsubscribe_to_justifications() {
-		let (io, _) = setup_io_handler(TestVoterState);
-		let (meta, _) = setup_session();
-
-		// Subscribe
-		let sub_request =
-			r#"{"jsonrpc":"2.0","method":"grandpa_subscribeJustifications","params":[],"id":1}"#;
-		let resp = io.handle_request_sync(sub_request, meta.clone());
-		let resp: Output = serde_json::from_str(&resp.unwrap()).unwrap();
-
-		let sub_id = match resp {
-			Output::Success(success) => success.result,
-			_ => panic!(),
-		};
+		let ser_id = serde_json::to_string(sub.subscription_id()).unwrap();

 		// Unsubscribe
 		let unsub_req = format!(
 			"{{\"jsonrpc\":\"2.0\",\"method\":\"grandpa_unsubscribeJustifications\",\"params\":[{}],\"id\":1}}",
-			sub_id
-		);
-		assert_eq!(
-			io.handle_request_sync(&unsub_req, meta.clone()),
-			Some(r#"{"jsonrpc":"2.0","result":true,"id":1}"#.into()),
+			ser_id
 		);
+		let (response, _) = rpc.raw_json_request(&unsub_req).await.unwrap();
+
+		assert_eq!(response, r#"{"jsonrpc":"2.0","result":true,"id":1}"#);

 		// Unsubscribe again and fail
-		assert_eq!(
-			io.handle_request_sync(&unsub_req, meta),
-			Some("{\"jsonrpc\":\"2.0\",\"error\":{\"code\":-32602,\"message\":\"Invalid subscription id.\"},\"id\":1}".into()),
-		);
+		let (response, _) = rpc.raw_json_request(&unsub_req).await.unwrap();
+		let expected = r#"{"jsonrpc":"2.0","result":false,"id":1}"#;
+
+		assert_eq!(response, expected);
 	}

-	#[test]
-	fn subscribe_and_unsubscribe_with_wrong_id() {
-		let (io, _) = setup_io_handler(TestVoterState);
-		let (meta, _) = setup_session();
-
-		// Subscribe
-		let sub_request =
-			r#"{"jsonrpc":"2.0","method":"grandpa_subscribeJustifications","params":[],"id":1}"#;
-		let resp = io.handle_request_sync(sub_request, meta.clone());
-		let resp: Output = serde_json::from_str(&resp.unwrap()).unwrap();
-		assert!(matches!(resp, Output::Success(_)));
+	#[tokio::test]
+	async fn subscribe_and_unsubscribe_with_wrong_id() {
+		let (rpc, _) = setup_io_handler(TestVoterState);
+		// Subscribe call.
+		let _sub = rpc
+			.subscribe("grandpa_subscribeJustifications", EmptyParams::new())
+			.await
+			.unwrap();

 		// Unsubscribe with wrong ID
-		assert_eq!(
-			io.handle_request_sync(
+		let (response, _) = rpc
+			.raw_json_request(
 				r#"{"jsonrpc":"2.0","method":"grandpa_unsubscribeJustifications","params":["FOO"],"id":1}"#,
-				meta.clone()
-			),
-			Some("{\"jsonrpc\":\"2.0\",\"error\":{\"code\":-32602,\"message\":\"Invalid subscription id.\"},\"id\":1}".into())
-		);
+			)
+			.await
+			.unwrap();
+		let expected = r#"{"jsonrpc":"2.0","result":false,"id":1}"#;
+
+		assert_eq!(response, expected);
 	}

 	fn create_justification() -> GrandpaJustification<Block> {
@@ -454,60 +414,41 @@ mod tests {
 		justification
 	}

-	#[test]
-	fn subscribe_and_listen_to_one_justification() {
-		let (io, justification_sender) = setup_io_handler(TestVoterState);
-		let (meta, receiver) = setup_session();
+	#[tokio::test]
+	async fn subscribe_and_listen_to_one_justification() {
+		let (rpc, justification_sender) = setup_io_handler(TestVoterState);

-		// Subscribe
-		let sub_request =
-			r#"{"jsonrpc":"2.0","method":"grandpa_subscribeJustifications","params":[],"id":1}"#;
-
-		let resp = io.handle_request_sync(sub_request, meta.clone());
-		let mut resp: serde_json::Value = serde_json::from_str(&resp.unwrap()).unwrap();
-		let sub_id: String = serde_json::from_value(resp["result"].take()).unwrap();
+		let mut sub = rpc
+			.subscribe("grandpa_subscribeJustifications", EmptyParams::new())
+			.await
+			.unwrap();

 		// Notify with a header and justification
 		let justification = create_justification();
 		justification_sender.notify(|| Ok::<_, ()>(justification.clone())).unwrap();

 		// Inspect what we received
-		let recv = futures::executor::block_on(receiver.take(1).collect::<Vec<_>>());
-		let recv: Notification = serde_json::from_str(&recv[0]).unwrap();
-		let mut json_map = match recv.params {
-			Params::Map(json_map) => json_map,
-			_ => panic!(),
-		};
-
-		let recv_sub_id: String = serde_json::from_value(json_map["subscription"].take()).unwrap();
-		let recv_justification: sp_core::Bytes =
-			serde_json::from_value(json_map["result"].take()).unwrap();
+		let (recv_justification, recv_sub_id): (sp_core::Bytes, SubscriptionId) =
+			sub.next().await.unwrap().unwrap();
 		let recv_justification: GrandpaJustification<Block> =
 			Decode::decode(&mut &recv_justification[..]).unwrap();

-		assert_eq!(recv.method, "grandpa_justifications");
-		assert_eq!(recv_sub_id, sub_id);
+		assert_eq!(&recv_sub_id, sub.subscription_id());
 		assert_eq!(recv_justification, justification);
 	}

-	#[test]
-	fn prove_finality_with_test_finality_proof_provider() {
+	#[tokio::test]
+	async fn prove_finality_with_test_finality_proof_provider() {
 		let finality_proof = FinalityProof {
 			block: header(42).hash(),
 			justification: create_justification().encode(),
 			unknown_headers: vec![header(2)],
 		};
-		let (io, _) =
+		let (rpc, _) =
 			setup_io_handler_with_finality_proofs(TestVoterState, Some(finality_proof.clone()));

-		let request =
-			"{\"jsonrpc\":\"2.0\",\"method\":\"grandpa_proveFinality\",\"params\":[42],\"id\":1}";
-
-		let meta = sc_rpc::Metadata::default();
-		let resp = io.handle_request_sync(request, meta);
-		let mut resp: serde_json::Value = serde_json::from_str(&resp.unwrap()).unwrap();
-		let result: sp_core::Bytes = serde_json::from_value(resp["result"].take()).unwrap();
-		let finality_proof_rpc: FinalityProof<Header> = Decode::decode(&mut &result[..]).unwrap();
+		let bytes: sp_core::Bytes = rpc.call("grandpa_proveFinality", [42]).await.unwrap();
+		let finality_proof_rpc: FinalityProof<Header> = Decode::decode(&mut &bytes[..]).unwrap();
 		assert_eq!(finality_proof_rpc, finality_proof);
 	}
 }