crates/starknet-devnet-server/src/rpc_core/error.rs (1)

46-56: Docstring nit: say “with reason”, not “with a message”.

The helper preserves the standard message and places details in data.reason. Update the comment to avoid confusion.

-// Creates a new `InvalidRequest` with a message
+// Creates a new `InvalidRequest` with a reason in `data.reason`

crates/starknet-devnet-server/src/rpc_handler.rs (1)

70-74: Avoid leaking internal rejection details to clients (optional).

err.to_string() in the fallback can expose framework internals. Consider returning invalid_request() without a reason, and keep the detailed warn! log.

-                warn!(target: "rpc", "Request rejection: {}", err);
-                Response::error(RpcError::invalid_request_with_reason(err.to_string())).into()
+                warn!(target: "rpc", "Request rejection: {}", err);
+                Response::error(RpcError::invalid_request()).into()

tests/integration/test_websocket.rs (1)

113-132: Make the test robust and check send result.

• Assert ws.send(...) succeeds (currently ignored).
• Avoid strict equality on the entire JSON; assert structure/fields to prevent brittleness if serde error wording changes subtly.

-    let _ =
-        ws.send(tokio_tungstenite::tungstenite::Message::Text("garbage_string".to_string())).await;
-
-    let resp_raw = ws.next().await.unwrap().unwrap();
-    let resp: serde_json::Value = serde_json::from_slice(&resp_raw.into_data()).unwrap();
-    assert_eq!(
-        resp,
-        json!({
-            "jsonrpc": "2.0",
-            "id": serde_json::Value::Null,
-            "error": { "code": -32700, "message": "Parse error", "data": {"reason" : "expected value at line 1 column 1"} }
-        })
-    );
+    ws.send(tokio_tungstenite::tungstenite::Message::Text("garbage_string".to_string()))
+        .await
+        .expect("ws send failed");
+
+    let resp_raw = ws.next().await.unwrap().unwrap();
+    let resp: serde_json::Value = serde_json::from_slice(&resp_raw.into_data()).unwrap();
+    assert_eq!(resp["jsonrpc"], "2.0");
+    assert_eq!(resp["id"], serde_json::Value::Null);
+    assert_eq!(resp["error"]["code"], -32700);
+    assert_eq!(resp["error"]["message"], "Parse error");
+    assert!(resp["error"]["data"]["reason"]
+        .as_str()
+        .unwrap()
+        .contains("expected value"));

crates/starknet-devnet-server/src/api/json_rpc_handler.rs (2)

36-36: Import nit: narrow the import to Id if that’s all you need.

Minor readability: import Id directly instead of the whole rpc_core for this use.

-use crate::{ServerConfig, rpc_core};
+use crate::ServerConfig;
+use crate::rpc_core::request::Id;

Then:

-                rpc_core::request::Id::Null
+                Id::Null

---

535-540: Tiny optimization: avoid json! round-trip when serializing.

Serialize the struct directly; it skips the intermediate Value.

-            Err(e) => json!(RpcResponse::from_rpc_error(
-                RpcError::parse_error(e.to_string()),
-                rpc_core::request::Id::Null
-            ))
-            .to_string(),
+            Err(e) => serde_json::to_string(&RpcResponse::from_rpc_error(
+                RpcError::parse_error(e.to_string()),
+                Id::Null
+            ))
+            .expect("serialize RpcResponse"),

tests/integration/general_rpc_tests.rs (1)

128-157: Add HTTP 200 assert for consistency.

The other tests assert status; add it here too.

     let resp = reqwest::Client::new()
         .post(format!("{}/rpc", devnet.url))
         .header("Content-Type", "application/json")
         .json(&json!({
             "jsonrpc": "2.0",
             "params": [],
             "id": 1
         }))
         .send()
         .await
         .unwrap();
 
+    assert_eq!(resp.status(), reqwest::StatusCode::OK);
     let error_resp: serde_json::Value = resp.json().await.unwrap();

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro