Enum PriceSourceError 

pub enum PriceSourceError {
    DecodeError(Error),
    EmptyTokenArrays,
    ArrayLengthMismatch {
        tokens_in: usize,
        amounts_in: usize,
        tokens_out: usize,
        amounts_out: usize,
    },
    InvalidSwapData {
        details: String,
    },
}

Errors that can occur when extracting price data from logs.

This error type preserves the original error information without type erasure, allowing callers to inspect and handle specific error cases.

Examples

use semioscan::price::{PriceSource, PriceSourceError};
use alloy_rpc_types::Log;
use alloy_sol_types::SolEvent;

fn extract_swap_from_log(&self, log: &Log) -> Result<Option<SwapData>, PriceSourceError> {
    let event = SwapEvent::decode_log(&log.into())
        .map_err(PriceSourceError::from)?;  // Preserves alloy_sol_types::Error

    if event.amounts.is_empty() {
        return Err(PriceSourceError::empty_token_arrays());
    }

    // ... rest of extraction logic
}

Variants

DecodeError(Error)

Failed to decode an event from the log data.

This preserves the original alloy_sol_types::Error without type erasure, allowing inspection of decode failures (wrong signature, corrupted data, etc.).

EmptyTokenArrays

Event was decoded but contains empty token arrays.

SwapMulti events must have at least one token in both tokensIn and tokensOut.

ArrayLengthMismatch

Token and amount arrays have mismatched lengths.

SwapMulti events require tokensIn.len() == amountsIn.len() and tokensOut.len() == amountsOut.len().

Fields

tokens_in: usize

Length of tokensIn array

amounts_in: usize

Length of amountsIn array

tokens_out: usize

Length of tokensOut array

amounts_out: usize

Length of amountsOut array

InvalidSwapData

Event was decoded but the swap data is invalid.

This is a catch-all for validation errors beyond the specific cases above, such as zero amounts, invalid token addresses, or other business logic violations.

Unlike the old string-based version, this stores the error in a Box<dyn Error> to preserve the source error chain and enable programmatic error handling.

Fields

details: String

Description of what makes the swap data invalid

Implementations

impl PriceSourceError

pub fn empty_token_arrays() -> Self

Create an EmptyTokenArrays error.

Use this when a SwapMulti event has empty tokensIn or tokensOut arrays.

pub fn array_length_mismatch( tokens_in: usize, amounts_in: usize, tokens_out: usize, amounts_out: usize, ) -> Self

Create an ArrayLengthMismatch error with specific lengths.

Use this when token and amount array lengths don’t match in SwapMulti events.

Examples

use semioscan::PriceSourceError;

let err = PriceSourceError::array_length_mismatch(2, 3, 1, 1);
assert!(err.to_string().contains("don't match"));

pub fn invalid_swap_data(details: impl Into<String>) -> Self

Create an InvalidSwapData error with details.

Use this for validation errors that don’t fit the more specific error types.

Examples

use semioscan::PriceSourceError;

let err = PriceSourceError::invalid_swap_data("Zero amount in swap");
assert!(err.to_string().contains("Invalid swap data"));

Trait Implementations

impl Debug for PriceSourceError

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

Formats the value using the given formatter.

impl Display for PriceSourceError

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

Formats the value using the given formatter.

impl Error for PriceSourceError

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 PriceSourceError

fn from(error: Error) -> Self

Converts to this type from the input type.

impl From<PriceSourceError> for PriceCalculationError

fn from(source: PriceSourceError) -> Self

Converts to this type from the input type.