mppx 0.8.15 → 0.8.18

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

@@ -1,1141 +0,0 @@
-import { Hex } from 'ox'
-import type { Address } from 'viem'
-import { describe, expect, test, vi } from 'vp/test'
-
-import * as Challenge from '../../../Challenge.js'
-import * as Constants from '../../../Constants.js'
-import * as Credential from '../../../Credential.js'
-import type { ChannelEntry } from '../client/ChannelOps.js'
-import type { SessionContext } from '../client/CredentialState.js'
-import {
-  createSessionReceipt,
-  formatNeedVoucherEvent,
-  serializeSessionReceipt,
-  tip20ChannelEscrow,
-  type ChannelDescriptor,
-} from '../precompile/Protocol.js'
-import type { SessionSnapshot } from '../Snapshot.js'
-import { initialState, type SessionState } from './Runtime.js'
-import {
-  applyTopUpResult,
-  closeHttpSession,
-  consumeSseSessionResponse,
-  createActiveSocketSession,
-  driveSseResponse,
-  isExpectedSocketReceipt,
-  managementInput,
-  postTopUp,
-  prepareWebSocketSession,
-  readNeedVoucherEventAmounts,
-  resolveManualTopUp,
-  resolveNeedVoucherContext,
-  resolveRetryHttpPaymentContext,
-  retryHttpPaymentRequired,
-  validateSocketCloseReadyReceipt,
-  validateSocketPaymentReceipt,
-  webSocketProbeUrl,
-  wrapSseResponse,
-  type TempoSessionChallenge,
-  type TopUpRequirement,
-} from './Transports.js'
-
-describe('HttpManagement', () => {
-  const channelId = '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex.Hex
-  const salt = '0x0000000000000000000000000000000000000000000000000000000000000002' as Hex.Hex
-  const expiringNonceHash =
-    '0x0000000000000000000000000000000000000000000000000000000000000003' as Hex.Hex
-  const token = '0x20c0000000000000000000000000000000000001' as Address
-  const payee = '0x0000000000000000000000000000000000000002' as Address
-
-  const descriptor: ChannelDescriptor = {
-    payer: '0x0000000000000000000000000000000000000001',
-    payee,
-    operator: '0x0000000000000000000000000000000000000000',
-    token,
-    salt,
-    authorizedSigner: '0x0000000000000000000000000000000000000001',
-    expiringNonceHash,
-  }
-
-  function channel(overrides: Partial<ChannelEntry> = {}): ChannelEntry {
-    return {
-      channelId,
-      cumulativeAmount: 5n,
-      deposit: 10n,
-      descriptor,
-      escrow: '0x4D50500000000000000000000000000000000000',
-      chainId: 4217,
-      opened: true,
-      ...overrides,
-    }
-  }
-
-  function challenge(snapshot?: SessionSnapshot): TempoSessionChallenge {
-    return Challenge.from({
-      id: 'challenge-1',
-      realm: 'example.test',
-      method: Constants.Methods.tempo,
-      intent: Constants.Intents.session,
-      request: {
-        amount: '1',
-        currency: token,
-        recipient: payee,
-        decimals: 6,
-        unitType: 'request',
-        methodDetails: {
-          chainId: 4217,
-          escrowContract: undefined,
-          sessionProtocol: Constants.SessionProtocols.v2,
-          ...(snapshot && { [Constants.MethodDetailKeys.sessionSnapshot]: snapshot }),
-        },
-      },
-    }) as TempoSessionChallenge
-  }
-
-  function snapshot(overrides: Partial<SessionSnapshot> = {}): SessionSnapshot {
-    return {
-      acceptedCumulative: '5',
-      chainId: 4217,
-      channelId,
-      deposit: '6',
-      descriptor,
-      escrow: '0x4D50500000000000000000000000000000000000',
-      requiredCumulative: '8',
-      settled: '0',
-      spent: '5',
-      units: 5,
-      ...overrides,
-    }
-  }
-
-  function response402(challenge_: TempoSessionChallenge) {
-    return new Response(null, {
-      status: 402,
-      headers: { [Constants.Headers.wwwAuthenticate]: Challenge.serialize(challenge_) },
-    })
-  }
-
-  function receiptHeader(acceptedCumulative: bigint, spent: bigint, challengeId = 'challenge-1') {
-    return serializeSessionReceipt(
-      createSessionReceipt({
-        acceptedCumulative,
-        challengeId,
-        channelId,
-        spent,
-        txHash: `0x${'aa'.repeat(32)}`,
-      }),
-    )
-  }
-
-  function authorizationHeader(init: RequestInit | undefined) {
-    const headers = init?.headers as Record<string, string> | undefined
-    return headers?.[Constants.Headers.authorization]
-  }
-
-  describe('precompile session HTTP management helpers', () => {
-    test('converts WebSocket URLs to HTTP probe URLs', () => {
-      expect(webSocketProbeUrl('ws://example.test/socket?stream=1').toString()).toBe(
-        'http://example.test/socket?stream=1',
-      )
-      expect(webSocketProbeUrl('wss://example.test/socket?stream=1').toString()).toBe(
-        'https://example.test/socket?stream=1',
-      )
-    })
-
-    test('leaves HTTP URLs unchanged for probe callers', () => {
-      expect(webSocketProbeUrl('https://example.test/socket?stream=1').toString()).toBe(
-        'https://example.test/socket?stream=1',
-      )
-    })
-
-    test('preserves query state and strips fragments from management URLs', () => {
-      expect(managementInput('https://example.test/resource?cursor=abc').toString()).toBe(
-        'https://example.test/resource?cursor=abc',
-      )
-      expect(managementInput('https://example.test/resource?cursor=abc#result').toString()).toBe(
-        'https://example.test/resource?cursor=abc',
-      )
-    })
-
-    test('resolves retry context from a session challenge snapshot and matching channel', () => {
-      const entry = channel()
-      expect(
-        resolveRetryHttpPaymentContext({
-          channel: entry,
-          response: response402(challenge(snapshot())),
-        }),
-      ).toMatchObject({
-        channel: entry,
-        challenge: { id: 'challenge-1' },
-        snapshot: { channelId },
-      })
-    })
-
-    test('does not resolve retry context without snapshot or matching channel', () => {
-      expect(
-        resolveRetryHttpPaymentContext({
-          channel: channel(),
-          response: response402(challenge()),
-        }),
-      ).toBeUndefined()
-      expect(
-        resolveRetryHttpPaymentContext({
-          channel: channel({ channelId: `0x${'99'.repeat(32)}` as Hex.Hex }),
-          response: response402(challenge(snapshot())),
-        }),
-      ).toBeUndefined()
-    })
-
-    test('postTopUp sends a top-up credential to the management URL', async () => {
-      const createSessionCredential = vi.fn(async (_challenge, context: SessionContext) => {
-        expect(context).toMatchObject({
-          action: 'topUp',
-          channelId,
-          descriptor,
-          additionalDepositRaw: '3',
-        })
-        return 'top-up-credential'
-      })
-      const fetch = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
-        expect(input.toString()).toBe('https://example.test/resource?cursor=abc')
-        expect(init?.method).toBe('POST')
-        expect(authorizationHeader(init)).toBe('top-up-credential')
-        return new Response(null, {
-          status: 204,
-          headers: { [Constants.Headers.paymentReceipt]: receiptHeader(8n, 5n) },
-        })
-      })
-
-      const receipt = await postTopUp({
-        additionalDeposit: 3n,
-        challenge: challenge(),
-        channel: channel(),
-        channelId,
-        createSessionCredential,
-        fetch,
-        input: 'https://example.test/resource?cursor=abc',
-      })
-
-      expect(receipt?.acceptedCumulative).toBe('8')
-      expect(createSessionCredential).toHaveBeenCalledOnce()
-      expect(fetch).toHaveBeenCalledOnce()
-    })
-
-    test('postTopUp retries once with the management route challenge', async () => {
-      const routeChallenge = { ...challenge(), id: 'management-challenge' } as TempoSessionChallenge
-      const createSessionCredential = vi.fn(async (challenge_) => `top-up-${challenge_.id}`)
-      const fetch = vi
-        .fn()
-        .mockResolvedValueOnce(response402(routeChallenge))
-        .mockResolvedValueOnce(
-          new Response(null, {
-            status: 204,
-            headers: {
-              [Constants.Headers.paymentReceipt]: receiptHeader(8n, 5n, routeChallenge.id),
-            },
-          }),
-        )
-
-      const receipt = await postTopUp({
-        additionalDeposit: 3n,
-        challenge: challenge(),
-        channel: channel(),
-        channelId,
-        createSessionCredential,
-        fetch,
-        input: 'https://example.test/resource',
-      })
-
-      expect(receipt?.challengeId).toBe(routeChallenge.id)
-      expect(createSessionCredential).toHaveBeenCalledTimes(2)
-      expect(authorizationHeader(fetch.mock.calls[1]?.[1])).toBe(`top-up-${routeChallenge.id}`)
-    })
-
-    test('retryHttpPaymentRequired signs the server-required cumulative voucher', async () => {
-      let entry = channel({ cumulativeAmount: 5n, deposit: 6n })
-      const topUpIfNeeded = vi.fn(async () => {
-        entry.deposit = 8n
-      })
-      const createSessionCredential = vi.fn(async (_challenge, context: SessionContext) => {
-        expect(context).toMatchObject({
-          action: 'voucher',
-          channelId,
-          descriptor,
-          cumulativeAmountRaw: '8',
-        })
-        entry.cumulativeAmount = 8n
-        return 'voucher-credential'
-      })
-      const fetch = vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
-        expect(authorizationHeader(init)).toBe('voucher-credential')
-        return new Response('ok', { status: 200 })
-      })
-      const setChallenge = vi.fn()
-      const restoreCumulative = vi.fn()
-
-      const retry = await retryHttpPaymentRequired({
-        createSessionCredential,
-        fetch,
-        getChannel: () => entry,
-        input: 'https://example.test/resource',
-        response: response402(challenge(snapshot())),
-        restoreCumulative,
-        setChallenge,
-        topUpIfNeeded,
-      })
-
-      expect(retry?.status).toBe(200)
-      expect(setChallenge).toHaveBeenCalledOnce()
-      expect(topUpIfNeeded).toHaveBeenCalledWith(
-        expect.objectContaining({ channelId, deposit: 6n, requiredCumulative: 8n }),
-      )
-      expect(restoreCumulative).not.toHaveBeenCalled()
-    })
-
-    test('retryHttpPaymentRequired restores cumulative authorization when retry fails', async () => {
-      const entry = channel({ cumulativeAmount: 5n })
-      const restoreCumulative = vi.fn()
-
-      await retryHttpPaymentRequired({
-        createSessionCredential: async () => 'voucher-credential',
-        fetch: async () => new Response('nope', { status: 500 }),
-        getChannel: () => entry,
-        input: 'https://example.test/resource',
-        response: response402(challenge(snapshot())),
-        restoreCumulative,
-        setChallenge() {},
-        topUpIfNeeded: async () => {},
-      })
-
-      expect(restoreCumulative).toHaveBeenCalledWith(channelId, 5n)
-    })
-
-    test('retryHttpPaymentRequired restores cumulative authorization when retry throws', async () => {
-      const entry = channel({ cumulativeAmount: 5n })
-      const restoreCumulative = vi.fn()
-
-      await expect(
-        retryHttpPaymentRequired({
-          createSessionCredential: async () => 'voucher-credential',
-          fetch: async () => {
-            throw new Error('network failed')
-          },
-          getChannel: () => entry,
-          input: 'https://example.test/resource',
-          response: response402(challenge(snapshot())),
-          restoreCumulative,
-          setChallenge() {},
-          topUpIfNeeded: async () => {},
-        }),
-      ).rejects.toThrow('network failed')
-
-      expect(restoreCumulative).toHaveBeenCalledWith(channelId, 5n)
-    })
-
-    test('closeHttpSession posts a close credential and parses the receipt', async () => {
-      const entry = channel()
-      const createSessionCredential = vi.fn(async (_challenge, context: SessionContext) => {
-        expect(context).toMatchObject({
-          action: 'close',
-          channelId,
-          descriptor,
-          cumulativeAmountRaw: '5',
-        })
-        return 'close-credential'
-      })
-
-      const receipt = await closeHttpSession({
-        createSessionCredential,
-        fetch: async (_input, init) => {
-          expect(authorizationHeader(init)).toBe('close-credential')
-          return new Response(null, {
-            status: 200,
-            headers: { [Constants.Headers.paymentReceipt]: receiptHeader(5n, 5n) },
-          })
-        },
-        lastUrl: 'https://example.test/resource',
-        signedCloseAmount: '5',
-        target: { challenge: challenge(), channel: entry, channelId },
-      })
-
-      expect(receipt?.spent).toBe('5')
-    })
-
-    test('closeHttpSession retries once with a fresh session challenge after 402', async () => {
-      const entry = channel()
-      const retryChallenge = { ...challenge(), id: 'challenge-2' } as TempoSessionChallenge
-      const setChallenge = vi.fn()
-      const closeAmounts: string[] = []
-      const createSessionCredential = vi.fn(async (challenge_, context: SessionContext) => {
-        if (context.action !== 'close') throw new Error('expected close context')
-        closeAmounts.push(context.cumulativeAmountRaw!)
-        return `close-${challenge_.id}`
-      })
-      const resolveSignedCloseAmount = vi.fn(() => '6')
-      const fetch = vi
-        .fn()
-        .mockResolvedValueOnce(response402(retryChallenge))
-        .mockResolvedValueOnce(
-          new Response(null, {
-            status: 200,
-            headers: { [Constants.Headers.paymentReceipt]: receiptHeader(6n, 6n, 'challenge-2') },
-          }),
-        )
-
-      const receipt = await closeHttpSession({
-        createSessionCredential,
-        fetch,
-        lastUrl: 'https://example.test/resource',
-        resolveSignedCloseAmount,
-        signedCloseAmount: '5',
-        setChallenge,
-        target: { challenge: challenge(), channel: entry, channelId },
-      })
-
-      expect(receipt?.spent).toBe('6')
-      expect(setChallenge).toHaveBeenCalledWith(retryChallenge)
-      expect(resolveSignedCloseAmount).toHaveBeenCalledOnce()
-      expect(resolveSignedCloseAmount).toHaveBeenCalledWith(retryChallenge)
-      expect(closeAmounts).toEqual(['5', '6'])
-      expect(createSessionCredential).toHaveBeenCalledTimes(2)
-      expect(createSessionCredential.mock.calls[1]?.[0]).toMatchObject({ id: retryChallenge.id })
-      expect(authorizationHeader(fetch.mock.calls[1]?.[1])).toBe('close-challenge-2')
-    })
-
-    test('closeHttpSession rejects a receipt without settlement proof', async () => {
-      const receipt = serializeSessionReceipt(
-        createSessionReceipt({
-          acceptedCumulative: 5n,
-          challengeId: 'challenge-1',
-          channelId,
-          spent: 5n,
-        }),
-      )
-      await expect(
-        closeHttpSession({
-          createSessionCredential: async () => 'close-credential',
-          fetch: async () =>
-            new Response(null, {
-              headers: { [Constants.Headers.paymentReceipt]: receipt },
-            }),
-          lastUrl: 'https://example.test/resource',
-          signedCloseAmount: '5',
-          target: { challenge: challenge(), channel: channel(), channelId },
-        }),
-      ).rejects.toThrow('Session close response included a mismatched payment receipt.')
-    })
-
-    test('closeHttpSession rejects an invalid settlement transaction hash', async () => {
-      for (const txHash of ['0x1234', `0x${'gg'.repeat(32)}`]) {
-        const receipt = serializeSessionReceipt(
-          createSessionReceipt({
-            acceptedCumulative: 5n,
-            challengeId: 'challenge-1',
-            channelId,
-            spent: 5n,
-            txHash: txHash as Hex.Hex,
-          }),
-        )
-        await expect(
-          closeHttpSession({
-            createSessionCredential: async () => 'close-credential',
-            fetch: async () =>
-              new Response(null, {
-                headers: { [Constants.Headers.paymentReceipt]: receipt },
-              }),
-            lastUrl: 'https://example.test/resource',
-            signedCloseAmount: '5',
-            target: { challenge: challenge(), channel: channel(), channelId },
-          }),
-        ).rejects.toThrow('Session close response included a mismatched payment receipt.')
-      }
-    })
-
-    test('closeHttpSession includes problem detail and challenge header on failure', async () => {
-      await expect(
-        closeHttpSession({
-          createSessionCredential: async () => 'close-credential',
-          fetch: async () =>
-            new Response(JSON.stringify({ detail: 'invalid close' }), {
-              status: 400,
-              headers: {
-                'Content-Type': 'application/problem+json',
-                [Constants.Headers.wwwAuthenticate]: 'Payment id="next"',
-              },
-            }),
-          lastUrl: 'https://example.test/resource',
-          signedCloseAmount: '5',
-          target: { challenge: challenge(), channel: channel(), channelId },
-        }),
-      ).rejects.toThrow(
-        'Close request failed with status 400: invalid close [WWW-Authenticate: Payment id="next"]',
-      )
-    })
-  })
-})
-
-describe('VoucherManagement', () => {
-  const channelId = `0x${'11'.repeat(32)}` as Hex.Hex
-  const challenge = Challenge.from({
-    id: 'challenge-1',
-    realm: 'example.test',
-    method: 'tempo',
-    intent: 'session',
-    request: {
-      amount: '1',
-      currency: '0x20c0000000000000000000000000000000000001',
-      recipient: '0x0000000000000000000000000000000000000002',
-      decimals: 0,
-      unitType: 'request',
-      methodDetails: {
-        chainId: 4217,
-        escrowContract: tip20ChannelEscrow,
-      },
-    },
-  }) as TempoSessionChallenge
-
-  function channel(overrides: Partial<ChannelEntry> = {}): ChannelEntry {
-    return {
-      channelId,
-      cumulativeAmount: 1n,
-      deposit: 10n,
-      descriptor: {
-        payer: '0x0000000000000000000000000000000000000001' as Address,
-        payee: '0x0000000000000000000000000000000000000002' as Address,
-        operator: '0x0000000000000000000000000000000000000000' as Address,
-        token: '0x20c0000000000000000000000000000000000001' as Address,
-        salt: `0x${'22'.repeat(32)}` as Hex.Hex,
-        authorizedSigner: '0x0000000000000000000000000000000000000001' as Address,
-        expiringNonceHash: `0x${'33'.repeat(32)}` as Hex.Hex,
-      },
-      escrow: tip20ChannelEscrow,
-      chainId: 4217,
-      opened: true,
-      ...overrides,
-    }
-  }
-
-  describe('resolveNeedVoucherContext', () => {
-    test('reads raw-unit amounts from need-voucher events', () => {
-      expect(
-        readNeedVoucherEventAmounts({
-          channelId,
-          acceptedCumulative: '1',
-          deposit: '3',
-          requiredCumulative: '5',
-        }),
-      ).toEqual({
-        acceptedCumulative: 1n,
-        deposit: 3n,
-        requiredCumulative: 5n,
-      })
-    })
-
-    test('tops up when required and returns voucher credential context', async () => {
-      const entry = channel({ cumulativeAmount: 1n })
-      const topUps: TopUpRequirement[] = []
-
-      const resolution = await resolveNeedVoucherContext({
-        assertVoucherWithinLocalLimit: vi.fn(),
-        challenge,
-        event: {
-          channelId,
-          requiredCumulative: '5',
-          acceptedCumulative: '1',
-          deposit: '3',
-        },
-        expectedChannelId: channelId,
-        getChannel: () => entry,
-        input: 'https://example.test/stream',
-        topUpIfNeeded: async (parameters) => {
-          topUps.push(parameters)
-        },
-      })
-
-      expect(topUps).toEqual([
-        {
-          challenge,
-          input: 'https://example.test/stream',
-          channelId,
-          deposit: 3n,
-          requiredCumulative: 5n,
-        },
-      ])
-      expect(resolution.status).toBe('ready')
-      if (resolution.status !== 'ready') throw new Error('expected ready resolution')
-      expect(entry.cumulativeAmount).toBe(1n)
-      expect(resolution.context).toMatchObject({
-        action: 'voucher',
-        channelId,
-        descriptor: entry.descriptor,
-        cumulativeAmountRaw: '5',
-      })
-    })
-
-    test('preserves higher local cumulative authorization', async () => {
-      const entry = channel({ cumulativeAmount: 9n })
-
-      const resolution = await resolveNeedVoucherContext({
-        assertVoucherWithinLocalLimit: vi.fn(),
-        challenge,
-        event: {
-          channelId,
-          requiredCumulative: '5',
-          acceptedCumulative: '1',
-          deposit: '10',
-        },
-        expectedChannelId: channelId,
-        getChannel: () => entry,
-        input: 'https://example.test/stream',
-        topUpIfNeeded: async () => {},
-      })
-
-      expect(entry.cumulativeAmount).toBe(9n)
-      expect(resolution.status).toBe('ready')
-      if (resolution.status !== 'ready') throw new Error('expected ready resolution')
-      expect(resolution.context.cumulativeAmountRaw).toBe('9')
-    })
-
-    test('ignores need-voucher when the active channel disappears after top-up', async () => {
-      const resolution = await resolveNeedVoucherContext({
-        assertVoucherWithinLocalLimit: vi.fn(),
-        challenge,
-        event: {
-          channelId,
-          requiredCumulative: '5',
-          acceptedCumulative: '1',
-          deposit: '10',
-        },
-        expectedChannelId: channelId,
-        getChannel: () => null,
-        input: 'https://example.test/stream',
-        topUpIfNeeded: async () => {},
-      })
-
-      expect(resolution).toEqual({ status: 'ignored', reason: 'missing-channel' })
-    })
-
-    test('ignores need-voucher events for another channel before top-up', async () => {
-      const topUpIfNeeded = vi.fn()
-
-      const resolution = await resolveNeedVoucherContext({
-        assertVoucherWithinLocalLimit: vi.fn(),
-        challenge,
-        event: {
-          channelId: `0x${'44'.repeat(32)}` as Hex.Hex,
-          requiredCumulative: '5',
-          acceptedCumulative: '1',
-          deposit: '10',
-        },
-        expectedChannelId: channelId,
-        getChannel: () => channel(),
-        input: 'https://example.test/stream',
-        topUpIfNeeded,
-      })
-
-      expect(resolution).toEqual({ status: 'ignored', reason: 'channel-mismatch' })
-      expect(topUpIfNeeded).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('resolveManualTopUp', () => {
-    test('returns a typed top-up target for an active manager session', () => {
-      const assertLimit = vi.fn()
-
-      const target = resolveManualTopUp({
-        amount: '1',
-        assertVoucherWithinLocalLimit: assertLimit,
-        channel: channel({ cumulativeAmount: 1_000_000n, deposit: 1_000_000n }),
-        decimals: 6,
-        lastChallenge: challenge,
-        lastUrl: 'https://api.example.com/data',
-      })
-
-      expect(target).toEqual({
-        additionalDeposit: 1_000_000n,
-        challenge,
-        channelId,
-        input: 'https://api.example.com/data',
-      })
-      expect(assertLimit).toHaveBeenCalledWith(2_000_000n)
-    })
-
-    test('rejects manual top-up when no channel is open or amount is non-positive', () => {
-      expect(() =>
-        resolveManualTopUp({
-          amount: '1',
-          assertVoucherWithinLocalLimit: vi.fn(),
-          channel: channel({ opened: false }),
-          decimals: 6,
-          lastChallenge: challenge,
-          lastUrl: 'https://api.example.com/data',
-        }),
-      ).toThrow('Cannot top up session: no open channel.')
-
-      expect(() =>
-        resolveManualTopUp({
-          amount: 0n,
-          assertVoucherWithinLocalLimit: vi.fn(),
-          channel: channel(),
-          decimals: 6,
-          lastChallenge: challenge,
-          lastUrl: 'https://api.example.com/data',
-        }),
-      ).toThrow('Top-up amount must be greater than zero.')
-    })
-  })
-
-  function activeState(entry: ChannelEntry): SessionState {
-    return {
-      status: 'active',
-      acceptedCumulative: entry.cumulativeAmount.toString(),
-      challengeId: 'challenge-1',
-      channelId: entry.channelId,
-      deposit: entry.deposit.toString(),
-      descriptor: entry.descriptor,
-      spent: '40',
-      units: 3,
-    }
-  }
-
-  describe('applyTopUpResult', () => {
-    test('adds top-up deposit without replacing it with accepted cumulative receipt value', () => {
-      const entry = channel({ cumulativeAmount: 100n, deposit: 500n })
-      const result = applyTopUpResult({
-        additionalDeposit: 200n,
-        channel: entry,
-        channelId,
-        currentState: activeState(entry),
-        receipt: createSessionReceipt({
-          acceptedCumulative: 100n,
-          challengeId: 'challenge-1',
-          channelId,
-          spent: 80n,
-          units: 4,
-        }),
-        spent: 40n,
-      })
-
-      expect(result?.channel.deposit).toBe(700n)
-      expect(result?.state).toMatchObject({
-        status: 'active',
-        acceptedCumulative: '100',
-        deposit: '700',
-        spent: '80',
-        units: 4,
-      })
-    })
-
-    test('projects active state without a receipt and preserves active units', () => {
-      const entry = channel({ cumulativeAmount: 100n, deposit: 500n })
-      const result = applyTopUpResult({
-        additionalDeposit: 50n,
-        channel: entry,
-        channelId,
-        challengeId: 'challenge-2',
-        currentState: activeState(entry),
-        spent: 40n,
-      })
-
-      expect(result?.channel.deposit).toBe(550n)
-      expect(result?.state).toMatchObject({
-        status: 'active',
-        challengeId: 'challenge-2',
-        deposit: '550',
-        spent: '40',
-        units: 3,
-      })
-    })
-
-    test('ignores top-ups for a different channel', () => {
-      const entry = channel({ deposit: 500n })
-      const result = applyTopUpResult({
-        additionalDeposit: 50n,
-        channel: entry,
-        channelId: `0x${'55'.repeat(32)}` as Hex.Hex,
-        currentState: initialState,
-        spent: 0n,
-      })
-
-      expect(result).toBeUndefined()
-      expect(entry.deposit).toBe(500n)
-    })
-  })
-})
-
-describe('SseDriver', () => {
-  test('preserves application frames and consumes payment receipts', async () => {
-    const receipt = createSessionReceipt({
-      acceptedCumulative: 2n,
-      challengeId: 'challenge-1',
-      channelId: `0x${'01'.repeat(32)}`,
-      spent: 2n,
-    })
-    const acceptReceipt = vi.fn()
-    const response = new Response(
-      [
-        ': keepalive\n\n',
-        'event: custom\ndata: hello\n\n',
-        `event: payment-receipt\ndata: ${JSON.stringify(receipt)}\n\n`,
-      ].join(''),
-    )
-
-    const frames = []
-    for await (const frame of driveSseResponse({
-      async onNeedVoucher() {},
-      onReceipt: acceptReceipt,
-      response,
-    }))
-      frames.push(frame)
-
-    expect(frames).toEqual([
-      { raw: ': keepalive\n\n' },
-      { data: 'hello', raw: 'event: custom\ndata: hello\n\n' },
-    ])
-    expect(acceptReceipt).toHaveBeenCalledWith(receipt)
-  })
-
-  test('wraps standard CRLF streams and preserves response metadata', async () => {
-    const receipt = createSessionReceipt({
-      acceptedCumulative: 2n,
-      challengeId: 'challenge-1',
-      channelId: `0x${'01'.repeat(32)}`,
-      spent: 2n,
-    })
-    const encoder = new TextEncoder()
-    const source = new Response(
-      new ReadableStream({
-        start(controller) {
-          controller.enqueue(encoder.encode(': keepalive\r\n\r'))
-          controller.enqueue(
-            encoder.encode(
-              [
-                '\nevent: custom\r\ndata: hello\r\n\r\n',
-                `event: payment-receipt\r\ndata: ${JSON.stringify(receipt)}\r\n\r\n`,
-              ].join(''),
-            ),
-          )
-          controller.close()
-        },
-      }),
-      {
-        headers: { 'content-length': '100', 'content-type': 'text/event-stream' },
-        status: 201,
-        statusText: 'Created',
-      },
-    )
-    Object.defineProperty(source, 'url', { value: 'https://example.com/stream' })
-
-    const response = wrapSseResponse({
-      async onNeedVoucher() {},
-      onReceipt() {},
-      response: source,
-    })
-
-    expect(response.status).toBe(201)
-    expect(response.statusText).toBe('Created')
-    expect(response.url).toBe('https://example.com/stream')
-    expect(response.headers.get('content-type')).toBe('text/event-stream')
-    expect(response.headers.has('content-length')).toBe(false)
-    expect(await response.text()).toBe(': keepalive\r\n\r\nevent: custom\r\ndata: hello\r\n\r\n')
-  })
-
-  test.each(['consumer', 'signal'] as const)(
-    'cancels the source stream from %s',
-    async (source) => {
-      const abortController = new AbortController()
-      const cancel = vi.fn()
-      const sourceResponse = new Response(
-        new ReadableStream({
-          cancel,
-          start(controller) {
-            controller.enqueue(new TextEncoder().encode('data: first\n\n'))
-          },
-        }),
-      )
-      const response = wrapSseResponse({
-        async onNeedVoucher() {},
-        onReceipt() {},
-        response: sourceResponse,
-        signal: abortController.signal,
-      })
-
-      const reader = response.body!.getReader()
-      await reader.read()
-      if (source === 'signal') abortController.abort()
-      else await reader.cancel()
-
-      await vi.waitFor(() => expect(cancel).toHaveBeenCalledOnce())
-    },
-  )
-
-  test('keeps voucher events bound to the challenge that opened the stream', async () => {
-    const channelId = `0x${'01'.repeat(32)}` as Hex.Hex
-    const token = '0x20c0000000000000000000000000000000000001' as Address
-    const payee = '0x0000000000000000000000000000000000000002' as Address
-    const descriptor: ChannelDescriptor = {
-      authorizedSigner: '0x0000000000000000000000000000000000000001',
-      expiringNonceHash: `0x${'03'.repeat(32)}` as Hex.Hex,
-      operator: '0x0000000000000000000000000000000000000000',
-      payee,
-      payer: '0x0000000000000000000000000000000000000001',
-      salt: `0x${'02'.repeat(32)}` as Hex.Hex,
-      token,
-    }
-    const makeChallenge = (id: string) =>
-      Challenge.from({
-        id,
-        intent: Constants.Intents.session,
-        method: Constants.Methods.tempo,
-        realm: 'example.test',
-        request: {
-          amount: '1',
-          currency: token,
-          methodDetails: { chainId: 4217, escrowContract: tip20ChannelEscrow },
-          recipient: payee,
-          unitType: 'request',
-        },
-      }) as TempoSessionChallenge
-    const streamChallenge = makeChallenge('challenge-1')
-    let currentChallenge = streamChallenge
-    const createSessionCredential = vi.fn(async () => 'Payment credential')
-    const channel: ChannelEntry = {
-      chainId: 4217,
-      channelId,
-      cumulativeAmount: 1n,
-      deposit: 10n,
-      descriptor,
-      escrow: tip20ChannelEscrow,
-      opened: true,
-    }
-    const response = new Response(
-      formatNeedVoucherEvent({
-        acceptedCumulative: '1',
-        channelId,
-        deposit: '10',
-        requiredCumulative: '2',
-      }),
-      { headers: { 'Content-Type': 'text/event-stream' } },
-    )
-    const stream = consumeSseSessionResponse('https://example.test/stream', response, undefined, {
-      acceptReceipt() {},
-      assertVoucherWithinLocalLimit() {},
-      createSessionCredential,
-      async doFetch() {
-        throw new Error('unexpected resource fetch')
-      },
-      fetch: vi.fn(async () => new Response(null, { status: 204 })),
-      getChallenge: () => currentChallenge,
-      getChannel: () => channel,
-      async topUpIfNeeded() {},
-    })
-
-    currentChallenge = makeChallenge('challenge-2')
-    const frames: string[] = []
-    for await (const frame of stream) frames.push(frame)
-
-    expect(frames).toEqual([])
-    expect(createSessionCredential).toHaveBeenCalledOnce()
-    expect(createSessionCredential).toHaveBeenCalledWith(
-      streamChallenge,
-      expect.objectContaining({ action: 'voucher', cumulativeAmountRaw: '2' }),
-    )
-  })
-})
-
-describe('WsDriver', () => {
-  const channelId = '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex.Hex
-  const challenge: TempoSessionChallenge = {
-    id: 'challenge-1',
-    realm: 'test',
-    method: 'tempo',
-    intent: 'session',
-    request: {
-      amount: '25',
-      currency: 'pathUSD',
-      methodDetails: { escrowContract: undefined },
-      recipient: 'payee',
-      unitType: 'chunk',
-    },
-  }
-
-  function receipt(overrides: Partial<Parameters<typeof createSessionReceipt>[0]> = {}) {
-    const parameters = {
-      acceptedCumulative: 80n,
-      challengeId: 'challenge-1',
-      channelId,
-      spent: 80n,
-      ...overrides,
-    }
-    return createSessionReceipt(parameters)
-  }
-
-  describe('WsDriver socket state', () => {
-    test('hydrates socket runtime state from the opening credential', () => {
-      const socket = {} as WebSocket
-      const credential = Credential.serialize({
-        challenge,
-        payload: { action: 'open', channelId },
-      })
-
-      expect(createActiveSocketSession({ challenge, credential, socket })).toEqual({
-        challenge,
-        channelId,
-        closeReadyReceipt: null,
-        deliveredChunks: 0n,
-        expectedCloseAmount: null,
-        socket,
-        tickCost: 25n,
-      })
-    })
-  })
-
-  describe('WsDriver receipt validation', () => {
-    test('matches receipts to active socket challenge and channel', () => {
-      expect(
-        isExpectedSocketReceipt({
-          challengeId: 'challenge-1',
-          channelId,
-          receipt: receipt(),
-        }),
-      ).toBe(true)
-
-      expect(
-        isExpectedSocketReceipt({
-          challengeId: 'challenge-2',
-          channelId,
-          receipt: receipt(),
-        }),
-      ).toBe(false)
-    })
-
-    test('validates close-ready receipts against local cumulative authorization', () => {
-      expect(
-        validateSocketCloseReadyReceipt({
-          challengeId: 'challenge-1',
-          channelId,
-          cumulativeAmount: 80n,
-          receipt: receipt(),
-        }),
-      ).toBeUndefined()
-
-      expect(
-        validateSocketCloseReadyReceipt({
-          challengeId: 'challenge-1',
-          channelId,
-          cumulativeAmount: 79n,
-          receipt: receipt(),
-        }),
-      ).toBe('received payment-close-ready beyond local voucher state')
-    })
-
-    test('validates final close receipts when a close amount is expected', () => {
-      expect(
-        validateSocketPaymentReceipt({
-          challengeId: 'challenge-1',
-          channelId,
-          expectedCloseAmount: '80',
-          receipt: receipt({ txHash: '0x1234' }),
-        }),
-      ).toBeUndefined()
-
-      expect(
-        validateSocketPaymentReceipt({
-          challengeId: 'challenge-1',
-          channelId,
-          expectedCloseAmount: '81',
-          receipt: receipt({ txHash: '0x1234' }),
-        }),
-      ).toBe('received mismatched payment-close receipt frame')
-    })
-  })
-
-  function makeChallenge(overrides: Partial<Challenge.Challenge> = {}): Challenge.Challenge {
-    return Challenge.from({
-      id: 'test-challenge',
-      realm: 'test.example.com',
-      method: 'tempo',
-      intent: 'session',
-      request: {
-        amount: '1000000',
-        currency: '0x20c0000000000000000000000000000000000001',
-        decimals: 6,
-        methodDetails: {
-          chainId: 4217,
-          escrowContract: tip20ChannelEscrow,
-          sessionProtocol: Constants.SessionProtocols.v2,
-        },
-        recipient: '0x742d35cc6634c0532925a3b844bc9e7595f8fe00',
-      },
-      ...overrides,
-    })
-  }
-
-  function make402Response(challenge: Challenge.Challenge): Response {
-    return new Response(null, {
-      status: 402,
-      headers: { [Constants.Headers.wwwAuthenticate]: Challenge.serialize(challenge) },
-    })
-  }
-
-  describe('prepareWebSocketSession', () => {
-    test('probes the HTTP URL, selects the tempo session challenge, and creates the opening credential', async () => {
-      const challenge = makeChallenge()
-      const events: string[] = []
-      const fetch = async (input: RequestInfo | URL) => {
-        events.push(`fetch:${input.toString()}`)
-        return make402Response(challenge)
-      }
-
-      const prepared = await prepareWebSocketSession({
-        async createSessionCredential(selected, context) {
-          events.push(`credential:${selected.id}:${Object.keys(context).length}`)
-          expect(selected).toEqual(challenge)
-          expect(context).toEqual({})
-          return 'Payment credential'
-        },
-        fetch,
-        input: 'wss://example.test/socket?stream=1',
-        onProbeUrl(url) {
-          events.push(`probe:${url.toString()}`)
-        },
-      })
-
-      expect(prepared).toEqual({
-        challenge,
-        credential: 'Payment credential',
-        httpUrl: new URL('https://example.test/socket?stream=1'),
-        wsUrl: new URL('wss://example.test/socket?stream=1'),
-      })
-      expect(events).toEqual([
-        'probe:https://example.test/socket?stream=1',
-        'fetch:https://example.test/socket?stream=1',
-        'credential:test-challenge:0',
-      ])
-    })
-
-    test('throws when the HTTP probe does not return a payment challenge', async () => {
-      await expect(
-        prepareWebSocketSession({
-          createSessionCredential: async () => 'unused',
-          fetch: async () => new Response(null, { status: 200 }),
-          input: 'ws://example.test/socket',
-        }),
-      ).rejects.toThrow(
-        'Expected a 402 payment challenge from http://example.test/socket, received 200 instead.',
-      )
-    })
-
-    test('throws when the probe does not advertise a tempo session challenge', async () => {
-      await expect(
-        prepareWebSocketSession({
-          createSessionCredential: async () => 'unused',
-          fetch: async () => make402Response(makeChallenge({ intent: 'charge' })),
-          input: 'ws://example.test/socket',
-        }),
-      ).rejects.toThrow(
-        'No payment challenge received from HTTP endpoint for this WebSocket URL. The server may not require payment or did not advertise a challenge.',
-      )
-    })
-  })
-})