mppx 0.8.12 → 0.8.14

package/src/tempo/session/client/CredentialState.ts

@@ -11,9 +11,11 @@ import type * as Challenge from '../../../Challenge.js'
 import * as Constants from '../../../Constants.js'
 import * as Account from '../../../viem/Account.js'
 import * as z from '../../../zod.js'
+import * as AutoSwap from '../../internal/auto-swap.js'
 import * as Chain from '../precompile/Chain.js'
 import * as Channel from '../precompile/Channel.js'
 import type { SessionCredentialPayload } from '../precompile/Protocol.js'
+import * as Voucher from '../precompile/Voucher.js'
 import type { SessionSnapshot } from '../Snapshot.js'
 import {
   createClosePayload,
@@ -24,6 +26,7 @@ import {
   resolveAuthorizedSigner,
   resolveEscrow,
   type ChannelEntry,
+  type TempoChannelCall,
 } from './ChannelOps.js'
 import { channelKey, entryKey, type ChannelSink } from './ChannelStore.js'
 import { assertWithinMaxDeposit, resolveOpeningDeposit } from './Runtime.js'
@@ -87,6 +90,7 @@ const hashSchema = z.custom<Hex>(
 /** Runtime schema for low-level TIP-1034 session credential context. */
 export const sessionContextSchema = z.object({
   account: z.optional(z.custom<Account.getResolver.Parameters['account']>()),
+  autoSwap: z.optional(z.custom<AutoSwap.resolve.Value>()),
   action: z.optional(z.enum(['open', 'topUp', 'voucher', 'close'])),
   channelId: z.optional(hashSchema),
   cumulativeAmount: z.optional(z.amount()),
@@ -102,6 +106,8 @@ export const sessionContextSchema = z.object({
 export type SessionContext = {
   /** Optional account override used for this credential only. */
   account?: Account.getResolver.Parameters['account'] | undefined
+  /** Automatically acquire the session currency from fallback stablecoins before open/top-up. */
+  autoSwap?: AutoSwap.resolve.Value | undefined
   /** Manual credential action. Omit for automatic open/recover/voucher management. */
   action?: 'open' | 'topUp' | 'voucher' | 'close' | undefined
   /** Channel ID being reused or manually operated on. */
@@ -309,6 +315,26 @@ export type ResolveRecoveredCumulativeParameters = {
   settled: bigint
 }
 
+/** Inputs used to validate and hydrate a server-provided session snapshot. */
+export type HydrateSessionSnapshotParameters = {
+  /** Account expected to own the channel and its voucher authority. */
+  account: ViemAccount
+  /** Viem client used to read authoritative TIP-1034 channel state. */
+  client: Client
+  /** Snapshot returned by an MPP server bootstrap. */
+  snapshot: SessionSnapshot
+  /** Optional state reader for deterministic tests. */
+  readChannelState?: ReadReusableChannelState | undefined
+}
+
+/** Validated client channel state reconstructed without local persistence. */
+export type HydratedSessionSnapshot = {
+  /** Reusable channel entry safe to cache locally. */
+  entry: ChannelEntry
+  /** Server-accounted delivered spend at bootstrap time. */
+  spent: bigint
+}
+
 /** Data-first description of the next credential operation the client should execute. */
 export type CredentialPlan =
   /** No reusable channel is available, so create an open transaction and initial voucher. */
@@ -476,7 +502,7 @@ function assertReusableChannelDescriptor(parameters: {
     throw new Error('context descriptor token does not match challenge')
   if (!isSameAddress(descriptor.payer, payer))
     throw new Error('context descriptor payer does not match account')
-  if (!isSameAddress(descriptor.authorizedSigner, authorizedSigner))
+  if (!isSameAddress(Channel.resolveAuthorizedSigner(descriptor), authorizedSigner))
     throw new Error('context descriptor authorizedSigner does not match account')
 }
 
@@ -501,7 +527,12 @@ export function resolveRecoveredCumulative(
   const { context, decimals, requestAmount, snapshot, settled } = parameters
 
   if (snapshot) {
-    return BigInt(snapshot.spent) + requestAmount
+    return [
+      BigInt(snapshot.acceptedCumulative),
+      BigInt(snapshot.requiredCumulative),
+      BigInt(snapshot.spent) + requestAmount,
+      settled,
+    ].reduce((highest, value) => (value > highest ? value : highest), 0n)
   }
 
   const contextCumulative = parseOptionalContextAmount(context, decimals, 'cumulativeAmount')
@@ -509,6 +540,78 @@ export function resolveRecoveredCumulative(
   return settled + requestAmount
 }
 
+/** Checks a server snapshot against its signed voucher and current TIP-1034 state. */
+export async function hydrateSessionSnapshot(
+  parameters: HydrateSessionSnapshotParameters,
+): Promise<HydratedSessionSnapshot> {
+  const { account, client, readChannelState, snapshot } = parameters
+  const signed = snapshot.highestVoucher
+  if (!signed) throw new Error('session snapshot is missing its highest signed voucher')
+  if (signed.channelId.toLowerCase() !== snapshot.channelId.toLowerCase())
+    throw new Error('session snapshot voucher channelId does not match snapshot channelId')
+
+  const acceptedCumulative = BigInt(snapshot.acceptedCumulative)
+  const voucherCumulative = BigInt(signed.cumulativeAmount)
+  const requiredCumulative = BigInt(snapshot.requiredCumulative)
+  const snapshotDeposit = BigInt(snapshot.deposit)
+  const snapshotSettled = BigInt(snapshot.settled)
+  const spent = BigInt(snapshot.spent)
+  if (voucherCumulative !== acceptedCumulative)
+    throw new Error('session snapshot voucher amount does not match acceptedCumulative')
+  if (spent > acceptedCumulative)
+    throw new Error('session snapshot spent exceeds acceptedCumulative')
+  if (snapshotSettled > snapshotDeposit)
+    throw new Error('session snapshot settled amount exceeds deposit')
+
+  if (
+    !Voucher.verifyVoucher(
+      snapshot.escrow,
+      snapshot.chainId,
+      {
+        channelId: signed.channelId,
+        cumulativeAmount: voucherCumulative,
+        signature: signed.signature,
+      },
+      Channel.resolveAuthorizedSigner(snapshot.descriptor),
+    )
+  )
+    throw new Error('session snapshot highest voucher signature is invalid')
+
+  const reusable = await resolveReusableChannel({
+    channelId: snapshot.channelId,
+    client,
+    descriptor: snapshot.descriptor,
+    expected: {
+      chainId: snapshot.chainId,
+      escrow: snapshot.escrow,
+      payee: snapshot.descriptor.payee,
+      payer: account.address,
+      authorizedSigner: resolveAuthorizedSigner(account),
+      token: snapshot.descriptor.token,
+    },
+    readChannelState,
+  })
+  const cumulativeAmount = [acceptedCumulative, requiredCumulative, reusable.state.settled].reduce(
+    (highest, value) => (value > highest ? value : highest),
+    0n,
+  )
+  if (cumulativeAmount > reusable.state.deposit)
+    throw new Error('recovered session cumulative amount exceeds on-chain channel deposit')
+
+  return {
+    entry: {
+      channelId: reusable.channelId,
+      cumulativeAmount,
+      deposit: reusable.state.deposit,
+      descriptor: snapshot.descriptor,
+      escrow: snapshot.escrow,
+      chainId: snapshot.chainId,
+      opened: true,
+    },
+    spent,
+  }
+}
+
 /** Returns whether `account` can satisfy the descriptor's voucher authority. */
 export function canSignDescriptor(
   account: ViemAccount,
@@ -516,9 +619,10 @@ export function canSignDescriptor(
 ): boolean {
   // Only the payer can deposit into and voucher against its own channel.
   if (!isSameAddress(account.address, descriptor.payer)) return false
-  const authority = descriptor.authorizedSigner
-  if (BigInt(authority) === 0n || isSameAddress(authority, descriptor.payer)) return true
-  return isSameAddress(resolveAuthorizedSigner(account), authority)
+  return isSameAddress(
+    resolveAuthorizedSigner(account),
+    Channel.resolveAuthorizedSigner(descriptor),
+  )
 }
 
 /** Chooses the next credential plan from local channel cache and optional caller context. */
@@ -559,22 +663,43 @@ export function planCredential(parameters: PlanCredentialParameters): Credential
 export async function executeCredentialPlan(
   plan: CredentialPlan,
   sink: ChannelSink,
+  autoSwap: AutoSwap.resolve.Resolved | false = false,
 ): Promise<SessionCredentialPayload> {
   switch (plan.type) {
     case 'open':
-      return open(plan, sink)
+      return open(plan, sink, autoSwap)
     case 'recover':
       return recover(plan, sink)
     case 'voucher':
       return voucher(plan, sink)
     case 'manual':
-      return manual(plan, sink)
+      return manual(plan, sink, autoSwap)
   }
 }
 
+async function resolveAutoSwapCalls(
+  autoSwap: AutoSwap.resolve.Resolved | false,
+  parameters: {
+    account: Address
+    amountOut: bigint
+    client: Client
+    tokenOut: Address
+  },
+): Promise<readonly TempoChannelCall[] | undefined> {
+  if (!autoSwap) return undefined
+  return (await AutoSwap.findCalls(parameters.client, {
+    account: parameters.account,
+    amountOut: parameters.amountOut,
+    tokenOut: parameters.tokenOut,
+    tokenIn: autoSwap.tokenIn,
+    slippage: autoSwap.slippage,
+  })) as readonly TempoChannelCall[] | undefined
+}
+
 async function open(
   plan: Extract<CredentialPlan, { type: 'open' }>,
   sink: ChannelSink,
+  autoSwap: AutoSwap.resolve.Resolved | false,
 ): Promise<SessionCredentialPayload> {
   const { account, resolved } = plan
   const deposit = resolveOpeningDeposit({
@@ -591,6 +716,12 @@ async function open(
     initialAmount: resolved.amount,
     operator: resolved.operator,
     payee: resolved.payee,
+    prefixCalls: await resolveAutoSwapCalls(autoSwap, {
+      account: account.address,
+      amountOut: deposit,
+      client: resolved.client,
+      tokenOut: resolved.token,
+    }),
     token: resolved.token,
   })
   await storeChannelEntry(sink, {
@@ -677,6 +808,7 @@ async function voucher(
 async function manual(
   plan: Extract<CredentialPlan, { type: 'manual' }>,
   sink: ChannelSink,
+  autoSwap: AutoSwap.resolve.Resolved | false,
 ): Promise<SessionCredentialPayload> {
   const { account, context, decimals, resolved } = plan
   const { descriptor } = context
@@ -695,26 +827,30 @@ async function manual(
     token: resolved.token,
   })
 
-  const payload = await executeManualCredential({
-    account,
-    channelId,
-    context,
-    decimals,
-    descriptor,
-    resolved,
-  })
+  const payload = await executeManualCredential(
+    {
+      account,
+      channelId,
+      context,
+      decimals,
+      descriptor,
+      resolved,
+    },
+    autoSwap,
+  )
   await applyCumulative(sink, resolved.key, payload)
   return payload
 }
 
 async function executeManualCredential(
   parameters: ManualCredentialParameters,
+  autoSwap: AutoSwap.resolve.Resolved | false,
 ): Promise<SessionCredentialPayload> {
   switch (parameters.context.action) {
     case 'open':
       return manualOpen(parameters)
     case 'topUp':
-      return manualTopUp(parameters)
+      return manualTopUp(parameters, autoSwap)
     case 'voucher':
       return manualVoucher(parameters)
     case 'close':
@@ -750,6 +886,7 @@ async function manualOpen(
 
 async function manualTopUp(
   parameters: ManualCredentialParameters,
+  autoSwap: AutoSwap.resolve.Resolved | false,
 ): Promise<SessionCredentialPayload> {
   const { account, channelId, context, decimals, descriptor, resolved } = parameters
   const additionalDeposit = requireContextAmount(context, decimals, 'additionalDeposit', 'topUp')
@@ -771,6 +908,12 @@ async function manualTopUp(
     resolved.chainId,
     resolved.feePayer,
     resolved.escrow,
+    await resolveAutoSwapCalls(autoSwap, {
+      account: account.address,
+      amountOut: additionalDeposit,
+      client: resolved.client,
+      tokenOut: resolved.token,
+    }),
   )
 }
 

package/src/tempo/session/client/Runtime.test.ts

@@ -30,6 +30,7 @@ import {
   nextSpentFromReceipt,
   parseManagerAmount,
   reduce,
+  resolveAutomaticTopUp,
   resolveCloseTarget,
   resolveNeedVoucherTransition,
   resolveOpeningDeposit,
@@ -925,6 +926,17 @@ describe('LocalAuthorization', () => {
       )
     })
 
+    test.each([
+      [{ topUpAmount: 80n, suggestedDeposit: 100n }, 80n],
+      [{ suggestedDeposit: 100n }, 100n],
+      [{}, 50n],
+      [{ maxDeposit: 180n, suggestedDeposit: 100n }, 80n],
+    ])('resolves bounded automatic top-ups %#', (policy, expected) => {
+      expect(resolveAutomaticTopUp({ deposit: 100n, requiredCumulative: 150n, ...policy })).toBe(
+        expected,
+      )
+    })
+
     test('enforces optional maxDeposit through the compatibility helper', () => {
       expect(() => assertWithinMaxDeposit(101n, 100n)).toThrow(
         'requested voucher amount 101 exceeds local maxDeposit 100',

package/src/tempo/session/client/Runtime.ts

@@ -533,6 +533,28 @@ export function resolveOpeningDeposit(parameters: ResolveOpeningDepositParameter
   return proposed
 }
 
+/** Resolves a bounded automatic refill, preferring explicit policy over server headroom. */
+export function resolveAutomaticTopUp(parameters: {
+  deposit: bigint
+  maxDeposit?: bigint | null | undefined
+  requiredCumulative: bigint
+  suggestedDeposit?: bigint | undefined
+  topUpAmount?: bigint | null | undefined
+}): bigint {
+  const { deposit, maxDeposit, requiredCumulative, suggestedDeposit, topUpAmount } = parameters
+  if (requiredCumulative <= deposit) return 0n
+  assertVoucherWithinLocalLimit({
+    cumulativeAmount: requiredCumulative,
+    maxVoucherCumulative: maxDeposit ?? null,
+  })
+  const shortfall = requiredCumulative - deposit
+  const preferred = topUpAmount ?? suggestedDeposit ?? shortfall
+  const proposed = preferred > shortfall ? preferred : shortfall
+  if (maxDeposit === null || maxDeposit === undefined) return proposed
+  const remaining = maxDeposit - deposit
+  return proposed < remaining ? proposed : remaining
+}
+
 /** Enforces the optional client-side maximum cumulative voucher authorization. */
 export function assertWithinMaxDeposit(
   cumulativeAmount: bigint,

package/src/tempo/session/client/Session.test.ts

@@ -1,13 +1,15 @@
 import { type Address, createClient, custom, decodeFunctionData, encodeFunctionResult } from 'viem'
 import { privateKeyToAccount } from 'viem/accounts'
 import { Account as TempoAccount, Secp256k1, Transaction } from 'viem/tempo'
-import { describe, expect, test } from 'vp/test'
+import { describe, expect, test, vi } from 'vp/test'
 
 import { serialize as serializeChallenge, type Challenge } from '../../../Challenge.js'
 import * as Fetch from '../../../client/internal/Fetch.js'
+import * as MethodChallenge from '../../../client/internal/MethodChallenge.js'
 import * as Constants from '../../../Constants.js'
 import * as Credential from '../../../Credential.js'
 import * as z from '../../../zod.js'
+import * as AutoSwap from '../../internal/auto-swap.js'
 import * as Methods from '../../Methods.js'
 import * as Channel from '../precompile/Channel.js'
 import { escrowAbi } from '../precompile/escrow.abi.js'
@@ -99,6 +101,14 @@ function openDeposit(payload: Types.SessionCredentialPayload): bigint {
   return openArgs(payload)[3]
 }
 
+function transactionCalls(payload: Types.SessionCredentialPayload) {
+  if (payload.action !== 'open' && payload.action !== 'topUp')
+    throw new Error('expected transaction payload')
+  const transaction = Transaction.deserialize(payload.transaction)
+  if (!('calls' in transaction)) throw new Error('expected tempo calls')
+  return transaction.calls as readonly { to?: Address; data?: `0x${string}` }[]
+}
+
 describe('precompile client session', () => {
   test('handles only TIP-1034 session challenges', () => {
     const method = session({ account, getClient: () => client })
@@ -205,7 +215,164 @@ describe('precompile client session', () => {
     expect(await response.text()).toBe(
       `${Types.formatMessageEvent('first')}${Types.formatMessageEvent('second')}`,
     )
-    expect(actions).toEqual(['open', 'voucher', 'topUp', 'voucher'])
+    expect(actions).toEqual(['open', 'topUp', 'voucher', 'voucher'])
+  })
+
+  test('tops up before signing plain HTTP vouchers through Fetch.from', async () => {
+    const challenge = makeChallenge({
+      suggestedDeposit: '100',
+      methodDetails: {
+        chainId,
+        escrowContract: tip20ChannelEscrow,
+        sessionProtocol: Constants.SessionProtocols.v2,
+      },
+    })
+    const actions: Types.SessionCredentialPayload['action'][] = []
+    const paidRequests: {
+      body: BodyInit | null
+      header: string | null
+      method: string | undefined
+    }[] = []
+    let opened: Extract<Types.SessionCredentialPayload, { action: 'open' }> | undefined
+    const rawFetch: typeof globalThis.fetch = async (_input, init) => {
+      const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+      if (!authorization)
+        return new Response(null, {
+          status: 402,
+          headers: { [Constants.Headers.wwwAuthenticate]: serializeChallenge(challenge) },
+        })
+
+      const payload = deserialize(authorization)
+      actions.push(payload.action)
+      if (payload.action === 'open') {
+        opened = payload
+        return new Response('opened')
+      }
+      if (payload.action === 'topUp') return new Response(null, { status: 204 })
+      if (payload.action !== 'voucher' || !opened) throw new Error('expected open voucher')
+
+      paidRequests.push({
+        body: init?.body ?? null,
+        header: new Headers(init?.headers).get('x-test'),
+        method: init?.method,
+      })
+      return new Response('paid')
+    }
+    const fetch = Fetch.from({
+      fetch: rawFetch,
+      methods: [
+        session({
+          account,
+          decimals: 0,
+          getClient: () => client,
+          maxDeposit: '300',
+        }),
+      ],
+    })
+
+    expect(await (await fetch('https://example.com/resource')).text()).toBe('opened')
+    const response = await fetch('https://example.com/resource', {
+      body: 'request-body',
+      headers: { 'x-test': 'preserved' },
+      method: 'POST',
+    })
+
+    expect(await response.text()).toBe('paid')
+    expect(actions).toEqual(['open', 'topUp', 'voucher'])
+    expect(paidRequests).toEqual([{ body: 'request-body', header: 'preserved', method: 'POST' }])
+  })
+
+  test('does not top up a stored channel owned by another account', async () => {
+    const channelStore = createChannelStore()
+    const foreign = '0x0000000000000000000000000000000000000004' as Address
+    await channelStore.set({
+      chainId,
+      channelId: `0x${'44'.repeat(32)}`,
+      cumulativeAmount: 100n,
+      deposit: 100n,
+      descriptor: { ...descriptor, authorizedSigner: foreign, payer: foreign },
+      escrow: tip20ChannelEscrow,
+      opened: true,
+    })
+    const actions: Types.SessionCredentialPayload['action'][] = []
+    const challenge = makeChallenge({
+      methodDetails: {
+        chainId,
+        escrowContract: tip20ChannelEscrow,
+        sessionProtocol: Constants.SessionProtocols.v2,
+      },
+    })
+    const fetch = Fetch.from({
+      fetch: async (_input, init) => {
+        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+        if (!authorization)
+          return new Response(null, {
+            status: 402,
+            headers: { [Constants.Headers.wwwAuthenticate]: serializeChallenge(challenge) },
+          })
+        actions.push(deserialize(authorization).action)
+        return new Response('paid')
+      },
+      methods: [session({ account, channelStore, decimals: 0, getClient: () => client })],
+    })
+
+    expect(await (await fetch('https://example.com/resource')).text()).toBe('paid')
+    expect(actions).toEqual(['open'])
+  })
+
+  test('uses a matching server snapshot deposit when checking headroom', async () => {
+    const channelStore = createChannelStore()
+    const channelId = Channel.computeId({ ...descriptor, chainId, escrow: tip20ChannelEscrow })
+    await channelStore.set({
+      chainId,
+      channelId,
+      cumulativeAmount: 100n,
+      deposit: 100n,
+      descriptor,
+      escrow: tip20ChannelEscrow,
+      opened: true,
+    })
+    const challenge = makeChallenge({
+      methodDetails: {
+        chainId,
+        escrowContract: tip20ChannelEscrow,
+        sessionProtocol: Constants.SessionProtocols.v2,
+        sessionSnapshot: {
+          acceptedCumulative: '100',
+          chainId,
+          channelId,
+          deposit: '200',
+          descriptor,
+          escrow: tip20ChannelEscrow,
+          requiredCumulative: '200',
+          settled: '0',
+          spent: '100',
+          units: 1,
+        },
+      },
+    })
+    let updatedDeposit = 0n
+    const method = session({
+      account,
+      channelStore,
+      decimals: 0,
+      getClient: () => client,
+      onChannelUpdate: (entry) => {
+        updatedDeposit = entry.deposit
+      },
+    })
+
+    await expect(
+      MethodChallenge.handle(method, {
+        challenge,
+        context: {},
+        fetch: async () => {
+          throw new Error('unexpected top-up')
+        },
+        input: 'https://example.com/resource',
+      }),
+    ).resolves.toBeUndefined()
+    expect(updatedDeposit).toBe(200n)
   })
 
   test('opens for the current amount without client deposit configuration', async () => {
@@ -218,6 +385,72 @@ describe('precompile client session', () => {
     expect(openDeposit(payload)).toBe(100n)
   })
 
+  test('atomically auto-swaps before opening a session channel', async () => {
+    const sourceToken = '0x0000000000000000000000000000000000000007' as Address
+    const swapCalls = [
+      { to: sourceToken, data: '0x1234' as const },
+      { to: '0x0000000000000000000000000000000000000008' as Address, data: '0x5678' as const },
+    ]
+    const findCalls = vi.spyOn(AutoSwap, 'findCalls').mockResolvedValue(swapCalls)
+    try {
+      const method = session({
+        account,
+        autoSwap: { slippage: 2, tokenIn: [sourceToken] },
+        getClient: () => client,
+      })
+      const payload = deserialize(
+        await method.createCredential({ challenge: makeChallenge(), context: {} }),
+      )
+
+      expect(findCalls).toHaveBeenCalledWith(expect.any(Object), {
+        account: account.address,
+        amountOut: 100n,
+        slippage: 2,
+        tokenIn: expect.arrayContaining([sourceToken]),
+        tokenOut: descriptor.token,
+      })
+      const calls = transactionCalls(payload)
+      expect(calls.slice(0, 2)).toEqual(swapCalls)
+      expect(calls[2]!.to?.toLowerCase()).toBe(tip20ChannelEscrow.toLowerCase())
+      expect(decodeFunctionData({ abi: escrowAbi, data: calls[2]!.data! }).functionName).toBe(
+        'open',
+      )
+    } finally {
+      findCalls.mockRestore()
+    }
+  })
+
+  test('atomically auto-swaps before topping up a session channel', async () => {
+    const sourceToken = '0x0000000000000000000000000000000000000007' as Address
+    const swapCalls = [{ to: sourceToken, data: '0x1234' as const }]
+    const findCalls = vi.spyOn(AutoSwap, 'findCalls').mockResolvedValue(swapCalls)
+    try {
+      const method = session({ account, autoSwap: true, getClient: () => client })
+      const payload = deserialize(
+        await method.createCredential({
+          challenge: makeChallenge(),
+          context: { action: 'topUp', additionalDepositRaw: '250', descriptor },
+        }),
+      )
+
+      expect(findCalls).toHaveBeenCalledWith(expect.any(Object), {
+        account: account.address,
+        amountOut: 250n,
+        slippage: 1,
+        tokenIn: AutoSwap.defaultCurrencies,
+        tokenOut: descriptor.token,
+      })
+      const calls = transactionCalls(payload)
+      expect(calls[0]).toEqual(swapCalls[0])
+      expect(calls[1]!.to?.toLowerCase()).toBe(tip20ChannelEscrow.toLowerCase())
+      expect(decodeFunctionData({ abi: escrowAbi, data: calls[1]!.data! }).functionName).toBe(
+        'topUp',
+      )
+    } finally {
+      findCalls.mockRestore()
+    }
+  })
+
   test('uses client chain ID when the challenge omits chain ID', async () => {
     const method = session({ account, getClient: () => client })
     const credential = deserializeCredential(
@@ -506,7 +739,7 @@ describe('precompile client session', () => {
     expect(payload.cumulativeAmount).toBe('400')
   })
 
-  test('ignores accepted snapshot headroom above current request spend', async () => {
+  test('does not decrease recovered authorization below accepted snapshot headroom', async () => {
     const method = session({ account, decimals: 0, maxDeposit: '1000', getClient: () => client })
     const channelId = Channel.computeId({ ...descriptor, chainId, escrow: tip20ChannelEscrow })
     const payload = deserialize(
@@ -535,7 +768,7 @@ describe('precompile client session', () => {
 
     expect(payload.action).toBe('voucher')
     if (payload.action !== 'voucher') throw new Error('expected voucher')
-    expect(payload.cumulativeAmount).toBe('400')
+    expect(payload.cumulativeAmount).toBe('500')
   })
 
   test('caps recovered voucher authorization by maxDeposit', async () => {
@@ -593,7 +826,7 @@ describe('precompile client session', () => {
         }),
         context: {},
       }),
-    ).rejects.toThrow('requested voucher amount 700 exceeds local maxDeposit 300')
+    ).rejects.toThrow('requested voucher amount 1000 exceeds local maxDeposit 300')
   })
 
   test('rejects descriptor recovery for closed or missing channels', async () => {