Struct EcRollupStatus 

pub struct EcRollupStatus {
    pub applied: EventSequence,
    pub frontier: EventSequence,
    /* private fields */
}

A snapshot of the rollup’s position. Every outbox event with sequence ≤ applied is folded into EC balances (settled and effective) and committed.

frontier is pinned at construction. refresh advances applied against that same fence, so lag drains toward it instead of chasing a frontier that new postings keep moving.

Fields

applied: EventSequence

The rollup job’s committed checkpoint.

frontier: EventSequence

The outbox frontier pinned when this snapshot was taken.

Implementations

impl EcRollupStatus

pub async fn refresh(&mut self) -> Result<(), LedgerError>

Re-read the committed checkpoint, keeping the pinned frontier, so repeated calls watch the lag drain toward the fence this snapshot captured.

pub async fn await_completion( &self, timeout: Duration, ) -> Result<(), LedgerError>

Await the rollup applying everything up to this snapshot’s pinned frontier.

On Ok(()) every posting that had been assigned an outbox sequence when the snapshot was taken — committed or still in flight — is folded into EC balances (settled and effective) and visible to subsequent reads.

This is what makes close_books(); ec_rollup_status().await? .await_completion(..) free of straggler holes: sequences are assigned at entry insert, before velocity enforcement, so anything that saw the period as open sits at or below the pinned frontier, and gapless delivery means the wait covers each one. The checkpoint only trails the applied state, so the fence never returns early.

The fence does not move: unlike re-reading status, the frontier stays where the snapshot pinned it, so a rollup publishing BalanceUpdated events as it drains cannot extend its own barrier.

timeout is mandatory: a wedged rollup surfaces as LedgerError::EcCaughtUpTimeout, never a silent hang.

pub fn lag(&self) -> u64

Outbox positions the rollup has yet to consume — the stream-lag SLO metric. Counts the BalanceUpdated events the rollup publishes itself and later crosses as skips, so a healthy stream can report a small nonzero lag; alert on lag that is large or not shrinking.

pub fn is_caught_up(&self) -> bool

Trait Implementations

impl Clone for EcRollupStatus

fn clone(&self) -> EcRollupStatus

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EcRollupStatus

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

Formats the value using the given formatter.