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-04-28 07:27:55 +00:00 · 2022-05-10 10:52:19 +02:00
parent e45d53552d
commit 29c0c6a4a8
93 changed files with 3813 additions and 5094 deletions
@@ -18,28 +18,27 @@

 //! Authoring RPC module errors.

-use crate::errors;
-use jsonrpc_core as rpc;
+use jsonrpsee::{
+	core::Error as JsonRpseeError,
+	types::error::{CallError, ErrorObject},
+};
 use sp_runtime::transaction_validity::InvalidTransaction;

 /// Author RPC Result type.
 pub type Result<T> = std::result::Result<T, Error>;

-/// Author RPC future Result type.
-pub type FutureResult<T> = jsonrpc_core::BoxFuture<Result<T>>;
-
 /// Author RPC errors.
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
 	/// Client error.
 	#[error("Client error: {}", .0)]
-	Client(Box<dyn std::error::Error + Send>),
+	Client(Box<dyn std::error::Error + Send + Sync>),
 	/// Transaction pool error,
 	#[error("Transaction pool error: {}", .0)]
 	Pool(#[from] sc_transaction_pool_api::error::Error),
 	/// Verification error
 	#[error("Extrinsic verification error: {}", .0)]
-	Verification(Box<dyn std::error::Error + Send>),
+	Verification(Box<dyn std::error::Error + Send + Sync>),
 	/// Incorrect extrinsic format.
 	#[error("Invalid extrinsic format: {}", .0)]
 	BadFormat(#[from] codec::Error),
@@ -58,98 +57,127 @@ pub enum Error {
 }

 /// Base code for all authorship errors.
-const BASE_ERROR: i64 = 1000;
+const BASE_ERROR: i32 = 1000;
 /// Extrinsic has an invalid format.
-const BAD_FORMAT: i64 = BASE_ERROR + 1;
+const BAD_FORMAT: i32 = BASE_ERROR + 1;
 /// Error during transaction verification in runtime.
-const VERIFICATION_ERROR: i64 = BASE_ERROR + 2;
+const VERIFICATION_ERROR: i32 = BASE_ERROR + 2;

 /// Pool rejected the transaction as invalid
-const POOL_INVALID_TX: i64 = BASE_ERROR + 10;
+const POOL_INVALID_TX: i32 = BASE_ERROR + 10;
 /// Cannot determine transaction validity.
-const POOL_UNKNOWN_VALIDITY: i64 = POOL_INVALID_TX + 1;
+const POOL_UNKNOWN_VALIDITY: i32 = POOL_INVALID_TX + 1;
 /// The transaction is temporarily banned.
-const POOL_TEMPORARILY_BANNED: i64 = POOL_INVALID_TX + 2;
+const POOL_TEMPORARILY_BANNED: i32 = POOL_INVALID_TX + 2;
 /// The transaction is already in the pool
-const POOL_ALREADY_IMPORTED: i64 = POOL_INVALID_TX + 3;
+const POOL_ALREADY_IMPORTED: i32 = POOL_INVALID_TX + 3;
 /// Transaction has too low priority to replace existing one in the pool.
-const POOL_TOO_LOW_PRIORITY: i64 = POOL_INVALID_TX + 4;
+const POOL_TOO_LOW_PRIORITY: i32 = POOL_INVALID_TX + 4;
 /// Including this transaction would cause a dependency cycle.
-const POOL_CYCLE_DETECTED: i64 = POOL_INVALID_TX + 5;
+const POOL_CYCLE_DETECTED: i32 = POOL_INVALID_TX + 5;
 /// The transaction was not included to the pool because of the limits.
-const POOL_IMMEDIATELY_DROPPED: i64 = POOL_INVALID_TX + 6;
+const POOL_IMMEDIATELY_DROPPED: i32 = POOL_INVALID_TX + 6;
 /// The transaction was not included to the pool since it is unactionable,
 /// it is not propagable and the local node does not author blocks.
-const POOL_UNACTIONABLE: i64 = POOL_INVALID_TX + 8;
+const POOL_UNACTIONABLE: i32 = POOL_INVALID_TX + 8;
+/// Transaction does not provide any tags, so the pool can't identify it.
+const POOL_NO_TAGS: i32 = POOL_INVALID_TX + 9;
+/// Invalid block ID.
+const POOL_INVALID_BLOCK_ID: i32 = POOL_INVALID_TX + 10;
+/// The pool is not accepting future transactions.
+const POOL_FUTURE_TX: i32 = POOL_INVALID_TX + 11;

-impl From<Error> for rpc::Error {
+impl From<Error> for JsonRpseeError {
 	fn from(e: Error) -> Self {
 		use sc_transaction_pool_api::error::Error as PoolError;

 		match e {
-			Error::BadFormat(e) => rpc::Error {
-				code: rpc::ErrorCode::ServerError(BAD_FORMAT),
-				message: format!("Extrinsic has invalid format: {}", e),
-				data: None,
-			},
-			Error::Verification(e) => rpc::Error {
-				code: rpc::ErrorCode::ServerError(VERIFICATION_ERROR),
-				message: format!("Verification Error: {}", e),
-				data: Some(e.to_string().into()),
-			},
-			Error::Pool(PoolError::InvalidTransaction(InvalidTransaction::Custom(e))) => rpc::Error {
-				code: rpc::ErrorCode::ServerError(POOL_INVALID_TX),
-				message: "Invalid Transaction".into(),
-				data: Some(format!("Custom error: {}", e).into()),
+			Error::BadFormat(e) => CallError::Custom(ErrorObject::owned(
+				BAD_FORMAT,
+				format!("Extrinsic has invalid format: {}", e),
+				None::<()>,
+			)),
+			Error::Verification(e) => CallError::Custom(ErrorObject::owned(
+				VERIFICATION_ERROR,
+				format!("Verification Error: {}", e),
+				Some(format!("{:?}", e)),
+			)),
+			Error::Pool(PoolError::InvalidTransaction(InvalidTransaction::Custom(e))) => {
+				CallError::Custom(ErrorObject::owned(
+					POOL_INVALID_TX,
+					"Invalid Transaction",
+					Some(format!("Custom error: {}", e)),
+				))
 			},
 			Error::Pool(PoolError::InvalidTransaction(e)) => {
 				let msg: &str = e.into();
-				rpc::Error {
-					code: rpc::ErrorCode::ServerError(POOL_INVALID_TX),
-					message: "Invalid Transaction".into(),
-					data: Some(msg.into()),
-				}
+				CallError::Custom(ErrorObject::owned(
+					POOL_INVALID_TX,
+					"Invalid Transaction",
+					Some(msg),
+				))
 			},
-			Error::Pool(PoolError::UnknownTransaction(e)) => rpc::Error {
-				code: rpc::ErrorCode::ServerError(POOL_UNKNOWN_VALIDITY),
-				message: "Unknown Transaction Validity".into(),
-				data: serde_json::to_value(e).ok(),
+			Error::Pool(PoolError::UnknownTransaction(e)) => {
+				CallError::Custom(ErrorObject::owned(
+					POOL_UNKNOWN_VALIDITY,
+					"Unknown Transaction Validity",
+					Some(format!("{:?}", e)),
+				))
 			},
-			Error::Pool(PoolError::TemporarilyBanned) => rpc::Error {
-				code: rpc::ErrorCode::ServerError(POOL_TEMPORARILY_BANNED),
-				message: "Transaction is temporarily banned".into(),
-				data: None,
-			},
-			Error::Pool(PoolError::AlreadyImported(hash)) => rpc::Error {
-				code: rpc::ErrorCode::ServerError(POOL_ALREADY_IMPORTED),
-				message: "Transaction Already Imported".into(),
-				data: Some(format!("{:?}", hash).into()),
-			},
-			Error::Pool(PoolError::TooLowPriority { old, new }) => rpc::Error {
-				code: rpc::ErrorCode::ServerError(POOL_TOO_LOW_PRIORITY),
-				message: format!("Priority is too low: ({} vs {})", old, new),
-				data: Some("The transaction has too low priority to replace another transaction already in the pool.".into()),
-			},
-			Error::Pool(PoolError::CycleDetected) => rpc::Error {
-				code: rpc::ErrorCode::ServerError(POOL_CYCLE_DETECTED),
-				message: "Cycle Detected".into(),
-				data: None,
-			},
-			Error::Pool(PoolError::ImmediatelyDropped) => rpc::Error {
-				code: rpc::ErrorCode::ServerError(POOL_IMMEDIATELY_DROPPED),
-				message: "Immediately Dropped".into(),
-				data: Some("The transaction couldn't enter the pool because of the limit".into()),
-			},
-			Error::Pool(PoolError::Unactionable) => rpc::Error {
-				code: rpc::ErrorCode::ServerError(POOL_UNACTIONABLE),
-				message: "Unactionable".into(),
-				data: Some(
-					"The transaction is unactionable since it is not propagable and \
-					 the local node does not author blocks".into(),
-				),
+			Error::Pool(PoolError::TemporarilyBanned) =>
+				CallError::Custom(ErrorObject::owned(
+				POOL_TEMPORARILY_BANNED,
+				"Transaction is temporarily banned",
+				None::<()>,
+			)),
+			Error::Pool(PoolError::AlreadyImported(hash)) =>
+				CallError::Custom(ErrorObject::owned(
+				POOL_ALREADY_IMPORTED,
+				"Transaction Already Imported",
+				Some(format!("{:?}", hash)),
+			)),
+			Error::Pool(PoolError::TooLowPriority { old, new }) => CallError::Custom(ErrorObject::owned(
+				POOL_TOO_LOW_PRIORITY,
+				format!("Priority is too low: ({} vs {})", old, new),
+				Some("The transaction has too low priority to replace another transaction already in the pool.")
+			)),
+			Error::Pool(PoolError::CycleDetected) =>
+				CallError::Custom(ErrorObject::owned(
+				POOL_CYCLE_DETECTED,
+				"Cycle Detected",
+				None::<()>
+			)),
+			Error::Pool(PoolError::ImmediatelyDropped) => CallError::Custom(ErrorObject::owned(
+				POOL_IMMEDIATELY_DROPPED,
+				"Immediately Dropped",
+				Some("The transaction couldn't enter the pool because of the limit"),
+			)),
+			Error::Pool(PoolError::Unactionable) => CallError::Custom(ErrorObject::owned(
+				POOL_UNACTIONABLE,
+				"Unactionable",
+				Some("The transaction is unactionable since it is not propagable and \
+				the local node does not author blocks")
+			)),
+			Error::Pool(PoolError::NoTagsProvided) => CallError::Custom(ErrorObject::owned(
+				POOL_NO_TAGS,
+				"No tags provided",
+				Some("Transaction does not provide any tags, so the pool can't identify it")
+			)),
+			Error::Pool(PoolError::InvalidBlockId(_)) =>
+				CallError::Custom(ErrorObject::owned(
+				POOL_INVALID_BLOCK_ID,
+				"The provided block ID is not valid",
+				None::<()>
+			)),
+			Error::Pool(PoolError::RejectedFutureTransaction) => {
+				CallError::Custom(ErrorObject::owned(
+					POOL_FUTURE_TX,
+					"The pool is not accepting future transactions",
+					None::<()>,
+				))
 			},
 			Error::UnsafeRpcCalled(e) => e.into(),
-			e => errors::internal(e),
-		}
+			e => CallError::Failed(e.into()),
+		}.into()
 	}
 }
@@ -18,85 +18,61 @@

 //! Substrate block-author/full-node API.

-pub mod error;
-pub mod hash;
-
-use self::error::{FutureResult, Result};
-use jsonrpc_derive::rpc;
-use jsonrpc_pubsub::{typed::Subscriber, SubscriptionId};
+use jsonrpsee::{core::RpcResult, proc_macros::rpc};
 use sc_transaction_pool_api::TransactionStatus;
 use sp_core::Bytes;

-pub use self::gen_client::Client as AuthorClient;
+pub mod error;
+pub mod hash;

 /// Substrate authoring RPC API
-#[rpc]
+#[rpc(client, server)]
 pub trait AuthorApi<Hash, BlockHash> {
-	/// RPC metadata
-	type Metadata;
-
 	/// Submit hex-encoded extrinsic for inclusion in block.
-	#[rpc(name = "author_submitExtrinsic")]
-	fn submit_extrinsic(&self, extrinsic: Bytes) -> FutureResult<Hash>;
+	#[method(name = "author_submitExtrinsic")]
+	async fn submit_extrinsic(&self, extrinsic: Bytes) -> RpcResult<Hash>;

 	/// Insert a key into the keystore.
-	#[rpc(name = "author_insertKey")]
-	fn insert_key(&self, key_type: String, suri: String, public: Bytes) -> Result<()>;
+	#[method(name = "author_insertKey")]
+	fn insert_key(&self, key_type: String, suri: String, public: Bytes) -> RpcResult<()>;

 	/// Generate new session keys and returns the corresponding public keys.
-	#[rpc(name = "author_rotateKeys")]
-	fn rotate_keys(&self) -> Result<Bytes>;
+	#[method(name = "author_rotateKeys")]
+	fn rotate_keys(&self) -> RpcResult<Bytes>;

 	/// Checks if the keystore has private keys for the given session public keys.
 	///
 	/// `session_keys` is the SCALE encoded session keys object from the runtime.
 	///
 	/// Returns `true` iff all private keys could be found.
-	#[rpc(name = "author_hasSessionKeys")]
-	fn has_session_keys(&self, session_keys: Bytes) -> Result<bool>;
+	#[method(name = "author_hasSessionKeys")]
+	fn has_session_keys(&self, session_keys: Bytes) -> RpcResult<bool>;

 	/// Checks if the keystore has private keys for the given public key and key type.
 	///
 	/// Returns `true` if a private key could be found.
-	#[rpc(name = "author_hasKey")]
-	fn has_key(&self, public_key: Bytes, key_type: String) -> Result<bool>;
+	#[method(name = "author_hasKey")]
+	fn has_key(&self, public_key: Bytes, key_type: String) -> RpcResult<bool>;

 	/// Returns all pending extrinsics, potentially grouped by sender.
-	#[rpc(name = "author_pendingExtrinsics")]
-	fn pending_extrinsics(&self) -> Result<Vec<Bytes>>;
+	#[method(name = "author_pendingExtrinsics")]
+	fn pending_extrinsics(&self) -> RpcResult<Vec<Bytes>>;

 	/// Remove given extrinsic from the pool and temporarily ban it to prevent reimporting.
-	#[rpc(name = "author_removeExtrinsic")]
+	#[method(name = "author_removeExtrinsic")]
 	fn remove_extrinsic(
 		&self,
 		bytes_or_hash: Vec<hash::ExtrinsicOrHash<Hash>>,
-	) -> Result<Vec<Hash>>;
+	) -> RpcResult<Vec<Hash>>;

 	/// Submit an extrinsic to watch.
 	///
 	/// See [`TransactionStatus`](sc_transaction_pool_api::TransactionStatus) for details on
 	/// transaction life cycle.
-	#[pubsub(
-		subscription = "author_extrinsicUpdate",
-		subscribe,
-		name = "author_submitAndWatchExtrinsic"
+	#[subscription(
+		name = "author_submitAndWatchExtrinsic" => "author_extrinsicUpdate",
+		unsubscribe = "author_unwatchExtrinsic",
+		item = TransactionStatus<Hash, BlockHash>,
 	)]
-	fn watch_extrinsic(
-		&self,
-		metadata: Self::Metadata,
-		subscriber: Subscriber<TransactionStatus<Hash, BlockHash>>,
-		bytes: Bytes,
-	);
-
-	/// Unsubscribe from extrinsic watching.
-	#[pubsub(
-		subscription = "author_extrinsicUpdate",
-		unsubscribe,
-		name = "author_unwatchExtrinsic"
-	)]
-	fn unwatch_extrinsic(
-		&self,
-		metadata: Option<Self::Metadata>,
-		id: SubscriptionId,
-	) -> Result<bool>;
+	fn watch_extrinsic(&self, bytes: Bytes);
 }
