Propagate cause of InvalidParams

http-server/src/tests.rs

@@ -158,11 +158,12 @@ async fn single_method_call_with_multiple_params_of_different_types() {
 async fn single_method_call_with_faulty_params_returns_err() {
 	let addr = server().with_default_timeout().await.unwrap();
 	let uri = to_http_uri(addr);
+	let expected = r#"{"jsonrpc":"2.0","error":{"code":-32602,"message":"invalid type: string \"this should be a number\", expected u64 at line 1 column 26"},"id":1}"#;
 
-	let req = r#"{"jsonrpc":"2.0","method":"add", "params":["Invalid"],"id":1}"#;
+	let req = r#"{"jsonrpc":"2.0","method":"add", "params":["this should be a number"],"id":1}"#;
 	let response = http_request(req.into(), uri).with_default_timeout().await.unwrap().unwrap();
 	assert_eq!(response.status, StatusCode::OK);
-	assert_eq!(response.body, invalid_params(Id::Num(1)));
+	assert_eq!(response.body, expected);
 }
 
 #[tokio::test]

proc-macros/Cargo.toml

@@ -19,6 +19,7 @@ quote = "1.0"
 syn = { version = "1.0", default-features = false, features = ["extra-traits", "full", "visit", "parsing"] }
 proc-macro-crate = "1"
 bae = "0.1.6"
+log = "0.4"
 
 [dev-dependencies]
 jsonrpsee = { path = "../jsonrpsee", features = ["full"] }

proc-macros/src/lib.rs

@@ -66,6 +66,8 @@ pub(crate) mod visitor;
 /// To use the `FooClient`, just import it in the context. To use the server, the `FooServer` trait must be implemented
 /// on your type first.
 ///
+/// Note: you need to import the `jsonrpsee` façade crate in your code for the macro to work properly.
+///
 /// ## Prerequisites
 ///
 /// - Implementors of the server trait must be `Sync`, `Send`, `Sized` and `'static`. If you want to implement this

proc-macros/src/render_server.rs

@@ -121,7 +121,8 @@ impl RpcDescription {
 				let rpc_method_name = self.rpc_identifier(&method.name);
 				// `parsing` is the code associated with parsing structure from the
 				// provided `RpcParams` object.
-				// `params_seq` is the comma-delimited sequence of parameters.
+				// `params_seq` is the comma-delimited sequence of parameters we're passing to the rust function
+				// called..
 				let (parsing, params_seq) = self.render_params_decoding(&method.params);
 
 				check_name(&rpc_method_name, rust_method_name.span());
@@ -272,11 +273,23 @@ impl RpcDescription {
 			let decode_fields = params.iter().map(|(name, ty)| {
 				if is_option(ty) {
 					quote! {
-						let #name: #ty = seq.optional_next()?;
+						let #name: #ty = match seq.optional_next() {
+							Ok(v) => v,
+							Err(e) => {
+								log::error!("Error parsing optional {:?} as {:?}: {:?}", stringify!(#name), stringify!(#ty), e);
+								return Err(e.into())
+							}
+						};
 					}
 				} else {
 					quote! {
-						let #name: #ty = seq.next()?;
+						let #name: #ty = match seq.next() {
+							Ok(v) => v,
+							Err(e) => {
+								log::error!("Error parsing {:?} as {:?}: {:?}", stringify!(#name), stringify!(#ty), e);
+								return Err(e.into())
+							}
+						};
 					}
 				}
 			});

tests/Cargo.toml

@@ -13,4 +13,5 @@ env_logger = "0.9"
 futures-channel = { version = "0.3.14", default-features = false }
 jsonrpsee = { path = "../jsonrpsee", features = ["full"] }
 tokio = { version = "1", features = ["full"] }
-serde_json = "1"
+serde_json = "1"
+log = "0.4"

tests/tests/proc_macros.rs

@@ -256,7 +256,8 @@ async fn macro_optional_param_parsing() {
 	// Named params using a map
 	let params = RawValue::from_string(r#"{"a": 22, "c": 50}"#.into()).ok();
 	let result = module.call("foo_optional_params", params).await.unwrap();
-	assert_eq!(result, r#"{"jsonrpc":"2.0","error":{"code":-32602,"message":"Invalid params"},"id":0}"#);
+	let expected = r#"{"jsonrpc":"2.0","error":{"code":-32602,"message":"Invalid params. Expected one of '[', ']' or ',' but found \"{\\\"a\\\": 22, \\\"c\\\": 50}\""},"id":0}"#;
+	assert_eq!(result, expected);
 }
 
 #[tokio::test]

types/src/error.rs

@@ -47,8 +47,8 @@ impl<T: fmt::Display> fmt::Display for Mismatch<T> {
 #[derive(Debug, thiserror::Error)]
 pub enum CallError {
 	/// Invalid params in the call.
-	#[error("Invalid params in the call")]
-	InvalidParams,
+	#[error("Invalid params in the call: {0}")]
+	InvalidParams(#[source] anyhow::Error),
 	/// The call failed (let jsonrpsee assign default error code and error message).
 	#[error("RPC Call failed: {0}")]
 	Failed(#[from] anyhow::Error),
@@ -162,7 +162,7 @@ impl Error {
 /// Error type with a special `subscription_closed` field to detect that
 /// a subscription has been closed to distinguish valid items produced
 /// by the server on the subscription stream from an error.
-#[derive(Deserialize, Serialize, Debug)]
+#[derive(Deserialize, Serialize, Debug, PartialEq)]
 pub struct SubscriptionClosedError {
 	subscription_closed: String,
 }

types/src/traits.rs

@@ -88,10 +88,10 @@ pub trait SubscriptionClient: Client {
 
 /// Marker trait for types that can be serialized as JSON array/sequence.
 ///
-/// If your type isn't a sequence such as `String`, `usize` or similar.
-/// You could insert it in a tuple, slice, array or Vec for it to work.
+/// If your type isn't a sequence, for example `String`, `usize` or similar
+/// you must insert it in a tuple, slice, array or Vec for it to work.
 pub trait ToRpcParams: Serialize {
-	/// Serialized the type as a JSON array.
+	/// Serialize the type as a JSON array.
 	fn to_rpc_params(&self) -> Result<Box<RawValue>, serde_json::Error> {
 		serde_json::to_string(&self).map(|json| RawValue::from_string(json).expect("JSON String; qed"))
 	}
@@ -110,7 +110,7 @@ macro_rules! array_impls {
 }
 
 array_impls! {
-	1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
+	0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
 }
 
 macro_rules! tuple_impls {

types/src/v2/params.rs

@@ -26,6 +26,7 @@
 
 use crate::error::CallError;
 use alloc::collections::BTreeMap;
+use anyhow::anyhow;
 use beef::Cow;
 use serde::de::{self, Deserializer, Unexpected, Visitor};
 use serde::ser::Serializer;
@@ -128,7 +129,7 @@ impl<'a> RpcParams<'a> {
 	{
 		// NOTE(niklasad1): Option::None is serialized as `null` so we provide that here.
 		let params = self.0.as_ref().map(AsRef::as_ref).unwrap_or("null");
-		serde_json::from_str(params).map_err(|_| CallError::InvalidParams)
+		serde_json::from_str(params).map_err(|e| CallError::InvalidParams(e.into()))
 	}
 
 	/// Attempt to parse parameters as an array of a single value of type `T`, and returns that value.
@@ -163,15 +164,20 @@ impl<'a> RpcParamsSequence<'a> {
 		T: Deserialize<'a>,
 	{
 		let mut json = self.0;
-
+		log::trace!("[next_inner] Params JSON: {:?}", json);
 		match json.as_bytes().get(0)? {
 			b']' => {
 				self.0 = "";
 
+				log::trace!("[next_inner] Reached end of sequence.");
 				return None;
 			}
 			b'[' | b',' => json = &json[1..],
-			_ => return Some(Err(CallError::InvalidParams)),
+			_ => {
+				let errmsg = format!("Invalid params. Expected one of '[', ']' or ',' but found {:?}", json);
+				log::error!("[next_inner] {}", errmsg);
+				return Some(Err(CallError::InvalidParams(anyhow!(errmsg))));
+			}
 		}
 
 		let mut iter = serde_json::Deserializer::from_str(json).into_iter::<T>();
@@ -182,10 +188,16 @@ impl<'a> RpcParamsSequence<'a> {
 
 				Some(Ok(value))
 			}
-			Err(_) => {
+			Err(e) => {
+				log::error!(
+					"[next_inner] Deserialization to {:?} failed. Error: {:?}, input JSON: {:?}",
+					std::any::type_name::<T>(),
+					e,
+					json
+				);
 				self.0 = "";
 
-				Some(Err(CallError::InvalidParams))
+				Some(Err(CallError::InvalidParams(e.into())))
 			}
 		}
 	}
@@ -211,7 +223,7 @@ impl<'a> RpcParamsSequence<'a> {
 	{
 		match self.next_inner() {
 			Some(result) => result,
-			None => Err(CallError::InvalidParams),
+			None => Err(CallError::InvalidParams(anyhow!("No more params"))),
 		}
 	}
 

utils/Cargo.toml

@@ -38,4 +38,6 @@ server = [
 
 [dev-dependencies]
 serde_json = "1.0"
-tokio = { version = "1", features = ["macros", "rt"] }
+env_logger = "0.9"
+tokio = { version = "1", features = ["macros", "rt"] }
+jsonrpsee = { path = "../jsonrpsee" }

utils/src/server/helpers.rs

@@ -61,7 +61,7 @@ pub fn send_error(id: Id, tx: &MethodSink, error: JsonRpcErrorObject) {
 	};
 
 	if let Err(err) = tx.unbounded_send(json) {
-		log::error!("Error sending response to the client: {:?}", err)
+		log::error!("Could not send error response to the client: {:?}", err)
 	}
 }