Struct Cumulative 

pub struct Cumulative {
    pub bytes: U256,
    pub amount: U256,
}

A lane’s cumulative voucher state: the absolute totals carried by the most recent voucher. Both advance monotonically over the lane’s lifetime. There is no nonce — amount is the sole monotone ordering and replay key (ADR 005 §Voucher wire format).

Fields

bytes: U256

Cumulative lane bytes paid for.

amount: U256

Cumulative lane amount paid (token base units).

Trait Implementations

impl Clone for Cumulative

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 Cumulative

impl Debug for Cumulative

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

Formats the value using the given formatter.

impl Default for Cumulative

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Cumulative

impl From<&WatermarkBundle> for Cumulative

fn from(bundle: &WatermarkBundle) -> Self

Decode a wallet-less resume bundle (issue #1481) into the full lane claim it represents, in the shape PoolLedger tracks.

This folds the chain half. A bundle reports two things: the signed anchor the node last accepted, and the frontier its chain has proved on top of that anchor. Decoding only the anchor would throw away verified_index chunks the node already holds preimages for — and the resuming signer would then re-sign from the anchor, open a fresh root beside a frontier the node is still metering, and watch every reveal that followed fold nothing (the node keeps the old root: a chain with reveals under it is worth more than the anchor a lagging voucher offers for it). So the fold is not an optimisation; it is what makes a resume converge.

It is the same fold a rollover performs — amount + verified_index × chunk_price, bytes + verified_index × CHUNK_BYTES — and the node’s watermark_bundle_for_reject documents it as the signer’s side of the bargain (ADR 005 §Watermark bundle). A bundle carrying no chain (verified_index == 0, the sealed or never-metered case) folds nothing and decodes to the anchor alone.

Infallible: the fold is computed in U256, so the u64 inputs cannot overflow it and a caller can re-seed from a bundle without a Result.

It is also unauthenticated, and deliberately so — this is arithmetic, not a trust boundary. verified_index is a number the node writes and no signature covers, so a bundle reaches this conversion only through resumable_watermark, which proves the anchor against the client’s own signature and the frontier against the bundle’s tip before any of it becomes money. Do not fold a bundle that has not been through that gate.

impl PartialEq for Cumulative

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Cumulative