Struct VoucherProgress 

pub struct VoucherProgress { /* private fields */ }

The lane’s committed voucher watermark, returned by [UpstreamPull::finish] / [UpstreamPull::abort] / [UpstreamPull::progress] and threaded through the test-util stream_fetch_tracked wrapper as an out-param, so the caller can persist what it paid (#852).

A pull runs through a PoolLedger seeded from the lane’s prior cumulative state; this watermark is that ledger read back (VoucherProgress::from_ledger) — so it always holds the absolute cumulative totals of the last presumed-accepted voucher (not per-stream deltas), exactly the (bytes_delivered, amount) pair the buyer-pool lane record expects. Because the copy-back runs on every return path (including the Err/timeout arms), the latest totals survive a mid-stream failure or a paid-but-corrupt delivery.

Implicit acceptance. The watermark tracks vouchers the upstream is presumed to have accepted — continued delivery is acceptance (ADR 005), so a sent voucher advances it and only an explicit VoucherRejected rewinds it.

Read the persistable totals via VoucherProgress::advanced, which yields None when nothing was paid on this stream (so there is nothing to persist).

Implementations

impl VoucherProgress

pub fn from_cumulative(cum: Cumulative, prior_amount: U256) -> Self

Build the watermark from a ledger Cumulative plus the lane’s seed amount. advanced is set when the cumulative amount rose past the seed, preserving the “something was paid iff the watermark advanced” contract even when the ledger was shared across concurrent streams.

Public because a caller that owns its ledger persists from it directly rather than through the &mut VoucherProgress out-param — including from a Drop, where nothing can be awaited and PoolLedger::committed is the only readable source (#1145 review).

pub const fn with_rebase_anchor(self, anchor: Option<Cumulative>) -> Self

Attach the watermark the ledger rebased DOWN to and has not persisted yet (PoolLedger::take_unsaved_rebase).

pub const fn rebase_anchor(&self) -> Option<Cumulative>

The watermark to overwrite the lane record with before advancing, when the ledger rebased down to the node’s and no persist has recorded it yet. A monotone advance refuses a lower watermark, so without the overwrite the next run would sign from the anchor the node refused.

pub fn from_ledger(ledger: &PoolLedger, prior_amount: U256) -> Self

The same watermark, read from a live ledger.

Prefer this wherever a ledger is in hand: it reads PoolLedger::settlement rather than a copied-back cumulative, so a voucher left armed by an ambiguous send is still reported as owed.

It also TAKES the ledger’s unsaved rebase anchor, so call it only where the result is persisted: the anchor is handed out once.

pub fn advanced(&self) -> Option<(U256, U256)>

The cumulative (bytes_delivered, amount) to persist via the lane record, or None if nothing new was paid on this stream (nothing to record).

pub const fn totals(&self) -> (U256, U256)

The cumulative (bytes_delivered, amount) this watermark carries, whether or not it advanced past the seed.

Trait Implementations

impl Clone for VoucherProgress

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for VoucherProgress

impl Debug for VoucherProgress

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

Formats the value using the given formatter.

impl Default for VoucherProgress

fn default() -> Self

Returns the “default value” for a type.