Enum Error

Source

#[non_exhaustive]pub enum Error {
Show 15 variants
    Exchange(Box<ExchangeErrorDetails>),
    Network(Box<NetworkError>),
    Authentication(Cow<'static, str>),
    RateLimit {
        message: Cow<'static, str>,
        retry_after: Option<Duration>,
    },
    InvalidRequest(Cow<'static, str>),
    Order(Box<OrderError>),
    InsufficientBalance(Cow<'static, str>),
    InvalidOrder(Cow<'static, str>),
    OrderNotFound(Cow<'static, str>),
    MarketNotFound(Cow<'static, str>),
    Parse(Box<ParseError>),
    WebSocket(Box<dyn StdError + Send + Sync + 'static>),
    Timeout(Cow<'static, str>),
    NotImplemented(Cow<'static, str>),
    Context {
        context: String,
        source: Box<Error>,
    },
}

Expand description

The primary error type for the ccxt-rust library.

Design constraints:

All large variants are boxed to keep enum size ≤ 56 bytes
Uses Cow<'static, str> for zero-allocation static strings
Verify with: assert!(std::mem::size_of::<Error>() <= 56);

§Example

use ccxt_core::error::Error;

let err = Error::authentication("Invalid API key");
assert!(err.to_string().contains("Invalid API key"));

Variants (Non-exhaustive)§

This enum is marked as 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.

§

Exchange(Box<ExchangeErrorDetails>)

Exchange-specific errors returned by the exchange API. Boxed to reduce enum size (ExchangeErrorDetails is large).

§

Network(Box<NetworkError>)

Network-related errors encapsulating transport layer issues. Boxed to reduce enum size.

§

Authentication(Cow<'static, str>)

Authentication errors (invalid API key, signature, etc.).

§

RateLimit

Rate limit exceeded with optional retry information.

Fields

§message: Cow<'static, str>

Error message

§retry_after: Option<Duration>

Optional duration to wait before retrying

§

InvalidRequest(Cow<'static, str>)

Invalid request parameters.

§

Order(Box<OrderError>)

Order-related errors. Boxed to reduce enum size.

§

InsufficientBalance(Cow<'static, str>)

Insufficient balance for an operation.

§

InvalidOrder(Cow<'static, str>)

Invalid order format or parameters.

§

OrderNotFound(Cow<'static, str>)

Order not found on the exchange.

§

MarketNotFound(Cow<'static, str>)

Market symbol not found or not supported.

§

Parse(Box<ParseError>)

Errors during response parsing. Boxed to reduce enum size.

§

WebSocket(Box<dyn StdError + Send + Sync + 'static>)

WebSocket communication errors. Uses Box<dyn StdError> to preserve original error for downcast.

§

Timeout(Cow<'static, str>)

Operation timeout.

§

NotImplemented(Cow<'static, str>)

Feature not implemented for this exchange.

§

Context

Error with additional context, preserving the error chain.

Fields

§context: String

Context message describing what operation failed

§source: Box<Error>

The underlying error

Implementations§

Source §

impl Error

Source

pub fn exchange(code: impl Into<String>, message: impl Into<String>) -> Self

Creates a new exchange error.

§Example

use ccxt_core::error::Error;

let err = Error::exchange("400", "Bad Request");

Source

pub fn exchange_with_data( code: impl Into<String>, message: impl Into<String>, data: Value, ) -> Self

Creates a new exchange error with raw response data.

Source

pub fn rate_limit( message: impl Into<Cow<'static, str>>, retry_after: Option<Duration>, ) -> Self

Creates a new rate limit error with optional retry duration. Accepts both &'static str (zero allocation) and String.

§Example

use ccxt_core::error::Error;
use std::time::Duration;

// Zero allocation (static string):
let err = Error::rate_limit("Too many requests", Some(Duration::from_secs(60)));

// Allocation (dynamic string):
let err = Error::rate_limit(format!("Rate limit: {}", 429), None);

Source

pub fn authentication(msg: impl Into<Cow<'static, str>>) -> Self

Creates an authentication error. Accepts both &'static str (zero allocation) and String.

Source

pub fn generic(msg: impl Into<Cow<'static, str>>) -> Self

Creates a generic error (for backwards compatibility).

Source

pub fn network(msg: impl Into<String>) -> Self

Creates a network error from a message.

Source

pub fn market_not_found(symbol: impl Into<Cow<'static, str>>) -> Self

Creates a market not found error. Accepts both &'static str (zero allocation) and String.

Source

pub fn not_implemented(feature: impl Into<Cow<'static, str>>) -> Self

Creates a not implemented error. Accepts both &'static str (zero allocation) and String.

Source

pub fn invalid_request(msg: impl Into<Cow<'static, str>>) -> Self

Creates an invalid request error.

Source

pub fn invalid_argument(msg: impl Into<Cow<'static, str>>) -> Self

Creates an invalid argument error (alias for invalid_request).

Source

pub fn bad_symbol(symbol: impl Into<String>) -> Self

Creates a bad symbol error (alias for invalid_request).

Source

pub fn insufficient_balance(msg: impl Into<Cow<'static, str>>) -> Self

Creates an insufficient balance error.

Source

pub fn timeout(msg: impl Into<Cow<'static, str>>) -> Self

Creates a timeout error.

Source

pub fn websocket(msg: impl Into<String>) -> Self

Creates a WebSocket error from a message string.

Source

pub fn websocket_error<E: StdError + Send + Sync + 'static>(err: E) -> Self

Creates a WebSocket error from any error type.

Source

pub fn context(self, context: impl Into<String>) -> Self

Attaches context to an existing error.

§Example

use ccxt_core::error::Error;

let err = Error::network("Connection refused")
    .context("Failed to fetch ticker for BTC/USDT");

Source

pub fn root_cause(&self) -> &Error

Returns the root cause of the error, skipping Context layers.

Source

pub fn find_variant<F>(&self, matcher: F) -> Option<&Error>
where F: Fn(&Error) -> bool,

Finds a specific error variant in the chain (penetrates Context layers). Useful for handling wrapped errors without manual unwrapping.

Source

pub fn report(&self) -> String

Generates a detailed error report with the full chain.

§Example

use ccxt_core::error::Error;

let err = Error::network("Connection refused")
    .context("Failed to fetch ticker");
println!("{}", err.report());
// Output:
// Failed to fetch ticker
// Caused by: Network error: Connection failed: Connection refused

Source