Test jsonrpsee v0.20

Cargo.toml

@@ -41,7 +41,8 @@ url = { version = "2.0.0", optional = true }
 
 # websocket dependent features
 futures = { version = "0.3", optional = true }
-jsonrpsee = { version = "0.16", optional = true, features = ["async-client", "client-ws-transport", "jsonrpsee-types"] }
+jsonrpsee = { version = "0.20", optional = true, features = ["async-client", "client-ws-transport-native-tls", "jsonrpsee-types"] }
+tokio = { version = "1.34", optional = true }
 tungstenite = { version = "0.21", optional = true, features = ["native-tls"] }
 ws = { version = "0.9.2", optional = true, features = ["ssl"] }
 
@@ -80,7 +81,7 @@ sync-api = ["ac-compose-macros/sync-api", "maybe-async/is_sync"]
 # Use the `jsonrpsee` crate for websocket communication. Does provide sync and async support but needs a tokio runtime.
 # Provides convenience functions such as subscription callbacks.
 # Most examples use the `jsonrpsee` feature and can be used for reference.
-jsonrpsee-client = ["std", "jsonrpsee", "futures"]
+jsonrpsee-client = ["std", "jsonrpsee", "futures", "tokio"]
 
 # Use the `tungstenite` crate for websocket communication. No async support but has some reconnection capabilities.
 # See the example `transfer_with_tungstenite_client` on how to use it.

src/rpc/jsonrpsee_client/mod.rs

@@ -14,15 +14,16 @@
 use crate::rpc::{Error, Request, Result, RpcParams, Subscribe};
 use futures::executor::block_on;
 use jsonrpsee::{
-	client_transport::ws::{Uri, WsTransportClientBuilder},
+	client_transport::ws::{Url, WsTransportClientBuilder},
 	core::{
 		client::{Client, ClientBuilder, ClientT, SubscriptionClientT},
 		traits::ToRpcParams,
 	},
 };
 use serde::de::DeserializeOwned;
-use serde_json::value::RawValue;
+use serde_json::{value::RawValue, Value};
 use std::sync::Arc;
+use tokio::runtime::Handle;
 
 pub use subscription::SubscriptionWrapper;
 
@@ -43,13 +44,13 @@ impl JsonrpseeClient {
 	}
 
 	pub async fn async_new(url: &str) -> Result<Self> {
-		let uri: Uri = url.parse().map_err(|e| Error::Client(Box::new(e)))?;
+		let uri: Url = url.parse().map_err(|e| Error::Client(Box::new(e)))?;
 		let (tx, rx) = WsTransportClientBuilder::default()
 			.build(uri)
 			.await
 			.map_err(|e| Error::Client(Box::new(e)))?;
 		let client = ClientBuilder::default()
-			.max_notifs_per_subscription(4096)
+			.max_buffer_capacity_per_subscription(4096)
 			.build_with_tokio(tx, rx);
 		Ok(Self { inner: Arc::new(client) })
 	}
@@ -64,11 +65,38 @@ impl Request for JsonrpseeClient {
 			.map_err(|e| Error::Client(Box::new(e)))
 	}
 }
+
 #[maybe_async::sync_impl]
 impl Request for JsonrpseeClient {
 	fn request<R: DeserializeOwned>(&self, method: &str, params: RpcParams) -> Result<R> {
-		block_on(self.inner.request(method, RpcParamsWrapper(params)))
-			.map_err(|e| Error::Client(Box::new(e)))
+		let handle = match Handle::try_current() {
+			Ok(handle) => handle,
+			Err(_) => {
+				// We are not inside a tokio runtime, so lets start one.
+				let rt =
+					tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap();
+				rt.handle().clone()
+			},
+		};
+
+		let client = self.inner.clone();
+		let method_string = method.to_string();
+
+		// The inner jsonrpsee client must not deserialize to the `R` value, because the return value must
+		// implement `Send`. But we do not want to enforce the `R` value to implement this solely because we need
+		// to de-async something. Therefore, the deserialization must happen outside of the newly spawned thread.
+		// We need to spawn a new thread because tokio does not allow the blocking of the main thread:
+		// ERROR: Cannot block the current thread from within a runtime.
+		// This happens because a function attempted to block the current thread while the thread is being used to drive asynchronous tasks.
+		let answer: Value = std::thread::spawn(move || {
+			handle.block_on(client.request(&method_string, RpcParamsWrapper(params)))
+		})
+		.join()
+		.unwrap()
+		.map_err(|e| Error::Client(Box::new(e)))?;
+
+		let deserialized_value: R = serde_json::from_value(answer)?;
+		Ok(deserialized_value)
 	}
 }