Enum RpcError

pub enum RpcError<E, ErrResp = Box<RawValue>> {
    ErrorResp(ErrorPayload<ErrResp>),
    NullResp,
    UnsupportedFeature(&'static str),
    LocalUsageError(Box<dyn Error + Send + Sync>),
    SerError(Error),
    DeserError {
        err: Error,
        text: String,
    },
    Transport(E),
}

An RPC error.

Variants

ErrorResp(ErrorPayload<ErrResp>)

Server returned an error response.

NullResp

Server returned a null response when a non-null response was expected.

UnsupportedFeature(&'static str)

Rpc server returned an unsupported feature.

LocalUsageError(Box<dyn Error + Send + Sync>)

Returned when a local pre-processing step fails. This allows custom errors from local signers or request pre-processors.

SerError(Error)

JSON serialization error.

Tuple Fields

0: Error

The underlying serde_json error.

DeserError

JSON deserialization error.

Fields

err: Error

The underlying serde_json error.

text: String

For deser errors, the text that failed to deserialize.

Transport(E)

Transport error.

This variant is used when the error occurs during communication.

Tuple Fields

0: E

The underlying transport error.

Implementations

impl<E, ErrResp> RpcError<E, ErrResp>

where ErrResp: RpcRecv,

pub const fn err_resp(err: ErrorPayload<ErrResp>) -> RpcError<E, ErrResp>

Instantiate a new ErrorResp from an error response.

pub fn local_usage( err: impl Error + Send + Sync + 'static, ) -> RpcError<E, ErrResp>

Instantiate a new LocalUsageError from a custom error.

pub fn local_usage_str(err: &str) -> RpcError<E, ErrResp>

Instantiate a new LocalUsageError from a custom error message.

pub fn deser_err(err: Error, text: impl AsRef<str>) -> RpcError<E, ErrResp>

Instantiate a new DeserError from a serde_json::Error and the text. This should be called when the error occurs during deserialization.

Note: This will check if the response is actually an ErrorPayload, if so it will return a RpcError::ErrorResp.

impl<E, ErrResp> RpcError<E, ErrResp>

pub const fn ser_err(err: Error) -> RpcError<E, ErrResp>

Instantiate a new SerError from a serde_json::Error. This should be called when the error occurs during serialization.

pub const fn is_ser_error(&self) -> bool

Check if the error is a serialization error.

pub const fn is_deser_error(&self) -> bool

Check if the error is a deserialization error.

pub const fn is_transport_error(&self) -> bool

Check if the error is a transport error.

pub const fn is_error_resp(&self) -> bool

Check if the error is an error response.

pub const fn is_null_resp(&self) -> bool

Check if the error is a null response.

pub const fn is_unsupported_feature(&self) -> bool

Check if the error is an unsupported feature error.

pub const fn is_local_usage_error(&self) -> bool

Check if the error is a local usage error.

pub const fn as_error_resp(&self) -> Option<&ErrorPayload<ErrResp>>

Fallible conversion to an error response.

pub const fn as_transport_err(&self) -> Option<&E>

Returns the transport error if this is a RpcError::Transport

impl<E> RpcError<E>

pub fn tx_hash_data(&self) -> Option<FixedBytes<32>>

Extracts a transaction hash from the error data field.

Useful for EIP-7966 eth_sendRawTransactionSync errors that return the transaction hash even when the transaction fails.

Returns Some(hash) if the data contains a valid 32-byte hex string.

Example

use alloy_json_rpc::{RpcError, ErrorPayload};
use alloy_primitives::B256;

// Simulate an EIP-7966 error response
let json = r#"{"code":5,"message":"insufficient funds","data":"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"}"#;
let error_payload: ErrorPayload = serde_json::from_str(json).unwrap();
let rpc_error: RpcError<(), _> = RpcError::ErrorResp(error_payload);

if let Some(tx_hash) = rpc_error.tx_hash_data() {
    println!("Transaction hash: {}", tx_hash);
}

Trait Implementations

impl<E, ErrResp> Debug for RpcError<E, ErrResp>

where E: Debug, ErrResp: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<E, ErrResp> Display for RpcError<E, ErrResp>

where ErrorPayload<ErrResp>: Display, E: Display,

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<E, ErrResp> Error for RpcError<E, ErrResp>

where E: Error, RpcError<E, ErrResp>: Debug + Display,

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl<E, ErrResp> From<E> for RpcError<E, ErrResp>

fn from(source: E) -> RpcError<E, ErrResp>

Converts to this type from the input type.