Implementation-defined RPC server errors are now accessible to client/ users

client/src/http_sender.rs

@@ -27,6 +27,13 @@ impl HttpSender {
     }
 }
 
+#[derive(Deserialize, Debug)]
+struct RpcErrorObject {
+    code: i64,
+    message: String,
+    /*data field omitted*/
+}
+
 impl RpcSender for HttpSender {
     fn send(&self, request: RpcRequest, params: serde_json::Value) -> Result<serde_json::Value> {
         // Concurrent requests are not supported so reuse the same request id for all requests
@@ -63,11 +70,20 @@ impl RpcSender for HttpSender {
 
                     let json: serde_json::Value = serde_json::from_str(&response.text()?)?;
                     if json["error"].is_object() {
-                        return Err(RpcError::RpcRequestError(format!(
-                            "RPC Error response: {}",
-                            serde_json::to_string(&json["error"]).unwrap()
-                        ))
-                        .into());
+                        return match serde_json::from_value::<RpcErrorObject>(json["error"].clone())
+                        {
+                            Ok(rpc_error_object) => Err(RpcError::RpcResponseError {
+                                code: rpc_error_object.code,
+                                message: rpc_error_object.message,
+                            }
+                            .into()),
+                            Err(err) => Err(RpcError::RpcRequestError(format!(
+                                "Failed to deserialize RPC error response: {} [{}]",
+                                serde_json::to_string(&json["error"]).unwrap(),
+                                err
+                            ))
+                            .into()),
+                        };
                     }
                     return Ok(json["result"].clone());
                 }

client/src/lib.rs

@@ -10,6 +10,7 @@ pub mod perf_utils;
 pub mod pubsub_client;
 pub mod rpc_client;
 pub mod rpc_config;
+pub mod rpc_custom_error;
 pub mod rpc_filter;
 pub mod rpc_request;
 pub mod rpc_response;

client/src/rpc_custom_error.rs

@@ -0,0 +1,72 @@
+//! Implementation defined RPC server errors
+
+use crate::rpc_response::RpcSimulateTransactionResult;
+use jsonrpc_core::{Error, ErrorCode};
+use solana_sdk::clock::Slot;
+
+const JSON_RPC_SERVER_ERROR_1: i64 = -32001;
+const JSON_RPC_SERVER_ERROR_2: i64 = -32002;
+const JSON_RPC_SERVER_ERROR_3: i64 = -32003;
+const JSON_RPC_SERVER_ERROR_4: i64 = -32004;
+const JSON_RPC_SERVER_ERROR_5: i64 = -32005;
+const JSON_RPC_SERVER_ERROR_6: i64 = -32006;
+
+pub enum RpcCustomError {
+    BlockCleanedUp {
+        slot: Slot,
+        first_available_block: Slot,
+    },
+    SendTransactionPreflightFailure {
+        message: String,
+        result: RpcSimulateTransactionResult,
+    },
+    TransactionSignatureVerificationFailure,
+    BlockNotAvailable {
+        slot: Slot,
+    },
+    RpcNodeUnhealthy,
+    TransactionPrecompileVerificationFailure(solana_sdk::transaction::TransactionError),
+}
+
+impl From<RpcCustomError> for Error {
+    fn from(e: RpcCustomError) -> Self {
+        match e {
+            RpcCustomError::BlockCleanedUp {
+                slot,
+                first_available_block,
+            } => Self {
+                code: ErrorCode::ServerError(JSON_RPC_SERVER_ERROR_1),
+                message: format!(
+                    "Block {} cleaned up, does not exist on node. First available block: {}",
+                    slot, first_available_block,
+                ),
+                data: None,
+            },
+            RpcCustomError::SendTransactionPreflightFailure { message, result } => Self {
+                code: ErrorCode::ServerError(JSON_RPC_SERVER_ERROR_2),
+                message,
+                data: Some(serde_json::json!(result)),
+            },
+            RpcCustomError::TransactionSignatureVerificationFailure => Self {
+                code: ErrorCode::ServerError(JSON_RPC_SERVER_ERROR_3),
+                message: "Transaction signature verification failure".to_string(),
+                data: None,
+            },
+            RpcCustomError::BlockNotAvailable { slot } => Self {
+                code: ErrorCode::ServerError(JSON_RPC_SERVER_ERROR_4),
+                message: format!("Block not available for slot {}", slot),
+                data: None,
+            },
+            RpcCustomError::RpcNodeUnhealthy => Self {
+                code: ErrorCode::ServerError(JSON_RPC_SERVER_ERROR_5),
+                message: "RPC node is unhealthy".to_string(),
+                data: None,
+            },
+            RpcCustomError::TransactionPrecompileVerificationFailure(e) => Self {
+                code: ErrorCode::ServerError(JSON_RPC_SERVER_ERROR_6),
+                message: format!("Transaction precompile verification failure {:?}", e),
+                data: None,
+            },
+        }
+    }
+}

client/src/rpc_request.rs

@@ -140,8 +140,10 @@ impl RpcRequest {
 
 #[derive(Debug, Error)]
 pub enum RpcError {
-    #[error("rpc request error: {0}")]
+    #[error("RPC request error: {0}")]
     RpcRequestError(String),
+    #[error("RPC response error {code}: {message}")]
+    RpcResponseError { code: i64, message: String },
     #[error("parse error: expected {0}")]
     ParseError(String), /* "expected" */
     // Anything in a `ForUser` needs to die.  The caller should be