[client] use types v2 (less alloc)

Cargo.toml

@@ -6,6 +6,7 @@ members = [
 	"http-server",
 	"test-utils",
 	"jsonrpsee",
+	"tests",
 	"types",
 	"utils",
 	"ws-client",

benches/Cargo.toml

@@ -12,6 +12,7 @@ criterion = "0.3"
 futures-channel = "0.3"
 jsonrpsee = { path = "../jsonrpsee", features = ["full"] }
 num_cpus = "1"
+serde_json = "1"
 tokio = { version = "1", features = ["full"] }
 
 [[bench]]

benches/bench.rs

@@ -1,16 +1,44 @@
 use criterion::*;
 use jsonrpsee::{
-	http_client::{jsonrpc::Params, Client, HttpClientBuilder},
+	http_client::{
+		traits::Client,
+		v2::params::{Id, JsonRpcParams},
+		v2::request::JsonRpcCallSer,
+		HttpClientBuilder,
+	},
 	ws_client::WsClientBuilder,
 };
 use std::sync::Arc;
 use tokio::runtime::Runtime as TokioRuntime;
 
 mod helpers;
 
-criterion_group!(benches, http_requests, websocket_requests);
+criterion_group!(benches, http_requests, websocket_requests, jsonrpsee_types_v2);
 criterion_main!(benches);
 
+fn v2_serialize<'a>(req: JsonRpcCallSer<'a>) -> String {
+	serde_json::to_string(&req).unwrap()
+}
+
+pub fn jsonrpsee_types_v2(crit: &mut Criterion) {
+	crit.bench_function("jsonrpsee_types_v2_array_ref", |b| {
+		b.iter(|| {
+			let params = &[1_u64.into(), 2_u32.into()];
+			let params = JsonRpcParams::ArrayRef(params);
+			let request = JsonRpcCallSer::new(Id::Number(0), "say_hello", params);
+			v2_serialize(request);
+		})
+	});
+
+	crit.bench_function("jsonrpsee_types_v2_vec", |b| {
+		b.iter(|| {
+			let params = JsonRpcParams::Array(vec![1_u64.into(), 2_u32.into()]);
+			let request = JsonRpcCallSer::new(Id::Number(0), "say_hello", params);
+			v2_serialize(request);
+		})
+	});
+}
+
 pub fn http_requests(crit: &mut Criterion) {
 	let rt = TokioRuntime::new().unwrap();
 	let url = rt.block_on(helpers::http_server());
@@ -22,7 +50,8 @@ pub fn http_requests(crit: &mut Criterion) {
 pub fn websocket_requests(crit: &mut Criterion) {
 	let rt = TokioRuntime::new().unwrap();
 	let url = rt.block_on(helpers::ws_server());
-	let client = Arc::new(rt.block_on(WsClientBuilder::default().build(&url)).unwrap());
+	let client =
+		Arc::new(rt.block_on(WsClientBuilder::default().max_concurrent_requests(1024 * 1024).build(&url)).unwrap());
 	run_round_trip(&rt, crit, client.clone(), "ws_round_trip");
 	run_concurrent_round_trip(&rt, crit, client.clone(), "ws_concurrent_round_trip");
 }
@@ -31,7 +60,7 @@ fn run_round_trip(rt: &TokioRuntime, crit: &mut Criterion, client: Arc<impl Clie
 	crit.bench_function(name, |b| {
 		b.iter(|| {
 			rt.block_on(async {
-				black_box(client.request::<String, _, _>("say_hello", Params::None).await.unwrap());
+				black_box(client.request::<String>("say_hello", JsonRpcParams::NoParams).await.unwrap());
 			})
 		})
 	});
@@ -51,7 +80,8 @@ fn run_concurrent_round_trip<C: 'static + Client + Send + Sync>(
 				for _ in 0..num_concurrent_tasks {
 					let client_rc = client.clone();
 					let task = rt.spawn(async move {
-						let _ = black_box(client_rc.request::<String, _, _>("say_hello", Params::None)).await;
+						let _ =
+							black_box(client_rc.request::<String>("say_hello", JsonRpcParams::NoParams).await.unwrap());
 					});
 					tasks.push(task);
 				}

examples/Cargo.toml

@@ -24,3 +24,7 @@ path = "ws.rs"
 [[example]]
 name = "ws_subscription"
 path = "ws_subscription.rs"
+
+[[example]]
+name = "proc_macro"
+path = "proc_macro.rs"

examples/http.rs

@@ -25,7 +25,7 @@
 // DEALINGS IN THE SOFTWARE.
 
 use jsonrpsee::{
-	http_client::{jsonrpc::Params, Client, HttpClientBuilder},
+	http_client::{traits::Client, HttpClientBuilder, JsonValue},
 	http_server::HttpServerBuilder,
 };
 use std::net::SocketAddr;
@@ -37,8 +37,10 @@ async fn main() -> anyhow::Result<()> {
 	let server_addr = run_server().await?;
 	let url = format!("http://{}", server_addr);
 
+	let params: &[JsonValue] = &[1_u64.into(), 2.into(), 3.into()];
+
 	let client = HttpClientBuilder::default().build(url)?;
-	let response: Result<String, _> = client.request("say_hello", Params::None).await;
+	let response: Result<String, _> = client.request("say_hello", params.into()).await;
 	println!("r: {:?}", response);
 
 	Ok(())

types/src/jsonrpc/wrapped/notification.rs → examples/proc_macro.rs

@@ -24,41 +24,34 @@
 // IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
-use crate::jsonrpc::{self, wrapped::Params};
-use core::fmt;
+use jsonrpsee::{http_client::HttpClientBuilder, http_server::HttpServerBuilder};
+use std::net::SocketAddr;
 
-/// Notification received on a server.
-///
-/// Wraps around a `jsonrpc::Notification`.
-#[derive(PartialEq)]
-pub struct Notification(jsonrpc::Notification);
-
-impl From<jsonrpc::Notification> for Notification {
-	fn from(notif: jsonrpc::Notification) -> Notification {
-		Notification(notif)
+jsonrpsee::proc_macros::rpc_client_api! {
+	RpcApi {
+		#[rpc(method = "state_getPairs", positional_params)]
+		fn storage_pairs(prefix: usize, hash: Option<String>) -> Vec<u8>;
 	}
 }
 
-impl From<Notification> for jsonrpc::Notification {
-	fn from(notif: Notification) -> jsonrpc::Notification {
-		notif.0
-	}
-}
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+	env_logger::init();
 
-impl Notification {
-	/// Returns the method of this notification.
-	pub fn method(&self) -> &str {
-		&self.0.method
-	}
+	let server_addr = run_server().await?;
+	let url = format!("http://{}", server_addr);
 
-	/// Returns the parameters of the notification.
-	pub fn params(&self) -> Params {
-		Params::from(&self.0.params)
-	}
+	let client = HttpClientBuilder::default().build(url)?;
+	let response = RpcApi::storage_pairs(&client, 0_usize, Some("aaa".to_string())).await?;
+	println!("r: {:?}", response);
+
+	Ok(())
 }
 
-impl fmt::Debug for Notification {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		f.debug_struct("Notification").field("method", &self.method()).field("params", &self.params()).finish()
-	}
+async fn run_server() -> anyhow::Result<SocketAddr> {
+	let mut server = HttpServerBuilder::default().build("127.0.0.1:0".parse()?)?;
+	server.register_method("state_getPairs", |_| Ok(vec![1, 2, 3]))?;
+	let addr = server.local_addr();
+	tokio::spawn(async move { server.start().await });
+	addr
 }

examples/ws.rs

@@ -25,7 +25,7 @@
 // DEALINGS IN THE SOFTWARE.
 
 use jsonrpsee::{
-	ws_client::{jsonrpc::Params, Client, WsClientBuilder},
+	ws_client::{traits::Client, v2::params::JsonRpcParams, WsClientBuilder},
 	ws_server::WsServer,
 };
 use std::net::SocketAddr;
@@ -37,7 +37,7 @@ async fn main() -> anyhow::Result<()> {
 	let url = format!("ws://{}", addr);
 
 	let client = WsClientBuilder::default().build(&url).await?;
-	let response: String = client.request("say_hello", Params::None).await?;
+	let response: String = client.request("say_hello", JsonRpcParams::NoParams).await?;
 	println!("r: {:?}", response);
 
 	Ok(())

examples/ws_subscription.rs

@@ -25,7 +25,7 @@
 // DEALINGS IN THE SOFTWARE.
 
 use jsonrpsee::{
-	ws_client::{jsonrpc::Params, SubscriptionClient, WsClientBuilder, WsSubscription},
+	ws_client::{traits::SubscriptionClient, v2::params::JsonRpcParams, Subscription, WsClientBuilder},
 	ws_server::WsServer,
 };
 use std::net::SocketAddr;
@@ -39,8 +39,8 @@ async fn main() -> anyhow::Result<()> {
 	let url = format!("ws://{}", addr);
 
 	let client = WsClientBuilder::default().build(&url).await?;
-	let mut subscribe_hello: WsSubscription<String> =
-		client.subscribe("subscribe_hello", Params::None, "unsubscribe_hello").await?;
+	let mut subscribe_hello: Subscription<String> =
+		client.subscribe("subscribe_hello", JsonRpcParams::NoParams, "unsubscribe_hello").await?;
 
 	let mut i = 0;
 	while i <= NUM_SUBSCRIPTION_RESPONSES {

http-client/Cargo.toml

@@ -18,7 +18,6 @@ log = "0.4"
 serde = { version = "1.0", default-features = false, features = ["derive"] }
 serde_json = "1.0"
 thiserror = "1.0"
-unicase = "2.6"
 url = "2.2"
 fnv = "1"