Enum EMSError

pub enum EMSError {
    ConnectionError(SmartString),
    AuthenticationError(SmartString),
    OrderSubmissionError(SmartString),
    OrderCancellationError(SmartString),
    OrderModificationError(SmartString),
    RateLimitExceeded {
        message: SmartString,
        retry_after_ms: Option<u64>,
    },
    InvalidOrderParameters(SmartString),
    InsufficientBalance(SmartString),
    InstrumentNotFound(SmartString),
    ExchangeApiError {
        exchange: SmartString,
        code: i32,
        message: SmartString,
        details: Option<SmartString>,
    },
    OperationNotSupported {
        exchange: SmartString,
        operation: SmartString,
    },
    UnknownError(SmartString),
    JsonError(Error),
    JsonParsingError {
        context: SmartString,
        message: SmartString,
    },
    IoError(Error),
    NetworkError(SmartString),
    Timeout {
        duration_ms: u64,
        context: SmartString,
    },
    WebSocketError(SmartString),
    WebSocketFrameError(String),
}

Errors that can occur in the Execution Management System

Variants

ConnectionError(SmartString)

Connection errors with the exchange

AuthenticationError(SmartString)

Authentication errors

OrderSubmissionError(SmartString)

Order submission errors

OrderCancellationError(SmartString)

Order cancellation errors

OrderModificationError(SmartString)

Order modification errors

RateLimitExceeded

Rate limiting errors

Fields

message: SmartString

Error message describing the rate limit violation

retry_after_ms: Option<u64>

Optional retry delay in milliseconds

InvalidOrderParameters(SmartString)

Invalid order parameters

InsufficientBalance(SmartString)

Insufficient balance errors

InstrumentNotFound(SmartString)

Instrument not found errors

ExchangeApiError

Exchange API error with detailed information

Fields

exchange: SmartString

Name of the exchange that generated the error

code: i32

Exchange-specific error code

message: SmartString

Error message from the exchange

details: Option<SmartString>

Optional additional error details

OperationNotSupported

Operation not supported by exchange

Fields

exchange: SmartString

Name of the exchange that doesn’t support the operation

operation: SmartString

Description of the unsupported operation

UnknownError(SmartString)

Unknown errors

JsonError(Error)

Error with JSON serialization/deserialization

JsonParsingError

JSON parsing error with context

Fields

context: SmartString

Context where the JSON parsing error occurred

message: SmartString

Detailed error message

IoError(Error)

General I/O errors

NetworkError(SmartString)

Network/HTTP errors

Timeout

Timeout errors

Fields

duration_ms: u64

Duration in milliseconds after which the timeout occurred

context: SmartString

Context or operation that timed out

WebSocketError(SmartString)

WebSocket errors

WebSocketFrameError(String)

WebSocket frame errors from yawc

Implementations

impl EMSError

Helper functions for common error scenarios

pub fn connection<S: Into<SmartString>>(msg: S) -> Self

Create a connection error with a descriptive message

pub fn auth<S: Into<SmartString>>(msg: S) -> Self

Create an authentication error with a descriptive message

pub fn order_submission<S: Into<SmartString>>(msg: S) -> Self

Create an order submission error with a descriptive message

pub fn order_cancellation<S: Into<SmartString>>(msg: S) -> Self

Create an order cancellation error with a descriptive message

pub fn order_modification<S: Into<SmartString>>(msg: S) -> Self

Create an order modification error with a descriptive message

pub fn rate_limit<S: Into<SmartString>>( msg: S, retry_after_ms: Option<u64>, ) -> Self

Create a rate limit error

pub fn invalid_params<S: Into<SmartString>>(msg: S) -> Self

Create an invalid order parameters error

pub fn insufficient_balance<S: Into<SmartString>>(msg: S) -> Self

Create an insufficient balance error

pub fn instrument_not_found<S: Into<SmartString>>(symbol: S) -> Self

Create an instrument not found error

pub fn exchange_api<S1, S2, S3>( exchange: S1, code: i32, message: S2, details: Option<S3>, ) -> Self

