Fix too-big-request error (#677)

* Fix BackgroundDevnet::send_custom_rpc; fix too big rpc req test

Author: FabijanC

crates/starknet-devnet-server/src/server.rs

@@ -18,6 +18,8 @@ use tower_http::trace::TraceLayer;
 use crate::api::http::{endpoints as http, HttpApiHandler};
 use crate::api::json_rpc::JsonRpcHandler;
 use crate::restrictive_mode::is_uri_path_restricted;
+use crate::rpc_core::error::RpcError;
+use crate::rpc_core::response::ResponseResult;
 use crate::rpc_handler::RpcHandler;
 use crate::{http_rpc_router, rpc_handler, ServerConfig};
 pub type StarknetDevnetServer = axum::serve::Serve<IntoMakeService<Router>, Router>;
@@ -174,20 +176,27 @@ async fn reject_too_big(
     request: Request,
     next: Next,
 ) -> Result<impl IntoResponse, (StatusCode, String)> {
+    fn bad_request(e: impl std::fmt::Display) -> (StatusCode, String) {
+        (StatusCode::BAD_REQUEST, format!("Invalid Content-Length: {e}"))
+    }
+
     if let Some(content_length) = request.headers().get(header::CONTENT_LENGTH) {
-        let content_length: usize = content_length
-            .to_str()
-            .map_err(|e| (StatusCode::BAD_REQUEST, format!("Invalid Content-Length: {e}")))?
-            .parse()
-            .map_err(|e| (StatusCode::BAD_REQUEST, format!("Invalid Content-Length: {e}")))?;
+        let content_length: usize =
+            content_length.to_str().map_err(bad_request)?.parse().map_err(bad_request)?;
 
         if content_length > payload_limit {
             return Err((
                 StatusCode::PAYLOAD_TOO_LARGE,
-                format!(
-                    "Received: {content_length} bytes, maximum (specifiable via \
-                     --request-body-size-limit): {payload_limit} bytes"
-                ),
+                serde_json::to_string(&ResponseResult::Error(RpcError {
+                    code: crate::rpc_core::error::ErrorCode::InvalidRequest,
+                    message: format!(
+                        "Request too big! Server received: {content_length} bytes; maximum \
+                         (specifiable via --request-body-size-limit): {payload_limit} bytes"
+                    )
+                    .into(),
+                    data: None,
+                }))
+                .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?,
             ));
         }
     }

tests/integration/common/background_devnet.rs

@@ -205,13 +205,24 @@ impl BackgroundDevnet {
             body_json["params"] = params;
         }
 
+        // Convert HTTP error to RPC error; panic if not possible.
         let json_rpc_result: serde_json::Value =
             self.reqwest_client().post_json_async(RPC_PATH, body_json).await.map_err(|err| {
-                RpcError {
-                    code: err.status().as_u16().into(),
-                    message: err.error_message().into(),
-                    data: None,
+                let err_msg = err.error_message();
+
+                if let Ok(rpc_error) = serde_json::from_str::<RpcError>(&err_msg) {
+                    return rpc_error;
+                };
+
+                if let Ok(err_val) = serde_json::from_str::<serde_json::Value>(&err_msg) {
+                    if let Some(err_prop) = err_val.get("error").cloned() {
+                        if let Ok(rpc_error) = serde_json::from_value::<RpcError>(err_prop) {
+                            return rpc_error;
+                        }
+                    }
                 }
+
+                panic!("Cannot extract RPC error from: {err_msg}")
             })?;
 
         if let Some(result) = json_rpc_result.get("result") {

tests/integration/general_integration_tests.rs

@@ -44,6 +44,15 @@ async fn too_big_request_rejected_via_non_rpc() {
     .expect_err("Request should have been rejected");
 
     assert_eq!(err.status(), StatusCode::PAYLOAD_TOO_LARGE);
+    assert_eq!(
+        serde_json::from_str::<serde_json::Value>(&err.error_message()).unwrap(),
+        json!({
+            "error": {
+                "code": -32600,
+                "message": format!("Request too big! Server received: 1111 bytes; maximum (specifiable via --request-body-size-limit): {limit} bytes"),
+            }
+        })
+    );
 
     // subtract enough so that the rest of the json body doesn't overflow the limit
     let nonexistent_path = "a".repeat(limit - 100);
@@ -71,7 +80,18 @@ async fn too_big_request_rejected_via_rpc() {
         .await
         .expect_err("Request should have been rejected");
 
-    assert_eq!(error.code, StatusCode::PAYLOAD_TOO_LARGE.as_u16() as i64);
+    assert_eq!(
+        error,
+        RpcError {
+            code: -32600,
+            message: format!(
+                "Request too big! Server received: 1168 bytes; maximum (specifiable via \
+                 --request-body-size-limit): {limit} bytes"
+            )
+            .into(),
+            data: None
+        }
+    );
 
     // subtract enough so that the rest of the json body doesn't overflow the limit
     let nonexistent_path = "a".repeat(limit - 100);