mppx 0.13.5 → 0.13.6

package/dist/tempo/session/client/Transports.js

@@ -298,12 +298,22 @@ export async function readProblemDetail(response) {
         return body;
     }
 }
+/** A dispatched deposit may have executed despite a failed or cancelled response. */
+export class UncertainFundingError extends Error {
+    constructor(reason) {
+        const detail = reason instanceof Error || reason instanceof DOMException ? reason.message : String(reason);
+        super(`${detail}; payment outcome unknown`);
+        this.name = 'UncertainFundingError';
+    }
+}
 /** Posts a top-up management credential and returns its receipt, when present. */
 export async function postTopUp(parameters) {
     const { channel, channelId } = parameters;
     if (!channel?.descriptor || channel.channelId !== channelId) {
         throw new Error('Cannot top up session: no local channel descriptor available.');
     }
+    if (channel.uncertainTopUp)
+        throw new Error('Session funding outcome is unknown; reconcile the pending payment before another top-up.');
     const response = await postManagementCredential({
         challenge: parameters.challenge,
         context: {
@@ -316,6 +326,12 @@ export async function postTopUp(parameters) {
         fetch: parameters.fetch,
         input: parameters.input,
         signal: parameters.signal,
+    }).catch(async (error) => {
+        if (error instanceof UncertainFundingError) {
+            channel.uncertainTopUp = true;
+            await parameters.onUncertainFunding?.(channel);
+        }
+        throw error;
     });
     if (!response.ok)
         throw new Error(`Top-up POST failed with status ${response.status}`);
@@ -324,13 +340,42 @@ export async function postTopUp(parameters) {
 }
 /** Posts a management credential and retries once with a refreshed TIP-1034 challenge. */
 async function postManagementCredential(parameters) {
-    const post = async (challenge) => parameters.fetch(managementInput(parameters.input), {
-        method: 'POST',
-        ...(parameters.signal ? { signal: parameters.signal } : {}),
-        headers: {
-            [Constants.Headers.authorization]: await parameters.createSessionCredential(challenge, parameters.context),
-        },
-    });
+    const post = async (challenge) => {
+        parameters.signal?.throwIfAborted();
+        const authorization = await parameters.createSessionCredential(challenge, parameters.context);
+        parameters.signal?.throwIfAborted();
+        const controller = new AbortController();
+        const abort = () => controller.abort(parameters.signal?.reason);
+        parameters.signal?.addEventListener('abort', abort, { once: true });
+        const timeout = setTimeout(() => controller.abort(new DOMException('Session management request timed out; payment outcome unknown', 'TimeoutError')), 30_000);
+        let onAbort;
+        const aborted = new Promise((_, reject) => {
+            onAbort = () => reject(controller.signal.reason);
+            controller.signal.addEventListener('abort', onAbort, { once: true });
+        });
+        try {
+            // Custom fetch implementations may ignore abort. Do not let their late
+            // response update funding state or trigger a refreshed-challenge retry.
+            return await Promise.race([
+                parameters.fetch(managementInput(parameters.input), {
+                    method: 'POST',
+                    signal: controller.signal,
+                    headers: { [Constants.Headers.authorization]: authorization },
+                }),
+                aborted,
+            ]);
+        }
+        catch (error) {
+            if (parameters.context.action === 'topUp')
+                throw new UncertainFundingError(error);
+            throw error;
+        }
+        finally {
+            clearTimeout(timeout);
+            parameters.signal?.removeEventListener('abort', abort);
+            controller.signal.removeEventListener('abort', onAbort);
+        }
+    };
     const response = await post(parameters.challenge);
     if (response.status !== 402)
         return response;

package/dist/tempo/session/precompile/Chain.js

@@ -263,8 +263,8 @@ function validateAutoSwapPrefix(parameters) {
         fail('approval amount does not match swap maximum input');
     if (!isAddressEqual(tokenOut, currency))
         fail('output token does not match channel currency');
-    if (swapAmountOut !== amountOut)
-        fail('output amount does not match channel deposit');
+    if (swapAmountOut <= 0n || swapAmountOut > amountOut)
+        fail('output amount must be positive and not exceed channel deposit');
     if (isAddressEqual(tokenIn, tokenOut))
         fail('input and output tokens must differ');
     const canonicalApprove = encodeFunctionData({
@@ -444,6 +444,7 @@ export async function sendCredentialTransaction(parameters) {
         // execution as the sender. It intentionally omits fee fields here; the
         // transport is responsible for validating its final sponsored envelope.
         await simulateTempoTransaction(client, FeePayer.simulationTransaction(transaction, { feePayer: true }));
+        FeePayer.assertRemainingValidity({ transaction, details });
         const txHash = await sendTransaction(client, serializedTransaction);
         return waitForSuccessfulReceipt(client, txHash);
     }
@@ -467,7 +468,9 @@ export async function sendCredentialTransaction(parameters) {
             return { feePayer: feePayer.address, transaction: sponsored };
         },
     });
+    FeePayer.assertRemainingValidity({ transaction: completed.transaction, details });
     const serialized = await signTempoTransaction(client, completed.transaction);
+    FeePayer.assertRemainingValidity({ transaction: completed.transaction, details });
     const receipt = await sendRawTransactionSync(client, {
         serializedTransaction: serialized,
     });

package/dist/tempo/session/server/ChannelStore.d.ts

@@ -1,5 +1,6 @@
 import type { Address, Hex } from 'viem';
 import type * as Challenge from '../../../Challenge.js';
+import { InsufficientBalanceError } from '../../../Errors.js';
 import type * as Store from '../../../Store.js';
 import type * as Chain from '../precompile/Chain.js';
 import type * as PrecompileChannel from '../precompile/Channel.js';
@@ -109,6 +110,8 @@ export type AcceptVoucherStateUpdateParameters = {
     channelState: Chain.ChannelState;
     /** Existing channel state being updated. */
     current: State | null;
+    /** When `channelState` was read from chain; omitted when it came from the store. */
+    verifiedAt?: number | undefined;
     /** Verified signed voucher. */
     voucher: SessionSignedVoucher;
 };
@@ -193,8 +196,14 @@ export type VerifyAndAcceptVoucherParameters = {
     requireAdvance?: boolean | undefined;
     /** Server channel store. */
     store: ChannelStore;
+    /** When `channelState` was read from chain; omitted when it came from the store. */
+    verifiedAt?: number | undefined;
     /** Signed cumulative voucher to verify and accept. */
     voucher: SignedVoucher;
+    /** Request price to charge in the same store update that accepts the voucher. */
+    chargeAmount?: bigint | undefined;
+    /** Called with the stored channel after `chargeAmount` was charged. */
+    onCharged?: ((channel: State) => void) | undefined;
 };
 /** Inputs for validating a cumulative voucher without recording it. */
 export type ValidateVoucherParameters = Omit<VerifyAndAcceptVoucherParameters, 'challenge' | 'store'>;
@@ -257,6 +266,8 @@ export interface BaseState {
     token: Address;
     /** Number of charge operations (API requests) fulfilled in the current session. */
     units: number;
+    /** Unix milliseconds when the channel's on-chain deposit, settlement and close state were last read. */
+    onChainVerifiedAt?: number | undefined;
     /** Uncommitted stream charges shared across workers. */
     streamReservations?: Record<string, {
         amount: bigint;
@@ -316,6 +327,29 @@ export declare function finalizeClosedChannelState(parameters: FinalizeClosedCha
 export declare function loadPrecompileChannel(parameters: LoadPrecompileChannelParameters): Promise<StoredPrecompileChannel>;
 /** Verifies a cumulative voucher without changing persisted channel state. */
 export declare function validateVoucher(parameters: ValidateVoucherParameters): Promise<VoucherValidation>;
+/**
+ * Checks a cumulative voucher's amounts against channel state, without its signature, so the
+ * check can run inside the store update that accepts it.
+ */
+export declare function assertVoucherAmounts(parameters: {
+    channel: Pick<State, 'highestVoucherAmount'>;
+    channelState: Chain.ChannelState;
+    minVoucherDelta: bigint;
+    voucher: Pick<SignedVoucher, 'cumulativeAmount'>;
+}): VoucherValidation;
+/**
+ * Charges `chargeAmount` to a channel state that just accepted a voucher, for the same store
+ * update. A charge the available balance cannot cover leaves the accepted state uncharged.
+ */
+export declare function planVoucherAcceptance(parameters: {
+    accepted: State;
+    chargeAmount?: bigint | undefined;
+}): {
+    channel: State;
+    charged: boolean;
+};
+/** Reports a request charge that the channel's available balance could not cover. */
+export declare function insufficientBalanceForCharge(channel: State, chargeAmount: bigint): InsufficientBalanceError;
 /** Verifies a cumulative voucher and returns a session receipt after store reconciliation. */
 export declare function verifyAndAcceptVoucher(parameters: VerifyAndAcceptVoucherParameters): Promise<SessionReceipt>;
 /**

package/dist/tempo/session/server/ChannelStore.js

@@ -1,4 +1,4 @@
-import { AmountExceedsDepositError, ChannelClosedError, ChannelNotFoundError, DeltaTooSmallError, InvalidSignatureError, VerificationFailedError, } from '../../../Errors.js';
+import { AmountExceedsDepositError, ChannelClosedError, ChannelNotFoundError, DeltaTooSmallError, InsufficientBalanceError, InvalidSignatureError, VerificationFailedError, } from '../../../Errors.js';
 import { createSessionReceipt } from '../precompile/Protocol.js';
 import { uint96 } from '../precompile/Protocol.js';
 import * as Voucher from '../precompile/Voucher.js';
@@ -100,14 +100,19 @@ export function topUpChannelState(parameters) {
 }
 /** Merges an accepted voucher into persisted channel state after signature and on-chain checks pass. */
 export function acceptVoucherStateUpdate(parameters) {
-    const { channelState, current, voucher } = parameters;
+    const { channelState, current, verifiedAt, voucher } = parameters;
     if (!current)
         throw new ChannelNotFoundError({ reason: 'channel not found' });
     if (current.finalized)
         throw new ChannelClosedError({ reason: 'channel is finalized' });
     if (current.closeRequestedAt !== 0n)
         throw new ChannelClosedError({ reason: 'channel has a pending close request' });
-    const onChain = mergeActiveOnChainState(current, channelState);
+    const onChain = {
+        ...mergeActiveOnChainState(current, channelState),
+        ...(verifiedAt === undefined
+            ? {}
+            : { onChainVerifiedAt: Math.max(verifiedAt, current.onChainVerifiedAt ?? 0) }),
+    };
     if (voucher.cumulativeAmount <= current.highestVoucherAmount) {
         return { ...current, ...onChain };
     }
@@ -239,13 +244,58 @@ export async function validateVoucher(parameters) {
         });
     return { alreadyAccepted: false };
 }
+/**
+ * Checks a cumulative voucher's amounts against channel state, without its signature, so the
+ * check can run inside the store update that accepts it.
+ */
+export function assertVoucherAmounts(parameters) {
+    const { channel, channelState, minVoucherDelta, voucher } = parameters;
+    validateChannelState(channelState);
+    if (voucher.cumulativeAmount > channelState.deposit)
+        throw new AmountExceedsDepositError({ reason: 'voucher amount exceeds on-chain deposit' });
+    if (voucher.cumulativeAmount < channel.highestVoucherAmount)
+        throw new VerificationFailedError({
+            reason: 'voucher cumulativeAmount must be strictly greater than highest accepted voucher',
+        });
+    if (voucher.cumulativeAmount <= channelState.settled)
+        throw new VerificationFailedError({
+            reason: 'voucher cumulativeAmount is below on-chain settled amount',
+        });
+    if (voucher.cumulativeAmount === channel.highestVoucherAmount)
+        return { alreadyAccepted: true };
+    const delta = voucher.cumulativeAmount - channel.highestVoucherAmount;
+    if (delta < minVoucherDelta)
+        throw new DeltaTooSmallError({
+            reason: `voucher delta ${delta} below minimum ${minVoucherDelta}`,
+        });
+    return { alreadyAccepted: false };
+}
+/**
+ * Charges `chargeAmount` to a channel state that just accepted a voucher, for the same store
+ * update. A charge the available balance cannot cover leaves the accepted state uncharged.
+ */
+export function planVoucherAcceptance(parameters) {
+    const { accepted, chargeAmount } = parameters;
+    if (chargeAmount === undefined)
+        return { channel: accepted, charged: false };
+    const deduction = planDeduction(accepted, chargeAmount);
+    if (deduction.op !== 'set')
+        return { channel: accepted, charged: false };
+    return { channel: deduction.value, charged: true };
+}
+/** Reports a request charge that the channel's available balance could not cover. */
+export function insufficientBalanceForCharge(channel, chargeAmount) {
+    return new InsufficientBalanceError({
+        reason: `requested ${chargeAmount}, available ${channel.highestVoucherAmount - channel.spent - reservedStreamAmount(channel)}`,
+    });
+}
 /** Verifies a cumulative voucher and returns a session receipt after store reconciliation. */
 export async function verifyAndAcceptVoucher(parameters) {
-    const { store, challenge, channel, voucher, channelState, requireAdvance } = parameters;
+    const { store, challenge, channel, voucher, channelState, requireAdvance, verifiedAt, chargeAmount, } = parameters;
     const validation = await validateVoucher(parameters);
-    if (validation.alreadyAccepted) {
-        if (requireAdvance)
-            throw new DeltaTooSmallError({ reason: 'voucher does not add new funds for this request' });
+    if (validation.alreadyAccepted && requireAdvance)
+        throw new DeltaTooSmallError({ reason: 'voucher does not add new funds for this request' });
+    if (validation.alreadyAccepted && chargeAmount === undefined)
         return createSessionReceipt({
             challengeId: challenge.id,
             channelId: voucher.channelId,
@@ -253,16 +303,26 @@ export async function verifyAndAcceptVoucher(parameters) {
             spent: channel.spent,
             units: channel.units,
         });
-    }
+    let charged = false;
     const updated = await store.updateChannel(voucher.channelId, (current) => {
         if (requireAdvance &&
             current !== null &&
             voucher.cumulativeAmount <= current.highestVoucherAmount)
             throw new DeltaTooSmallError({ reason: 'voucher does not add new funds for this request' });
-        return acceptVoucherStateUpdate({ channelState, current, voucher });
+        const acceptance = planVoucherAcceptance({
+            accepted: acceptVoucherStateUpdate({ channelState, current, verifiedAt, voucher }),
+            chargeAmount,
+        });
+        charged = acceptance.charged;
+        return acceptance.channel;
     });
     if (!updated)
         throw new ChannelNotFoundError({ reason: 'channel not found' });
+    if (chargeAmount !== undefined) {
+        if (!charged)
+            throw insufficientBalanceForCharge(updated, chargeAmount);
+        parameters.onCharged?.(updated);
+    }
     return createSessionReceipt({
         challengeId: challenge.id,
         channelId: voucher.channelId,

package/dist/tempo/session/server/CredentialVerification.d.ts

@@ -85,6 +85,12 @@ export type BroadcastCredentialPayloadParameters = {
     requireVoucherAdvance?: boolean | undefined;
     /** Server-side channel store. */
     store: ChannelStore.ChannelStore;
+    /** Maximum age of verified on-chain state a voucher may be accepted against. See `session.Parameters`. @default 0 */
+    voucherStateMaxAge?: number | undefined;
+    /** Request price a voucher credential pays in the same store update that accepts it. */
+    chargeAmount?: bigint | undefined;
+    /** Called with the stored channel after `chargeAmount` was charged. */
+    onCharged?: ((channel: ChannelStore.State) => void) | undefined;
 };
 /** @deprecated Use {@link BroadcastCredentialPayloadParameters}. */
 export type VerifyCredentialPayloadParameters = BroadcastCredentialPayloadParameters;
@@ -106,7 +112,7 @@ export type VoucherCredentialActionParameters = BroadcastCredentialActionParamet
 /** Inputs for broadcasting and settling a cooperative close credential. */
 export type CloseCredentialActionParameters = BroadcastCredentialActionParameters<'close'>;
 /** Inputs for validating a session credential without applying its state transition. */
-export type ValidateCredentialPayloadParameters = Pick<BroadcastCredentialPayloadParameters, 'account' | 'channelStateTtl' | 'chainId' | 'client' | 'credentialSource' | 'escrow' | 'expectedOperator' | 'feePayer' | 'feePayerPolicy' | 'feeToken' | 'lastOnChainVerified' | 'minVoucherDelta' | 'payload' | 'store' | 'challenge'> & {
+export type ValidateCredentialPayloadParameters = Pick<BroadcastCredentialPayloadParameters, 'account' | 'channelStateTtl' | 'chainId' | 'client' | 'credentialSource' | 'escrow' | 'expectedOperator' | 'feePayer' | 'feePayerPolicy' | 'feeToken' | 'lastOnChainVerified' | 'minVoucherDelta' | 'payload' | 'store' | 'challenge' | 'voucherStateMaxAge'> & {
     /** Allows terminal broadcast to recover accepted funds before rejecting a pending close. */
     allowPendingClose?: boolean | undefined;
 };

package/dist/tempo/session/server/CredentialVerification.js

@@ -368,14 +368,22 @@ async function validateVoucherCredential(parameters, payload) {
     assertCredentialSourceCanSpend({ chainId, channel, source: credentialSource });
     if (channel.finalized)
         throw new ChannelClosedError({ reason: 'channel is finalized' });
-    const channelState = await resolveVoucherChannelState({
+    const channelState = canUseStoredChannelState({
         channel,
         channelId,
-        channelStateTtl,
-        client,
-        escrow,
         lastOnChainVerified,
-    });
+        voucher,
+        voucherStateMaxAge: parameters.voucherStateMaxAge ?? 0,
+    })
+        ? storedChannelState(channel)
+        : await resolveVoucherChannelState({
+            channel,
+            channelId,
+            channelStateTtl,
+            client,
+            escrow,
+            lastOnChainVerified,
+        });
     if (parameters.allowPendingClose && channelState.closeRequestedAt !== 0)
         return;
     await ChannelStore.validateVoucher({
@@ -387,17 +395,36 @@ async function validateVoucherCredential(parameters, payload) {
     });
 }
 async function resolveVoucherChannelState(parameters) {
-    const { channel, channelId, channelStateTtl, client, escrow, forceRefresh, lastOnChainVerified } = parameters;
+    const { channelId, channelStateTtl, client, escrow, forceRefresh, lastOnChainVerified } = parameters;
     const shouldRefresh = forceRefresh || Date.now() - (lastOnChainVerified.get(channelId) ?? 0) > channelStateTtl;
     const state = shouldRefresh ? await Chain.getChannelState(client, channelId, escrow) : undefined;
-    if (state?.closeRequestedAt)
+    if (state && (state.closeRequestedAt !== 0 || state.deposit === 0n))
         lastOnChainVerified.delete(channelId);
     else if (state)
         lastOnChainVerified.set(channelId, Date.now());
+    if (state)
+        return state;
+    const { channel } = parameters;
+    return storedChannelState(typeof channel === 'function' ? await channel() : channel);
+}
+/**
+ * Whether a voucher may be checked against the stored channel instead of waiting for a chain read.
+ * A payer can withdraw only after the escrow's close grace period, so a voucher within the deposit
+ * of recently verified open state stays settleable while a fresh read finishes.
+ */
+function canUseStoredChannelState(parameters) {
+    const { channel, channelId, lastOnChainVerified, voucher, voucherStateMaxAge } = parameters;
+    const verifiedAt = Math.max(lastOnChainVerified.get(channelId) ?? 0, channel.onChainVerifiedAt ?? 0);
+    return (voucherStateMaxAge > 0 &&
+        channel.closeRequestedAt === 0n &&
+        Date.now() - verifiedAt <= voucherStateMaxAge &&
+        voucher.cumulativeAmount <= channel.deposit);
+}
+function storedChannelState(channel) {
     return {
-        deposit: state?.deposit ?? uint96(channel.deposit),
-        settled: state?.settled ?? uint96(channel.settledOnChain),
-        closeRequestedAt: state?.closeRequestedAt ?? Number(channel.closeRequestedAt),
+        deposit: uint96(channel.deposit),
+        settled: uint96(channel.settledOnChain),
+        closeRequestedAt: Number(channel.closeRequestedAt),
     };
 }
 async function validateCloseCredential(parameters, payload) {
@@ -602,26 +629,81 @@ async function handleVoucherCredential(parameters) {
     const voucher = Voucher.parseVoucherFromPayload(channelId, payload.cumulativeAmount, payload.signature);
     assertDescriptor(payload);
     validateChannelDescriptor(payload.descriptor, channelId, chainId, escrow, request.recipient, request.currency, expectedOperator);
-    const channel = await ChannelStore.loadPrecompileChannel({
-        descriptor: payload.descriptor,
-        channelId,
-        chainId,
-        escrow,
-        store,
-        validateDescriptor: true,
-    });
+    const voucherStateMaxAge = parameters.voucherStateMaxAge ?? 0;
+    const { chargeAmount, onCharged } = parameters;
+    let loadingChannel;
+    const loadChannel = () => {
+        loadingChannel ??= ChannelStore.loadPrecompileChannel({
+            descriptor: payload.descriptor,
+            channelId,
+            chainId,
+            escrow,
+            store,
+            validateDescriptor: true,
+        });
+        return loadingChannel;
+    };
+    // The on-chain read does not depend on the stored channel, so it overlaps the store read.
+    // Store errors still take precedence because the stored channel is awaited first.
+    let reading;
+    const readChannelState = () => {
+        if (reading)
+            return reading;
+        const startedAt = Date.now();
+        const state = resolveVoucherChannelState({
+            channel: loadChannel,
+            channelId,
+            channelStateTtl,
+            client,
+            escrow,
+            forceRefresh: true,
+            lastOnChainVerified,
+        });
+        state.catch(() => { });
+        reading = { startedAt, state };
+        return reading;
+    };
+    const recentlyRead = voucherStateMaxAge > 0 &&
+        Date.now() - (lastOnChainVerified.get(channelId) ?? 0) <=
+            Math.min(channelStateTtl, voucherStateMaxAge);
+    if (!recentlyRead)
+        readChannelState();
+    if (voucherStateMaxAge > 0 && store.updateChannelResult) {
+        const receipt = await acceptVoucherInOneUpdate(parameters, voucher, payload.descriptor);
+        if (receipt) {
+            if (reading)
+                recordOnChainReadInBackground(parameters, channelId, reading);
+            return receipt;
+        }
+    }
+    const channel = await loadChannel();
     assertCredentialSourceCanSpend({ chainId, channel, source: credentialSource });
     if (channel.finalized)
         throw new ChannelClosedError({ reason: 'channel is finalized' });
-    const channelState = await resolveVoucherChannelState({
+    if (canUseStoredChannelState({
         channel,
         channelId,
-        channelStateTtl,
-        client,
-        escrow,
-        forceRefresh: true,
         lastOnChainVerified,
-    });
+        voucher,
+        voucherStateMaxAge,
+    })) {
+        if (reading)
+            recordOnChainReadInBackground(parameters, channelId, reading);
+        return ChannelStore.verifyAndAcceptVoucher({
+            store,
+            minVoucherDelta,
+            requireAdvance: parameters.requireVoucherAdvance,
+            challenge,
+            channel,
+            voucher,
+            channelState: storedChannelState(channel),
+            methodDetails: { chainId, escrowContract: escrow },
+            chargeAmount,
+            onCharged,
+        });
+    }
+    const { startedAt, state } = readChannelState();
+    const channelState = await state;
     const reconciled = channel.closeRequestedAt === 0n
         ? channel
         : ((await store.updateChannel(channelId, (current) => ChannelStore.reconcileExpiredPendingClose({
@@ -630,30 +712,7 @@ async function handleVoucherCredential(parameters) {
             state: channelState,
         }))) ?? channel);
     if (channelState.closeRequestedAt !== 0) {
-        const closing = await store.updateChannel(channelId, (current) => current
-            ? {
-                ...current,
-                settledOnChain: channelState.settled > current.settledOnChain
-                    ? channelState.settled
-                    : current.settledOnChain,
-                closeRequestedAt: BigInt(channelState.closeRequestedAt) > current.closeRequestedAt
-                    ? BigInt(channelState.closeRequestedAt)
-                    : current.closeRequestedAt,
-            }
-            : current);
-        if (closing && !closing.finalized && channelState.deposit > 0n)
-            await maybeSettleScheduled({
-                account: parameters.account,
-                channel: closing,
-                client,
-                feePayer: parameters.feePayer,
-                feePayerPolicy: parameters.feePayerPolicy,
-                feeToken: parameters.feeToken,
-                onSessionSettlement: parameters.onSessionSettlement,
-                onSessionSettlementFailure: parameters.onSessionSettlementFailure,
-                schedule: {},
-                store,
-            });
+        await recordPendingClose(parameters, channelId, channelState);
         throw new ChannelClosedError({ reason: 'channel has a pending close request' });
     }
     return ChannelStore.verifyAndAcceptVoucher({
@@ -665,8 +724,121 @@ async function handleVoucherCredential(parameters) {
         voucher,
         channelState,
         methodDetails: { chainId, escrowContract: escrow },
+        verifiedAt: startedAt,
+        chargeAmount,
+        onCharged,
     });
 }
+/**
+ * Accepts a voucher, and charges its request, in one store update with no separate read: the
+ * update checks the stored channel itself. Returns `undefined` without writing when the stored
+ * on-chain state was not verified recently enough to accept against.
+ */
+async function acceptVoucherInOneUpdate(parameters, voucher, descriptor) {
+    const { challenge, chainId, chargeAmount, credentialSource, escrow, lastOnChainVerified, minVoucherDelta, requireVoucherAdvance, store, } = parameters;
+    const voucherStateMaxAge = parameters.voucherStateMaxAge ?? 0;
+    const valid = await Voucher.verifyVoucher(escrow, chainId, voucher, authorizedSigner(descriptor));
+    if (!valid)
+        throw new InvalidSignatureError({ reason: 'invalid voucher signature' });
+    const outcome = await store.updateChannelResult(voucher.channelId, (current) => {
+        if (!current)
+            throw new ChannelNotFoundError({ reason: 'channel not found' });
+        if (!ChannelStore.isPrecompileState(current))
+            throw new VerificationFailedError({ reason: 'channel is not precompile-backed' });
+        assertSameDescriptor(descriptor, current.descriptor);
+        validateChannelDescriptor(descriptor, voucher.channelId, chainId, escrow, current.payee, current.token);
+        assertCredentialSourceCanSpend({ chainId, channel: current, source: credentialSource });
+        if (current.finalized)
+            throw new ChannelClosedError({ reason: 'channel is finalized' });
+        if (!canUseStoredChannelState({
+            channel: current,
+            channelId: voucher.channelId,
+            lastOnChainVerified,
+            voucher,
+            voucherStateMaxAge,
+        }))
+            return { op: 'noop', result: undefined };
+        if (requireVoucherAdvance && voucher.cumulativeAmount <= current.highestVoucherAmount)
+            throw new DeltaTooSmallError({ reason: 'voucher does not add new funds for this request' });
+        const channelState = storedChannelState(current);
+        const { alreadyAccepted } = ChannelStore.assertVoucherAmounts({
+            channel: current,
+            channelState,
+            minVoucherDelta,
+            voucher,
+        });
+        if (alreadyAccepted && chargeAmount === undefined)
+            return { op: 'noop', result: { channel: current, charged: false } };
+        const acceptance = ChannelStore.planVoucherAcceptance({
+            accepted: ChannelStore.acceptVoucherStateUpdate({ channelState, current, voucher }),
+            chargeAmount,
+        });
+        return { op: 'set', value: acceptance.channel, result: acceptance };
+    });
+    if (!outcome)
+        return undefined;
+    if (chargeAmount !== undefined) {
+        if (!outcome.charged)
+            throw ChannelStore.insufficientBalanceForCharge(outcome.channel, chargeAmount);
+        parameters.onCharged?.(outcome.channel);
+    }
+    return createSessionReceipt({
+        challengeId: challenge.id,
+        channelId: voucher.channelId,
+        acceptedCumulative: outcome.channel.highestVoucherAmount,
+        spent: outcome.channel.spent,
+        units: outcome.channel.units,
+    });
+}
+/** Persists a pending close seen on chain and settles the channel while the payee still can. */
+async function recordPendingClose(parameters, channelId, channelState) {
+    const { client, store } = parameters;
+    const closing = await store.updateChannel(channelId, (current) => current
+        ? {
+            ...current,
+            settledOnChain: channelState.settled > current.settledOnChain
+                ? channelState.settled
+                : current.settledOnChain,
+            closeRequestedAt: BigInt(channelState.closeRequestedAt) > current.closeRequestedAt
+                ? BigInt(channelState.closeRequestedAt)
+                : current.closeRequestedAt,
+        }
+        : current);
+    if (closing && !closing.finalized && channelState.deposit > 0n)
+        await maybeSettleScheduled({
+            account: parameters.account,
+            channel: closing,
+            client,
+            feePayer: parameters.feePayer,
+            feePayerPolicy: parameters.feePayerPolicy,
+            feeToken: parameters.feeToken,
+            onSessionSettlement: parameters.onSessionSettlement,
+            onSessionSettlementFailure: parameters.onSessionSettlementFailure,
+            schedule: {},
+            store,
+        });
+}
+/**
+ * Records an on-chain read that a voucher did not wait for: a pending close is persisted so later
+ * vouchers are rejected, and open state extends the verified age of the stored channel.
+ */
+function recordOnChainReadInBackground(parameters, channelId, read) {
+    read.state
+        .then(async (state) => {
+        if (state.closeRequestedAt !== 0)
+            return recordPendingClose(parameters, channelId, state);
+        if (state.deposit === 0n)
+            return;
+        await parameters.store.updateChannel(channelId, (current) => current && !current.finalized && current.closeRequestedAt === 0n
+            ? {
+                ...current,
+                ...ChannelStore.mergeActiveOnChainState(current, state),
+                onChainVerifiedAt: Math.max(read.startedAt, current.onChainVerifiedAt ?? 0),
+            }
+            : current);
+    })
+        .catch(() => { });
+}
 const sendMethods = new Set([
     'eth_sendRawTransaction',
     'eth_sendRawTransactionSync',