@@ -18,38 +18,33 @@

 //! Error helpers for Chain RPC module.

-use crate::errors;
-use jsonrpc_core as rpc;
-
+use jsonrpsee::{
+	core::Error as JsonRpseeError,
+	types::error::{CallError, ErrorObject},
+};
 /// Chain RPC Result type.
 pub type Result<T> = std::result::Result<T, Error>;

-/// Chain RPC future Result type.
-pub type FutureResult<T> = jsonrpc_core::BoxFuture<Result<T>>;
-
 /// Chain RPC errors.
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
 	/// Client error.
 	#[error("Client error: {}", .0)]
-	Client(#[from] Box<dyn std::error::Error + Send>),
+	Client(#[from] Box<dyn std::error::Error + Send + Sync>),
 	/// Other error type.
 	#[error("{0}")]
 	Other(String),
 }

 /// Base error code for all chain errors.
-const BASE_ERROR: i64 = 3000;
+const BASE_ERROR: i32 = 3000;

-impl From<Error> for rpc::Error {
+impl From<Error> for JsonRpseeError {
 	fn from(e: Error) -> Self {
 		match e {
-			Error::Other(message) => rpc::Error {
-				code: rpc::ErrorCode::ServerError(BASE_ERROR + 1),
-				message,
-				data: None,
-			},
-			e => errors::internal(e),
+			Error::Other(message) =>
+				CallError::Custom(ErrorObject::owned(BASE_ERROR + 1, message, None::<()>)).into(),
+			e => e.into(),
 		}
 	}
 }
@@ -18,96 +18,59 @@

 //! Substrate blockchain API.

-pub mod error;
-
-use self::error::{FutureResult, Result};
-use jsonrpc_core::Result as RpcResult;
-use jsonrpc_derive::rpc;
-use jsonrpc_pubsub::{typed::Subscriber, SubscriptionId};
+use jsonrpsee::{core::RpcResult, proc_macros::rpc};
 use sp_rpc::{list::ListOrValue, number::NumberOrHex};

-pub use self::gen_client::Client as ChainClient;
+pub mod error;

-/// Substrate blockchain API
-#[rpc]
+#[rpc(client, server)]
 pub trait ChainApi<Number, Hash, Header, SignedBlock> {
-	/// RPC metadata
-	type Metadata;
-
-	/// Get header of a relay chain block.
-	#[rpc(name = "chain_getHeader")]
-	fn header(&self, hash: Option<Hash>) -> FutureResult<Option<Header>>;
+	/// Get header.
+	#[method(name = "chain_getHeader")]
+	async fn header(&self, hash: Option<Hash>) -> RpcResult<Option<Header>>;

 	/// Get header and body of a relay chain block.
-	#[rpc(name = "chain_getBlock")]
-	fn block(&self, hash: Option<Hash>) -> FutureResult<Option<SignedBlock>>;
+	#[method(name = "chain_getBlock")]
+	async fn block(&self, hash: Option<Hash>) -> RpcResult<Option<SignedBlock>>;

 	/// Get hash of the n-th block in the canon chain.
 	///
 	/// By default returns latest block hash.
-	#[rpc(name = "chain_getBlockHash", alias("chain_getHead"))]
+	#[method(name = "chain_getBlockHash", aliases = ["chain_getHead"])]
 	fn block_hash(
 		&self,
 		hash: Option<ListOrValue<NumberOrHex>>,
-	) -> Result<ListOrValue<Option<Hash>>>;
+	) -> RpcResult<ListOrValue<Option<Hash>>>;

 	/// Get hash of the last finalized block in the canon chain.
-	#[rpc(name = "chain_getFinalizedHead", alias("chain_getFinalisedHead"))]
-	fn finalized_head(&self) -> Result<Hash>;
+	#[method(name = "chain_getFinalizedHead", aliases = ["chain_getFinalisedHead"])]
+	fn finalized_head(&self) -> RpcResult<Hash>;

-	/// All head subscription
-	#[pubsub(subscription = "chain_allHead", subscribe, name = "chain_subscribeAllHeads")]
-	fn subscribe_all_heads(&self, metadata: Self::Metadata, subscriber: Subscriber<Header>);
-
-	/// Unsubscribe from all head subscription.
-	#[pubsub(subscription = "chain_allHead", unsubscribe, name = "chain_unsubscribeAllHeads")]
-	fn unsubscribe_all_heads(
-		&self,
-		metadata: Option<Self::Metadata>,
-		id: SubscriptionId,
-	) -> RpcResult<bool>;
-
-	/// New head subscription
-	#[pubsub(
-		subscription = "chain_newHead",
-		subscribe,
-		name = "chain_subscribeNewHeads",
-		alias("subscribe_newHead", "chain_subscribeNewHead")
+	/// All head subscription.
+	#[subscription(
+		name = "chain_subscribeAllHeads" => "chain_allHead",
+		unsubscribe = "chain_unsubscribeAllHeads",
+		item = Header
 	)]
