refactor(remote ext): use jsonrpsee

utils/frame/remote-externalities/Cargo.toml

@@ -13,16 +13,15 @@ readme = "README.md"
 targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
-jsonrpc-core-client = { version = "15.1.0", features = ["http"] }
-sc-rpc-api = { version = "0.9.0", path = "../../../client/rpc-api" }
-sc-rpc = { version = "3.0.0", path = "../../../client/rpc" }
-futures = "0.3"
+jsonrpsee-http-client = { version = "0.2.0-alpha", default-features = false, features = ["tokio02"] }
+# Needed by `jsonrpsee-proc-macros`
+jsonrpsee-types = "0.2.0-alpha"
+jsonrpsee-proc-macros = "0.2.0-alpha"
 
 hex-literal = "0.3.1"
 env_logger = "0.8.2"
 log = "0.4.11"
 codec = { package = "parity-scale-codec", version = "2.0.0" }
-tokio = "0.1.22"
 
 sp-io = { version = "3.0.0", path = "../../../primitives/io" }
 sp-core = { version = "3.0.0", path = "../../../primitives/core" }

utils/frame/remote-externalities/src/lib.rs

@@ -101,9 +101,13 @@
 //! }
 //! ```
 
+// jsonrpsee_proc_macros generates faulty warnings: https://github.com/paritytech/jsonrpsee/issues/106
+#![allow(dead_code)]
+
 use std::{
 	fs,
 	path::{Path, PathBuf},
+	sync::Arc,
 };
 use log::*;
 use sp_core::{hashing::twox_128};
@@ -112,18 +116,24 @@ use sp_core::{
 	hexdisplay::HexDisplay,
 	storage::{StorageKey, StorageData},
 };
-use futures::{
-	compat::Future01CompatExt,
-	TryFutureExt,
-};
 use codec::{Encode, Decode};
+use jsonrpsee_http_client::{HttpClient, HttpConfig};
 
 type KeyPair = (StorageKey, StorageData);
-type Number = u32;
 type Hash = sp_core::H256;
 // TODO: make these two generic.
 
-const LOG_TARGET: &'static str = "remote-ext";
+const LOG_TARGET: &str = "remote-ext";
+const TARGET: &str = "http://localhost:9933";
+
+jsonrpsee_proc_macros::rpc_client_api! {
+	RpcApi {
+		#[rpc(method = "state_getPairs", positional_params)]
+		fn storage_pairs(prefix: StorageKey, hash: Option<Hash>) -> Vec<(StorageKey, StorageData)>;
+		#[rpc(method = "chain_getFinalizedHead")]
+		fn finalized_head() -> Hash;
+	}
+}
 
 /// The execution mode.
 #[derive(Clone)]
@@ -150,6 +160,10 @@ pub struct OfflineConfig {
 pub struct OnlineConfig {
 	/// The HTTP uri to use.
 	pub uri: String,
+	/// JSONRPC HTTP Client.
+	//
+	// NOTE: Arc is used here because `HttpClient` doesn't implement `Clone`.
+	pub rpc: Arc<HttpClient>,
 	/// The block number at which to connect. Will be latest finalized head if not provided.
 	pub at: Option<Hash>,
 	/// An optional cache file to WRITE to, not for reading. Not cached if set to `None`.
@@ -161,7 +175,13 @@ pub struct OnlineConfig {
 impl Default for OnlineConfig {
 	fn default() -> Self {
 		Self {
-			uri: "http://localhost:9933".into(),
+			uri: TARGET.to_owned(),
+			rpc: Arc::new(
+				HttpClient::new(
+					TARGET,
+					HttpConfig { max_request_body_size: u32::MAX }
+				).expect("valid HTTP url; qed")
+			),
 			at: None,
 			cache: None,
 			modules: Default::default(),
@@ -202,12 +222,7 @@ impl Default for Builder {
 	fn default() -> Self {
 		Self {
 			inject: Default::default(),
-			mode: Mode::Online(OnlineConfig {
-				at: None,
-				uri: "http://localhost:9933".into(),
-				cache: None,
-				modules: Default::default(),
-			}),
+			mode: Mode::Online(OnlineConfig::default())
 		}
 	}
 }
@@ -232,14 +247,10 @@ impl Builder {
 // RPC methods
 impl Builder {
 	async fn rpc_get_head(&self) -> Result<Hash, &'static str> {
-		let uri = self.as_online().uri.clone();
 		trace!(target: LOG_TARGET, "rpc: finalized_head");
-		let client: sc_rpc_api::chain::ChainClient<Number, Hash, (), ()> =
-			jsonrpc_core_client::transports::http::connect(&uri)
-				.compat()
-				.map_err(|_| "client initialization failed")
-				.await?;
-		client.finalized_head().compat().map_err(|_| "rpc finalized_head failed.").await
+		RpcApi::finalized_head(&*self.as_online().rpc)
+			.await
+			.map_err(|_| "rpc finalized_head failed.")
 	}
 
 	/// Relay the request to `state_getPairs` rpc endpoint.
@@ -250,18 +261,10 @@ impl Builder {
 		prefix: StorageKey,
 		at: Hash,
 	) -> Result<Vec<KeyPair>, &'static str> {
-		let uri = self.as_online().uri.clone();
 		trace!(target: LOG_TARGET, "rpc: storage_pairs: {:?} / {:?}", prefix, at);
-		let client: sc_rpc_api::state::StateClient<Hash> =
-			jsonrpc_core_client::transports::http::connect(&uri)
-				.compat()
-				.map_err(|_| "client initialization failed")
-				.await?;
-		client
-			.storage_pairs(prefix, Some(at))
-			.compat()
-			.map_err(|_| "rpc finalized_head failed.")
+		RpcApi::storage_pairs(&*self.as_online().rpc, prefix, Some(at))
 			.await
+			.map_err(|_| "rpc finalized_head failed")
 	}
 }