Enum OdosError 

pub enum OdosError {
    Http(Error),
    Api {
        status: StatusCode,
        message: String,
        code: OdosErrorCode,
        trace_id: Option<TraceId>,
    },
    Json(Error),
    Hex(FromHexError),
    InvalidInput(String),
    MissingData(String),
    UnsupportedChain {
        chain_id: u64,
    },
    Contract(String),
    TransactionAssembly(String),
    QuoteRequest(String),
    Configuration(String),
    Timeout(String),
    RateLimit {
        message: String,
        retry_after: Option<Duration>,
        code: OdosErrorCode,
        trace_id: Option<TraceId>,
    },
    Internal(String),
}

Comprehensive error types for the Odos SDK

This enum provides detailed error types for different failure scenarios, allowing users to handle specific error conditions appropriately.

Error Categories

• Network Errors: HTTP, timeout, and connectivity issues
• API Errors: Responses from the Odos service indicating various failures
• Input Errors: Invalid parameters or missing required data
• System Errors: Rate limiting and internal failures

Retryable Errors

Some error types are marked as retryable (see OdosError::is_retryable):

• Timeout errors
• Certain HTTP errors (5xx status codes, connection issues)
• Some API errors (server errors)

Note: Rate limiting errors (429) are NOT retryable. Applications must handle rate limits globally with proper coordination rather than retrying individual requests.

Examples

use odos_sdk::{OdosError, Result};
use reqwest::StatusCode;

// Create different error types
let api_error = OdosError::api_error(StatusCode::BAD_REQUEST, "Invalid input".to_string());
let timeout_error = OdosError::timeout_error("Request timed out");
let rate_limit_error = OdosError::rate_limit_error("Too many requests");

// Check if errors are retryable
assert!(!api_error.is_retryable());  // 4xx errors are not retryable
assert!(timeout_error.is_retryable()); // Timeouts are retryable
assert!(!rate_limit_error.is_retryable()); // Rate limits are NOT retryable

// Get error categories for metrics
assert_eq!(api_error.category(), "api");
assert_eq!(timeout_error.category(), "timeout");
assert_eq!(rate_limit_error.category(), "rate_limit");

Variants

Http(Error)

HTTP request errors

Api

API errors returned by the Odos service

Fields

status: StatusCode

message: String

code: OdosErrorCode

trace_id: Option<TraceId>

Json(Error)

JSON serialization/deserialization errors

Hex(FromHexError)

Hex decoding errors

InvalidInput(String)

Invalid input parameters

MissingData(String)

Missing required data

UnsupportedChain

Chain not supported

Fields

chain_id: u64

Contract(String)

Contract interaction errors

TransactionAssembly(String)

Transaction assembly errors

QuoteRequest(String)

Quote request errors

Configuration(String)

Configuration errors

Timeout(String)

Timeout errors

RateLimit

Rate limit exceeded

Contains an optional retry_after duration from the Retry-After HTTP header, the error code from the Odos API, and an optional trace_id for debugging.

Fields

message: String

retry_after: Option<Duration>

code: OdosErrorCode

trace_id: Option<TraceId>

Internal(String)

Generic internal error

Implementations

impl OdosError

pub fn api_error(status: StatusCode, message: String) -> Self

Create an API error from response (without error code or trace ID)

pub fn api_error_with_code( status: StatusCode, message: String, code: OdosErrorCode, trace_id: Option<TraceId>, ) -> Self

Create an API error with error code and trace ID

pub fn invalid_input(message: impl Into<String>) -> Self

Create an invalid input error

pub fn missing_data(message: impl Into<String>) -> Self

Create a missing data error

pub fn unsupported_chain(chain_id: u64) -> Self

Create an unsupported chain error

pub fn contract_error(message: impl Into<String>) -> Self

Create a contract error

pub fn transaction_assembly_error(message: impl Into<String>) -> Self

Create a transaction assembly error

pub fn quote_request_error(message: impl Into<String>) -> Self

Create a quote request error

pub fn configuration_error(message: impl Into<String>) -> Self

Create a configuration error

pub fn timeout_error(message: impl Into<String>) -> Self

Create a timeout error

pub fn rate_limit_error(message: impl Into<String>) -> Self

Create a rate limit error with optional retry-after duration

pub fn rate_limit_error_with_retry_after( message: impl Into<String>, retry_after: Option<Duration>, ) -> Self

Create a rate limit error with retry-after duration

pub fn rate_limit_error_with_retry_after_and_trace( message: impl Into<String>, retry_after: Option<Duration>, code: OdosErrorCode, trace_id: Option<TraceId>, ) -> Self

Create a rate limit error with all fields

pub fn internal_error(message: impl Into<String>) -> Self