-	fn subscribe_new_heads(&self, metadata: Self::Metadata, subscriber: Subscriber<Header>);
+	fn subscribe_all_heads(&self);

-	/// Unsubscribe from new head subscription.
-	#[pubsub(
-		subscription = "chain_newHead",
-		unsubscribe,
-		name = "chain_unsubscribeNewHeads",
-		alias("unsubscribe_newHead", "chain_unsubscribeNewHead")
+	/// New head subscription.
+	#[subscription(
+		name = "chain_subscribeNewHeads" => "chain_newHead",
+		aliases = ["subscribe_newHead", "chain_subscribeNewHead"],
+		unsubscribe = "chain_unsubscribeNewHeads",
+		unsubscribe_aliases = ["unsubscribe_newHead", "chain_unsubscribeNewHead"],
+		item = Header
 	)]
-	fn unsubscribe_new_heads(
-		&self,
-		metadata: Option<Self::Metadata>,
-		id: SubscriptionId,
-	) -> RpcResult<bool>;
+	fn subscribe_new_heads(&self);

-	/// Finalized head subscription
-	#[pubsub(
-		subscription = "chain_finalizedHead",
-		subscribe,
-		name = "chain_subscribeFinalizedHeads",
-		alias("chain_subscribeFinalisedHeads")
+	/// Finalized head subscription.
+	#[subscription(
+		name = "chain_subscribeFinalizedHeads" => "chain_finalizedHead",
+		aliases = ["chain_subscribeFinalisedHeads"],
+		unsubscribe = "chain_unsubscribeFinalizedHeads",
+		unsubscribe_aliases = ["chain_unsubscribeFinalisedHeads"],
+		item = Header
 	)]
