enha: send original error response in ProxyGetRequest

proc-macros/tests/ui/incorrect/rpc/rpc_empty_bounds.stderr

@@ -17,6 +17,10 @@ error[E0277]: the trait bound `<Conf as Config>::Hash: Clone` is not satisfied
   |
   = note: required for `Result<<Conf as Config>::Hash, ErrorObject<'_>>` to implement `IntoResponse`
   = note: this error originates in the attribute macro `rpc` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider removing this method call, as the receiver has type `&Self` and `&Self: Clone` trivially holds
+  |
+9 | #[rpc(server, client, namespace = "foo", client_bounds(), server_bounds())]
+  |
 
 error[E0277]: the trait bound `<Conf as Config>::Hash: DeserializeOwned` is not satisfied
  --> tests/ui/incorrect/rpc/rpc_empty_bounds.rs:9:1

server/src/middleware/http/proxy_get_request.rs

@@ -36,7 +36,7 @@ use hyper::header::{ACCEPT, CONTENT_TYPE};
 use hyper::http::HeaderValue;
 use hyper::{Method, Uri};
 use jsonrpsee_core::BoxError;
-use jsonrpsee_types::{Id, RequestSer};
+use jsonrpsee_types::{ErrorCode, ErrorObject, Id, RequestSer};
 use std::collections::HashMap;
 use std::future::Future;
 use std::pin::Pin;
@@ -179,16 +179,25 @@ where
 						bytes.extend(data);
 					}
 
-					#[derive(serde::Deserialize)]
-					struct RpcPayload<'a> {
+					#[derive(serde::Deserialize, serde::Serialize, Debug)]
+					struct SuccessResponse<'a> {
 						#[serde(borrow)]
 						result: &'a serde_json::value::RawValue,
 					}
 
-					let response = if let Ok(payload) = serde_json::from_slice::<RpcPayload>(&bytes) {
+					#[derive(serde::Deserialize, serde::Serialize, Debug)]
+					struct ErrorResponse<'a> {
+						#[serde(borrow)]
+						error: &'a serde_json::value::RawValue,
+					}
+
+					let response = if let Ok(payload) = serde_json::from_slice::<SuccessResponse>(&bytes) {
 						http::response::ok_response(payload.result.to_string())
 					} else {
-						http::response::internal_error()
+						let error = serde_json::from_slice::<ErrorResponse>(&bytes)
+							.and_then(|payload| serde_json::from_str::<ErrorObject>(&payload.error.to_string()))
+							.unwrap_or_else(|_| ErrorObject::from(ErrorCode::InternalError));
+						http::response::error_response(error)
 					};
 
 					Ok(response)

server/src/transport/http.rs

@@ -18,7 +18,7 @@
 
 /// Returns true if the `content_type` header indicates a valid JSON message.
 pub fn is_json(content_type: Option<&hyper::header::HeaderValue>) -> bool {
 	content_type.and_then(|val| val.to_str().ok()).map_or(false, |content| {
 		content.eq_ignore_ascii_case("application/json")
 			|| content.eq_ignore_ascii_case("application/json; charset=utf-8")
 			|| content.eq_ignore_ascii_case("application/json;charset=utf-8")
@@ -111,7 +111,7 @@
 /// HTTP response helpers.
 pub mod response {
 	use jsonrpsee_types::error::{reject_too_big_request, ErrorCode};
-	use jsonrpsee_types::{ErrorObjectOwned, Id, Response, ResponsePayload};
+	use jsonrpsee_types::{ErrorObject, ErrorObjectOwned, Id, Response, ResponsePayload};
 
 	use crate::{HttpBody, HttpResponse};
 
@@ -127,6 +127,12 @@
 		from_template(hyper::StatusCode::INTERNAL_SERVER_ERROR, error, JSON)
 	}
 
+	/// Create a json response for general errors returned by the called method.
+	pub fn error_response(error: ErrorObject) -> HttpResponse {
+		let error = serde_json::to_string(&error).expect("JSON serialization infallible; qed");
+		from_template(hyper::StatusCode::INTERNAL_SERVER_ERROR, error, JSON)
+	}
+
 	/// Create a text/plain response for not allowed hosts.
 	pub fn host_not_allowed() -> HttpResponse {
 		from_template(hyper::StatusCode::FORBIDDEN, "Provided Host header is not whitelisted.\n", TEXT)