Struct MemoryPoolStateStore 

pub struct MemoryPoolStateStore { /* private fields */ }

In-memory PoolStateStore for tests and the trait’s reference semantics. Not durable — drops with the process. The runtime uses the redb-backed impl in crates/node.

Implementations

impl MemoryPoolStateStore

pub fn new() -> Self

Construct an empty store.

pub fn len(&self) -> usize

Snapshot the current entry count. Useful in tests to assert that rejected vouchers did not write through. A poisoned mutex reports 0 rather than panicking.

pub fn is_empty(&self) -> bool

true when no lanes are tracked.

Trait Implementations

impl Debug for MemoryPoolStateStore

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

Formats the value using the given formatter.

impl Default for MemoryPoolStateStore

fn default() -> Self

Returns the “default value” for a type.

impl PoolStateStore for MemoryPoolStateStore

fn load_all(&self) -> Result<Vec<LaneState>, StoreError>

Load every persisted lane. Called once during node bring-up so the runtime can hydrate its in-memory map before the voucher-accepting handler starts.

fn record(&self, state: &LaneState) -> Result<(), StoreError>

Record the post-acceptance state for one lane in the store’s working set. A disk-backed store MAY buffer this in memory and make it durable later via flush; it is not required to fsync before returning Ok. Frontier state is safe to lose on a crash (an honest client resumes forward; an un-redeemed replay is still on-chain-payable).

fn set_registered_until( &self, key: LaneKey, registered_until: u64, ) -> Result<(), StoreError>

Raise this lane’s observed on-chain registration expiry (LaneState::registered_until) to registered_until, monotonically — a lower or equal value is a no-op, and 0 (unknown) never lowers a known value. Touches ONLY that field, never the replay-critical last_* tuple, so the seller redeemer can record a fresh registration without racing a concurrent voucher advance into a lost update. A no-op for a lane with no record. Buffered like record; durability is the next flush’s job.

fn set_paid_cumulative( &self, key: LaneKey, paid_cumulative: U256, ) -> Result<(), StoreError>

Raise this lane’s paid cumulative (LaneState::paid_cumulative) to paid_cumulative, monotonically — a lower or equal value is a no-op. Touches ONLY that field, never the replay-critical last_* tuple, so the seller PoolRedeemed watcher can record an observed redemption without racing a concurrent voucher advance into a lost update. A no-op for a lane with no record. Buffered like record; durability is the next flush’s job. Persisting it is what stops a restarted node from forgetting prior redemptions and re-submitting already-redeemed lanes (#2052).

fn forget(&self, key: LaneKey) -> Result<(), StoreError>

Drop the persisted entry for a settled lane. A no-op if the lane has no record.

fn get(&self, key: LaneKey) -> Result<Option<LaneState>, StoreError>

Point-lookup the persisted state for one lane, or None if no record exists. Used by the on-chain seller redemption path to read the latest accepted voucher (last_amount / last_bytes_delivered / last_signature) when deciding whether an accrued claim crosses the redemption threshold — always the freshest committed voucher.

fn flush(&self) -> Result<(), StoreError>

Force all buffered lane state durable (fsync, for disk-backed impls).