-	fn subscribe_finalized_heads(&self, metadata: Self::Metadata, subscriber: Subscriber<Header>);
-
-	/// Unsubscribe from finalized head subscription.
-	#[pubsub(
-		subscription = "chain_finalizedHead",
-		unsubscribe,
-		name = "chain_unsubscribeFinalizedHeads",
-		alias("chain_unsubscribeFinalisedHeads")
-	)]
-	fn unsubscribe_finalized_heads(
-		&self,
-		metadata: Option<Self::Metadata>,
-		id: SubscriptionId,
-	) -> RpcResult<bool>;
+	fn subscribe_finalized_heads(&self);
 }
@@ -16,89 +16,82 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.

-//! Substrate state API.
-
-use crate::state::error::FutureResult;
-use jsonrpc_derive::rpc;
-use sp_core::storage::{PrefixedStorageKey, StorageData, StorageKey};
-
-pub use self::gen_client::Client as ChildStateClient;
+//! Substrate child state API
 use crate::state::ReadProof;
+use jsonrpsee::{core::RpcResult, proc_macros::rpc};
+use sp_core::storage::{PrefixedStorageKey, StorageData, StorageKey};

 /// Substrate child state API
 ///
 /// Note that all `PrefixedStorageKey` are deserialized
 /// from json and not guaranteed valid.
-#[rpc]
+#[rpc(client, server)]
 pub trait ChildStateApi<Hash> {
-	/// RPC Metadata
-	type Metadata;
-
-	/// DEPRECATED: Please use `childstate_getKeysPaged` with proper paging support.
 	/// Returns the keys with prefix from a child storage, leave empty to get all the keys
-	#[rpc(name = "childstate_getKeys")]
-	fn storage_keys(
+	#[method(name = "childstate_getKeys")]
+	#[deprecated(since = "2.0.0", note = "Please use `getKeysPaged` with proper paging support")]
+	async fn storage_keys(
 		&self,
 		child_storage_key: PrefixedStorageKey,
 		prefix: StorageKey,
 		hash: Option<Hash>,
-	) -> FutureResult<Vec<StorageKey>>;
+	) -> RpcResult<Vec<StorageKey>>;

 	/// Returns the keys with prefix from a child storage with pagination support.
 	/// Up to `count` keys will be returned.
 	/// If `start_key` is passed, return next keys in storage in lexicographic order.
-	#[rpc(name = "childstate_getKeysPaged", alias("childstate_getKeysPagedAt"))]
-	fn storage_keys_paged(
+	#[method(name = "childstate_getKeysPaged", aliases = ["childstate_getKeysPagedAt"])]
+	async fn storage_keys_paged(
 		&self,
 		child_storage_key: PrefixedStorageKey,
 		prefix: Option<StorageKey>,
 		count: u32,
 		start_key: Option<StorageKey>,
 		hash: Option<Hash>,
-	) -> FutureResult<Vec<StorageKey>>;
+	) -> RpcResult<Vec<StorageKey>>;

 	/// Returns a child storage entry at a specific block's state.
-	#[rpc(name = "childstate_getStorage")]
-	fn storage(
+	#[method(name = "childstate_getStorage")]
+	async fn storage(
 		&self,
 		child_storage_key: PrefixedStorageKey,
 		key: StorageKey,
 		hash: Option<Hash>,
-	) -> FutureResult<Option<StorageData>>;
+	) -> RpcResult<Option<StorageData>>;

 	/// Returns child storage entries for multiple keys at a specific block's state.
-	#[rpc(name = "childstate_getStorageEntries")]
-	fn storage_entries(
+	#[method(name = "childstate_getStorageEntries")]
+	async fn storage_entries(
 		&self,
 		child_storage_key: PrefixedStorageKey,
 		keys: Vec<StorageKey>,
 		hash: Option<Hash>,
-	) -> FutureResult<Vec<Option<StorageData>>>;
+	) -> RpcResult<Vec<Option<StorageData>>>;

 	/// Returns the hash of a child storage entry at a block's state.
-	#[rpc(name = "childstate_getStorageHash")]
-	fn storage_hash(
+	#[method(name = "childstate_getStorageHash")]
+	async fn storage_hash(
 		&self,
 		child_storage_key: PrefixedStorageKey,
 		key: StorageKey,
 		hash: Option<Hash>,
-	) -> FutureResult<Option<Hash>>;
+	) -> RpcResult<Option<Hash>>;

 	/// Returns the size of a child storage entry at a block's state.
-	#[rpc(name = "childstate_getStorageSize")]
-	fn storage_size(
+	#[method(name = "childstate_getStorageSize")]
+	async fn storage_size(
 		&self,
 		child_storage_key: PrefixedStorageKey,
 		key: StorageKey,
 		hash: Option<Hash>,
-	) -> FutureResult<Option<u64>>;
+	) -> RpcResult<Option<u64>>;

 	/// Returns proof of storage for child key entries at a specific block's state.
-	#[rpc(name = "state_getChildReadProof")]
-	fn read_child_proof(
+	#[method(name = "state_getChildReadProof")]
+	async fn read_child_proof(
 		&self,
 		child_storage_key: PrefixedStorageKey,
 		keys: Vec<StorageKey>,
 		hash: Option<Hash>,
-	) -> FutureResult<ReadProof<Hash>>;
+	) -> RpcResult<ReadProof<Hash>>;
 }
@@ -18,14 +18,10 @@

 //! Error helpers for Dev RPC module.

-use crate::errors;
-use jsonrpc_core as rpc;
-
-/// Dev RPC Result type.
-pub type Result<T> = std::result::Result<T, Error>;
-
-/// Dev RPC future Result type.
-pub type FutureResult<T> = jsonrpc_core::BoxFuture<Result<T>>;
+use jsonrpsee::{
+	core::Error as JsonRpseeError,
+	types::error::{CallError, ErrorObject},
+};

 /// Dev RPC errors.
 #[derive(Debug, thiserror::Error)]
@@ -45,27 +41,21 @@ pub enum Error {
 }

 /// Base error code for all dev errors.
-const BASE_ERROR: i64 = 6000;
+const BASE_ERROR: i32 = 6000;

