Enum SignerError

pub enum SignerError {
    InvalidPassphrase(String),
    InvalidAddress,
    BuilderError(BuilderError),
    WalletError(WalletError),
    CryptoError(CryptoError),
    RustcFromHexError(FromHexError),
    TypeError(TypeError),
}

Represents errors that can occur within the signing process.

This enum encapsulates a variety of errors that may arise when performing operations related to signing transactions, messages, or performing cryptographic operations within a blockchain context. It includes errors related to invalid input data (like passphrases or addresses), failures in underlying cryptographic operations, and errors from external libraries used for tasks such as hex encoding/decoding or type conversion.

Variants of this enum are designed to be converted from errors thrown by these operations, allowing for a unified error handling interface throughout the signing process.

Variants

• InvalidPassphrase: Occurs when a passphrase does not meet validation criteria.
• InvalidAddress: Triggered by malformed blockchain addresses.
• BuilderError: Wraps errors from the construction of cryptographic objects.
• WalletError: Encompasses errors from wallet operations.
• FromHexError: Pertains to failures in hexadecimal to binary data conversion.
• CryptoError: Covers general cryptographic failures.
• RustcFromHexError: Specific to hex decoding issues via rustc_serialize.
• TypeError: Indicates failures in type conversion or coercion.

Examples

Handling a SignerError in a function that performs signing operations might look like this:

use neo3::prelude::*;
 async fn sign_data(data: &[u8]) -> Result<(), wallets::SignerError> {
    // Example function body
    Ok(())
}

async fn example_usage() {
    let data = b"example data";

    match sign_data(data).await {
        Ok(_) => println!("Data signed successfully"),
        Err(e) => match e {
            wallets::SignerError::InvalidPassphrase(_) => println!("Invalid passphrase provided"),
            wallets::SignerError::InvalidAddress => println!("Invalid address"),
            // Handle other errors accordingly
            _ => println!("An error occurred: {:?}", e),
        },
    }
}

Variants

InvalidPassphrase(String)

Represents an error when an invalid passphrase is provided. This could happen during the decryption of a private key or any operation that requires passphrase verification.

InvalidAddress

Indicates that the provided address is not valid. This error might occur if an address does not comply with expected formats or checksums.

BuilderError(BuilderError)

Wraps errors related to building or configuring objects, possibly during the setup of cryptographic operations or when constructing complex objects that have specific requirements.

WalletError(WalletError)

Encapsulates errors that originate from wallet operations. This can include issues with creating, loading, or performing transactions with wallets.

CryptoError(CryptoError)

Covers general cryptographic errors such as failures in hashing, signature generation, or encryption/decryption processes.

RustcFromHexError(FromHexError)

An error for hex decoding issues.

TypeError(TypeError)

Indicates a failure related to type conversion or coercion. This variant is useful for signaling issues when trying to convert between incompatible types, such as when deserializing data into a specific structure.

Trait Implementations

impl Debug for SignerError

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

Formats the value using the given formatter.

impl Display for SignerError

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

Formats the value using the given formatter.

impl Error for SignerError

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 SignerError

fn from(source: BuilderError) -> Self

Converts to this type from the input type.

impl From<CryptoError> for SignerError

fn from(source: CryptoError) -> Self

Converts to this type from the input type.

impl From<FromHexError> for SignerError

fn from(source: FromHexError) -> Self

Converts to this type from the input type.

impl From<TypeError> for SignerError

fn from(source: TypeError) -> 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.