Enum OdosError

pub enum OdosError {
    Http(Error),
    Api {
        status: StatusCode,
        message: String,
    },
    Json(Error),
    Hex(FromHexError),
    InvalidInput(String),
    MissingData(String),
    UnsupportedChain {
        chain_id: u64,
    },
    Contract(String),
    TransactionAssembly(String),
    QuoteRequest(String),
    Configuration(String),
    Timeout(String),
    RateLimit(String),
    CircuitBreakerOpen(String),
    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: Circuit breaker, 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)
• Rate limiting errors
• Some API errors (server errors, rate limits)

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 circuit_breaker_error = OdosError::circuit_breaker_error("Circuit breaker is open");

// Check if errors are retryable
assert!(!api_error.is_retryable());  // 4xx errors are not retryable
assert!(timeout_error.is_retryable()); // Timeouts are retryable
assert!(!circuit_breaker_error.is_retryable()); // Circuit breaker prevents retries

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

Variants

Http(Error)

HTTP request errors

Api

API errors returned by the Odos service

Fields

status: StatusCode

message: String

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(String)

Rate limit exceeded

CircuitBreakerOpen(String)

Circuit breaker is open

This error occurs when the circuit breaker has detected too many failures and has opened to prevent further requests. The circuit breaker will automatically transition to half-open state after a timeout period, allowing a limited number of requests to test if the service has recovered.

When this occurs:

• When the failure count exceeds the configured threshold
• During the open state of the circuit breaker
• Before the reset timeout has elapsed

How to handle:

• Wait for the circuit breaker to reset (typically 60 seconds by default)
• Check the circuit breaker status using [OdosSorV2::circuit_breaker_status]
• Implement exponential backoff in your retry logic
• Consider using alternative service endpoints if available

This error is not retryable as the circuit breaker is specifically designed to prevent additional load on a failing service.

Internal(String)

Generic internal error

Implementations

impl OdosError

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

Create an API error from response

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

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

Create a circuit breaker error

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

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

Get the error category for metrics

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

fn from(err: 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.