where S1: Into<SmartString>, S2: Into<SmartString>, S3: Into<SmartString>,

Create an exchange API error

pub fn not_supported<S1, S2>(exchange: S1, operation: S2) -> Self

where S1: Into<SmartString>, S2: Into<SmartString>,

Create an operation not supported error

pub fn websocket<S: Into<SmartString>>(msg: S) -> Self

Create a WebSocket error

pub fn timeout<S: Into<SmartString>>(duration_ms: u64, context: S) -> Self

Create a timeout error

pub fn json_parse<S1, S2>(context: S1, message: S2) -> Self

where S1: Into<SmartString>, S2: Into<SmartString>,

Create a JSON parsing error with context

pub fn internal<S: Into<SmartString>>(msg: S) -> Self

Create an internal error

pub fn channel_send_error(err: &impl Display) -> Self

Optimized error creation helpers that avoid temporary String allocations These use write! directly into SmartString for better performance Create a channel send error with optimized formatting

pub fn json_error(err: &impl Display) -> Self

Create a JSON error with optimized formatting

pub fn connection_failed(err: &impl Display) -> Self

Create a connection failed error with optimized formatting

pub fn http_status_error(status: u16) -> SmartString

Create an HTTP status error with optimized formatting

pub fn rate_limit_with_exchange(exchange: &str, msg: &str) -> SmartString

Create a rate limit error with optimized formatting

pub fn auth_failed_error(exchange: &str) -> Self

Create an authentication failed error with optimized formatting

pub fn access_forbidden_error(exchange: &str) -> Self

Create an access forbidden error with optimized formatting

pub fn rate_limit_exceeded_error(exchange: &str) -> SmartString

Create a rate limit exceeded error with optimized formatting

pub fn internal_server_error(exchange: &str) -> Self

Create an internal server error with optimized formatting

pub fn service_unavailable_error(exchange: &str) -> Self

Create a service unavailable error with optimized formatting

pub fn gateway_timeout_error(exchange: &str) -> SmartString

Create a gateway timeout error with optimized formatting

pub fn auth_exchange_failed(exchange: &str, err: &impl Display) -> Self

Create an auth error with optimized formatting for exchange auth failures

pub fn auth_invalid_header_name(err: &impl Display) -> Self

Create an auth error with optimized formatting for header name errors

pub fn auth_invalid_header_value(err: &impl Display) -> Self

Create an auth error with optimized formatting for header value errors

pub const fn is_recoverable(&self) -> bool

Check if error is recoverable (e.g., temporary network issues)

pub const fn retry_delay_ms(&self) -> Option<u64>

Get retry delay in milliseconds if applicable

Trait Implementations

impl Clone for EMSError

Manual Clone implementation for EMSError (some inner types don’t implement Clone)

fn clone(&self) -> Self

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EMSError

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

Formats the value using the given formatter.

impl Display for EMSError

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

Formats the value using the given formatter.

impl Error for EMSError

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 ErrorClassification for EMSError

fn is_per_order_error(&self) -> bool

Check if this error is a per-order validation error (not transport-level)

fn is_transport_error(&self) -> bool

Check if this error is a transport-level error affecting the entire batch

impl From<AuthenticationError> for EMSError

fn from(err: AuthenticationError) -> Self

Converts to this type from the input type.

impl From<BithumbError> for EMSError

fn from(err: BithumbError) -> Self

Converts to this type from the input type.

impl From<CommonError> for EMSError

Conversion from CommonError

fn from(err: CommonError) -> Self

Converts to this type from the input type.

impl From<Error> for EMSError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for EMSError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for EMSError

Conversion from anyhow::Error

fn from(err: Error) -> Self

Converts to this type from the input type.

impl From<Error> for EMSError

Conversion from reqwest::Error

fn from(err: Error) -> Self

Converts to this type from the input type.

impl<T> From<SendError<T>> for EMSError

Conversion from flume::SendError

fn from(err: SendError<T>) -> Self

Converts to this type from the input type.