Enum ReactiveEngineError 

#[non_exhaustive]
pub enum ReactiveEngineError {
    Subscriber(SubscriberError),
    Runtime(ReactiveError),
    Baseline(ReactiveBaselineError),
    Acknowledgement(SubscriberError),
    Checkpoint(DurableCheckpointError),
    MissingCheckpointBlock,
    PreconfirmationNotCheckpointable,
    RuntimeCheckpoint(String),
    PendingCheckpointCommit,
    PendingAcknowledgementCommit,
    UncommittedDeliveryMetadata,
    SubscriberChainMismatch {
        subscriber_chain_id: u64,
        cache_chain_id: u64,
    },
    SubscriberNotDurable,
    MissingReplayWitness,
    ReplayDeliveryMismatch,
    DeliveryWitness(String),
    MissingPayloadCommitment,
    PendingCheckpointCacheChanged {
        staged_generation: u64,
        current_generation: u64,
    },
    CheckpointReorgOutsideJournal {
        common_ancestor: u64,
        oldest_journaled: Option<u64>,
        journal_depth: usize,
    },
    OwnerCatchupOutsideJournal {
        number: u64,
        hash: B256,
    },
}

Error returned by ReactiveEngine helpers that combine subscriber polling and runtime ingestion.

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.

Subscriber(SubscriberError)

Subscriber polling failed.

Runtime(ReactiveError)

Runtime ingestion failed.

Baseline(ReactiveBaselineError)

Canonical cold-start baseline adoption failed.

Acknowledgement(SubscriberError)

Runtime ingestion succeeded, but its durable delivery acknowledgement did not commit. The subscriber may replay the batch.

Checkpoint(DurableCheckpointError)

Runtime ingestion succeeded, but the resulting cache state could not be durably checkpointed. The engine retains the commit in memory and must retry it before polling another batch.

MissingCheckpointBlock

A checkpointed ingest had no canonical block to bind the state to.

PreconfirmationNotCheckpointable

Speculative pre-confirmation state is intentionally excluded from canonical durable checkpoints.

RuntimeCheckpoint(String)

Runtime rollback/finality state could not be encoded for the checkpoint.

PendingCheckpointCommit

A crash-safe checkpoint commit is pending, so the engine cannot switch to ordinary acknowledgement ordering without first completing it.

PendingAcknowledgementCommit

An ordinary delivery acknowledgement is pending, so the engine cannot switch to checkpointed ingestion and retroactively make it durable.

UncommittedDeliveryMetadata

A caller attempted to use a raw ingestion helper with subscriber-owned commit metadata. Only the combined polling helpers can preserve the required ingest-before-checkpoint-before-acknowledgement ordering.

SubscriberChainMismatch

Subscriber and cache are bound to different chains.

Fields

subscriber_chain_id: u64

Chain reported by the subscriber.

cache_chain_id: u64

Chain configured on the cache.

SubscriberNotDurable

Crash-safe checkpoint APIs require durable replay/resume semantics.

MissingReplayWitness

A restored delivery token predates or otherwise lacks the core witness needed to prove that a replay carries the same delivery.

ReplayDeliveryMismatch

A source reused a committed token for different records, routing, controls, chain identity, or provider resume state.

DeliveryWitness(String)

The stable delivery witness could not be encoded.

MissingPayloadCommitment

A tokened network-generic header/body cannot be witnessed completely without a source-supplied canonical wire commitment.

PendingCheckpointCacheChanged

Cache state changed after a batch was staged for a checkpoint. Retrying would bind those unrelated mutations to the older delivery metadata.

Fields

staged_generation: u64

Generation immediately after the staged batch was ingested.

current_generation: u64

Generation observed when checkpoint commit was retried.

CheckpointReorgOutsideJournal

Checkpointed ingestion cannot durably acknowledge a reorg when the runtime no longer retains every potentially affected journal entry.

Fields

common_ancestor: u64

Last block shared by the old and replacement branches.

oldest_journaled: Option<u64>

Oldest retained effect-bearing journal block, if any.

journal_depth: usize

Configured maximum journal entries.

OwnerCatchupOutsideJournal

Owner-scoped catch-up would mutate a historical block for which the runtime has no rollback journal entry.

Fields

number: u64

Catch-up block number.

hash: B256

Catch-up block hash.

Trait Implementations

impl Debug for ReactiveEngineError

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

Formats the value using the given formatter.

impl Display for ReactiveEngineError

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

Formats the value using the given formatter.

impl Error for ReactiveEngineError

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<ReactiveBaselineError> for ReactiveEngineError

fn from(source: ReactiveBaselineError) -> Self

Converts to this type from the input type.

impl From<ReactiveError> for ReactiveEngineError

fn from(error: ReactiveError) -> Self

Converts to this type from the input type.

impl From<SubscriberError> for ReactiveEngineError

fn from(source: SubscriberError) -> Self

Converts to this type from the input type.