Enum Error

pub enum Error {
    UnknownFunction(String),
    UnknownSelector(Selector),
    NotADeploymentTransaction,
    ContractNotDeployed,
    ZeroData(String, Error),
    AbiError(Error),
    TransportError(TransportError),
    PendingTransactionError(PendingTransactionError),
}

Error when interacting with contracts.

Variants

UnknownFunction(String)

Unknown function referenced.

UnknownSelector(Selector)

Unknown function selector referenced.

NotADeploymentTransaction

Called deploy with a transaction that is not a deployment transaction.

ContractNotDeployed

contractAddress was not found in the deployment transaction’s receipt.

ZeroData(String, Error)

The contract returned no data.

AbiError(Error)

An error occurred ABI encoding or decoding.

TransportError(TransportError)

An error occurred interacting with a contract over RPC.

PendingTransactionError(PendingTransactionError)

An error occurred while waiting for a pending transaction.

Implementations

impl Error

pub fn as_revert_data(&self) -> Option<Bytes>

Return the revert data in case the call reverted.

pub fn as_decoded_interface_error<E: SolInterface>(&self) -> Option<E>

Attempts to decode the revert data into one of the custom errors in SolInterface.

Returns an enum container type consisting of the custom errors defined in the interface.

None is returned if the revert data is empty or if the data could not be decoded into one of the custom errors defined in the interface.

Example

use alloy_provider::ProviderBuilder;
use alloy_sol_types::sol;

sol! {
    #[derive(Debug, PartialEq, Eq)]
    #[sol(rpc, bytecode = "694207")]
    contract ThrowsError {
        error SomeCustomError(uint64 a);
        error AnotherError(uint64 b);

        function error(uint64 a) external {
            revert SomeCustomError(a);
        }
    }
}

#[tokio::main]
async fn main() {
    let provider = ProviderBuilder::new().connect_anvil_with_wallet();

    let throws_err = ThrowsError::deploy(provider).await.unwrap();

    let err = throws_err.error(42).call().await.unwrap_err();

    let custom_err =
        err.as_decoded_interface_error::<ThrowsError::ThrowsErrorErrors>().unwrap();

    // Handle the custom error enum
    match custom_err {
        ThrowsError::ThrowsErrorErrors::SomeCustomError(a) => { /* handle error */ }
        ThrowsError::ThrowsErrorErrors::AnotherError(b) => { /* handle error */ }
    }
}

pub fn as_decoded_error<E: SolError>(&self) -> Option<E>

Decode the revert data into a custom SolError type.

Returns an instance of the custom error type if decoding was successful, otherwise None.

Example

use alloy_provider::ProviderBuilder;
use alloy_sol_types::sol;
use ThrowsError::SomeCustomError;
sol! {
    #[derive(Debug, PartialEq, Eq)]
    #[sol(rpc, bytecode = "694207")]
    contract ThrowsError {
        error SomeCustomError(uint64 a);
        error AnotherError(uint64 b);

        function error(uint64 a) external {
            revert SomeCustomError(a);
        }
    }
}

#[tokio::main]
async fn main() {
    let provider = ProviderBuilder::new().connect_anvil_with_wallet();

    let throws_err = ThrowsError::deploy(provider).await.unwrap();

    let err = throws_err.error(42).call().await.unwrap_err();

    let custom_err = err.as_decoded_error::<SomeCustomError>().unwrap();

    assert_eq!(custom_err, SomeCustomError { a: 42 });
}

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

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 From<Error> for Error

fn from(source: AbiError) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(e: Error) -> Self

Converts to this type from the input type.

impl From<PendingTransactionError> for Error

fn from(source: PendingTransactionError) -> Self

Converts to this type from the input type.

impl From<RpcError<TransportErrorKind>> for Error

fn from(source: TransportError) -> Self

Converts to this type from the input type.