unify usage of JSON via Box<RawValue>

benches/bench.rs

@@ -113,7 +113,7 @@ pub fn jsonrpsee_types_v2(crit: &mut Criterion) {
 	// Construct the serialized array request using the `RawValue` directly.
 	crit.bench_function("jsonrpsee_types_array_params_baseline", |b| {
 		b.iter(|| {
-			let params = serde_json::value::RawValue::from_string("[1, 2]".to_string()).unwrap();
+			let params = serde_json::value::to_raw_value("[1, 2]").unwrap();
 
 			let request = Request::borrowed("say_hello", Some(&params), Id::Number(0));
 			v2_serialize(request);
@@ -136,8 +136,7 @@ pub fn jsonrpsee_types_v2(crit: &mut Criterion) {
 	// Construct the serialized object request using the `RawValue` directly.
 	crit.bench_function("jsonrpsee_types_object_params_baseline", |b| {
 		b.iter(|| {
-			let params = serde_json::value::RawValue::from_string(r#"{"key": 1}"#.to_string()).unwrap();
-
+			let params = serde_json::value::to_raw_value(r#"{"key": 1}"#).unwrap();
 			let request = Request::borrowed("say_hello", Some(&params), Id::Number(0));
 			v2_serialize(request);
 		})

benches/helpers.rs

@@ -132,7 +132,6 @@ pub async fn http_server(handle: tokio::runtime::Handle) -> (String, jsonrpsee::
 #[cfg(not(feature = "jsonrpc-crate"))]
 pub async fn ws_server(handle: tokio::runtime::Handle) -> (String, jsonrpsee::server::ServerHandle) {
 	use jsonrpsee::server::{ServerBuilder, ServerConfig};
-	use serde_json::value::RawValue;
 
 	let config = ServerConfig::builder()
 		.max_request_body_size(u32::MAX)
@@ -151,7 +150,7 @@ pub async fn ws_server(handle: tokio::runtime::Handle) -> (String, jsonrpsee::se
 			UNSUB_METHOD_NAME,
 			|_params, pending, _ctx, _| async move {
 				let sink = pending.accept().await?;
-				let json = RawValue::from_string("\"Hello\")".to_string()).unwrap();
+				let json = serde_json::value::to_raw_value(&"Hello").unwrap();
 				sink.send(json).await?;
 
 				Ok(())

client/http-client/src/client.rs

@@ -387,13 +387,13 @@ where
 			let id = self.id_manager.next_request_id();
 			let params = params.to_rpc_params()?;
 
-		let method_response = run_future_until_timeout(
-			self.service.call(Request::borrowed(method, params.as_deref(), id.clone())),
-			self.request_timeout,
-		)
-		.await?
-		.into_method_call()
-		.expect("Method call must return a method call response; qed");
+			let method_response = run_future_until_timeout(
+				self.service.call(Request::borrowed(method, params.as_deref(), id.clone())),
+				self.request_timeout,
+			)
+			.await?
+			.into_method_call()
+			.expect("Method call must return a method call reponse; qed");
 
 			let rp = ResponseSuccess::try_from(method_response.into_inner())?;
 

core/src/params.rs

@@ -33,6 +33,7 @@ use serde_json::value::RawValue;
 /// Helper module for building parameters.
 mod params_builder {
 	use serde::Serialize;
+	use serde_json::value::RawValue;
 
 	/// Initial number of bytes for a parameter length.
 	const PARAM_BYTES_CAPACITY: usize = 128;
@@ -107,7 +108,7 @@ mod params_builder {
 		}
 
 		/// Finish the building process and return a JSON compatible string.
-		pub(crate) fn build(mut self) -> Option<String> {
+		pub(crate) fn build(mut self) -> Option<Box<RawValue>> {
 			if self.bytes.is_empty() {
 				return None;
 			}
@@ -120,7 +121,8 @@ mod params_builder {
 			}
 
 			// Safety: This is safe because JSON does not emit invalid UTF-8.
-			Some(unsafe { String::from_utf8_unchecked(self.bytes) })
+			let json_str = unsafe { String::from_utf8_unchecked(self.bytes) };
+			Some(RawValue::from_string(json_str).expect("Valid JSON; qed"))
 		}
 	}
 }
@@ -164,7 +166,7 @@ impl Default for ObjectParams {
 
 impl ToRpcParams for ObjectParams {
 	fn to_rpc_params(self) -> Result<Option<Box<RawValue>>, serde_json::Error> {
-		if let Some(json) = self.0.build() { RawValue::from_string(json).map(Some) } else { Ok(None) }
+		Ok(self.0.build())
 	}
 }
 
@@ -206,7 +208,7 @@ impl Default for ArrayParams {
 
 impl ToRpcParams for ArrayParams {
 	fn to_rpc_params(self) -> Result<Option<Box<RawValue>>, serde_json::Error> {
-		if let Some(json) = self.0.build() { RawValue::from_string(json).map(Some) } else { Ok(None) }
+		Ok(self.0.build())
 	}
 }
 

core/src/server/rpc_module.rs

@@ -325,15 +325,15 @@ impl Methods {
 	/// async fn main() {
 	///     use jsonrpsee::{RpcModule, SubscriptionMessage};
 	///     use jsonrpsee::types::{response::Success, Response};
-	///     use jsonrpsee::core::JsonRawValue;
+	///     use jsonrpsee::core::to_json_raw_value;
 	///     use futures_util::StreamExt;
 	///
 	///     let mut module = RpcModule::new(());
 	///     module.register_subscription("hi", "hi", "goodbye", |_, pending, _, _| async {
 	///         let sink = pending.accept().await?;
 	///
 	///         // see comment above.
-	///         let msg = JsonRawValue::from_string("\"one answer\"".into()).unwrap();  
+	///         let msg = to_json_raw_value(&"one answer").unwrap();
 	///         sink.send(msg).await?;
 	///
 	///         Ok(())
@@ -423,12 +423,12 @@ impl Methods {
 	/// #[tokio::main]
 	/// async fn main() {
 	///     use jsonrpsee::{RpcModule, SubscriptionMessage};
-	///     use jsonrpsee::core::{EmptyServerParams, RpcResult, JsonRawValue};
+	///     use jsonrpsee::core::{EmptyServerParams, RpcResult, to_json_raw_value};
 	///
 	///     let mut module = RpcModule::new(());
 	///     module.register_subscription("hi", "hi", "goodbye", |_, pending, _, _| async move {
 	///         let sink = pending.accept().await?;
-	///         let msg = JsonRawValue::from_string("\"one answer\"".into()).unwrap();  
+	///         let msg = to_json_raw_value(&"one answer").unwrap();
 	///         sink.send(msg).await?;
 	///         Ok(())
 	///     }).unwrap();

core/src/traits.rs

@@ -50,7 +50,7 @@ use serde_json::value::RawValue;
 /// impl ToRpcParams for ManualParam {
 ///     fn to_rpc_params(self) -> Result<Option<Box<RawValue>>, serde_json::Error> {
 ///         // Manually define a valid JSONRPC parameter.
-///         RawValue::from_string("[1, \"2\", 3]".to_string()).map(Some)
+///         serde_json::value::to_raw_value("[1,2,3]").map(Some)
 ///     }
 /// }
 /// ```
@@ -85,8 +85,8 @@ pub trait ToRpcParams {
 macro_rules! to_rpc_params_impl {
 	() => {
 		fn to_rpc_params(self) -> Result<Option<Box<RawValue>>, serde_json::Error> {
-			let json = serde_json::to_string(&self)?;
-			RawValue::from_string(json).map(Some)
+			let json = serde_json::value::to_raw_value(&self)?;
+			Ok(Some(json))
 		}
 	};
 }

proc-macros/src/lib.rs

@@ -148,7 +148,7 @@
 /// - `namespace`: add a prefix to all the methods and subscriptions in this RPC. For example, with namespace `foo` and
 ///   method `spam`, the resulting method name will be `foo_spam`.
 /// - `namespace_separator`: customize the separator used between namespace and method name. Defaults to `_`.
 ///		For example, `namespace = "foo", namespace_separator = "."` results in method names like `foo.bar` instead of `foo_bar`.
 /// - `server_bounds`: replace *all* auto-generated trait bounds with the user-defined ones for the server
 ///   implementation.
 /// - `client_bounds`: replace *all* auto-generated trait bounds with the user-defined ones for the client
@@ -233,7 +233,7 @@
 /// mod rpc_impl {
 ///     use jsonrpsee::{proc_macros::rpc, Extensions};
 ///     use jsonrpsee::server::{PendingSubscriptionSink, SubscriptionMessage, IntoSubscriptionCloseResponse, SubscriptionCloseResponse};
-///     use jsonrpsee::core::{async_trait, RpcResult, SubscriptionResult, JsonRawValue};
+///     use jsonrpsee::core::{async_trait, RpcResult, SubscriptionResult, to_json_raw_value};
 ///
 ///     enum CloseResponse {
 ///         None,
@@ -248,8 +248,7 @@
 ///                // Send a close response as an ordinary subscription notification
 ///                // when the subscription is terminated.
 ///                CloseResponse::Failed => {
-///                     const FAILED: &str = "\"Failed\"";
-///                     let err = JsonRawValue::from_string(FAILED.to_string()).unwrap();
+///                     let err = to_json_raw_value(&"Failed").unwrap();
 ///                     SubscriptionCloseResponse::Notif(err.into())
 ///                }
 ///            }
@@ -336,7 +335,7 @@
 ///         // as subscription responses.
 ///         async fn sub_override_notif_method(&self, pending: PendingSubscriptionSink) -> SubscriptionResult {
 ///             let mut sink = pending.accept().await?;
-///             let msg = JsonRawValue::from_string("\"Response_A\"".into()).unwrap();
+///             let msg = to_json_raw_value(&"Response_A").unwrap();
 ///             sink.send(msg).await?;
 ///             Ok(())
 ///         }
@@ -345,8 +344,8 @@
 ///         async fn sub(&self, pending: PendingSubscriptionSink) -> SubscriptionResult {
 ///             let sink = pending.accept().await?;
 ///
-///             let msg1 = JsonRawValue::from_string("\"Response_A\"".into()).unwrap();
-///             let msg2 = JsonRawValue::from_string("\"Response_B\"".into()).unwrap();
+///             let msg1 = to_json_raw_value(&"Response_A").unwrap();
+///             let msg2 = to_json_raw_value(&"Response_B").unwrap();
 ///
 ///             sink.send(msg1).await?;
 ///             sink.send(msg2).await?;
@@ -362,7 +361,7 @@
 ///                 return CloseResponse::None;
 ///             };
 ///
-///             let msg = JsonRawValue::from_string("\"Response_A\"".into()).unwrap();
+///             let msg = to_json_raw_value(&"Response_A").unwrap();
 ///
 ///             if sink.send(msg).await.is_ok() {
 ///                 CloseResponse::Failed

proc-macros/tests/ui/correct/basic.rs

@@ -4,7 +4,7 @@ use std::net::SocketAddr;
 
 use jsonrpsee::core::client::ClientT;
 use jsonrpsee::core::params::ArrayParams;
-use jsonrpsee::core::{JsonRawValue, RpcResult, SubscriptionResult, async_trait};
+use jsonrpsee::core::{RpcResult, SubscriptionResult, async_trait, to_json_raw_value};
 use jsonrpsee::proc_macros::rpc;
 use jsonrpsee::types::ErrorObject;
 use jsonrpsee::ws_client::*;
@@ -96,11 +96,11 @@ impl RpcServer for RpcServerImpl {
 	async fn sub(&self, pending: PendingSubscriptionSink) -> SubscriptionResult {
 		let sink = pending.accept().await?;
 
-		let response_a = JsonRawValue::from_string("\"Response_A\"".into()).unwrap();
-		let response_b = JsonRawValue::from_string("\"Response_B\"".into()).unwrap();
+		let msg1 = to_json_raw_value(&"Response_A").unwrap();
+		let msg2 = to_json_raw_value(&"Response_B").unwrap();
 
-		sink.send(response_a).await?;
-		sink.send(response_b).await?;
+		sink.send(msg1).await?;
+		sink.send(msg2).await?;
 
 		Ok(())
 	}

proc-macros/tests/ui/correct/only_server.rs

@@ -1,6 +1,6 @@
 use std::net::SocketAddr;
 
-use jsonrpsee::core::{JsonRawValue, RpcResult, SubscriptionResult, async_trait};
+use jsonrpsee::core::{RpcResult, SubscriptionResult, async_trait, to_json_raw_value};
 use jsonrpsee::proc_macros::rpc;
 use jsonrpsee::server::{PendingSubscriptionSink, ServerBuilder};
 
@@ -31,11 +31,10 @@ impl RpcServer for RpcServerImpl {
 	async fn sub(&self, pending: PendingSubscriptionSink) -> SubscriptionResult {
 		let sink = pending.accept().await?;
 
-		let response_a = JsonRawValue::from_string("\"Response_A\"".into()).unwrap();
-		let response_b = JsonRawValue::from_string("\"Response_B\"".into()).unwrap();
-
-		sink.send(response_a).await?;
-		sink.send(response_b).await?;
+		let msg1 = to_json_raw_value(&"Response_A").unwrap();
+		let msg2 = to_json_raw_value(&"Response_B").unwrap();
+		sink.send(msg1).await?;
+		sink.send(msg2).await?;
 
 		Ok(())
 	}

tests/proc-macro-core/src/lib.rs

@@ -1,7 +1,7 @@
 //! Test module for the proc-macro API to make sure that it compiles with the core features.
 
 use jsonrpsee::PendingSubscriptionSink;
-use jsonrpsee::core::{JsonRawValue, SubscriptionResult, async_trait};
+use jsonrpsee::core::{SubscriptionResult, async_trait, to_json_raw_value};
 use jsonrpsee::proc_macros::rpc;
 use jsonrpsee::types::ErrorObjectOwned;
 use serde::{Deserialize, Serialize};
@@ -52,7 +52,7 @@ impl ApiServer for () {
 
 	async fn sub(&self, pending: PendingSubscriptionSink, _: PubSubKind, _: PubSubParams) -> SubscriptionResult {
 		let sink = pending.accept().await?;
-		let msg = JsonRawValue::from_string("\"msg\"".into())?;
+		let msg = to_json_raw_value("msg")?;
 		sink.send(msg).await?;
 		Ok(())
 	}

tests/tests/proc_macros.rs

@@ -47,7 +47,6 @@ mod rpc_impl {
 	use jsonrpsee::core::{SubscriptionResult, async_trait};
 	use jsonrpsee::proc_macros::rpc;
 	use jsonrpsee::types::{ErrorObject, ErrorObjectOwned};
-	use serde_json::value::RawValue;
 
 	pub struct CustomSubscriptionRet;
 
@@ -178,7 +177,7 @@ mod rpc_impl {
 
 		async fn sub_not_result(&self, pending: PendingSubscriptionSink) {
 			let sink = pending.accept().await.unwrap();
-			let msg = RawValue::from_string("\"lo\"".into()).unwrap();
+			let msg = serde_json::value::to_raw_value("lo").unwrap();
 			sink.send(msg).await.unwrap();
 		}
 
@@ -189,7 +188,7 @@ mod rpc_impl {
 		fn sync_sub(&self, pending: PendingSubscriptionSink) {
 			tokio::spawn(async move {
 				let sink = pending.accept().await.unwrap();
-				let msg = RawValue::from_string("\"hello\"".into()).unwrap();
+				let msg = serde_json::value::to_raw_value("hello").unwrap();
 				sink.send(msg).await.unwrap();
 			});
 		}

tests/tests/rpc_module.rs

@@ -274,7 +274,7 @@ async fn close_test_subscribing_without_server() {
 	module
 		.register_subscription("my_sub", "my_sub", "my_unsub", |_, pending, _, _| async move {
 			let sink = pending.accept().await?;
-			let msg = RawValue::from_string("\"lo\"".into())?;
+			let msg = serde_json::value::to_raw_value("lo")?;
 
 			// make sure to only send one item
 			sink.send(msg.clone()).await?;

types/src/request.rs

@@ -236,7 +236,7 @@ mod test {
 	fn serialize_call() {
 		let method = "subtract";
 		let id = Id::Number(1); // It's enough to check one variant, since the type itself also has tests.
-		let params = Some(RawValue::from_string("[42,23]".into()).unwrap());
+		let params = Some(serde_json::value::to_raw_value("[42,23]").unwrap());
 
 		let test_vector: &[(&'static str, Option<_>, Option<_>, &'static str)] = &[
 			// With all fields set.