-impl From<Error> for rpc::Error {
+impl From<Error> for JsonRpseeError {
 	fn from(e: Error) -> Self {
+		let msg = e.to_string();
+
 		match e {
-			Error::BlockQueryError(_) => rpc::Error {
-				code: rpc::ErrorCode::ServerError(BASE_ERROR + 1),
-				message: e.to_string(),
-				data: None,
-			},
-			Error::BlockExecutionFailed => rpc::Error {
-				code: rpc::ErrorCode::ServerError(BASE_ERROR + 3),
-				message: e.to_string(),
-				data: None,
-			},
-			Error::WitnessCompactionFailed => rpc::Error {
-				code: rpc::ErrorCode::ServerError(BASE_ERROR + 4),
-				message: e.to_string(),
-				data: None,
-			},
-			e => errors::internal(e),
+			Error::BlockQueryError(_) =>
+				CallError::Custom(ErrorObject::owned(BASE_ERROR + 1, msg, None::<()>)),
+			Error::BlockExecutionFailed =>
+				CallError::Custom(ErrorObject::owned(BASE_ERROR + 3, msg, None::<()>)),
+			Error::WitnessCompactionFailed =>
+				CallError::Custom(ErrorObject::owned(BASE_ERROR + 4, msg, None::<()>)),
+			Error::UnsafeRpcCalled(e) => e.into(),
 		}
+		.into()
 	}
 }
@@ -22,9 +22,8 @@

 pub mod error;

-use self::error::Result;
 use codec::{Decode, Encode};
-use jsonrpc_derive::rpc;
+use jsonrpsee::{core::RpcResult, proc_macros::rpc};
 use scale_info::TypeInfo;
 use serde::{Deserialize, Serialize};

@@ -52,13 +51,13 @@ pub struct BlockStats {
 ///
 /// This API contains unstable and unsafe methods only meant for development nodes. They
 /// are all flagged as unsafe for this reason.
-#[rpc]
+#[rpc(client, server)]
 pub trait DevApi<Hash> {
 	/// Reexecute the specified `block_hash` and gather statistics while doing so.
 	///
 	/// This function requires the specified block and its parent to be available
 	/// at the queried node. If either the specified block or the parent is pruned,
 	/// this function will return `None`.
-	#[rpc(name = "dev_getBlockStats")]
-	fn block_stats(&self, block_hash: Hash) -> Result<Option<BlockStats>>;
+	#[method(name = "dev_getBlockStats")]
+	fn block_stats(&self, block_hash: Hash) -> RpcResult<Option<BlockStats>>;
 }
@@ -1,28 +0,0 @@
-// This file is part of Substrate.
-
-// Copyright (C) 2018-2022 Parity Technologies (UK) Ltd.
-// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// 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 log::warn;
-
-pub fn internal<E: std::fmt::Display>(e: E) -> jsonrpc_core::Error {
-	warn!("Unknown error: {}", e);
-	jsonrpc_core::Error {
-		code: jsonrpc_core::ErrorCode::InternalError,
-		message: "Unknown error occurred".into(),
-		data: Some(e.to_string().into()),
-	}
-}
@@ -1,41 +0,0 @@
-// This file is part of Substrate.
-
-// Copyright (C) 2018-2022 Parity Technologies (UK) Ltd.
-// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// 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 futures::{channel::oneshot, Future};
-use std::pin::Pin;
-
-/// Wraps around `oneshot::Receiver` and adjusts the error type to produce an internal error if the
-/// sender gets dropped.
-pub struct Receiver<T>(pub oneshot::Receiver<T>);
-
-impl<T> Future for Receiver<T> {
-	type Output = Result<T, jsonrpc_core::Error>;
-
-	fn poll(
-		mut self: Pin<&mut Self>,
-		cx: &mut std::task::Context<'_>,
-	) -> std::task::Poll<Self::Output> {
-		Future::poll(Pin::new(&mut self.0), cx).map_err(|_| jsonrpc_core::Error::internal_error())
-	}
-}
-
-impl<T: Send + 'static> jsonrpc_core::WrapFuture<T, jsonrpc_core::Error> for Receiver<T> {
-	fn into_future(self) -> jsonrpc_core::BoxFuture<Result<T, jsonrpc_core::Error>> {
-		Box::pin(async { self.await })
-	}
-}
@@ -22,15 +22,9 @@

 #![warn(missing_docs)]

-mod errors;
-mod helpers;
-mod metadata;
 mod policy;

-pub use helpers::Receiver;
-pub use jsonrpc_core::IoHandlerExtension as RpcExtension;
-pub use metadata::Metadata;
-pub use policy::{DenyUnsafe, UnsafeRpcError};
+pub use policy::DenyUnsafe;

 pub mod author;
 pub mod chain;
@@ -1,60 +0,0 @@
-// This file is part of Substrate.
-
-// Copyright (C) 2017-2022 Parity Technologies (UK) Ltd.
-// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this program. If not, see <https://www.gnu.org/licenses/>.
-
-//! RPC Metadata
-use std::sync::Arc;
-
-use futures::channel::mpsc;
-use jsonrpc_pubsub::{PubSubMetadata, Session};
-
-/// RPC Metadata.
-///
-/// Manages persistent session for transports that support it
-/// and may contain some additional info extracted from specific transports
-/// (like remote client IP address, request headers, etc)
-#[derive(Default, Clone)]
-pub struct Metadata {
-	session: Option<Arc<Session>>,
-}
-
-impl jsonrpc_core::Metadata for Metadata {}
-impl PubSubMetadata for Metadata {
-	fn session(&self) -> Option<Arc<Session>> {
-		self.session.clone()
-	}
-}
-
-impl Metadata {
-	/// Create new `Metadata` with session (Pub/Sub) support.
-	pub fn new(transport: mpsc::UnboundedSender<String>) -> Self {
-		Metadata { session: Some(Arc::new(Session::new(transport))) }
-	}
-
-	/// Create new `Metadata` for tests.
-	#[cfg(test)]
-	pub fn new_test() -> (mpsc::UnboundedReceiver<String>, Self) {
-		let (tx, rx) = mpsc::unbounded();
-		(rx, Self::new(tx))
-	}
-}
-
-impl From<mpsc::UnboundedSender<String>> for Metadata {
-	fn from(sender: mpsc::UnboundedSender<String>) -> Self {
-		Self::new(sender)
-	}
-}
@@ -18,7 +18,10 @@

 //! Offchain RPC errors.

-use jsonrpc_core as rpc;
+use jsonrpsee::{
+	core::Error as JsonRpseeError,
+	types::error::{CallError, ErrorObject},
+};

 /// Offchain RPC Result type.
 pub type Result<T> = std::result::Result<T, Error>;
@@ -35,16 +38,17 @@ pub enum Error {
 }

 /// Base error code for all offchain errors.
-const BASE_ERROR: i64 = 5000;
+const BASE_ERROR: i32 = 5000;

-impl From<Error> for rpc::Error {
+impl From<Error> for JsonRpseeError {
 	fn from(e: Error) -> Self {
 		match e {
-			Error::UnavailableStorageKind => rpc::Error {
-				code: rpc::ErrorCode::ServerError(BASE_ERROR + 1),
-				message: "This storage kind is not available yet".into(),
-				data: None,
-			},
+			Error::UnavailableStorageKind => CallError::Custom(ErrorObject::owned(
+				BASE_ERROR + 1,
+				"This storage kind is not available yet",
+				None::<()>,
+			))
+			.into(),
 			Error::UnsafeRpcCalled(e) => e.into(),
 		}
 	}
@@ -18,22 +18,19 @@

 //! Substrate offchain API.

-pub mod error;
-
-use self::error::Result;
-use jsonrpc_derive::rpc;
+use jsonrpsee::{core::RpcResult, proc_macros::rpc};
 use sp_core::{offchain::StorageKind, Bytes};

-pub use self::gen_client::Client as OffchainClient;
+pub mod error;

 /// Substrate offchain RPC API
-#[rpc]
+#[rpc(client, server)]
 pub trait OffchainApi {
 	/// Set offchain local storage under given key and prefix.
-	#[rpc(name = "offchain_localStorageSet")]
-	fn set_local_storage(&self, kind: StorageKind, key: Bytes, value: Bytes) -> Result<()>;
+	#[method(name = "offchain_localStorageSet")]
+	fn set_local_storage(&self, kind: StorageKind, key: Bytes, value: Bytes) -> RpcResult<()>;

 	/// Get offchain local storage under given key and prefix.
-	#[rpc(name = "offchain_localStorageGet")]
-	fn get_local_storage(&self, kind: StorageKind, key: Bytes) -> Result<Option<Bytes>>;
+	#[method(name = "offchain_localStorageGet")]
+	fn get_local_storage(&self, kind: StorageKind, key: Bytes) -> RpcResult<Option<Bytes>>;
 }
@@ -21,7 +21,13 @@
 //! Contains a `DenyUnsafe` type that can be used to deny potentially unsafe
 //! RPC when accessed externally.

-use jsonrpc_core as rpc;
+use jsonrpsee::{
+	core::Error as JsonRpseeError,
+	types::{
+		error::{CallError, ErrorCode},
+		ErrorObject,
+	},
+};

 /// Signifies whether a potentially unsafe RPC should be denied.
 #[derive(Clone, Copy, Debug)]
@@ -55,8 +61,18 @@ impl std::fmt::Display for UnsafeRpcError {

 impl std::error::Error for UnsafeRpcError {}

-impl From<UnsafeRpcError> for rpc::Error {
-	fn from(error: UnsafeRpcError) -> rpc::Error {
-		rpc::Error { code: rpc::ErrorCode::MethodNotFound, message: error.to_string(), data: None }
+impl From<UnsafeRpcError> for CallError {
+	fn from(e: UnsafeRpcError) -> CallError {
+		CallError::Custom(ErrorObject::owned(
+			ErrorCode::MethodNotFound.code(),
+			e.to_string(),
+			None::<()>,
+		))
+	}
+}
+
+impl From<UnsafeRpcError> for JsonRpseeError {
+	fn from(e: UnsafeRpcError) -> JsonRpseeError {
+		JsonRpseeError::Call(e.into())
 	}
 }
@@ -18,21 +18,19 @@

 //! State RPC errors.

-use crate::errors;
-use jsonrpc_core as rpc;
-
+use jsonrpsee::{
+	core::Error as JsonRpseeError,
+	types::error::{CallError, ErrorObject},
+};
 /// State RPC Result type.
 pub type Result<T> = std::result::Result<T, Error>;

-/// State RPC future Result type.
-pub type FutureResult<T> = jsonrpc_core::BoxFuture<Result<T>>;
-
 /// State RPC errors.
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
 	/// Client error.
 	#[error("Client error: {}", .0)]
-	Client(#[from] Box<dyn std::error::Error + Send>),
+	Client(#[from] Box<dyn std::error::Error + Send + Sync>),
 	/// Provided block range couldn't be resolved to a list of blocks.
 	#[error("Cannot resolve a block range ['{:?}' ... '{:?}]. {}", .from, .to, .details)]
 	InvalidBlockRange {
@@ -57,22 +55,18 @@ pub enum Error {
 }

 /// Base code for all state errors.
-const BASE_ERROR: i64 = 4000;
+const BASE_ERROR: i32 = 4000;

-impl From<Error> for rpc::Error {
+impl From<Error> for JsonRpseeError {
 	fn from(e: Error) -> Self {
 		match e {
-			Error::InvalidBlockRange { .. } => rpc::Error {
-				code: rpc::ErrorCode::ServerError(BASE_ERROR + 1),
-				message: format!("{}", e),
-				data: None,
-			},
-			Error::InvalidCount { .. } => rpc::Error {
-				code: rpc::ErrorCode::ServerError(BASE_ERROR + 2),
-				message: format!("{}", e),
-				data: None,
-			},
-			e => errors::internal(e),
+			Error::InvalidBlockRange { .. } =>
+				CallError::Custom(ErrorObject::owned(BASE_ERROR + 1, e.to_string(), None::<()>))
+					.into(),
+			Error::InvalidCount { .. } =>
+				CallError::Custom(ErrorObject::owned(BASE_ERROR + 2, e.to_string(), None::<()>))
+					.into(),
+			e => Self::to_call_error(e),
 		}
 	}
 }
@@ -18,161 +18,122 @@

 //! Substrate state API.

-pub mod error;
-pub mod helpers;
-
-use self::error::FutureResult;
-use jsonrpc_core::Result as RpcResult;
-use jsonrpc_derive::rpc;
-use jsonrpc_pubsub::{typed::Subscriber, SubscriptionId};
+use jsonrpsee::{core::RpcResult, proc_macros::rpc};
 use sp_core::{
 	storage::{StorageChangeSet, StorageData, StorageKey},
 	Bytes,
 };
 use sp_version::RuntimeVersion;

-pub use self::{gen_client::Client as StateClient, helpers::ReadProof};
+pub mod error;
+pub mod helpers;
+
+pub use self::helpers::ReadProof;

 /// Substrate state API
-#[rpc]
+#[rpc(client, server)]
 pub trait StateApi<Hash> {
-	/// RPC Metadata
-	type Metadata;
-
 	/// Call a contract at a block's state.
-	#[rpc(name = "state_call", alias("state_callAt"))]
-	fn call(&self, name: String, bytes: Bytes, hash: Option<Hash>) -> FutureResult<Bytes>;
+	#[method(name = "state_call", aliases = ["state_callAt"])]
+	async fn call(&self, name: String, bytes: Bytes, hash: Option<Hash>) -> RpcResult<Bytes>;

-	/// DEPRECATED: Please use `state_getKeysPaged` with proper paging support.
 	/// Returns the keys with prefix, leave empty to get all the keys.
-	#[rpc(name = "state_getKeys")]
-	fn storage_keys(&self, prefix: StorageKey, hash: Option<Hash>)
-		-> FutureResult<Vec<StorageKey>>;
-
-	/// Returns the keys with prefix, leave empty to get all the keys
-	#[rpc(name = "state_getPairs")]
-	fn storage_pairs(
+	#[method(name = "state_getKeys")]
+	#[deprecated(since = "2.0.0", note = "Please use `getKeysPaged` with proper paging support")]
+	async fn storage_keys(
 		&self,
 		prefix: StorageKey,
 		hash: Option<Hash>,
-	) -> FutureResult<Vec<(StorageKey, StorageData)>>;
+	) -> RpcResult<Vec<StorageKey>>;
+
+	/// Returns the keys with prefix, leave empty to get all the keys
+	#[method(name = "state_getPairs")]
+	async fn storage_pairs(
+		&self,
+		prefix: StorageKey,
+		hash: Option<Hash>,
+	) -> RpcResult<Vec<(StorageKey, StorageData)>>;

 	/// Returns the keys with prefix with pagination support.
 	/// Up to `count` keys will be returned.
 	/// If `start_key` is passed, return next keys in storage in lexicographic order.
-	#[rpc(name = "state_getKeysPaged", alias("state_getKeysPagedAt"))]
-	fn storage_keys_paged(
+	#[method(name = "state_getKeysPaged", aliases = ["state_getKeysPagedAt"])]
+	async fn storage_keys_paged(
 		&self,
 		prefix: Option<StorageKey>,
 		count: u32,
 		start_key: Option<StorageKey>,
 		hash: Option<Hash>,
-	) -> FutureResult<Vec<StorageKey>>;
+	) -> RpcResult<Vec<StorageKey>>;

 	/// Returns a storage entry at a specific block's state.
-	#[rpc(name = "state_getStorage", alias("state_getStorageAt"))]
-	fn storage(&self, key: StorageKey, hash: Option<Hash>) -> FutureResult<Option<StorageData>>;
+	#[method(name = "state_getStorage", aliases = ["state_getStorageAt"])]
+	async fn storage(&self, key: StorageKey, hash: Option<Hash>) -> RpcResult<Option<StorageData>>;

 	/// Returns the hash of a storage entry at a block's state.
-	#[rpc(name = "state_getStorageHash", alias("state_getStorageHashAt"))]
-	fn storage_hash(&self, key: StorageKey, hash: Option<Hash>) -> FutureResult<Option<Hash>>;
+	#[method(name = "state_getStorageHash", aliases = ["state_getStorageHashAt"])]
+	async fn storage_hash(&self, key: StorageKey, hash: Option<Hash>) -> RpcResult<Option<Hash>>;

 	/// Returns the size of a storage entry at a block's state.
-	#[rpc(name = "state_getStorageSize", alias("state_getStorageSizeAt"))]
-	fn storage_size(&self, key: StorageKey, hash: Option<Hash>) -> FutureResult<Option<u64>>;
+	#[method(name = "state_getStorageSize", aliases = ["state_getStorageSizeAt"])]
+	async fn storage_size(&self, key: StorageKey, hash: Option<Hash>) -> RpcResult<Option<u64>>;

 	/// Returns the runtime metadata as an opaque blob.
-	#[rpc(name = "state_getMetadata")]
-	fn metadata(&self, hash: Option<Hash>) -> FutureResult<Bytes>;
+	#[method(name = "state_getMetadata")]
+	async fn metadata(&self, hash: Option<Hash>) -> RpcResult<Bytes>;

 	/// Get the runtime version.
-	#[rpc(name = "state_getRuntimeVersion", alias("chain_getRuntimeVersion"))]
-	fn runtime_version(&self, hash: Option<Hash>) -> FutureResult<RuntimeVersion>;
+	#[method(name = "state_getRuntimeVersion", aliases = ["chain_getRuntimeVersion"])]
+	async fn runtime_version(&self, hash: Option<Hash>) -> RpcResult<RuntimeVersion>;

 	/// 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).
-	#[rpc(name = "state_queryStorage")]
-	fn query_storage(
+	#[method(name = "state_queryStorage")]
+	async fn query_storage(
 		&self,
 		keys: Vec<StorageKey>,
 		block: Hash,
 		hash: Option<Hash>,
-	) -> FutureResult<Vec<StorageChangeSet<Hash>>>;
+	) -> RpcResult<Vec<StorageChangeSet<Hash>>>;

 	/// Query storage entries (by key) starting at block hash given as the second parameter.
-	#[rpc(name = "state_queryStorageAt")]
-	fn query_storage_at(
+	#[method(name = "state_queryStorageAt")]
+	async fn query_storage_at(
 		&self,
 		keys: Vec<StorageKey>,
 		at: Option<Hash>,
-	) -> FutureResult<Vec<StorageChangeSet<Hash>>>;
+	) -> RpcResult<Vec<StorageChangeSet<Hash>>>;

 	/// Returns proof of storage entries at a specific block's state.
-	#[rpc(name = "state_getReadProof")]
-	fn read_proof(
+	#[method(name = "state_getReadProof")]
+	async fn read_proof(
 		&self,
 		keys: Vec<StorageKey>,
 		hash: Option<Hash>,
-	) -> FutureResult<ReadProof<Hash>>;
+	) -> RpcResult<ReadProof<Hash>>;

 	/// New runtime version subscription
-	#[pubsub(
-		subscription = "state_runtimeVersion",
-		subscribe,
-		name = "state_subscribeRuntimeVersion",
-		alias("chain_subscribeRuntimeVersion")
+	#[subscription(
+		name = "state_subscribeRuntimeVersion" => "state_runtimeVersion",
+		unsubscribe = "state_unsubscribeRuntimeVersion",
+		aliases = ["chain_subscribeRuntimeVersion"],
+		unsubscribe_aliases = ["chain_unsubscribeRuntimeVersion"],
+		item = RuntimeVersion,
 	)]
-	fn subscribe_runtime_version(
-		&self,
-		metadata: Self::Metadata,
-		subscriber: Subscriber<RuntimeVersion>,
-	);
+	fn subscribe_runtime_version(&self);

-	/// Unsubscribe from runtime version subscription
-	#[pubsub(
-		subscription = "state_runtimeVersion",
-		unsubscribe,
-		name = "state_unsubscribeRuntimeVersion",
-		alias("chain_unsubscribeRuntimeVersion")
+	/// New storage subscription
+	#[subscription(
+		name = "state_subscribeStorage" => "state_storage",
+		unsubscribe = "state_unsubscribeStorage",
+		item = StorageChangeSet<Hash>,
 	)]
-	fn unsubscribe_runtime_version(
-		&self,
-		metadata: Option<Self::Metadata>,
-		id: SubscriptionId,
-	) -> RpcResult<bool>;
+	fn subscribe_storage(&self, keys: Option<Vec<StorageKey>>);

-	/// Subscribe to the changes in the storage.
-	///
-	/// This RPC endpoint has two modes of operation:
-	///   1) When `keys` is not `None` you'll only be informed about the changes
-	///      done to the specified keys; this is RPC-safe.
-	///   2) When `keys` is `None` you'll be informed of *all* of the changes;
-	///      **this is RPC-unsafe**.
-	///
-	/// When subscribed to all of the changes this API will emit every storage
-	/// change for every block that is imported. These changes will only be sent
-	/// after a block is imported. If you require a consistent view across all changes
-	/// of every block, you need to take this into account.
-	#[pubsub(subscription = "state_storage", subscribe, name = "state_subscribeStorage")]
-	fn subscribe_storage(
-		&self,
-		metadata: Self::Metadata,
-		subscriber: Subscriber<StorageChangeSet<Hash>>,
-		keys: Option<Vec<StorageKey>>,
-	);
-
-	/// Unsubscribe from storage subscription
-	#[pubsub(subscription = "state_storage", unsubscribe, name = "state_unsubscribeStorage")]
-	fn unsubscribe_storage(
-		&self,
-		metadata: Option<Self::Metadata>,
-		id: SubscriptionId,
-	) -> RpcResult<bool>;
-
-	/// The `state_traceBlock` RPC provides a way to trace the re-execution of a single
+	/// The `traceBlock` RPC provides a way to trace the re-execution of a single
 	/// block, collecting Spans and Events from both the client and the relevant WASM runtime.
 	/// The Spans and Events are conceptually equivalent to those from the [Tracing][1] crate.
 	///
@@ -323,13 +284,13 @@ pub trait StateApi<Hash> {
 	/// narrow down the traces using a smaller set of targets and/or storage keys.
 	///
 	/// If you are having issues with maximum payload size you can use the flag
-	/// `-lstate_tracing=trace` to get some logging during tracing.
-	#[rpc(name = "state_traceBlock")]
-	fn trace_block(
+	/// `-ltracing=trace` to get some logging during tracing.
+	#[method(name = "state_traceBlock")]
+	async fn trace_block(
 		&self,
 		block: Hash,
 		targets: Option<String>,
 		storage_keys: Option<String>,
 		methods: Option<String>,
-	) -> FutureResult<sp_rpc::tracing::TraceBlockResponse>;
+	) -> RpcResult<sp_rpc::tracing::TraceBlockResponse>;
 }
@@ -19,7 +19,10 @@
 //! System RPC module errors.

 use crate::system::helpers::Health;
-use jsonrpc_core as rpc;
+use jsonrpsee::{
+	core::Error as JsonRpseeError,
+	types::error::{CallError, ErrorObject},
+};

 /// System RPC Result type.
 pub type Result<T> = std::result::Result<T, Error>;
@@ -35,22 +38,24 @@ pub enum Error {
 	MalformattedPeerArg(String),
 }

-/// Base code for all system errors.
-const BASE_ERROR: i64 = 2000;
+// Base code for all system errors.
+const BASE_ERROR: i32 = 2000;
+// Provided block range couldn't be resolved to a list of blocks.
+const NOT_HEALTHY_ERROR: i32 = BASE_ERROR + 1;
+// Peer argument is malformatted.
+const MALFORMATTED_PEER_ARG_ERROR: i32 = BASE_ERROR + 2;

-impl From<Error> for rpc::Error {
+impl From<Error> for JsonRpseeError {
 	fn from(e: Error) -> Self {
 		match e {
-			Error::NotHealthy(ref h) => rpc::Error {
-				code: rpc::ErrorCode::ServerError(BASE_ERROR + 1),
-				message: format!("{}", e),
-				data: serde_json::to_value(h).ok(),
-			},
-			Error::MalformattedPeerArg(ref e) => rpc::Error {
-				code: rpc::ErrorCode::ServerError(BASE_ERROR + 2),
-				message: e.clone(),
-				data: None,
-			},
+			Error::NotHealthy(ref h) =>
+				CallError::Custom(ErrorObject::owned(NOT_HEALTHY_ERROR, e.to_string(), Some(h))),
+			Error::MalformattedPeerArg(e) => CallError::Custom(ErrorObject::owned(
+				MALFORMATTED_PEER_ARG_ERROR + 2,
+				e,
+				None::<()>,
+			)),
 		}
+		.into()
 	}
 }
@@ -18,65 +18,61 @@

 //! Substrate system API.

+use jsonrpsee::{
+	core::{JsonValue, RpcResult},
+	proc_macros::rpc,
+};
+
+pub use self::helpers::{Health, NodeRole, PeerInfo, SyncState, SystemInfo};
+
 pub mod error;
 pub mod helpers;

-use crate::helpers::Receiver;
-use jsonrpc_core::BoxFuture;
-use jsonrpc_derive::rpc;
-
-use self::error::Result as SystemResult;
-
-pub use self::{
-	gen_client::Client as SystemClient,
-	helpers::{Health, NodeRole, PeerInfo, SyncState, SystemInfo},
-};
-
 /// Substrate system RPC API
-#[rpc]
+#[rpc(client, server)]
 pub trait SystemApi<Hash, Number> {
 	/// Get the node's implementation name. Plain old string.
-	#[rpc(name = "system_name")]
-	fn system_name(&self) -> SystemResult<String>;
+	#[method(name = "system_name")]
+	fn system_name(&self) -> RpcResult<String>;

 	/// Get the node implementation's version. Should be a semver string.
-	#[rpc(name = "system_version")]
-	fn system_version(&self) -> SystemResult<String>;
+	#[method(name = "system_version")]
+	fn system_version(&self) -> RpcResult<String>;

 	/// Get the chain's name. Given as a string identifier.
-	#[rpc(name = "system_chain")]
-	fn system_chain(&self) -> SystemResult<String>;
+	#[method(name = "system_chain")]
+	fn system_chain(&self) -> RpcResult<String>;

 	/// Get the chain's type.
-	#[rpc(name = "system_chainType")]
-	fn system_type(&self) -> SystemResult<sc_chain_spec::ChainType>;
+	#[method(name = "system_chainType")]
+	fn system_type(&self) -> RpcResult<sc_chain_spec::ChainType>;

 	/// Get a custom set of properties as a JSON object, defined in the chain spec.
-	#[rpc(name = "system_properties")]
-	fn system_properties(&self) -> SystemResult<sc_chain_spec::Properties>;
+	#[method(name = "system_properties")]
+	fn system_properties(&self) -> RpcResult<sc_chain_spec::Properties>;

 	/// Return health status of the node.
 	///
 	/// Node is considered healthy if it is:
 	/// - connected to some peers (unless running in dev mode)
 	/// - not performing a major sync
-	#[rpc(name = "system_health", returns = "Health")]
-	fn system_health(&self) -> Receiver<Health>;
+	#[method(name = "system_health")]
+	async fn system_health(&self) -> RpcResult<Health>;

 	/// Returns the base58-encoded PeerId of the node.
-	#[rpc(name = "system_localPeerId", returns = "String")]
-	fn system_local_peer_id(&self) -> Receiver<String>;
+	#[method(name = "system_localPeerId")]
+	async fn system_local_peer_id(&self) -> RpcResult<String>;

-	/// Returns the multiaddresses that the local node is listening on
+	/// Returns the multi-addresses that the local node is listening on
 	///
 	/// The addresses include a trailing `/p2p/` with the local PeerId, and are thus suitable to
-	/// be passed to `system_addReservedPeer` or as a bootnode address for example.
-	#[rpc(name = "system_localListenAddresses", returns = "Vec<String>")]
-	fn system_local_listen_addresses(&self) -> Receiver<Vec<String>>;
+	/// be passed to `addReservedPeer` or as a bootnode address for example.
+	#[method(name = "system_localListenAddresses")]
+	async fn system_local_listen_addresses(&self) -> RpcResult<Vec<String>>;

 	/// Returns currently connected peers
-	#[rpc(name = "system_peers", returns = "Vec<PeerInfo<Hash, Number>>")]
-	fn system_peers(&self) -> BoxFuture<jsonrpc_core::Result<Vec<PeerInfo<Hash, Number>>>>;
+	#[method(name = "system_peers")]
+	async fn system_peers(&self) -> RpcResult<Vec<PeerInfo<Hash, Number>>>;

 	/// Returns current state of the network.
 	///
@@ -84,47 +80,44 @@ pub trait SystemApi<Hash, Number> {
 	/// as its format might change at any time.
 	// TODO: the future of this call is uncertain: https://github.com/paritytech/substrate/issues/1890
 	// https://github.com/paritytech/substrate/issues/5541
-	#[rpc(name = "system_unstable_networkState", returns = "jsonrpc_core::Value")]
-	fn system_network_state(&self) -> BoxFuture<jsonrpc_core::Result<jsonrpc_core::Value>>;
+	#[method(name = "system_unstable_networkState")]
+	async fn system_network_state(&self) -> RpcResult<JsonValue>;

 	/// Adds a reserved peer. Returns the empty string or an error. The string
 	/// parameter should encode a `p2p` multiaddr.
 	///
 	/// `/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV`
 	/// is an example of a valid, passing multiaddr with PeerId attached.
-	#[rpc(name = "system_addReservedPeer", returns = "()")]
-	fn system_add_reserved_peer(&self, peer: String) -> BoxFuture<Result<(), jsonrpc_core::Error>>;
+	#[method(name = "system_addReservedPeer")]
+	async fn system_add_reserved_peer(&self, peer: String) -> RpcResult<()>;

 	/// Remove a reserved peer. Returns the empty string or an error. The string
 	/// should encode only the PeerId e.g. `QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV`.
-	#[rpc(name = "system_removeReservedPeer", returns = "()")]
-	fn system_remove_reserved_peer(
-		&self,
-		peer_id: String,
-	) -> BoxFuture<Result<(), jsonrpc_core::Error>>;
+	#[method(name = "system_removeReservedPeer")]
+	async fn system_remove_reserved_peer(&self, peer_id: String) -> RpcResult<()>;

 	/// Returns the list of reserved peers
-	#[rpc(name = "system_reservedPeers", returns = "Vec<String>")]
-	fn system_reserved_peers(&self) -> Receiver<Vec<String>>;
+	#[method(name = "system_reservedPeers")]
+	async fn system_reserved_peers(&self) -> RpcResult<Vec<String>>;

 	/// Returns the roles the node is running as.
-	#[rpc(name = "system_nodeRoles", returns = "Vec<NodeRole>")]
-	fn system_node_roles(&self) -> Receiver<Vec<NodeRole>>;
+	#[method(name = "system_nodeRoles")]
+	async fn system_node_roles(&self) -> RpcResult<Vec<NodeRole>>;

 	/// Returns the state of the syncing of the node: starting block, current best block, highest
 	/// known block.
-	#[rpc(name = "system_syncState", returns = "SyncState<Number>")]
-	fn system_sync_state(&self) -> Receiver<SyncState<Number>>;
+	#[method(name = "system_syncState")]
+	async fn system_sync_state(&self) -> RpcResult<SyncState<Number>>;

 	/// Adds the supplied directives to the current log filter
 	///
 	/// The syntax is identical to the CLI `<target>=<level>`:
 	///
 	/// `sync=debug,state=trace`
-	#[rpc(name = "system_addLogFilter", returns = "()")]
-	fn system_add_log_filter(&self, directives: String) -> Result<(), jsonrpc_core::Error>;
+	#[method(name = "system_addLogFilter")]
+	fn system_add_log_filter(&self, directives: String) -> RpcResult<()>;

 	/// Resets the log filter to Substrate defaults
-	#[rpc(name = "system_resetLogFilter", returns = "()")]
-	fn system_reset_log_filter(&self) -> Result<(), jsonrpc_core::Error>;
+	#[method(name = "system_resetLogFilter")]
+	fn system_reset_log_filter(&self) -> RpcResult<()>;
 }