Enum BlockWindowError 

pub enum BlockWindowError {
    InvalidRange {
        start_block: BlockNumber,
        end_block: BlockNumber,
    },
    InvalidTimestampRange {
        start_ts: UnixTimestamp,
        end_ts: UnixTimestamp,
    },
    InvalidDateConversion {
        date: NaiveDate,
    },
    DateArithmeticOverflow {
        date: NaiveDate,
    },
    CacheIoError {
        path: String,
        source: Error,
    },
    SerializationError {
        source: Error,
    },
    Rpc(RpcError),
}

Errors that can occur during block window calculations.

This error type covers validation errors, RPC failures, cache I/O errors, and serialization errors that can occur when calculating block windows for specific dates on various chains.

Examples

use semioscan::{BlockWindowCalculator, BlockWindowError};
use alloy_chains::NamedChain;
use chrono::NaiveDate;

async fn example() -> Result<(), BlockWindowError> {
    let calculator = BlockWindowCalculator::with_disk_cache(provider, "cache.json")?;
    let date = NaiveDate::from_ymd_opt(2024, 1, 15).unwrap();

    match calculator.get_daily_window(NamedChain::Arbitrum, date).await {
        Ok(window) => println!("Success: {:?}", window),
        Err(BlockWindowError::InvalidRange { start_block, end_block }) => {
            eprintln!("Invalid block range: start={}, end={}", start_block, end_block);
        }
        Err(BlockWindowError::Rpc(e)) => {
            eprintln!("RPC error, will retry: {}", e);
        }
        Err(e) => eprintln!("Other error: {}", e),
    }
    Ok(())
}

Variants

InvalidRange

Invalid block range where end block is less than start block.

This error occurs when you attempt to create a block window where the ending block number comes before the starting block number. You can use the start_block and end_block fields to understand which blocks caused the validation to fail.

Fields

start_block: BlockNumber

The starting block number of the invalid range

end_block: BlockNumber

The ending block number of the invalid range

InvalidTimestampRange

Invalid timestamp range where end timestamp is not after start timestamp.

This error occurs when validating a time window where the end timestamp is less than or equal to the start timestamp. You can access the specific timestamp values to understand the validation failure.

Fields

start_ts: UnixTimestamp

The starting Unix timestamp

end_ts: UnixTimestamp

The ending Unix timestamp (should be after start_ts)

InvalidDateConversion

Date cannot be converted to a valid UTC timestamp.

This error occurs when attempting to convert a date to UTC time fails, typically when the date represents an invalid or ambiguous time.

Fields

date: NaiveDate

The date that could not be converted to UTC

DateArithmeticOverflow

Arithmetic overflow when performing date calculations.

This error occurs when date arithmetic (such as adding days) would overflow beyond the valid range of representable dates.

Fields

date: NaiveDate

The date that caused the overflow

CacheIoError

Error reading from or writing to the block window cache.

This error occurs when filesystem operations fail while accessing the cache file. You can access the specific path and underlying I/O error to understand what went wrong.

Fields

path: String

Path to the cache file that caused the error

source: Error

The underlying I/O error

SerializationError

Error serializing or deserializing block window data.

This error occurs when JSON serialization/deserialization fails while reading or writing cached block windows. You can access the underlying serde_json error for details.

Fields

source: Error

The underlying serde_json error

Rpc(RpcError)

RPC error when communicating with blockchain provider.

This wraps RpcError for blockchain provider failures during block window calculations (e.g., fetching block numbers, block details).

Implementations

impl BlockWindowError

pub fn invalid_range(start_block: BlockNumber, end_block: BlockNumber) -> Self

Create an InvalidRange error with start and end block numbers.

pub fn invalid_timestamp_range( start_ts: UnixTimestamp, end_ts: UnixTimestamp, ) -> Self

Create an InvalidTimestampRange error with start and end timestamps.

pub fn invalid_date_conversion(date: NaiveDate) -> Self

Create an InvalidDateConversion error for a date that cannot be converted to UTC.

pub fn date_arithmetic_overflow(date: NaiveDate) -> Self

Create a DateArithmeticOverflow error when date arithmetic overflows.

pub fn cache_io_error(path: impl Into<String>, source: Error) -> Self

Create a CacheIoError from a path and I/O error.

pub fn serialization_error(source: Error) -> Self

Create a SerializationError from a serde_json error.

Trait Implementations

impl Debug for BlockWindowError

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

Formats the value using the given formatter.

impl Display for BlockWindowError

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

Formats the value using the given formatter.

impl Error for BlockWindowError

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<BlockWindowError> for SemioscanError

fn from(source: BlockWindowError) -> Self

Converts to this type from the input type.

impl From<RpcError> for BlockWindowError

fn from(source: RpcError) -> Self

Converts to this type from the input type.