feat(starknet_gateway_types,starknet_http_server): move spec error conversion to the http server

Author: yair-starkware

Cargo.lock

@@ -1,5 +1,3 @@
-use axum::http::StatusCode;
-use axum::response::{IntoResponse, Response};
 use enum_assoc::Assoc;
 use papyrus_network_types::network_types::BroadcastedMessageMetadata;
 use papyrus_rpc::error::{
@@ -59,25 +57,6 @@ pub enum GatewaySpecError {
     ValidationFailure { data: String },
 }
 
-impl IntoResponse for GatewaySpecError {
-    fn into_response(self) -> Response {
-        let as_rpc = self.into_rpc();
-        // TODO(Arni): Fix the status code. The status code should be a HTTP status code - not a
-        // Json RPC error code. status code.
-        let status =
-            StatusCode::from_u16(u16::try_from(as_rpc.code).expect("Expecting a valid u16"))
-                .expect("Expecting a valid error code");
-
-        let resp = Response::builder()
-            .status(status)
-            .body((as_rpc.message, as_rpc.data))
-            .expect("Expecting valid response");
-        let status = resp.status();
-        let body = serde_json::to_string(resp.body()).expect("Expecting valid body");
-        (status, body).into_response()
-    }
-}
-
 impl std::fmt::Display for GatewaySpecError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let as_rpc = self.clone().into_rpc();

crates/starknet_gateway_types/src/errors.rs

@@ -15,9 +15,11 @@ workspace = true
 axum.workspace = true
 hyper.workspace = true
 infra_utils.workspace = true
+jsonrpsee = { workspace = true, features = ["full"] }
 papyrus_config.workspace = true
 reqwest = { workspace = true, optional = true }
 serde.workspace = true
+serde_json.workspace = true
 starknet_api.workspace = true
 starknet_gateway_types.workspace = true
 starknet_sequencer_infra.workspace = true

crates/starknet_http_server/Cargo.toml

@@ -1,8 +1,48 @@
+use axum::response::{IntoResponse, Response};
+use jsonrpsee::types::error::ErrorCode;
+use starknet_gateway_types::communication::GatewayClientError;
+use starknet_gateway_types::errors::GatewayError;
 use thiserror::Error;
+use tracing::error;
 
 /// Errors originating from `[`HttpServer::run`]` command.
 #[derive(Debug, Error)]
 pub enum HttpServerRunError {
     #[error(transparent)]
     ServerStartupError(#[from] hyper::Error),
 }
+
+/// Wraps the `GatewayClientError` in order to implement Axum's `IntoResponse` trait.
+#[derive(Error, Debug)]
+#[error(transparent)]
+pub struct GatewayClientErrorWrapper(#[from] GatewayClientError);
+
+impl IntoResponse for GatewayClientErrorWrapper {
+    fn into_response(self) -> Response {
+        let general_rpc_error = match self.0 {
+            GatewayClientError::ClientError(e) => {
+                error!("Got a gateway client: {}", e);
+                jsonrpsee::types::ErrorObject::owned(
+                    ErrorCode::InternalError.code(),
+                    "Internal error",
+                    None::<()>,
+                )
+            }
+            GatewayClientError::GatewayError(GatewayError::GatewaySpecError {
+                source,
+                p2p_message_metadata: _,
+            }) => {
+                let rpc_spec_error = source.into_rpc();
+                jsonrpsee::types::ErrorObject::owned(
+                    ErrorCode::ServerError(rpc_spec_error.code).code(),
+                    rpc_spec_error.message,
+                    rpc_spec_error.data,
+                )
+            }
+        };
+
+        serde_json::to_vec(&general_rpc_error)
+            .expect("Expecting a serializable error.")
+            .into_response()
+    }
+}

crates/starknet_http_server/src/errors.rs

@@ -8,20 +8,19 @@ use infra_utils::type_name::short_type_name;
 use starknet_api::rpc_transaction::RpcTransaction;
 use starknet_api::transaction::TransactionHash;
 use starknet_gateway_types::communication::SharedGatewayClient;
-use starknet_gateway_types::errors::GatewaySpecError;
 use starknet_gateway_types::gateway_types::GatewayInput;
 use starknet_sequencer_infra::component_definitions::ComponentStarter;
 use starknet_sequencer_infra::errors::ComponentError;
-use tracing::{error, info, instrument};
+use tracing::{debug, info, instrument};
 
 use crate::config::HttpServerConfig;
-use crate::errors::HttpServerRunError;
+use crate::errors::{GatewayClientErrorWrapper, HttpServerRunError};
 
 #[cfg(test)]
 #[path = "http_server_test.rs"]
 pub mod http_server_test;
 
-pub type HttpServerResult<T> = Result<T, GatewaySpecError>;
+pub type HttpServerResult<T> = Result<T, GatewayClientErrorWrapper>;
 
 pub struct HttpServer {
     pub config: HttpServerConfig,
@@ -64,16 +63,16 @@ async fn add_tx(
 ) -> HttpServerResult<Json<TransactionHash>> {
     let gateway_input: GatewayInput = GatewayInput { rpc_tx: tx.clone(), message_metadata: None };
 
-    let add_tx_result = app_state.gateway_client.add_tx(gateway_input).await.map_err(|join_err| {
-        error!("Failed to process tx: {}", join_err);
-        GatewaySpecError::UnexpectedError { data: "Internal server error".to_owned() }
+    let add_tx_result = app_state.gateway_client.add_tx(gateway_input).await.map_err(|e| {
+        debug!("Error while adding transaction: {}", e);
+        GatewayClientErrorWrapper::from(e)
     });
 
     add_tx_result_as_json(add_tx_result)
 }
 
 pub(crate) fn add_tx_result_as_json(
-    result: Result<TransactionHash, GatewaySpecError>,
+    result: Result<TransactionHash, GatewayClientErrorWrapper>,
 ) -> HttpServerResult<Json<TransactionHash>> {
     let tx_hash = result?;
     Ok(Json(tx_hash))