mppx 0.8.14 → 0.8.17

package/src/tempo/server/internal/transport.test.ts

@@ -738,8 +738,15 @@ describe('sse transport', () => {
 
   test('respondReceipt with non-SSE upstream Response still deducts from channel', async () => {
     const store = memoryStore()
+    const settled: Array<{ spent: bigint; units: number }> = []
     await seedChannel(store, 10000000n)
-    const transport = sse({ store })
+    const transport = sse({
+      store,
+      async settleCharged(channel) {
+        settled.push({ spent: channel.spent, units: channel.units })
+        return undefined
+      },
+    })
     const request = new Request('https://test.example.com/session', {
       body: JSON.stringify({ prompt: 'hello' }),
       headers: makeAuthorizedRequest().headers,
@@ -768,6 +775,7 @@ describe('sse transport', () => {
     expect(channel!.units).toBe(1)
     expect(receipt.spent).toBe('1000000')
     expect(receipt.units).toBe(1)
+    expect(settled).toEqual([{ spent: 1000000n, units: 1 }])
 
     expect(JSON.parse(body)).toEqual({ content: 'hello' })
     expect(response.headers.get('Content-Type')).toBe('application/json')
@@ -806,8 +814,18 @@ describe('sse transport', () => {
 
   test('respondReceipt with 204 content response still deducts from channel', async () => {
     const store = memoryStore()
+    let resolveSettlement!: (channel: ChannelStore.State) => void
+    const settlement = new Promise<ChannelStore.State>((resolve) => {
+      resolveSettlement = resolve
+    })
     await seedChannel(store, 10000000n)
-    const transport = sse({ store })
+    const transport = sse({
+      store,
+      async settleCharged(channel) {
+        resolveSettlement(channel)
+        return undefined
+      },
+    })
     const request = new Request('https://test.example.com/session', {
       body: JSON.stringify({ prompt: 'hello' }),
       headers: makeAuthorizedRequest().headers,
@@ -827,11 +845,12 @@ describe('sse transport', () => {
     expect(await response.text()).toBe('')
     const receipt = deserializeSessionReceipt(response.headers.get('Payment-Receipt')!)
 
-    await Promise.resolve()
+    const settled = await settlement
 
     const channel = await store.getChannel(channelId)
     expect(channel!.spent).toBe(1000000n)
     expect(channel!.units).toBe(1)
+    expect(settled).toMatchObject({ spent: 1000000n, units: 1 })
     expect(receipt.spent).toBe('1000000')
     expect(receipt.units).toBe(1)
   })

package/src/tempo/server/internal/transport.ts

@@ -12,6 +12,7 @@ import * as Transport from '../../../server/Transport.js'
 import type { SessionReceipt } from '../../session/precompile/Protocol.js'
 import { requireSessionCredentialContext } from '../../session/precompile/Protocol.js'
 import * as ChannelStore from '../../session/server/ChannelStore.js'
+import type { SettleChargedSessionChannel } from '../../session/server/Settlement.js'
 import * as Sse_core from '../../session/server/Sse.js'
 import { captureRequestBodyProbe, shouldChargePlainResponse } from './request-body.js'
 
@@ -48,7 +49,12 @@ function hasPrepaidSessionTick(receipt: SessionReceipt): boolean {
  * - Auto-detection of upstream SSE responses
  * - Fallback to standard HTTP receipt handling for plain Response
  */
-export function sse(options: sse.Options & { store: ChannelStore.ChannelStore }): Sse {
+export function sse(
+  options: sse.Options & {
+    settleCharged?: SettleChargedSessionChannel | undefined
+    store: ChannelStore.ChannelStore
+  },
+): Sse {
   const { pollingInterval, poll } = options
 
   // When `poll` is true, strip `waitForUpdate` so the SSE charge loop
@@ -117,6 +123,7 @@ export function sse(options: sse.Options & { store: ChannelStore.ChannelStore })
           tickCost,
           pollIntervalMs: pollingInterval,
           generate,
+          onChargeCommitted: options.settleCharged,
           prepaidUnits: hasPrepaidSessionTick(receipt as SessionReceipt) ? 1 : 0,
           signal: input.signal,
         })
@@ -174,20 +181,25 @@ export function sse(options: sse.Options & { store: ChannelStore.ChannelStore })
         response: response as Response,
         challengeId: verifiedChallengeId,
       })
+      const chargePlainResponse = async () => {
+        const result = await ChannelStore.deductFromChannel(store, channelId, tickCost)
+        if (result.ok) await options.settleCharged?.(result.channel)
+        return result
+      }
 
       // Non-SSE response (e.g. upstream returned JSON instead of event-stream).
       // Need to deduct tickCost so request isn't free.
       // For null-body statuses, the request shape determines whether the
       // response is management (no charge) or plain content (charge one tick).
       if (isNullBodyStatus(chargedResponse.status)) {
-        void ChannelStore.deductFromChannel(store, channelId, tickCost)
+        void chargePlainResponse()
         return chargedResponse
       }
 
       const stream = new ReadableStream<Uint8Array>({
         async start(controller) {
           // deduction completes before consumer reads
-          const result = await ChannelStore.deductFromChannel(store, channelId, tickCost)
+          const result = await chargePlainResponse()
           if (!result.ok) {
             controller.error(
               new Errors.InsufficientBalanceError({

package/src/tempo/session/README.md

@@ -83,6 +83,13 @@ sequenceDiagram
 route handler. `open` and `voucher` used on non-billable requests are also
 management updates.
 
+When `Fetch.from` creates an automatic `open`, it keeps the channel entry
+provisional until the server accepts the response or acknowledges the open with
+a matching receipt or session snapshot. Rejected or unacknowledged opens are
+discarded so the next request retries `open`; concurrent automatic opens for the
+same payment scope are serialized. Direct credential creation and
+`SessionManager` retain their existing lifecycle ownership.
+
 The current HTTP contract is deliberately pre-handler: voucher acceptance and
 default request charging occur before the handler runs. A handler failure can
 therefore follow an accepted voucher and recorded `spent`. Sessions does not
@@ -179,6 +186,118 @@ sequenceDiagram
 The initial SSE POST is excluded from default HTTP charging to prevent double
 counting. Stream accounting remains owned by the transport driver.
 
+## Server transport configuration
+
+A session method owns the account, channel store, verification policy, and
+settlement schedule. Routes add prices and application content. HTTP and SSE
+run through configured route handlers; WebSocket uses a session-bound helper
+because its application messages no longer pass through HTTP.
+
+| Server shape           | Session option | Content API                         | Charging                            |
+| ---------------------- | -------------- | ----------------------------------- | ----------------------------------- |
+| HTTP only              | Omit `sse`     | `result.withReceipt(Response)`      | Once per billable request           |
+| SSE only               | `sse: true`    | `result.withReceipt(AsyncIterable)` | Each `stream.charge()`              |
+| WebSocket only         | Omit `sse`     | `mppx.session.serveWebSocket(...)`  | Each `stream.charge()`              |
+| HTTP + SSE + WebSocket | `sse: true`    | All three APIs                      | Selected by route and response type |
+
+All transports for one session service must share the same configured session
+method and store. `serveWebSocket` is bound to both the store and settlement
+policy, so callers pass neither dependency again. `tempo.Ws.serve` remains the
+low-level adapter for custom integrations.
+
+### Shared method configuration
+
+```ts
+const session = tempo.session({
+  account,
+  currency,
+  getClient: () => client,
+  settlementSchedule: { units: 100 },
+  store,
+  // Include when this instance serves any SSE route.
+  sse: true,
+})
+
+const mppx = Mppx.create({ methods: [session], secretKey })
+```
+
+`sse: true` enables async-iterable responses without changing ordinary
+`Response` handling, so a mixed server uses one session method.
+
+### HTTP
+
+```ts
+const httpRoute = mppx.session({ amount: '0.01', unitType: 'request' })
+const result = await httpRoute(request)
+
+if (result.status === 402) return result.challenge
+return result.withReceipt(Response.json({ ok: true }))
+```
+
+HTTP accounting charges the configured route amount before application content
+runs. A plain `Response` selects normal HTTP handling even when `sse: true`.
+
+### SSE
+
+```ts
+const sseRoute = mppx.session({ amount: '0.001', unitType: 'token' })
+const result = await sseRoute(request)
+
+if (result.status === 402) return result.challenge
+return result.withReceipt(async function* (stream) {
+  for await (const token of generateTokens()) {
+    await stream.charge()
+    yield token
+  }
+})
+```
+
+SSE requires `sse: true` on the shared session method. The async iterable
+selects SSE framing and transport-owned metering.
+
+### WebSocket
+
+```ts
+const wsRoute = mppx.session({ amount: '0.001', unitType: 'token' })
+
+webSocketServer.on('connection', (socket, request) => {
+  void mppx.session.serveWebSocket({
+    generate: async function* (stream) {
+      for await (const token of generateTokens()) {
+        await stream.charge()
+        yield token
+      }
+    },
+    route: wsRoute,
+    socket,
+    url: new URL(request.url!, `ws://${request.headers.host}`),
+  })
+})
+```
+
+The application still exposes `wsRoute` over HTTP for the initial challenge
+probe. The bound helper reuses the session store and automatic settlement
+schedule for in-band WebSocket vouchers and charges.
+
+### Mixed server
+
+```ts
+const httpRoute = mppx.session({ amount: '0.01', unitType: 'request' })
+const sseRoute = mppx.session({ amount: '0.001', unitType: 'token' })
+const wsRoute = mppx.session({ amount: '0.001', unitType: 'token' })
+
+async function handler(request: Request) {
+  const pathname = new URL(request.url).pathname
+  if (pathname === '/api/data') return serveHttp(httpRoute, request)
+  if (pathname === '/api/events') return serveSse(sseRoute, request)
+  if (pathname === '/ws') return serveWebSocketProbe(wsRoute, request)
+  return new Response('Not found', { status: 404 })
+}
+```
+
+Each route can choose its own price and unit type. Verification, channel state,
+and settlement policy remain shared through the single session method.
+
 ## Extension boundaries
 
 | Change                         | Preserve                                                                                        |

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

@@ -16,7 +16,7 @@ import { escrowAbi } from '../precompile/escrow.abi.js'
 import { tip20ChannelEscrow } from '../precompile/Protocol.js'
 import * as Types from '../precompile/Protocol.js'
 import * as Voucher from '../precompile/Voucher.js'
-import { createChannelStore } from './ChannelStore.js'
+import { channelKey, createChannelStore } from './ChannelStore.js'
 import { session } from './Session.js'
 
 const account = privateKeyToAccount(
@@ -60,6 +60,13 @@ type SessionChallenge = Challenge<
   typeof Methods.session.name
 >
 
+const defaultChannelKey = channelKey({
+  chainId,
+  escrow: tip20ChannelEscrow,
+  payee: descriptor.payee,
+  token: descriptor.token,
+})
+
 function makeChallenge(overrides: Partial<SessionChallenge['request']> = {}): SessionChallenge {
   const request: SessionChallenge['request'] = {
     amount: '100',
@@ -78,6 +85,83 @@ function makeChallenge(overrides: Partial<SessionChallenge['request']> = {}): Se
   }
 }
 
+function makeSessionChallenge(
+  overrides: Partial<SessionChallenge['request']> = {},
+): SessionChallenge {
+  return makeChallenge({
+    ...overrides,
+    methodDetails: {
+      chainId,
+      escrowContract: tip20ChannelEscrow,
+      sessionProtocol: Constants.SessionProtocols.v2,
+      ...overrides.methodDetails,
+    },
+  })
+}
+
+function paymentRequired(challenge: SessionChallenge, headers?: HeadersInit): Response {
+  const responseHeaders = new Headers(headers)
+  responseHeaders.set(Constants.Headers.wwwAuthenticate, serializeChallenge(challenge))
+  return new Response(null, {
+    headers: responseHeaders,
+    status: 402,
+  })
+}
+
+function withSnapshot(
+  payload: Types.SessionCredentialPayload,
+  acceptedCumulative?: string,
+): SessionChallenge {
+  if (payload.action !== 'open') throw new Error('expected open credential')
+  return {
+    ...makeSessionChallenge({
+      methodDetails: {
+        chainId,
+        escrowContract: tip20ChannelEscrow,
+        sessionProtocol: Constants.SessionProtocols.v2,
+        sessionSnapshot: {
+          acceptedCumulative: acceptedCumulative ?? payload.cumulativeAmount,
+          chainId,
+          channelId: payload.channelId,
+          deposit: '1000',
+          descriptor: payload.descriptor,
+          escrow: tip20ChannelEscrow,
+          requiredCumulative: '200',
+          settled: '0',
+          spent: payload.cumulativeAmount,
+        },
+      },
+    }),
+    id: 'replacement-id',
+  }
+}
+
+function makeSessionMethod(
+  channelStore = createChannelStore(),
+  parameters: Partial<session.Parameters> = {},
+) {
+  return session({
+    account,
+    channelStore,
+    decimals: 0,
+    getClient: () => client,
+    maxDeposit: '1000',
+    ...parameters,
+  })
+}
+
+function makeSessionFetch(
+  fetch: typeof globalThis.fetch,
+  channelStore = createChannelStore(),
+  maxPaymentRetries?: number,
+) {
+  return Fetch.from({
+    fetch,
+    maxPaymentRetries,
+    methods: [makeSessionMethod(channelStore)],
+  })
+}
+
 function deserialize(credential: string) {
   return Credential.deserialize(credential).payload as Types.SessionCredentialPayload
 }
@@ -233,14 +317,16 @@ describe('precompile client session', () => {
       header: string | null
       method: string | undefined
     }[] = []
+    const vouchers: string[] = []
     let opened: Extract<Types.SessionCredentialPayload, { action: 'open' }> | undefined
+    const paymentRequired = () =>
+      new Response(null, {
+        status: 402,
+        headers: { [Constants.Headers.wwwAuthenticate]: serializeChallenge(challenge) },
+      })
     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) },
-        })
+      if (!authorization) return paymentRequired()
 
       const payload = deserialize(authorization)
       actions.push(payload.action)
@@ -250,6 +336,8 @@ describe('precompile client session', () => {
       }
       if (payload.action === 'topUp') return new Response(null, { status: 204 })
       if (payload.action !== 'voucher' || !opened) throw new Error('expected open voucher')
+      vouchers.push(authorization)
+      if (vouchers.length === 1) return paymentRequired()
 
       paidRequests.push({
         body: init?.body ?? null,
@@ -278,11 +366,192 @@ describe('precompile client session', () => {
     })
 
     expect(await response.text()).toBe('paid')
-    expect(actions).toEqual(['open', 'topUp', 'voucher'])
+    expect(actions).toEqual(['open', 'topUp', 'voucher', 'voucher'])
+    expect(new Set(vouchers).size).toBe(1)
     expect(paidRequests).toEqual([{ body: 'request-body', header: 'preserved', method: 'POST' }])
   })
 
-  test('does not top up a stored channel owned by another account', async () => {
+  test('retries an open rejected by a replacement challenge', async () => {
+    const challenge = makeSessionChallenge({ suggestedDeposit: '1000' })
+    const replacement = { ...challenge, id: 'replacement-id' }
+    const channelStore = createChannelStore()
+    const actions: Types.SessionCredentialPayload['action'][] = []
+    let paidRequests = 0
+    const fetch = makeSessionFetch(async (_input, init) => {
+      const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+      if (!authorization) return paymentRequired(challenge)
+      actions.push(deserialize(authorization).action)
+      if (++paidRequests === 1) return paymentRequired(replacement)
+      return new Response('rejected', { status: 500 })
+    }, channelStore)
+
+    expect((await fetch('https://example.com/resource')).status).toBe(500)
+    expect(actions).toEqual(['open', 'open'])
+    expect(await channelStore.get(defaultChannelKey)).toBeUndefined()
+  })
+
+  test('retries an open after the paid request throws', async () => {
+    const challenge = makeSessionChallenge({ suggestedDeposit: '1000' })
+    const actions: Types.SessionCredentialPayload['action'][] = []
+    const fetch = makeSessionFetch(async (_input, init) => {
+      const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+      if (!authorization) return paymentRequired(challenge)
+      actions.push(deserialize(authorization).action)
+      throw new Error('paid request failed')
+    })
+
+    await expect(fetch('https://example.com/resource')).rejects.toThrow('paid request failed')
+    await expect(fetch('https://example.com/resource')).rejects.toThrow('paid request failed')
+    expect(actions).toEqual(['open', 'open'])
+  })
+
+  test('keeps an open acknowledged by a payment receipt', async () => {
+    const challenge = makeSessionChallenge({ suggestedDeposit: '1000' })
+    const channelStore = createChannelStore()
+    const actions: Types.SessionCredentialPayload['action'][] = []
+    const credentials: string[] = []
+    let paidRequests = 0
+    const fetch = makeSessionFetch(async (_input, init) => {
+      const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+      if (!authorization) return paymentRequired(challenge)
+      const payload = deserialize(authorization)
+      actions.push(payload.action)
+      credentials.push(authorization)
+      if (++paidRequests === 1) return paymentRequired(challenge)
+      if (paidRequests > 2) return new Response('rejected', { status: 500 })
+      return paymentRequired(challenge, {
+        [Constants.Headers.paymentReceipt]: Types.serializeSessionReceipt(
+          Types.createSessionReceipt({
+            acceptedCumulative: 100n,
+            challengeId: challenge.id,
+            channelId: payload.channelId,
+            spent: 100n,
+          }),
+        ),
+      })
+    }, channelStore)
+
+    expect((await fetch('https://example.com/resource')).status).toBe(500)
+    expect(actions).toEqual(['open', 'open', 'voucher'])
+    expect(credentials[0]).toBe(credentials[1])
+    expect(await channelStore.get(defaultChannelKey)).toMatchObject({ opened: true })
+  })
+
+  test.each([
+    [
+      'keeps an open acknowledged by the final session snapshot',
+      undefined,
+      ['open', 'voucher'],
+      true,
+    ],
+    [
+      'fails closed on malformed acknowledgement snapshots without leaking the open lock',
+      'not-a-number',
+      ['open', 'open'],
+      undefined,
+    ],
+  ])('%s', async (_name, acceptedCumulative, expectedActions, expectedOpened) => {
+    const challenge = makeSessionChallenge({ suggestedDeposit: '1000' })
+    const channelStore = createChannelStore()
+    const actions: Types.SessionCredentialPayload['action'][] = []
+    let paidRequests = 0
+    const fetch = makeSessionFetch(
+      async (_input, init) => {
+        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+        if (!authorization) return paymentRequired(challenge)
+        const payload = deserialize(authorization)
+        actions.push(payload.action)
+        if (++paidRequests > 1) return new Response('rejected', { status: 500 })
+        return paymentRequired(withSnapshot(payload, acceptedCumulative))
+      },
+      channelStore,
+      1,
+    )
+
+    expect((await fetch('https://example.com/resource')).status).toBe(402)
+    expect((await fetch('https://example.com/resource')).status).toBe(500)
+    expect(actions).toEqual(expectedActions)
+    expect((await channelStore.get(defaultChannelKey))?.opened).toBe(expectedOpened)
+  })
+
+  test('keeps an acknowledged open when challenge ordering throws', async () => {
+    const challenge = makeSessionChallenge({ suggestedDeposit: '1000' })
+    const channelStore = createChannelStore()
+    const actions: Types.SessionCredentialPayload['action'][] = []
+    let ordered = 0
+    let paidRequests = 0
+    const fetch = Fetch.from({
+      fetch: async (_input, init) => {
+        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+        if (!authorization) return paymentRequired(challenge)
+        const payload = deserialize(authorization)
+        actions.push(payload.action)
+        if (++paidRequests > 1) return new Response('paid')
+        return paymentRequired(withSnapshot(payload))
+      },
+      methods: [makeSessionMethod(channelStore)],
+      orderChallenges(candidates) {
+        if (++ordered === 2) throw new Error('ordering failed')
+        return candidates
+      },
+    })
+
+    await expect(fetch('https://example.com/resource')).rejects.toThrow('ordering failed')
+    expect(await (await fetch('https://example.com/resource')).text()).toBe('paid')
+    expect(actions).toEqual(['open', 'voucher'])
+    expect(await channelStore.get(defaultChannelKey)).toMatchObject({ opened: true })
+  })
+
+  test('serializes concurrent opens against the committed channel', async () => {
+    const challenge = makeSessionChallenge()
+    const channelStore = createChannelStore()
+    const actions: Types.SessionCredentialPayload['action'][] = []
+    const vouchers: bigint[] = []
+    const firstGate = Promise.withResolvers<void>()
+    const firstRequest = Promise.withResolvers<void>()
+    const waitersReady = Promise.withResolvers<void>()
+    let credentialPlans = 0
+    const fetch = Fetch.from({
+      fetch: async (input, init) => {
+        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+        if (!authorization) return paymentRequired(challenge)
+        const payload = deserialize(authorization)
+        actions.push(payload.action)
+        if (payload.action === 'topUp') return new Response(null, { status: 204 })
+        if (payload.action === 'voucher') vouchers.push(BigInt(payload.cumulativeAmount))
+        if (input.toString().endsWith('/first')) {
+          firstRequest.resolve()
+          await firstGate.promise
+          return new Response('paid')
+        }
+        return new Response('rejected', { status: 500 })
+      },
+      methods: [
+        makeSessionMethod(channelStore, {
+          resolveAccount() {
+            if (++credentialPlans === 3) waitersReady.resolve()
+            return account
+          },
+        }),
+      ],
+    })
+
+    const first = fetch('https://example.com/first')
+    await firstRequest.promise
+    const second = fetch('https://example.com/second')
+    const third = fetch('https://example.com/third')
+    await waitersReady.promise
+    firstGate.resolve()
+
+    expect((await first).status).toBe(200)
+    expect((await second).status).toBe(500)
+    expect((await third).status).toBe(500)
+    expect(actions).toEqual(['open', 'topUp', 'voucher', 'topUp', 'voucher'])
+    expect(vouchers).toEqual([200n, 300n])
+    expect(await channelStore.get(defaultChannelKey)).toMatchObject({ opened: true })
+  })
+
+  test('replaces a stored channel owned by another account', async () => {
     const channelStore = createChannelStore()
     const foreign = '0x0000000000000000000000000000000000000004' as Address
     await channelStore.set({
@@ -295,29 +564,21 @@ describe('precompile client session', () => {
       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 })],
-    })
+    const challenge = makeSessionChallenge({ suggestedDeposit: '1000' })
+    const fetch = makeSessionFetch(async (_input, init) => {
+      const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+      if (!authorization) return paymentRequired(challenge)
+      actions.push(deserialize(authorization).action)
+      return new Response('paid')
+    }, channelStore)
 
     expect(await (await fetch('https://example.com/resource')).text()).toBe('paid')
-    expect(actions).toEqual(['open'])
+    expect(await (await fetch('https://example.com/resource')).text()).toBe('paid')
+    expect(actions).toEqual(['open', 'voucher'])
+    expect(await channelStore.get(defaultChannelKey)).toMatchObject({
+      descriptor: { authorizedSigner: account.address, payer: account.address },
+      opened: true,
+    })
   })
 
   test('uses a matching server snapshot deposit when checking headroom', async () => {
@@ -519,12 +780,17 @@ describe('precompile client session', () => {
     expect(openDeposit(payload)).toBe(100n)
   })
 
-  test('rejects open when maxDeposit is below the request amount', async () => {
+  test('rejects open above maxDeposit without leaking the Fetch lock', async () => {
     const method = session({ account, decimals: 0, maxDeposit: '50', getClient: () => client })
+    const fetch = Fetch.from({
+      fetch: async () => paymentRequired(makeSessionChallenge()),
+      methods: [method],
+    })
 
-    await expect(
-      method.createCredential({ challenge: makeChallenge(), context: {} }),
-    ).rejects.toThrow('requested voucher amount 100 exceeds local maxDeposit 50')
+    for (let attempt = 0; attempt < 2; attempt++)
+      await expect(fetch('https://example.com/resource')).rejects.toThrow(
+        'requested voucher amount 100 exceeds local maxDeposit 50',
+      )
   })
 
   test('rejects explicit opening deposits below the request amount', async () => {