Struct MemoryBuyerPoolStore 

pub struct MemoryBuyerPoolStore { /* private fields */ }

In-memory BuyerPoolStore 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 MemoryBuyerPoolStore

pub fn new() -> Self

Construct an empty store.

pub fn len(&self) -> usize

Snapshot the current entry count (test helper).

pub fn is_empty(&self) -> bool

true when no pools are tracked.

Trait Implementations

impl BuyerPoolStore for MemoryBuyerPoolStore

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

Load every persisted buyer pool. Called once at bring-up to hydrate the in-memory pool map and seed the reclaim sweep.

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

Persist (insert or overwrite) the state for one pool, keyed by state.pool_id (primary) with state.owner maintained as a secondary reuse index. MUST be durable before returning Ok.

fn forget(&self, owner: Address) -> Result<(), StoreError>

Drop the persisted entry the owner index currently maps owner to (after the pool is reclaimed or closed), removing it from both the primary table and the owner index. A no-op if no record exists. MUST commit durably.

fn forget_if_pool( &self, owner: Address, pool_id: PoolId, ) -> Result<bool, StoreError>

Compare-and-delete: drop owner’s entry only if the stored record’s pool_id still equals pool_id. Returns true if a row was deleted, false if the stored row was for a different pool (already replaced by a newer open) or no row exists.

fn get_by_pool_id( &self, pool_id: PoolId, ) -> Result<Option<BuyerPoolState>, StoreError>

Point-lookup the live pool by its primary key, or None if none is tracked. Unlike Self::get_by_owner this needs no secondary index hop.

fn get_by_owner( &self, owner: Address, ) -> Result<Option<BuyerPoolState>, StoreError>

Point-lookup the live pool for owner, or None if none is tracked. The open-pool trigger uses this to reuse an existing pool instead of opening a new one.

fn advance_progress( &self, owner: Address, pool_id: PoolId, lane: LaneKey, bytes: U256, amount: U256, ) -> Result<AdvanceOutcome, StoreError>

Atomically advance the committed progress for lane inside owner’s pool.

fn rebase_progress( &self, owner: Address, pool_id: PoolId, lane: LaneKey, anchor: BuyerLaneProgress, totals: BuyerLaneProgress, ) -> Result<AdvanceOutcome, StoreError>

Atomically overwrite the committed progress for lane inside owner’s pool with anchor and advance it to totals (BuyerPoolState::rebase_lane) — the same owner-index and pool_id checks and the same single durable write transaction as Self::advance_progress, without the monotonicity check against the recorded progress. Never returns AdvanceOutcome::Regressed.

fn seed_progress( &self, owner: Address, pool_id: PoolId, lane: LaneKey, bytes: U256, amount: U256, ) -> Result<AdvanceOutcome, StoreError>

Atomically record lane’s on-chain watermark in owner’s pool (BuyerPoolState::seed_lane): the same owner-index and pool_id checks and the same single durable write transaction as Self::advance_progress. A lane new to the row moves its amount out of BuyerPoolState::redeemed_elsewhere.

fn add_deposit( &self, owner: Address, pool_id: PoolId, additional: U256, ) -> Result<DepositOutcome, StoreError>

Atomically add additional to the committed deposit for owner’s pool.

fn delegate_lanes( &self, deployment: Deployment, pool_id: PoolId, signer: Address, ) -> Result<Vec<(Address, BuyerLaneProgress)>, StoreError>

The recorded progress of every lane signer holds in pool_id on deployment, as (provider, progress) pairs ordered by provider.

fn advance_delegate_progress( &self, deployment: Deployment, lane: LaneKey, totals: BuyerLaneProgress, ) -> Result<AdvanceOutcome, StoreError>

Atomically advance the delegate lane lane on deployment to totals, with the monotonicity rule of BuyerPoolState::advance_lane. A lane with no recorded progress takes the totals as its first record. Returns AdvanceOutcome::Advanced or AdvanceOutcome::Regressed. MUST commit durably.

fn rebase_delegate_progress( &self, deployment: Deployment, lane: LaneKey, anchor: BuyerLaneProgress, totals: BuyerLaneProgress, ) -> Result<AdvanceOutcome, StoreError>

Atomically overwrite the delegate lane lane on deployment with anchor and advance it to totals, with the rule of BuyerPoolState::rebase_lane. The recorded lane is not read, so the overwrite also replaces a record that cannot be decoded. Always returns AdvanceOutcome::Advanced. MUST commit durably.

impl Debug for MemoryBuyerPoolStore

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

Formats the value using the given formatter.

impl Default for MemoryBuyerPoolStore

fn default() -> Self

Returns the “default value” for a type.