Create an internal error

pub fn is_retryable(&self) -> bool

Check if the error is retryable

For API errors, the retryability is determined by the error code. For Unknown error codes, falls back to HTTP status code checking.

pub fn is_rate_limit(&self) -> bool

Check if this error is specifically a rate limit error

This is a convenience method to help with error handling patterns. Rate limit errors indicate that the Odos API has rejected the request due to too many requests being made in a given time period.

Examples

use odos_sdk::{OdosError, OdosSor, QuoteRequest};

match client.get_swap_quote(request).await {
    Ok(quote) => { /* handle quote */ }
    Err(e) if e.is_rate_limit() => {
        // Specific handling for rate limits
        eprintln!("Rate limited - consider backing off");
    }
    Err(e) => { /* handle other errors */ }
}

pub fn retry_after(&self) -> Option<Duration>

Get the retry-after duration for rate limit errors

Returns Some(duration) if this is a rate limit error with a retry-after value, None otherwise.

Examples

use odos_sdk::OdosError;
use std::time::Duration;

let error = OdosError::rate_limit_error_with_retry_after(
    "Rate limited",
    Some(Duration::from_secs(30))
);

if let Some(duration) = error.retry_after() {
    println!("Retry after {} seconds", duration.as_secs());
}

pub fn error_code(&self) -> Option<&OdosErrorCode>

Get the Odos API error code if available

Returns the strongly-typed error code for API and rate limit errors, or None for other error types.

Examples

use odos_sdk::{OdosError, error_code::OdosErrorCode};
use reqwest::StatusCode;

let error = OdosError::api_error_with_code(
    StatusCode::BAD_REQUEST,
    "Invalid chain ID".to_string(),
    OdosErrorCode::from(4001),
    None
);

if let Some(code) = error.error_code() {
    if code.is_invalid_chain_id() {
        println!("Chain ID validation failed");
    }
}

pub fn trace_id(&self) -> Option<TraceId>

Get the Odos API trace ID if available

Returns the trace ID for debugging API errors, or None for other error types or if the trace ID was not included in the API response.

Examples

use odos_sdk::OdosError;

if let Some(trace_id) = error.trace_id() {
    eprintln!("Error trace ID for support: {}", trace_id);
}

pub fn category(&self) -> &'static str

Get the error category for metrics

pub fn suggested_retry_delay(&self) -> Option<Duration>

Get suggested retry delay for this error

Returns a suggested delay before retrying the operation based on the error type:

• Rate Limit: Returns the retry_after value from the API if available, otherwise suggests 60 seconds. Note: Rate limits should be handled at the application level with proper coordination.
• Timeout: Suggests 1 second delay before retry
• HTTP Server Errors (5xx): Suggests 2 seconds with exponential backoff
• HTTP Connection Errors: Suggests 500ms before retry
• Non-retryable Errors: Returns None

Examples

use odos_sdk::{OdosClient, QuoteRequest};
use std::time::Duration;

match client.quote(request).await {
    Ok(quote) => { /* handle quote */ }
    Err(e) => {
        if let Some(delay) = e.suggested_retry_delay() {
            println!("Retrying after {} seconds", delay.as_secs());
            tokio::time::sleep(delay).await;
            // Retry the operation...
        } else {
            println!("Error is not retryable: {}", e);
        }
    }
}

pub fn is_client_error(&self) -> bool

Check if this is a client error (4xx status code)

Returns true if this is an API error with a 4xx status code, indicating that the request was invalid and should not be retried without modification.

Examples

use odos_sdk::OdosError;
use reqwest::StatusCode;

let error = OdosError::api_error(
    StatusCode::BAD_REQUEST,
    "Invalid chain ID".to_string()
);

assert!(error.is_client_error());
assert!(!error.is_retryable());

pub fn is_server_error(&self) -> bool

Check if this is a server error (5xx status code)

Returns true if this is an API error with a 5xx status code, indicating a server-side problem that may be resolved by retrying.

Examples

use odos_sdk::OdosError;
use reqwest::StatusCode;

let error = OdosError::api_error(
    StatusCode::INTERNAL_SERVER_ERROR,
    "Server error".to_string()
);

assert!(error.is_server_error());
assert!(error.is_retryable());

Trait Implementations

impl Debug for OdosError

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

Formats the value using the given formatter.

impl Display for OdosError

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

Formats the value using the given formatter.

impl Error for OdosError

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<Error> for OdosError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for OdosError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<FromHexError> for OdosError

fn from(source: FromHexError) -> Self

Converts to this type from the input type.

impl From<OdosChainError> for OdosError

fn from(err: OdosChainError) -> Self

Converts to this type from the input type.