Enum EvmError 

#[non_exhaustive]
pub enum EvmError {
    Config(String),
    InvalidInput(String),
    Rpc {
        method: &'static str,
        code: Option<i64>,
        message: String,
        transient: bool,
    },
    ChainIdMismatch {
        expected: u64,
        actual: u64,
    },
    InvalidResponse(String),
    TransactionReverted {
        hash: Option<B256>,
        revert: Option<RevertReason>,
    },
    ReceiptTimeout {
        hash: B256,
        nonce: Option<u64>,
        timeout: Duration,
    },
    BroadcastUnknown {
        hash: B256,
        nonce: u64,
        message: String,
    },
    NonceUsed {
        hash: B256,
        nonce: u64,
    },
    InvalidReceipt {
        hash: B256,
        message: String,
    },
    CodeMismatch {
        address: Address,
        expected: ParalockContract,
        empty: bool,
    },
    Timeout {
        what: String,
        timeout: Duration,
    },
    ReadOnly,
    Signer(String),
    Signature(SignatureError),
    WrongSigner {
        expected: Address,
        recovered: Address,
    },
    PreimageMismatch {
        hashlock: B256,
    },
    LockEventMissing {
        key: B256,
        status: EscrowStatus,
        from_block: u64,
    },
    SettlementNotIndexed {
        key: B256,
    },
    FeeCapExceeded {
        estimated: u128,
        cap: u128,
    },
    PublicNetwork {
        chain_id: u64,
        name: &'static str,
    },
}

Everything that can go wrong in this crate.

Errors never contain private keys. RPC error messages have the configured RPC URL redacted (it often embeds an API key).

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Config(String)

The configuration is unusable (bad RPC URL, fee token on a non-Tempo chain, …).

InvalidInput(String)

An argument failed validation before anything was sent.

Rpc

The RPC request failed (after the configured retries for transient failures).

Fields

method: &'static str

The JSON-RPC method (or client operation) that failed.

code: Option<i64>

JSON-RPC error code, when the node returned one.

message: String

The error message, with the RPC URL redacted.

transient: bool

True for transport failures, timeouts, rate limits and 5xx responses: retrying later may succeed.

ChainIdMismatch

The RPC node serves another chain than the one configured. Nothing was sent.

Fields

expected: u64

The configured chain id.

actual: u64

The chain id the node reported.

InvalidResponse(String)

The node’s response is malformed or inconsistent (it is treated as untrusted input).

TransactionReverted

A transaction reverted: either its simulation (hash is None, nothing was sent) or on-chain after it was mined.

Fields

hash: Option<B256>

The mined transaction, or None when the revert was caught by simulation before sending.

revert: Option<RevertReason>

The decoded revert, when the node returned revert data.

ReceiptTimeout

A sent transaction was not mined within the receipt timeout. It may still be pending: wait again (wait_for_receipt / wait_for_sent), check transaction_status, or replace it with higher fees (bump, same nonce). Retrying the operation from scratch instead would send a second transaction.

Fields

hash: B256

The transaction hash (the newest version, if it was replaced with higher fees).

nonce: Option<u64>

Its nonce, when known (always for transactions this process sent).

timeout: Duration

The timeout that elapsed.

BroadcastUnknown

The broadcast of a signed transaction failed and the node could not be asked whether it received it anyway (e.g. the response was lost and the follow-up lookup failed too). It may have been sent: look it up (transaction_status, wait_for_receipt) or replace it (bump) before sending the operation again.

Fields

hash: B256

The signed transaction’s hash.

nonce: u64

Its nonce.

message: String

The broadcast error, with the RPC URL redacted.

NonceUsed

A transaction cannot be replaced: its nonce is already used by a mined transaction (this one, an earlier version of it, or another transaction of the account). Wait for its receipt instead (wait_for_sent).

Fields

hash: B256

The transaction that was to be replaced.

nonce: u64

Its nonce.

InvalidReceipt

The receipt of a mined transaction is malformed (e.g. it has no status).

Fields

hash: B256

The transaction hash.

message: String

What is wrong with the receipt.

CodeMismatch

The address does not hold the runtime code of the expected Paralock contract (no code, another contract or another build). Refuse to use it as an escrow.

Fields

address: Address

The checked address.

expected: ParalockContract

The contract it was expected to hold.

empty: bool

True when the address holds no code at all.

Timeout

A waiter gave up.

Fields

what: String

What was awaited.

timeout: Duration

The timeout that elapsed.

ReadOnly

The client has no signer.

Signer(String)

The signer failed (a KMS error, a mismatched chain id, …).

Signature(SignatureError)

A claim signature is malformed or not canonical.

WrongSigner

The claim signature does not recover to the swap’s signer. Nothing was sent.

Fields

expected: Address

The swap’s signer.

recovered: Address

The address the signature recovers to.

PreimageMismatch

sha256(preimage) is not the swap’s hashlock. Nothing was sent.

Fields

hashlock: B256

The swap’s hashlock.

LockEventMissing

The entry exists on-chain but its Locked event was not found from the configured start block (the start block is after the contract’s deployment, or the node has not indexed the log yet).

Fields

key: B256

Hashlock (htlc) or escrow id (adaptor).

status: EscrowStatus

Its on-chain status.

from_block: u64

The configured first block of the scan.

SettlementNotIndexed

The entry is settled on-chain but neither its Claimed nor its Refunded event is served yet. Retry later.

Fields

key: B256

Hashlock (htlc) or escrow id (adaptor).

FeeCapExceeded

The fee estimate exceeds EvmConfig::max_fee_per_gas. Nothing was sent.

Fields

estimated: u128

The estimated maxFeePerGas.

cap: u128

The configured cap.

PublicNetwork

deploy_paralock_contracts refuses known public networks.

Fields

chain_id: u64

The chain id.

name: &'static str

The network’s name.

Implementations

impl EvmError

pub fn is_transient(&self) -> bool

True when retrying the same operation later may succeed: transient RPC failures, receipt or wait timeouts, an uncertain broadcast, and events that are not indexed yet.

When EvmError::tx_hash is Some, a transaction may already be out: retry by waiting for (or bumping) that transaction, not by sending the operation again.

pub fn tx_hash(&self) -> Option<B256>

The hash of the transaction this error is about, if one was signed and (possibly) broadcast: a receipt timeout, an uncertain broadcast, a mined revert, a nonce already used, or a malformed receipt. None means the failing step sent nothing (an earlier step of a multi-transaction call, such as the approval in approve_and_lock, may have).

Keep it when converting this error into another type: it is what lets a caller wait for, look up or replace the transaction instead of sending a second one.

pub fn nonce(&self) -> Option<u64>

The nonce of the transaction this error is about, when known (see EvmError::tx_hash).

pub fn revert_name(&self) -> Option<&str>

The custom error name of a revert ("SwapExpired", "SwapSettled", …), if this is a decoded revert.

pub fn revert(&self) -> Option<&RevertReason>

The decoded revert, if this is a revert.

Trait Implementations

impl Debug for EvmError

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

Formats the value using the given formatter.

impl Display for EvmError

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

Formats the value using the given formatter.

impl Error for EvmError

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<SignatureError> for EvmError

fn from(source: SignatureError) -> Self

Converts to this type from the input type.