Enum ChainSourceError 

#[non_exhaustive]
pub enum ChainSourceError {
    Transport(String),
    Malformed(String),
    Unsupported(&'static str),
    Timeout,
    RateLimited,
    NoProvider,
    TooManyRecords {
        count: usize,
        limit: usize,
    },
}

The reason a ChainSource could not reliably answer a read.

This is the recommended type Error for any provider that participates in the shared registry, so aggregators can reason about failures uniformly. It is #[non_exhaustive]: new failure modes may be added in a minor release, so consumers MUST include a wildcard match arm.

Every variant is a “could not reliably answer” signal — consumers fail closed on all of them. The absence of a queried coin/spend/lineage is expressed as Ok(None), never as an error here.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Transport(String)

A transport/connection failure reaching the underlying backend (socket, HTTP, IPC). The message is the backend’s own, carried verbatim for diagnostics.

Malformed(String)

The backend responded, but the payload could not be parsed into the expected chain type (a truncated coin record, an undecodable spend). The read is untrustworthy → fail closed.

Unsupported(&'static str)

The backend does not support this query at all (e.g. a light source with no timestamp index). The &'static str names the unsupported capability.

Timeout

The read did not complete within the source’s deadline. Whether the answer would have been present is unknown → fail closed.

RateLimited

The backend refused the read for rate-limiting. The answer is unknown → fail closed.

NoProvider

No provider was available to answer (an empty/exhausted registry). Distinct from Ok(None): the chain was never consulted, so the answer is unknown → fail closed.

TooManyRecords

The backend returned more records than the consumer’s hostile-input bound allows.

Distinct from Malformed: each record may be individually well-formed, but the count exceeds the cap the consumer will accept, so the read is refused → fail closed. This lets a consumer distinguish “the data is corrupt” from “the response is too large”.

Fields

count: usize

The number of records the backend returned.

limit: usize

The maximum number of records the consumer will accept.

Trait Implementations

impl Clone for ChainSourceError

fn clone(&self) -> ChainSourceError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChainSourceError

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

Formats the value using the given formatter.

impl Display for ChainSourceError

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

Formats the value using the given formatter.

impl Eq for ChainSourceError

impl Error for ChainSourceError

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 PartialEq for ChainSourceError

fn eq(&self, other: &ChainSourceError) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ChainSourceError