Enum WalletError

pub enum WalletError {
    AccountState(String),
    NoKeyPair,
    EcdsaError(Error),
    HexError(FromHexError),
    IoError(Error),
    NoDefaultAccount,
    SignHashError,
    CryptoError(CryptoError),
    TransactionError(TransactionError),
    BuilderError(BuilderError),
    VerifyError,
    LedgerError(String),
    NoAccounts,
    YubiHsmError(String),
    ProviderError(ProviderError),
    DecryptionError(String),
    SigningError(String),
    FileError(String),
    ParseError(String),
    ImportError(String),
    InvalidPassword,
    DeserializationError(String),
}

Errors that may occur within wallet operations.

This enum encompasses a range of errors that can arise when interacting with cryptocurrency wallets, including but not limited to account state issues, cryptographic errors, and IO operations. It is designed to be comprehensive, covering errors from underlying libraries (such as ECDSA operations, hex encoding/decoding) as well as wallet-specific errors like missing key pairs or default accounts.

Variants

• AccountState: Represents errors related to an account’s state, such as when an account cannot be found or is in an invalid state for the requested operation.
• NoKeyPair: Indicates that a key pair was expected but none was found.
• EcdsaError: Wraps errors from the ecdsa crate, typically related to signature operations.
• HexError: Wraps errors from the hex crate, often arising during hex encoding or decoding.
• IoError: Wraps standard IO errors that might occur during file operations.
• NoDefaultAccount: Signals that a default account was expected but not set.
• InvalidKeyPair: General error for when a key pair is invalid or fails validation.
• CryptoError: Wraps cryptographic errors, potentially from operations like hashing or encryption.
• TransactionError: Encapsulates errors that may occur during transaction creation or processing.
• BuilderError: Wraps errors that occur during the construction of complex objects, possibly due to invalid parameters.
• DecryptionError: Indicates an error occurred during account decryption.
• SigningError: Indicates an error occurred during transaction signing.
• FileError: Indicates an error occurred during file operations.
• ParseError: Indicates an error occurred during parsing operations.
• ImportError: Indicates an error occurred during key import operations.
• InvalidPassword: Indicates that an invalid password was provided.
• NoAccounts: Indicates that no accounts were found in the wallet.
• YubiHsmError: Wraps errors related to YubiHSM operations.
• ProviderError: Wraps errors from the RPC provider.

Examples

Handling a WalletError might look like this:

let result = some_wallet_operation();
    match result {
        Ok(_) => println!("Operation successful"),
        Err(wallets::WalletError::NoKeyPair) => println!("Key pair missing"),
        Err(e) => println!("An error occurred: {:?}", e),
    }

This approach allows for precise error handling and reporting, facilitating debugging and user feedback.

Variants

AccountState(String)

Error indicating an issue with the account’s state, such as being locked or insufficient funds. The contained message provides additional detail.

NoKeyPair

Indicates that no key pair is available for a cryptographic operation, possibly because it has not been generated or imported.

EcdsaError(Error)

Wraps errors from the ecdsa crate, related to ECDSA signature operations. This could include errors during signature generation or verification.

HexError(FromHexError)

Represents errors encountered during hex encoding or decoding operations, such as an invalid hex character or incorrect string length.

IoError(Error)

Encapsulates errors arising from IO operations, like reading from or writing to files. This includes file not found, permissions issues, and other file-related errors.

NoDefaultAccount

Signifies that the wallet does not have a designated default account, which might be required for certain operations or configurations.

SignHashError

Used when a key pair is found to be invalid, such as when a private key does not match the public key, or the key pair cannot be used for signing due to corruption.

CryptoError(CryptoError)

Wraps generic cryptographic errors that might occur during operations such as encryption, decryption, hashing, or key generation.

TransactionError(TransactionError)

Covers errors related to the creation, signing, or broadcasting of transactions, including invalid transaction formats, insufficient gas, or nonce issues.

BuilderError(BuilderError)

Indicates issues encountered during the construction or configuration of wallet components, such as invalid parameters or configurations that cannot be applied.

VerifyError

Indicates an invalid signature

LedgerError(String)

Errors related to Ledger hardware wallet operations

NoAccounts

Error indicating no accounts in wallet

YubiHsmError(String)

Errors related to YubiHSM operations

ProviderError(ProviderError)

Errors from the RPC provider

DecryptionError(String)

Errors during account decryption

SigningError(String)

Errors during transaction signing

FileError(String)

Errors during file operations

ParseError(String)

Errors during parsing operations

ImportError(String)

Errors during key import operations

InvalidPassword

Invalid password provided

DeserializationError(String)

Errors during deserialization

Trait Implementations

impl Debug for WalletError

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

Formats the value using the given formatter.

impl Display for WalletError

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

Formats the value using the given formatter.

impl Error for WalletError

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<BuilderError> for WalletError

fn from(source: BuilderError) -> Self

Converts to this type from the input type.

impl From<CryptoError> for WalletError

fn from(source: CryptoError) -> Self

Converts to this type from the input type.

impl From<Error> for WalletError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for WalletError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<FromHexError> for WalletError

fn from(source: FromHexError) -> Self

Converts to this type from the input type.

impl From<ProviderError> for WalletError

fn from(source: ProviderError) -> Self

Converts to this type from the input type.

impl From<TransactionError> for WalletError

fn from(source: TransactionError) -> Self

Converts to this type from the input type.

impl From<WalletError> for SignerError

fn from(source: WalletError) -> Self

Converts to this type from the input type.