mppx 0.8.17 → 0.8.18

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

@@ -1,4247 +0,0 @@
-import * as node_http from 'node:http'
-
-import { serve } from '@hono/node-server'
-import { Hono } from 'hono'
-import { Challenge, Constants, Credential } from 'mppx'
-import { Mppx as Mppx_server, tempo as tempo_server } from 'mppx/server'
-import { Secp256k1 } from 'ox'
-import { TxEnvelopeTempo } from 'ox/tempo'
-import {
-  type Address,
-  createClient,
-  custom,
-  defineChain,
-  encodeAbiParameters,
-  encodeEventTopics,
-  encodeFunctionData,
-  encodeFunctionResult,
-  type Hex,
-  maxUint256,
-  zeroAddress,
-} from 'viem'
-import { privateKeyToAccount } from 'viem/accounts'
-import { Transaction } from 'viem/tempo'
-import { describe, expect, test, vi } from 'vp/test'
-import { WebSocket, WebSocketServer } from 'ws'
-import * as Http from '~test/Http.js'
-
-import * as NodeRequest from '../../../server/Request.js'
-import * as Store from '../../../Store.js'
-import { charge as clientCharge } from '../../client/Charge.js'
-import * as Methods from '../../Methods.js'
-import * as ClientOps from '../client/ChannelOps.js'
-import { sessionManager as precompileSessionManager } from '../client/SessionManager.js'
-import * as Channel from '../precompile/Channel.js'
-import { escrowAbi } from '../precompile/escrow.abi.js'
-import { tip20ChannelEscrow } from '../precompile/Protocol.js'
-import { deserializeSessionReceipt } from '../precompile/Protocol.js'
-import type { SessionReceipt } from '../precompile/Protocol.js'
-import type { SessionCredentialPayload } from '../precompile/Protocol.js'
-import * as Types from '../precompile/Protocol.js'
-import * as Voucher from '../precompile/Voucher.js'
-import * as ChannelStore from './ChannelStore.js'
-import { charge, session, type ResolveSessionChannelId } from './Session.js'
-import * as TempoWs from './Ws.js'
-
-const payerPrivateKey = '0xac0974bec39a17e36ba6a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80'
-const payer = privateKeyToAccount(payerPrivateKey)
-const wrongPayer = privateKeyToAccount(
-  '0x59c6995e998f97a5a0044966f094538a009d74290f5811cfba6a6b4d238ff944',
-)
-const chainId = 42431
-const payee = '0x0000000000000000000000000000000000000002' as Address
-const token = '0x0000000000000000000000000000000000000003' as Address
-const wrongTarget = '0x0000000000000000000000000000000000000004' as Address
-const testChain = defineChain({
-  id: chainId,
-  name: 'Tempo Test',
-  nativeCurrency: { name: 'Tempo', symbol: 'TEMPO', decimals: 18 },
-  rpcUrls: { default: { http: ['http://localhost'] } },
-})
-
-type RpcCall = { method: string; params?: unknown }
-type ChainState = { settled: bigint; deposit: bigint; closeRequestedAt: number }
-type SessionRequest = ReturnType<typeof Methods.session.schema.request.parse>
-
-function channelStore(store: Store.Store | Store.AtomicStore): ChannelStore.ChannelStore {
-  return ChannelStore.fromStore(store)
-}
-
-function createSigningClient(account = payer) {
-  return createClient({
-    account,
-    chain: testChain,
-    transport: custom({
-      async request(args) {
-        if (args.method === 'eth_chainId') return `0x${chainId.toString(16)}`
-        if (args.method === 'eth_getTransactionCount') return '0x0'
-        if (args.method === 'eth_estimateGas') return '0x5208'
-        if (args.method === 'eth_maxPriorityFeePerGas') return '0x1'
-        if (args.method === 'eth_getBlockByNumber') return { baseFeePerGas: '0x1' }
-        throw new Error(`unexpected signing rpc request: ${args.method}`)
-      },
-    }),
-  })
-}
-
-function createServerClient(
-  calls: RpcCall[] = [],
-  account: typeof payer | null = payer,
-  _eventChannelId: Hex = `0x${'00'.repeat(32)}` as Hex,
-  options: {
-    descriptor?: Channel.ChannelDescriptor
-    receipt?:
-      | Record<string, unknown>
-      | (() => Record<string, unknown> | Promise<Record<string, unknown>>)
-    sentReceipt?:
-      | Record<string, unknown>
-      | (() => Record<string, unknown> | Promise<Record<string, unknown>>)
-    state?: ChainState | (() => ChainState | Promise<ChainState>)
-  } = {},
-) {
-  let sentTransaction = false
-  return createClient({
-    ...(account ? { account } : {}),
-    chain: testChain,
-    transport: custom({
-      async request(args) {
-        calls.push(args)
-        if (args.method === 'eth_chainId') return `0x${chainId.toString(16)}`
-        if (args.method === 'eth_getTransactionCount') return '0x0'
-        if (args.method === 'eth_estimateGas') return '0x5208'
-        if (args.method === 'eth_maxPriorityFeePerGas') return '0x1'
-        if (args.method === 'eth_getBlockByNumber') return { baseFeePerGas: '0x1' }
-        if (args.method === 'eth_sendRawTransaction') {
-          sentTransaction = true
-          return `0x${'aa'.repeat(32)}`
-        }
-        if (args.method === 'eth_getTransactionReceipt') {
-          const receipt = sentTransaction
-            ? (options.sentReceipt ?? options.receipt)
-            : options.receipt
-          return typeof receipt === 'function' ? receipt() : (receipt ?? null)
-        }
-        if (args.method === 'eth_sendTransaction') {
-          sentTransaction = true
-          return `0x${'bb'.repeat(32)}`
-        }
-        if (args.method === 'eth_call') {
-          const configuredState =
-            typeof options.state === 'function' ? await options.state() : options.state
-          const state = configuredState ?? { settled: 100n, deposit: 1_000n, closeRequestedAt: 0 }
-          const data = (args.params as [{ data?: Hex }])[0].data
-          const getChannelSelector = options.descriptor
-            ? encodeFunctionData({
-                abi: escrowAbi,
-                functionName: 'getChannel',
-                args: [options.descriptor],
-              }).slice(0, 10)
-            : undefined
-          if (data && getChannelSelector && data.slice(0, 10) === getChannelSelector)
-            return encodeFunctionResult({
-              abi: escrowAbi,
-              functionName: 'getChannel',
-              result: { descriptor: options.descriptor!, state },
-            })
-          return encodeFunctionResult({
-            abi: escrowAbi,
-            functionName: 'getChannelState',
-            result: state,
-          })
-        }
-        throw new Error(`unexpected rpc request: ${args.method}`)
-      },
-    }),
-  })
-}
-
-function createStateClient(
-  account: typeof payer | null = payer,
-  state: ChainState = {
-    settled: 0n,
-    deposit: 1_000n,
-    closeRequestedAt: 0,
-  },
-) {
-  return createClient({
-    ...(account ? { account } : {}),
-    chain: testChain,
-    transport: custom({
-      async request(args) {
-        if (args.method === 'eth_chainId') return `0x${chainId.toString(16)}`
-        if (args.method === 'eth_call')
-          return encodeFunctionResult({
-            abi: escrowAbi,
-            functionName: 'getChannelState',
-            result: state,
-          })
-        if (args.method === 'eth_getTransactionCount') return '0x0'
-        if (args.method === 'eth_estimateGas') return '0x5208'
-        if (args.method === 'eth_maxPriorityFeePerGas') return '0x1'
-        if (args.method === 'eth_getBlockByNumber') return { baseFeePerGas: '0x1' }
-        throw new Error(`unexpected rpc request: ${args.method}`)
-      },
-    }),
-  })
-}
-
-function createServer(parameters: Partial<session.Parameters> = {}) {
-  const rawStore = Store.memory()
-  const rpcCalls: RpcCall[] = []
-  const serverClient = createServerClient(rpcCalls)
-  const method = session({
-    amount: '1',
-    chainId,
-    currency: token,
-    decimals: 0,
-    recipient: payee,
-    store: rawStore,
-    unitType: 'request',
-    getClient: () => serverClient,
-    ...parameters,
-  })
-  return { method, store: channelStore(rawStore), rpcCalls }
-}
-
-function makeChallenge(
-  channelId?: Hex,
-  options: { operator?: Address | undefined } = {},
-): Challenge.Challenge<SessionRequest, 'session', 'tempo'> {
-  return {
-    id: 'challenge-id',
-    realm: 'api.example.com',
-    method: 'tempo',
-    intent: 'session',
-    request: makeRequest(channelId, options),
-  } as Challenge.Challenge<SessionRequest, 'session', 'tempo'>
-}
-
-function makeRequest(
-  channelId?: Hex,
-  options: { operator?: Address | undefined } = {},
-): SessionRequest {
-  return {
-    amount: '100',
-    currency: token,
-    recipient: payee,
-    unitType: 'request',
-    methodDetails: {
-      chainId,
-      escrowContract: tip20ChannelEscrow,
-      ...(channelId && { channelId }),
-      ...(options.operator ? { operator: options.operator } : {}),
-    },
-  }
-}
-
-type VerifyRequest = Parameters<NonNullable<ReturnType<typeof session>['verify']>>[0]['request']
-
-function verifyRequest(
-  channelId?: Hex,
-  options: { operator?: Address | undefined } = {},
-): VerifyRequest {
-  // `verify()` receives the HMAC-bound canonical challenge request. The public
-  // request schema input still includes parse-only fields like `decimals`, so
-  // keep this test bridge in one place instead of casting every verification.
-  return makeRequest(channelId, options) as unknown as VerifyRequest
-}
-
-function verifyRequestWithFeePayer(channelId: Hex, feePayer: typeof payer): VerifyRequest {
-  const request = makeRequest(channelId)
-  return {
-    ...request,
-    feePayer,
-    methodDetails: {
-      ...request.methodDetails,
-      feePayer: true,
-    },
-  } as unknown as VerifyRequest
-}
-
-function sourceFor(account = payer): string {
-  return `did:pkh:eip155:${chainId}:${account.address}`
-}
-
-function voucherCredential(payload: SessionCredentialPayload, channelId: Hex) {
-  return {
-    challenge: makeChallenge(channelId),
-    payload,
-    source: sourceFor(),
-  }
-}
-
-let saltCounter = 0
-
-async function createOpenPayload(
-  parameters: {
-    deposit?: bigint | undefined
-    initialAmount?: bigint | undefined
-    escrow?: Address | undefined
-    account?: typeof payer | undefined
-    operator?: Address | undefined
-    authorizedSigner?: Address | undefined
-  } = {},
-): Promise<Extract<SessionCredentialPayload, { action: 'open' }>> {
-  const account = parameters.account ?? payer
-  const escrow = parameters.escrow ?? tip20ChannelEscrow
-  const initialAmount = Types.uint96(parameters.initialAmount ?? 100n)
-  const deposit = Types.uint96(parameters.deposit ?? 1_000n)
-  const salt = `0x${(++saltCounter).toString(16).padStart(64, '0')}` as Hex
-  const operator = parameters.operator ?? zeroAddress
-  const authorizedSigner = parameters.authorizedSigner ?? account.address
-  const data = encodeFunctionData({
-    abi: escrowAbi,
-    functionName: 'open',
-    args: [payee, operator, token, deposit, salt, authorizedSigner],
-  })
-  const signingClient = createSigningClient(account)
-  const transaction = (await Transaction.serialize({
-    chainId,
-    calls: [{ to: escrow, data }],
-    feeToken: token,
-    nonce: 0,
-  })) as Hex
-  const expiringNonceHash = Channel.computeExpiringNonceHash(
-    Transaction.deserialize(
-      transaction as Transaction.TransactionSerializedTempo,
-    ) as Channel.ExpiringNonceTransaction,
-    { sender: account.address },
-  )
-  const descriptor = {
-    payer: account.address,
-    payee,
-    operator,
-    token,
-    salt,
-    authorizedSigner,
-    expiringNonceHash,
-  } satisfies Channel.ChannelDescriptor
-  const channelId = Channel.computeId({ ...descriptor, chainId, escrow })
-  const signature = await Voucher.signVoucher(
-    signingClient,
-    account,
-    { channelId, cumulativeAmount: initialAmount },
-    escrow,
-    chainId,
-  )
-  return {
-    action: 'open',
-    type: 'transaction',
-    channelId,
-    transaction,
-    signature,
-    descriptor,
-    cumulativeAmount: initialAmount.toString(),
-    authorizedSigner: descriptor.authorizedSigner,
-  }
-}
-
-function sponsorTransaction(
-  serializedTransaction: Hex,
-  options: { gas?: bigint | undefined } = {},
-): Hex {
-  const transaction = Transaction.deserialize(
-    serializedTransaction as Transaction.TransactionSerializedTempo,
-  )
-  const envelope = TxEnvelopeTempo.from({
-    ...transaction,
-    feePayerSignature: null,
-    gas: options.gas ?? 100_000n,
-    maxFeePerGas: 1n,
-    maxPriorityFeePerGas: 1n,
-    nonceKey: maxUint256,
-    validBefore: Math.floor(Date.now() / 1_000) + 600,
-  } as never)
-  return TxEnvelopeTempo.serialize(envelope, {
-    signature: Secp256k1.sign({
-      payload: TxEnvelopeTempo.getSignPayload(envelope),
-      privateKey: payerPrivateKey,
-    }),
-  }) as Hex
-}
-
-async function createSponsoredOpenPayload(): Promise<
-  Extract<SessionCredentialPayload, { action: 'open' }>
-> {
-  const payload = await createOpenPayload()
-  const transaction = sponsorTransaction(payload.transaction)
-  const signed = Transaction.deserialize(transaction as Transaction.TransactionSerializedTempo)
-  const expiringNonceHash = Channel.computeExpiringNonceHash(
-    Channel.transactionForExpiringNonceHash({ feePayer: true, transaction: signed }),
-    { sender: payer.address },
-  )
-  const descriptor = { ...payload.descriptor, expiringNonceHash }
-  const channelId = Channel.computeId({ ...descriptor, chainId, escrow: tip20ChannelEscrow })
-  const signature = await Voucher.signVoucher(
-    createSigningClient(),
-    payer,
-    { channelId, cumulativeAmount: BigInt(payload.cumulativeAmount) },
-    tip20ChannelEscrow,
-    chainId,
-  )
-  return { ...payload, channelId, transaction, signature, descriptor }
-}
-
-function transactionReceipt(logs: readonly Record<string, unknown>[]) {
-  return {
-    blockHash: `0x${'01'.repeat(32)}`,
-    blockNumber: '0x1',
-    contractAddress: null,
-    cumulativeGasUsed: '0x1',
-    effectiveGasPrice: '0x1',
-    from: payer.address,
-    gasUsed: '0x1',
-    logs,
-    logsBloom: `0x${'00'.repeat(256)}`,
-    status: '0x1',
-    to: tip20ChannelEscrow,
-    transactionHash: `0x${'aa'.repeat(32)}`,
-    transactionIndex: '0x0',
-    type: '0x76',
-  }
-}
-
-function openedLog(
-  payload: Extract<SessionCredentialPayload, { action: 'open' }>,
-  deposit = 1_000n,
-) {
-  return {
-    address: tip20ChannelEscrow,
-    data: encodeAbiParameters(
-      [
-        { type: 'address' },
-        { type: 'address' },
-        { type: 'address' },
-        { type: 'bytes32' },
-        { type: 'bytes32' },
-        { type: 'uint96' },
-      ],
-      [
-        payload.descriptor.operator,
-        payload.descriptor.token,
-        payload.descriptor.authorizedSigner,
-        payload.descriptor.salt,
-        payload.descriptor.expiringNonceHash,
-        deposit,
-      ],
-    ),
-    topics: encodeEventTopics({
-      abi: escrowAbi,
-      eventName: 'ChannelOpened',
-      args: {
-        channelId: payload.channelId,
-        payer: payload.descriptor.payer,
-        payee: payload.descriptor.payee,
-      },
-    }),
-  }
-}
-
-function settledLog(channelId: Hex, newSettled: bigint) {
-  return {
-    address: tip20ChannelEscrow,
-    data: encodeAbiParameters(
-      [{ type: 'uint96' }, { type: 'uint96' }, { type: 'uint96' }],
-      [newSettled, newSettled, newSettled],
-    ),
-    topics: encodeEventTopics({
-      abi: escrowAbi,
-      eventName: 'Settled',
-      args: { channelId, payer: payer.address, payee: payer.address },
-    }),
-  }
-}
-
-function closedLog(channelId: Hex, settledToPayee: bigint, refundedToPayer: bigint) {
-  return {
-    address: tip20ChannelEscrow,
-    data: encodeAbiParameters(
-      [{ type: 'uint96' }, { type: 'uint96' }],
-      [settledToPayee, refundedToPayer],
-    ),
-    topics: encodeEventTopics({
-      abi: escrowAbi,
-      eventName: 'ChannelClosed',
-      args: { channelId, payer: payer.address, payee: payer.address },
-    }),
-  }
-}
-
-function topUpLog(
-  payload: Extract<SessionCredentialPayload, { action: 'topUp' }>,
-  newDeposit: bigint,
-) {
-  return {
-    address: tip20ChannelEscrow,
-    data: encodeAbiParameters([{ type: 'uint96' }, { type: 'uint96' }], [1_000n, newDeposit]),
-    topics: encodeEventTopics({
-      abi: escrowAbi,
-      eventName: 'TopUp',
-      args: { channelId: payload.channelId, payer: payer.address, payee },
-    }),
-  }
-}
-
-async function createTopUpPayload(
-  descriptor: Channel.ChannelDescriptor,
-  additionalDeposit = 500n,
-): Promise<Extract<SessionCredentialPayload, { action: 'topUp' }>> {
-  const data = encodeFunctionData({
-    abi: escrowAbi,
-    functionName: 'topUp',
-    args: [descriptor, Types.uint96(additionalDeposit)],
-  })
-  const transaction = (await Transaction.serialize({
-    chainId,
-    calls: [{ to: tip20ChannelEscrow, data }],
-    feeToken: token,
-    nonce: 0,
-  })) as Hex
-  const channelId = Channel.computeId({ ...descriptor, chainId, escrow: tip20ChannelEscrow })
-  return {
-    action: 'topUp',
-    type: 'transaction',
-    channelId,
-    descriptor,
-    transaction,
-    additionalDeposit: additionalDeposit.toString(),
-  }
-}
-
-async function persistPrecompileChannel(
-  store: ChannelStore.ChannelStore,
-  payload: Extract<SessionCredentialPayload, { action: 'open' }>,
-  overrides: Partial<ChannelStore.State> = {},
-) {
-  await store.updateChannel(payload.channelId, () => ({
-    backend: 'precompile',
-    channelId: payload.channelId,
-    chainId,
-    escrowContract: tip20ChannelEscrow,
-    closeRequestedAt: 0n,
-    payer: payload.descriptor.payer,
-    payee,
-    token,
-    authorizedSigner: payload.descriptor.authorizedSigner,
-    deposit: 1_000n,
-    settledOnChain: 0n,
-    highestVoucherAmount: BigInt(payload.cumulativeAmount),
-    highestVoucher: {
-      channelId: payload.channelId,
-      cumulativeAmount: BigInt(payload.cumulativeAmount),
-      signature: payload.signature,
-    },
-    spent: 0n,
-    units: 0,
-    finalized: false,
-    createdAt: new Date(0).toISOString(),
-    descriptor: payload.descriptor,
-    operator: payload.descriptor.operator,
-    salt: payload.descriptor.salt,
-    expiringNonceHash: payload.descriptor.expiringNonceHash,
-    ...overrides,
-  }))
-}
-
-describe('precompile server session unit guardrails', () => {
-  test('request marks TIP-1034 session challenges', async () => {
-    const { method } = createServer()
-
-    const challengeRequest = await method.request!({
-      credential: null,
-      request: {
-        amount: '1',
-        currency: token,
-        decimals: 0,
-        recipient: payee,
-        unitType: 'request',
-      },
-    } as never)
-
-    expect(challengeRequest.sessionProtocol).toBe(Constants.SessionProtocols.v2)
-  })
-
-  test('request normalizes fee-payer to boolean for challenge issuance and account for verification', async () => {
-    const { method } = createServer({ feePayer: wrongPayer })
-
-    const challengeRequest = await method.request!({
-      credential: null,
-      request: {
-        amount: '1',
-        currency: token,
-        decimals: 0,
-        recipient: payee,
-        unitType: 'request',
-      },
-    } as never)
-    expect(challengeRequest.feePayer).toBe(true)
-
-    const verificationRequest = await method.request!({
-      credential: { challenge: {}, payload: {} } as never,
-      request: {
-        amount: '1',
-        currency: token,
-        decimals: 0,
-        feePayer: payer,
-        recipient: payee,
-        unitType: 'request',
-      },
-    } as never)
-    expect(verificationRequest.feePayer).toBe(payer)
-  })
-
-  test('request allows callers to explicitly disable precompile fee-payer', async () => {
-    const { method } = createServer({ feePayer: wrongPayer })
-
-    const challengeRequest = await method.request!({
-      credential: null,
-      request: {
-        amount: '1',
-        currency: token,
-        decimals: 0,
-        feePayer: false,
-        recipient: payee,
-        unitType: 'request',
-      },
-    } as never)
-    expect(challengeRequest.feePayer).toBeUndefined()
-
-    const verificationRequest = await method.request!({
-      credential: { challenge: {}, payload: {} } as never,
-      request: {
-        amount: '1',
-        currency: token,
-        decimals: 0,
-        feePayer: false,
-        recipient: payee,
-        unitType: 'request',
-      },
-    } as never)
-    expect(verificationRequest.feePayer).toBe(false)
-  })
-
-  test('request returns a server session snapshot for a known precompile channel', async () => {
-    const { method, store } = createServer()
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    const highestVoucher = await ClientOps.createVoucherPayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(250n),
-      chainId,
-    )
-    if (highestVoucher.action !== 'voucher') throw new Error('expected voucher payload')
-    await persistPrecompileChannel(store, openPayload, {
-      highestVoucherAmount: 250n,
-      highestVoucher: {
-        channelId: openPayload.channelId,
-        cumulativeAmount: 250n,
-        signature: highestVoucher.signature,
-      },
-      spent: 200n,
-      units: 2,
-    })
-
-    const request = await method.request!({
-      credential: {
-        challenge: {},
-        payload: {},
-      } as never,
-      request: {
-        amount: '1',
-        channelId: openPayload.channelId,
-        currency: token,
-        decimals: 0,
-        recipient: payee,
-        unitType: 'request',
-      },
-    } as never)
-
-    expect(request.sessionSnapshot).toEqual({
-      acceptedCumulative: '250',
-      chainId,
-      channelId: openPayload.channelId,
-      closeRequestedAt: undefined,
-      deposit: '1000',
-      descriptor: openPayload.descriptor,
-      escrow: tip20ChannelEscrow,
-      highestVoucher: {
-        channelId: openPayload.channelId,
-        cumulativeAmount: '250',
-        signature: highestVoucher.signature,
-      },
-      requiredCumulative: '201',
-      settled: '0',
-      spent: '200',
-      units: 2,
-    })
-  })
-
-  test('request can resolve a server session snapshot from request identity', async () => {
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    const highestVoucher = await ClientOps.createVoucherPayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(250n),
-      chainId,
-    )
-    if (highestVoucher.action !== 'voucher') throw new Error('expected voucher payload')
-    const { method, store } = createServer({
-      resolveChannelId({ request, credential, paymentRequest, store: hookStore }) {
-        expect(request?.headers.get('cookie')).toBe('sid=session-1')
-        expect(credential).toBeNull()
-        expect(paymentRequest.unitType).toBe('request')
-        expect(hookStore).toBe(store)
-        return openPayload.channelId
-      },
-    })
-    await persistPrecompileChannel(store, openPayload, {
-      highestVoucherAmount: 250n,
-      highestVoucher: {
-        channelId: openPayload.channelId,
-        cumulativeAmount: 250n,
-        signature: highestVoucher.signature,
-      },
-      spent: 200n,
-      units: 2,
-    })
-
-    const request = await method.request!({
-      capturedRequest: {
-        hasBody: false,
-        headers: new Headers({ cookie: 'sid=session-1' }),
-        method: 'GET',
-        url: new URL('https://api.example.com/resource'),
-      },
-      credential: null,
-      request: {
-        amount: '1',
-        currency: token,
-        decimals: 0,
-        recipient: payee,
-        unitType: 'request',
-      },
-    } as never)
-
-    expect(request.sessionSnapshot).toMatchObject({
-      channelId: openPayload.channelId,
-      descriptor: openPayload.descriptor,
-      requiredCumulative: '201',
-      spent: '200',
-    })
-  })
-
-  test('request prefers explicit channel ID over custom channel resolver', async () => {
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    const { method, store } = createServer({
-      resolveChannelId() {
-        throw new Error('unexpected resolver call')
-      },
-    })
-    await persistPrecompileChannel(store, openPayload)
-
-    const request = await method.request!({
-      credential: null,
-      request: {
-        amount: '1',
-        channelId: openPayload.channelId,
-        currency: token,
-        decimals: 0,
-        recipient: payee,
-        unitType: 'request',
-      },
-    } as never)
-
-    expect(request.sessionSnapshot?.channelId).toBe(openPayload.channelId)
-  })
-
-  test('request uses zero effective amount for non-content snapshot hints', async () => {
-    const { method, store } = createServer()
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    const highestVoucher = await ClientOps.createVoucherPayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(250n),
-      chainId,
-    )
-    if (highestVoucher.action !== 'voucher') throw new Error('expected voucher payload')
-    await persistPrecompileChannel(store, openPayload, {
-      highestVoucherAmount: 250n,
-      highestVoucher: {
-        channelId: openPayload.channelId,
-        cumulativeAmount: 250n,
-        signature: highestVoucher.signature,
-      },
-      spent: 250n,
-      units: 2,
-    })
-
-    const request = await method.request!({
-      capturedRequest: {
-        hasBody: false,
-        headers: new Headers(),
-        method: 'HEAD',
-        url: new URL('https://api.example.com/resource'),
-      },
-      credential: {
-        challenge: {},
-        payload: {},
-      } as never,
-      request: {
-        amount: '1',
-        channelId: openPayload.channelId,
-        currency: token,
-        decimals: 0,
-        recipient: payee,
-        unitType: 'request',
-      },
-    } as never)
-
-    expect(request.sessionSnapshot).toMatchObject({
-      acceptedCumulative: '250',
-      requiredCumulative: '250',
-      spent: '250',
-    })
-  })
-
-  test('request throws when resolved precompile client chain mismatches requested chain', async () => {
-    const { method } = createServer({ chainId: 1 })
-
-    await expect(
-      method.request!({
-        credential: null,
-        request: {
-          amount: '1',
-          chainId: 1,
-          currency: token,
-          decimals: 0,
-          recipient: payee,
-          unitType: 'request',
-        },
-      } as never),
-    ).rejects.toThrow('Client not configured with chainId 1.')
-  })
-
-  test('fully validates a session credential without broadcasting or changing channel state', async () => {
-    const { method, rpcCalls, store } = createServer()
-    const openPayload = await createOpenPayload()
-    await persistPrecompileChannel(store, openPayload)
-    const payload = await ClientOps.createVoucherPayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(200n),
-      chainId,
-    )
-
-    const validation = await method.validate!({
-      credential: {
-        challenge: makeChallenge(openPayload.channelId),
-        payload,
-        source: sourceFor(),
-      },
-      request: verifyRequest(openPayload.channelId),
-    })
-
-    await method.validate!({
-      credential: {
-        challenge: makeChallenge(openPayload.channelId),
-        payload,
-        source: sourceFor(),
-      },
-      request: verifyRequest(openPayload.channelId),
-    })
-
-    expect(validation.details).toEqual({ action: 'voucher', channelId: openPayload.channelId })
-    expect(await store.getChannel(openPayload.channelId)).toMatchObject({
-      highestVoucherAmount: 100n,
-      spent: 0n,
-      units: 0,
-    })
-    expect(rpcCalls.map(({ method }) => method)).toEqual(['eth_call'])
-    expect(rpcCalls.map(({ method }) => method)).not.toContain('eth_sendRawTransaction')
-    expect(rpcCalls.map(({ method }) => method)).not.toContain('eth_sendRawTransactionSync')
-  })
-
-  test('simulates unsponsored open and top-up credentials during validation', async () => {
-    const { method, rpcCalls, store } = createServer()
-    const openPayload = await createOpenPayload()
-
-    await method.validate!({
-      credential: { challenge: makeChallenge(openPayload.channelId), payload: openPayload },
-      request: verifyRequest(openPayload.channelId),
-    })
-    await persistPrecompileChannel(store, openPayload)
-    const topUpPayload = await createTopUpPayload(openPayload.descriptor, 100n)
-
-    await method.validate!({
-      credential: { challenge: makeChallenge(topUpPayload.channelId), payload: topUpPayload },
-      request: verifyRequest(topUpPayload.channelId),
-    })
-
-    expect(rpcCalls.map(({ method }) => method)).toEqual(['eth_call', 'eth_call', 'eth_call'])
-    expect(await store.getChannel(openPayload.channelId)).toMatchObject({
-      deposit: 1_000n,
-      highestVoucherAmount: 100n,
-    })
-  })
-
-  test('does not simulate sponsored credentials during validation but checks top-up state', async () => {
-    const { method, rpcCalls, store } = createServer({ feePayer: payer })
-    const openPayload = await createSponsoredOpenPayload()
-
-    await method.validate!({
-      credential: { challenge: makeChallenge(openPayload.channelId), payload: openPayload },
-      request: verifyRequestWithFeePayer(openPayload.channelId, payer),
-    })
-    await persistPrecompileChannel(store, openPayload)
-    const topUpPayload = await createTopUpPayload(openPayload.descriptor, 100n)
-    topUpPayload.transaction = sponsorTransaction(topUpPayload.transaction)
-
-    await method.validate!({
-      credential: { challenge: makeChallenge(topUpPayload.channelId), payload: topUpPayload },
-      request: verifyRequestWithFeePayer(topUpPayload.channelId, payer),
-    })
-
-    expect(rpcCalls.map(({ method }) => method)).toEqual(['eth_call'])
-    expect(await store.getChannel(openPayload.channelId)).toMatchObject({
-      deposit: 1_000n,
-      highestVoucherAmount: 100n,
-    })
-  })
-
-  test('rejects sponsored credentials that exceed the fee-payer policy during validation', async () => {
-    const { method, rpcCalls } = createServer({
-      feePayer: payer,
-      feePayerPolicy: { maxGas: 1n },
-    })
-    const payload = await createSponsoredOpenPayload()
-
-    payload.transaction = sponsorTransaction(payload.transaction, { gas: 2n })
-
-    await expect(
-      method.validate!({
-        credential: { challenge: makeChallenge(payload.channelId), payload },
-        request: verifyRequestWithFeePayer(payload.channelId, payer),
-      }),
-    ).rejects.toThrow(/fee-sponsored transaction gas exceeds sponsor policy/)
-    expect(rpcCalls).toEqual([])
-  })
-
-  test('validates close credentials without marking the channel pending', async () => {
-    const { method, rpcCalls, store } = createServer()
-    const openPayload = await createOpenPayload()
-    await persistPrecompileChannel(store, openPayload, { payee: payer.address })
-    const payload = await ClientOps.createClosePayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(100n),
-      chainId,
-    )
-
-    await method.validate!({
-      credential: { challenge: makeChallenge(openPayload.channelId), payload },
-      request: verifyRequest(openPayload.channelId),
-    })
-
-    expect((await store.getChannel(openPayload.channelId))?.closeRequestedAt).toBe(0n)
-    expect(rpcCalls.map(({ method }) => method)).toEqual(['eth_call'])
-  })
-
-  test('rejects open transactions targeting the wrong address', async () => {
-    const { method } = createServer()
-    const payload = await createOpenPayload({ escrow: wrongTarget })
-
-    await expect(
-      method.verify({
-        credential: { challenge: makeChallenge(payload.channelId), payload },
-        request: verifyRequest(payload.channelId),
-      }),
-    ).rejects.toThrow(/descriptor does not match channelId|wrong address/)
-  })
-
-  test('rejects smuggled extra calls in open transactions', async () => {
-    const { method } = createServer()
-    const payload = await createOpenPayload()
-    const tampered = await createOpenPayload()
-
-    // Reuse a valid descriptor/signature, but submit a transaction whose calls
-    // do not correspond to that descriptor. This exercises the same one-call /
-    // smuggling guard as legacy server session tests without requiring a live
-    // chain-backed precompile.
-    const smuggled = { ...payload, transaction: tampered.transaction }
-
-    await expect(
-      method.verify({
-        credential: {
-          challenge: makeChallenge(payload.channelId),
-          payload: smuggled,
-        },
-        request: verifyRequest(payload.channelId),
-      }),
-    ).rejects.toThrow(/does not match/)
-  })
-
-  test('rejects descriptors that do not match the challenge channel ID', async () => {
-    const { method } = createServer()
-    const payload = await createOpenPayload()
-    const badDescriptor = {
-      ...payload.descriptor,
-      token: '0x0000000000000000000000000000000000000005' as Address,
-    }
-
-    await expect(
-      method.verify({
-        credential: {
-          challenge: makeChallenge(payload.channelId),
-          payload: { ...payload, descriptor: badDescriptor },
-        },
-        request: verifyRequest(payload.channelId),
-      }),
-    ).rejects.toThrow(/descriptor does not match channelId/)
-  })
-
-  test('rejects invalid initial voucher signatures', async () => {
-    const { method } = createServer()
-    const payload = await createOpenPayload()
-    const badSignaturePayload = {
-      ...payload,
-      signature: (await createOpenPayload({ account: wrongPayer })).signature,
-    }
-
-    await expect(
-      method.verify({
-        credential: {
-          challenge: makeChallenge(payload.channelId),
-          payload: badSignaturePayload,
-        },
-        request: verifyRequest(payload.channelId),
-      }),
-    ).rejects.toThrow(/invalid voucher signature/)
-  })
-
-  test('rejects missing precompile descriptors with a verification error', async () => {
-    const { method } = createServer()
-    const payload = await createOpenPayload()
-    const { descriptor: _descriptor, ...payloadWithoutDescriptor } = payload
-
-    await expect(
-      method.verify({
-        credential: {
-          challenge: makeChallenge(payload.channelId),
-          payload: payloadWithoutDescriptor,
-        },
-        request: verifyRequest(payload.channelId),
-      }),
-    ).rejects.toThrow(/descriptor required for TIP-1034 session action/)
-  })
-
-  test('rejects uint96 overflow in credential amount parsing', async () => {
-    const { method } = createServer()
-    const payload = await createOpenPayload()
-
-    await expect(
-      method.verify({
-        credential: {
-          challenge: makeChallenge(payload.channelId),
-          payload: { ...payload, cumulativeAmount: (1n << 96n).toString() },
-        },
-        request: verifyRequest(payload.channelId),
-      }),
-    ).rejects.toThrow(/outside uint96 bounds/)
-  })
-
-  test('rejects settle when no account is available', async () => {
-    const { store } = createServer()
-    const openPayload = await createOpenPayload()
-    await persistPrecompileChannel(store, openPayload)
-
-    const { settle } = await import('./Session.js')
-    await expect(
-      settle(store, createServerClient([], null), openPayload.channelId),
-    ).rejects.toThrow(/no account available/)
-  })
-
-  test('rejects settle when sender is not the channel payee or operator', async () => {
-    const { store } = createServer()
-    const openPayload = await createOpenPayload()
-    await persistPrecompileChannel(store, openPayload)
-
-    const { settle } = await import('./Session.js')
-    await expect(
-      settle(store, createServerClient([], wrongPayer), openPayload.channelId),
-    ).rejects.toThrow(/tx sender .* is not the channel payee/)
-  })
-
-  test('accepts settle sender matching a nonzero precompile operator', async () => {
-    const { store } = createServer()
-    const openPayload = await createOpenPayload({
-      operator: wrongPayer.address,
-    })
-    await persistPrecompileChannel(store, openPayload)
-
-    const { settle } = await import('./Session.js')
-    const client = createClient({
-      account: wrongPayer,
-      chain: testChain,
-      transport: custom({
-        async request(args) {
-          if (args.method === 'eth_chainId') return `0x${chainId.toString(16)}`
-          throw new Error(`unexpected rpc request: ${args.method}`)
-        },
-      }),
-    })
-    await expect(settle(store, client, openPayload.channelId)).rejects.toThrow(
-      /eth_getTransactionCount/,
-    )
-  })
-
-  test('precompile settle fee payer options still enforce payee sender policy', async () => {
-    const { store } = createServer()
-    const openPayload = await createOpenPayload()
-    await persistPrecompileChannel(store, openPayload)
-
-    const { settle } = await import('./Session.js')
-    await expect(
-      settle(store, createServerClient([], payer), openPayload.channelId, {
-        feePayer: wrongPayer,
-      }),
-    ).rejects.toThrow(/tx sender .* is not the channel payee/)
-  })
-
-  test('accepts precompile settle fee token options', async () => {
-    const { store } = createServer()
-    const openPayload = await createOpenPayload()
-    await persistPrecompileChannel(store, openPayload, {
-      payee: payer.address,
-    })
-    const client = createClient({
-      account: payer,
-      chain: testChain,
-      transport: custom({
-        async request(args) {
-          if (args.method === 'eth_chainId') return `0x${chainId.toString(16)}`
-          if (args.method === 'eth_sendTransaction') throw new Error('sent fee-token settle')
-          throw new Error(`unexpected rpc request: ${args.method}`)
-        },
-      }),
-    })
-
-    const { settle } = await import('./Session.js')
-    await expect(
-      settle(store, client, openPayload.channelId, {
-        feeToken: token,
-      }),
-    ).rejects.toThrow(/eth_getTransactionCount/)
-  })
-
-  test('accepts settle account override matching the channel payee', async () => {
-    const { store } = createServer()
-    const openPayload = await createOpenPayload()
-    await persistPrecompileChannel(store, openPayload, {
-      payee: wrongPayer.address,
-    })
-    const client = createClient({
-      account: payer,
-      chain: testChain,
-      transport: custom({
-        async request(args) {
-          if (args.method === 'eth_sendTransaction') throw new Error('sent settle transaction')
-          if (args.method === 'eth_chainId') return `0x${chainId.toString(16)}`
-          throw new Error(`unexpected rpc request: ${args.method}`)
-        },
-      }),
-    })
-
-    const { settle } = await import('./Session.js')
-    await expect(
-      settle(store, client, openPayload.channelId, {
-        account: wrongPayer,
-      }),
-    ).rejects.toThrow(/eth_getTransactionCount/)
-  })
-
-  test('rejects precompile settle fee-payer policy violations', async () => {
-    const { store } = createServer()
-    const openPayload = await createOpenPayload()
-    await persistPrecompileChannel(store, openPayload, {
-      payee: payer.address,
-    })
-
-    const { settle } = await import('./Session.js')
-    await expect(
-      settle(store, createServerClient([], payer), openPayload.channelId, {
-        feePayer: wrongPayer,
-        feePayerPolicy: { maxGas: 1n },
-        feeToken: token,
-      }),
-    ).rejects.toThrow(/fee-payer policy maxGas exceeded/)
-  })
-
-  test('rejects close voucher below local spent', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload()
-    await persistPrecompileChannel(store, openPayload, {
-      payee: payer.address,
-      spent: 150n,
-    })
-    const method = session({
-      account: payer,
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () => createStateClient(payer),
-    })
-    const payload = await ClientOps.createClosePayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(100n),
-      chainId,
-    )
-
-    await expect(
-      method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload,
-        },
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(/close voucher amount must be >= 150 \(spent\)/)
-  })
-
-  test('rejects close voucher below on-chain settled', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload()
-    await persistPrecompileChannel(store, openPayload, {
-      payee: payer.address,
-    })
-    const method = session({
-      account: payer,
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () =>
-        createStateClient(payer, {
-          settled: 100n,
-          deposit: 1_000n,
-          closeRequestedAt: 0,
-        }),
-    })
-    const payload = await ClientOps.createClosePayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(99n),
-      chainId,
-    )
-
-    await expect(
-      method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload,
-        },
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(/close voucher amount must be >= 100 \(on-chain settled\)/)
-  })
-
-  test('rejects close capture exceeding on-chain precompile deposit', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload()
-    await persistPrecompileChannel(store, openPayload, {
-      payee: payer.address,
-      spent: 100n,
-    })
-    const method = session({
-      account: payer,
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () =>
-        createStateClient(payer, {
-          settled: 0n,
-          deposit: 99n,
-          closeRequestedAt: 0,
-        }),
-    })
-    const payload = await ClientOps.createClosePayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(100n),
-      chainId,
-    )
-
-    await expect(
-      method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload,
-        },
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(/close capture amount exceeds on-chain deposit/)
-  })
-
-  test('rejects close for locally finalized and pending precompile channels', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload()
-    const payload = await ClientOps.createClosePayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(100n),
-      chainId,
-    )
-    const method = session({
-      account: payer,
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () => createStateClient(payer),
-    })
-
-    await persistPrecompileChannel(store, openPayload, {
-      finalized: true,
-      payee: payer.address,
-    })
-    await expect(
-      method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload,
-        },
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(/channel is already finalized/)
-
-    await persistPrecompileChannel(store, openPayload, {
-      closeRequestedAt: 1n,
-      payee: payer.address,
-    })
-    await expect(
-      method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload,
-        },
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(/channel has a pending close request/)
-  })
-
-  test('accepts valid precompile open with voucher and stores state', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    const method = session({
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () =>
-        createServerClient([], payer, openPayload.channelId, {
-          descriptor: openPayload.descriptor,
-          receipt: transactionReceipt([openedLog(openPayload)]),
-          state: { settled: 0n, deposit: 1_000n, closeRequestedAt: 0 },
-        }),
-    })
-
-    const receipt = (await method.verify({
-      credential: {
-        challenge: makeChallenge(openPayload.channelId),
-        payload: openPayload,
-      },
-      request: verifyRequest(openPayload.channelId),
-    })) as SessionReceipt
-
-    const stored = await store.getChannel(openPayload.channelId)
-    expect(receipt.acceptedCumulative).toBe('100')
-    expect(stored?.backend).toBe('precompile')
-    expect(stored?.deposit).toBe(1_000n)
-    expect(stored?.highestVoucherAmount).toBe(100n)
-    if (!stored || !ChannelStore.isPrecompileState(stored))
-      throw new Error('expected precompile state')
-    expect(stored.descriptor).toEqual(openPayload.descriptor)
-  })
-
-  test('reopening existing precompile channel with higher voucher updates highest voucher only', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    await persistPrecompileChannel(store, openPayload, {
-      highestVoucherAmount: 100n,
-      spent: 75n,
-      units: 3,
-    })
-    const reopenPayload = { ...openPayload, cumulativeAmount: '250' }
-    reopenPayload.signature = await Voucher.signVoucher(
-      createSigningClient(),
-      payer,
-      { channelId: openPayload.channelId, cumulativeAmount: 250n },
-      tip20ChannelEscrow,
-      chainId,
-    )
-    const method = session({
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () =>
-        createServerClient([], payer, openPayload.channelId, {
-          descriptor: openPayload.descriptor,
-          receipt: transactionReceipt([openedLog(openPayload)]),
-          state: { settled: 0n, deposit: 1_000n, closeRequestedAt: 0 },
-        }),
-    })
-
-    const receipt = (await method.verify({
-      credential: {
-        challenge: makeChallenge(openPayload.channelId),
-        payload: reopenPayload,
-      },
-      request: verifyRequest(openPayload.channelId),
-    })) as SessionReceipt
-
-    const stored = await store.getChannel(openPayload.channelId)
-    expect(receipt.acceptedCumulative).toBe('250')
-    expect(receipt.spent).toBe('75')
-    expect(receipt.units).toBe(3)
-    expect(stored?.highestVoucherAmount).toBe(250n)
-    expect(stored?.spent).toBe(75n)
-    expect(stored?.units).toBe(3)
-  })
-
-  test('reopening existing precompile channel with same voucher preserves accounting', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    await persistPrecompileChannel(store, openPayload, {
-      highestVoucherAmount: 100n,
-      spent: 75n,
-      units: 3,
-    })
-    const method = session({
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () =>
-        createServerClient([], payer, openPayload.channelId, {
-          descriptor: openPayload.descriptor,
-          receipt: transactionReceipt([openedLog(openPayload)]),
-          state: { settled: 0n, deposit: 1_000n, closeRequestedAt: 0 },
-        }),
-    })
-
-    const receipt = (await method.verify({
-      credential: {
-        challenge: makeChallenge(openPayload.channelId),
-        payload: openPayload,
-      },
-      request: verifyRequest(openPayload.channelId),
-    })) as SessionReceipt
-
-    const stored = await store.getChannel(openPayload.channelId)
-    expect(receipt.acceptedCumulative).toBe('100')
-    expect(receipt.spent).toBe('75')
-    expect(receipt.units).toBe(3)
-    expect(stored?.highestVoucherAmount).toBe(100n)
-    expect(stored?.spent).toBe(75n)
-    expect(stored?.units).toBe(3)
-  })
-
-  test('case-variant precompile channelId does not reset open accounting', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    await persistPrecompileChannel(store, openPayload, { spent: 75n, units: 3 })
-    const mixedCaseChannelId = openPayload.channelId.replace(/[a-f]/g, (char) =>
-      char.toUpperCase(),
-    ) as Hex
-    const method = session({
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () =>
-        createServerClient([], payer, openPayload.channelId, {
-          descriptor: openPayload.descriptor,
-          receipt: transactionReceipt([openedLog(openPayload)]),
-          state: { settled: 0n, deposit: 1_000n, closeRequestedAt: 0 },
-        }),
-    })
-
-    const receipt = (await method.verify({
-      credential: {
-        challenge: makeChallenge(mixedCaseChannelId),
-        payload: { ...openPayload, channelId: mixedCaseChannelId },
-      },
-      request: verifyRequest(mixedCaseChannelId),
-    })) as SessionReceipt
-
-    const stored = await store.getChannel(openPayload.channelId)
-    expect(receipt.spent).toBe('75')
-    expect(receipt.units).toBe(3)
-    expect(stored?.spent).toBe(75n)
-    expect(stored?.units).toBe(3)
-  })
-
-  test('uses payer as precompile voucher signer when authorized signer is zero', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload({
-      authorizedSigner: zeroAddress,
-      initialAmount: 100n,
-    })
-    expect(openPayload.descriptor.authorizedSigner).toBe(zeroAddress)
-    const method = session({
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () =>
-        createServerClient([], payer, openPayload.channelId, {
-          descriptor: openPayload.descriptor,
-          receipt: transactionReceipt([openedLog(openPayload)]),
-          state: { settled: 0n, deposit: 1_000n, closeRequestedAt: 0 },
-        }),
-    })
-
-    const receipt = (await method.verify({
-      credential: {
-        challenge: makeChallenge(openPayload.channelId),
-        payload: openPayload,
-      },
-      request: verifyRequest(openPayload.channelId),
-    })) as SessionReceipt
-
-    const stored = await store.getChannel(openPayload.channelId)
-    expect(receipt.acceptedCumulative).toBe('100')
-    expect(stored?.authorizedSigner).toBe(payer.address)
-  })
-
-  test('accepts precompile top-up and preserves spent accounting', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    await persistPrecompileChannel(store, openPayload, {
-      deposit: 1_000n,
-      spent: 125n,
-      units: 4,
-    })
-    const topUpPayload = await createTopUpPayload(openPayload.descriptor, 500n)
-    const method = session({
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () =>
-        createServerClient([], payer, topUpPayload.channelId, {
-          receipt: transactionReceipt([topUpLog(topUpPayload, 1_500n)]),
-          state: { settled: 0n, deposit: 1_500n, closeRequestedAt: 0 },
-        }),
-    })
-
-    const receipt = (await method.verify({
-      credential: {
-        challenge: makeChallenge(openPayload.channelId),
-        payload: topUpPayload,
-      },
-      request: verifyRequest(openPayload.channelId),
-    })) as SessionReceipt
-
-    const stored = await store.getChannel(openPayload.channelId)
-    expect(receipt.spent).toBe('125')
-    expect(receipt.units).toBe(4)
-    expect(stored?.deposit).toBe(1_500n)
-    expect(stored?.spent).toBe(125n)
-    expect(stored?.units).toBe(4)
-  })
-
-  test('rejects top-up validation when on-chain state has pending close', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    await persistPrecompileChannel(store, openPayload, { deposit: 1_000n })
-    const topUpPayload = await createTopUpPayload(openPayload.descriptor, 500n)
-    const method = session({
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () =>
-        createServerClient([], payer, topUpPayload.channelId, {
-          receipt: transactionReceipt([topUpLog(topUpPayload, 1_500n)]),
-          state: { settled: 0n, deposit: 1_500n, closeRequestedAt: 1 },
-        }),
-    })
-
-    await expect(
-      method.validate!({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload: topUpPayload,
-        },
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(/pending close request/)
-  })
-
-  test('rejects precompile top-up on unknown channel', async () => {
-    const { method } = createServer()
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    const topUpPayload = await createTopUpPayload(openPayload.descriptor, 500n)
-
-    await expect(
-      method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload: topUpPayload,
-        },
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(/channel not found/)
-  })
-
-  test('rejects precompile top-up descriptor mismatches', async () => {
-    const { method, store } = createServer()
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    await persistPrecompileChannel(store, openPayload)
-    const badDescriptor = { ...openPayload.descriptor, payee: wrongTarget }
-    const topUpPayload = await createTopUpPayload(badDescriptor, 500n)
-
-    await expect(
-      method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload: { ...topUpPayload, channelId: openPayload.channelId },
-        },
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(/descriptor does not match/)
-  })
-
-  test('accepts increasing precompile voucher and stores accounting state', async () => {
-    const { method, store } = createServer({ channelStateTtl: Number.MAX_SAFE_INTEGER })
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    await persistPrecompileChannel(store, openPayload, {
-      highestVoucherAmount: 100n,
-      spent: 100n,
-      units: 1,
-    })
-    const voucher = await ClientOps.createVoucherPayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(250n),
-      chainId,
-    )
-
-    const receipt = (await method.verify({
-      credential: voucherCredential(voucher, openPayload.channelId),
-      request: verifyRequest(openPayload.channelId),
-    })) as SessionReceipt
-
-    const stored = await store.getChannel(openPayload.channelId)
-    expect(receipt.acceptedCumulative).toBe('250')
-    expect(receipt.spent).toBe('100')
-    expect(receipt.units).toBe(1)
-    expect(stored?.highestVoucherAmount).toBe(250n)
-    expect(stored?.spent).toBe(100n)
-    expect(stored?.units).toBe(1)
-  })
-
-  test('accepts exact precompile voucher replay idempotently', async () => {
-    const { method, store } = createServer({ channelStateTtl: Number.MAX_SAFE_INTEGER })
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    const voucher = await ClientOps.createVoucherPayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(250n),
-      chainId,
-    )
-    if (voucher.action !== 'voucher') throw new Error('expected voucher payload')
-    await persistPrecompileChannel(store, openPayload, {
-      highestVoucherAmount: 250n,
-      highestVoucher: {
-        channelId: openPayload.channelId,
-        cumulativeAmount: 250n,
-        signature: voucher.signature,
-      },
-      spent: 250n,
-      units: 2,
-    })
-
-    const receipt = (await method.verify({
-      credential: voucherCredential(voucher, openPayload.channelId),
-      request: verifyRequest(openPayload.channelId),
-    })) as SessionReceipt
-
-    const stored = await store.getChannel(openPayload.channelId)
-    expect(receipt.acceptedCumulative).toBe('250')
-    expect(receipt.spent).toBe('250')
-    expect(receipt.units).toBe(2)
-    expect(stored?.highestVoucherAmount).toBe(250n)
-    expect(stored?.units).toBe(2)
-  })
-
-  test('rejects lower precompile voucher replay', async () => {
-    const { method, store } = createServer({ channelStateTtl: Number.MAX_SAFE_INTEGER })
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    await persistPrecompileChannel(store, openPayload, {
-      highestVoucherAmount: 500n,
-      spent: 500n,
-      units: 5,
-    })
-    const voucher = await ClientOps.createVoucherPayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(250n),
-      chainId,
-    )
-
-    await expect(
-      method.verify({
-        credential: voucherCredential(voucher, openPayload.channelId),
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(
-      /strictly greater than highest accepted voucher|non-increasing voucher|voucher replay/,
-    )
-  })
-
-  test('rejects precompile voucher below minVoucherDelta', async () => {
-    const { method, store } = createServer({
-      channelStateTtl: Number.MAX_SAFE_INTEGER,
-      minVoucherDelta: '200',
-    })
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    await persistPrecompileChannel(store, openPayload, { highestVoucherAmount: 100n })
-    const voucher = await ClientOps.createVoucherPayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(250n),
-      chainId,
-    )
-
-    await expect(
-      method.verify({
-        credential: voucherCredential(voucher, openPayload.channelId),
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(/voucher delta 150 below minimum 200/)
-  })
-
-  test('rejects idempotent precompile voucher replay after on-chain settlement catches up', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    await persistPrecompileChannel(store, openPayload, {
-      highestVoucherAmount: 500n,
-      settledOnChain: 500n,
-      spent: 500n,
-      units: 10,
-    })
-    const voucher = await ClientOps.createVoucherPayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(500n),
-      chainId,
-    )
-    const method = session({
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () =>
-        createStateClient(payer, { settled: 500n, deposit: 1_000n, closeRequestedAt: 0 }),
-    })
-
-    await expect(
-      method.verify({
-        credential: voucherCredential(voucher, openPayload.channelId),
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(/below on-chain settled amount/)
-  })
-
-  test('rejects stale or hijacked precompile voucher signatures', async () => {
-    const { method, store } = createServer({ channelStateTtl: Number.MAX_SAFE_INTEGER })
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    await persistPrecompileChannel(store, openPayload, { highestVoucherAmount: 100n })
-    const signature = await Voucher.signVoucher(
-      createSigningClient(wrongPayer),
-      wrongPayer,
-      { channelId: openPayload.channelId, cumulativeAmount: 250n },
-      tip20ChannelEscrow,
-      chainId,
-    )
-
-    await expect(
-      method.verify({
-        credential: voucherCredential(
-          {
-            action: 'voucher',
-            channelId: openPayload.channelId,
-            cumulativeAmount: '250',
-            descriptor: openPayload.descriptor,
-            signature,
-          },
-          openPayload.channelId,
-        ),
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(/invalid voucher signature/)
-  })
-
-  test('rejects precompile voucher exceeding deposit', async () => {
-    const { method, store } = createServer({ channelStateTtl: Number.MAX_SAFE_INTEGER })
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    await persistPrecompileChannel(store, openPayload, { deposit: 300n })
-    const voucher = await ClientOps.createVoucherPayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(350n),
-      chainId,
-    )
-
-    await expect(
-      method.verify({
-        credential: voucherCredential(voucher, openPayload.channelId),
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(/exceeds.*deposit|insufficient channel deposit/)
-  })
-
-  test('rejects precompile voucher when on-chain state has pending close', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    await persistPrecompileChannel(store, openPayload, { closeRequestedAt: 0n })
-    const voucher = await ClientOps.createVoucherPayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(250n),
-      chainId,
-    )
-    const method = session({
-      amount: '1',
-      chainId,
-      channelStateTtl: 0,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () =>
-        createStateClient(payer, { settled: 0n, deposit: 1_000n, closeRequestedAt: 1 }),
-    })
-
-    await expect(
-      method.verify({
-        credential: voucherCredential(voucher, openPayload.channelId),
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(/pending close request/)
-  })
-
-  test('rejects precompile voucher when on-chain deposit is zero', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    await persistPrecompileChannel(store, openPayload, { deposit: 1_000n })
-    const voucher = await ClientOps.createVoucherPayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(250n),
-      chainId,
-    )
-    const method = session({
-      amount: '1',
-      chainId,
-      channelStateTtl: 0,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () => createStateClient(payer, { settled: 0n, deposit: 0n, closeRequestedAt: 0 }),
-    })
-
-    await expect(
-      method.verify({
-        credential: voucherCredential(voucher, openPayload.channelId),
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(/deposit is zero|channel deposit is zero|not found/)
-  })
-
-  test('rejects precompile voucher on unknown channel', async () => {
-    const { method } = createServer({ channelStateTtl: Number.MAX_SAFE_INTEGER })
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    const voucher = await ClientOps.createVoucherPayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(250n),
-      chainId,
-    )
-
-    await expect(
-      method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload: voucher,
-        },
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(/unknown channel|not found/)
-  })
-
-  describe('respond', () => {
-    function respond(action: SessionCredentialPayload['action'], input: Request) {
-      const { method } = createServer()
-      return method.respond!({
-        credential: {
-          challenge: makeChallenge(`0x${'01'.repeat(32)}` as Hex),
-          payload: { action },
-        },
-        input,
-      } as never)
-    }
-
-    test('returns 204 for close management requests', () => {
-      const result = respond('close', new Request('http://localhost', { method: 'GET' }))
-      expect(result).toBeInstanceOf(Response)
-      expect((result as Response).status).toBe(204)
-    })
-
-    test('returns 204 for top-up management requests', () => {
-      const result = respond('topUp', new Request('http://localhost', { method: 'POST' }))
-      expect(result).toBeInstanceOf(Response)
-      expect((result as Response).status).toBe(204)
-    })
-
-    test('returns 204 for open POST management requests', () => {
-      const result = respond('open', new Request('http://localhost', { method: 'POST' }))
-      expect(result).toBeInstanceOf(Response)
-      expect((result as Response).status).toBe(204)
-    })
-
-    test('returns 204 for voucher POST management requests', () => {
-      const result = respond('voucher', new Request('http://localhost', { method: 'POST' }))
-      expect(result).toBeInstanceOf(Response)
-      expect((result as Response).status).toBe(204)
-    })
-
-    test('lets open and voucher GET content requests through', () => {
-      expect(respond('open', new Request('http://localhost', { method: 'GET' }))).toBeUndefined()
-      expect(respond('voucher', new Request('http://localhost', { method: 'GET' }))).toBeUndefined()
-    })
-
-    test('lets open and voucher POST content requests with bodies through', () => {
-      expect(
-        respond(
-          'open',
-          new Request('http://localhost', { method: 'POST', headers: { 'content-length': '1' } }),
-        ),
-      ).toBeUndefined()
-      expect(
-        respond(
-          'voucher',
-          new Request('http://localhost', {
-            method: 'POST',
-            headers: { 'transfer-encoding': 'chunked' },
-          }),
-        ),
-      ).toBeUndefined()
-    })
-
-    test('returns 204 for voucher POST with content-length zero', () => {
-      const result = respond(
-        'voucher',
-        new Request('http://localhost', { method: 'POST', headers: { 'content-length': '0' } }),
-      )
-      expect(result).toBeInstanceOf(Response)
-      expect((result as Response).status).toBe(204)
-    })
-  })
-
-  describe('default HTTP auto-billing', () => {
-    function createRoute(rawStore: Store.AtomicStore) {
-      return Mppx_server.create({
-        methods: [
-          tempo_server.session({
-            amount: '1',
-            chainId,
-            currency: token,
-            decimals: 0,
-            recipient: payee,
-            store: rawStore,
-            unitType: 'request',
-            getClient: () => createStateClient(payer),
-          }),
-        ],
-        realm: 'api.example.com',
-        secretKey: 'test-secret-key-test-secret-key-32',
-      }).session({ amount: '1', decimals: 0, unitType: 'request' })
-    }
-
-    test('GET content flow charges once and rejects same-voucher replay', async () => {
-      const rawStore = Store.memory()
-      const store = channelStore(rawStore)
-      const openPayload = await createOpenPayload({ initialAmount: 1n })
-      await persistPrecompileChannel(store, openPayload, {
-        highestVoucherAmount: 1n,
-        spent: 0n,
-        units: 0,
-      })
-      const route = createRoute(rawStore)
-      const voucher = await ClientOps.createVoucherPayload(
-        createSigningClient(),
-        payer,
-        openPayload.descriptor,
-        Types.uint96(1n),
-        chainId,
-      )
-
-      const serve = async (request: Request) => {
-        const result = await route(request)
-        if (result.status === 402) return result.challenge
-        return result.withReceipt(new Response('paid-content'))
-      }
-
-      const first = await route(new Request('https://api.example.com/resource'))
-      expect(first.status).toBe(402)
-      if (first.status !== 402) throw new Error('expected challenge')
-
-      const paid = await serve(
-        new Request('https://api.example.com/resource', {
-          headers: {
-            Authorization: Credential.serialize({
-              challenge: Challenge.fromResponse(first.challenge),
-              payload: voucher,
-              source: sourceFor(),
-            }),
-          },
-        }),
-      )
-      expect(paid.status).toBe(200)
-      expect(await paid.text()).toBe('paid-content')
-      const receipt = deserializeSessionReceipt(paid.headers.get('Payment-Receipt') as string)
-      expect(receipt.acceptedCumulative).toBe('1')
-      expect(receipt.spent).toBe('1')
-      expect(receipt.units).toBe(1)
-
-      const replayChallenge = await route(new Request('https://api.example.com/resource'))
-      expect(replayChallenge.status).toBe(402)
-      if (replayChallenge.status !== 402) throw new Error('expected challenge')
-
-      const replay = await serve(
-        new Request('https://api.example.com/resource', {
-          headers: {
-            Authorization: Credential.serialize({
-              challenge: Challenge.fromResponse(replayChallenge.challenge),
-              payload: voucher,
-              source: sourceFor(),
-            }),
-          },
-        }),
-      )
-      expect(replay.status).toBe(402)
-      expect(replay.headers.get('Payment-Receipt')).toBeNull()
-    })
-
-    test('POST content flow charges once and rejects same-voucher replay', async () => {
-      const rawStore = Store.memory()
-      const store = channelStore(rawStore)
-      const openPayload = await createOpenPayload({ initialAmount: 1n })
-      await persistPrecompileChannel(store, openPayload)
-      const route = createRoute(rawStore)
-      const voucher = await ClientOps.createVoucherPayload(
-        createSigningClient(),
-        payer,
-        openPayload.descriptor,
-        Types.uint96(1n),
-        chainId,
-      )
-      const makeRequest = (authorization?: string) =>
-        new Request('https://api.example.com/resource', {
-          method: 'POST',
-          body: '{}',
-          headers: {
-            'content-length': '2',
-            'content-type': 'application/json',
-            ...(authorization ? { Authorization: authorization } : {}),
-          },
-        })
-
-      const first = await route(makeRequest())
-      expect(first.status).toBe(402)
-      if (first.status !== 402) throw new Error('expected challenge')
-
-      const result = await route(
-        makeRequest(
-          Credential.serialize({
-            challenge: Challenge.fromResponse(first.challenge),
-            payload: voucher,
-            source: sourceFor(),
-          }),
-        ),
-      )
-      expect(result.status).toBe(200)
-      if (result.status !== 200) throw new Error('expected paid response')
-      const paid = result.withReceipt(new Response('paid-content'))
-      const receipt = deserializeSessionReceipt(paid.headers.get('Payment-Receipt') as string)
-      expect(receipt.spent).toBe('1')
-      expect(receipt.units).toBe(1)
-
-      const replayChallenge = await route(makeRequest())
-      expect(replayChallenge.status).toBe(402)
-      if (replayChallenge.status !== 402) throw new Error('expected challenge')
-      const replay = await route(
-        makeRequest(
-          Credential.serialize({
-            challenge: Challenge.fromResponse(replayChallenge.challenge),
-            payload: voucher,
-            source: sourceFor(),
-          }),
-        ),
-      )
-      expect(replay.status).toBe(402)
-      if (replay.status !== 402) throw new Error('expected challenge')
-      expect(replay.challenge.headers.get('Payment-Receipt')).toBeNull()
-    })
-
-    test('verification errors do not include Payment-Receipt', async () => {
-      const rawStore = Store.memory()
-      const store = channelStore(rawStore)
-      const openPayload = await createOpenPayload({ initialAmount: 100n })
-      await persistPrecompileChannel(store, openPayload)
-      const route = createRoute(rawStore)
-      const first = await route(new Request('https://api.example.com/resource'))
-      expect(first.status).toBe(402)
-      if (first.status !== 402) throw new Error('expected challenge')
-
-      const failed = await route(
-        new Request('https://api.example.com/resource', {
-          headers: {
-            Authorization: Credential.serialize({
-              challenge: Challenge.fromResponse(first.challenge),
-              payload: {
-                action: 'voucher',
-                channelId: openPayload.channelId,
-                cumulativeAmount: '100',
-                descriptor: openPayload.descriptor,
-                signature: (await createOpenPayload({ account: wrongPayer })).signature,
-              },
-              source: sourceFor(),
-            }),
-          },
-        }),
-      )
-
-      expect(failed.status).toBe(402)
-      if (failed.status !== 402) throw new Error('expected challenge')
-      expect(failed.challenge.headers.get('Payment-Receipt')).toBeNull()
-    })
-  })
-
-  describe('same-route bootstrap', () => {
-    function createBootstrapRoute(parameters: {
-      rawStore: Store.AtomicStore
-      recipient?: Address | undefined
-      resolveChannelId?: ResolveSessionChannelId | undefined
-    }) {
-      return Mppx_server.create({
-        methods: [
-          tempo_server.session({
-            amount: '1',
-            bootstrap: true,
-            chainId,
-            currency: token,
-            decimals: 0,
-            getClient: () => createStateClient(payer),
-            recipient: parameters.recipient ?? payee,
-            resolveChannelId: parameters.resolveChannelId,
-            store: parameters.rawStore,
-            unitType: 'request',
-          }),
-        ],
-        realm: 'api.example.com',
-        secretKey: 'test-secret-key-test-secret-key-32',
-      }).session({ amount: '1', decimals: 0, unitType: 'request' })
-    }
-
-    async function createBootstrapCredential(response: Response) {
-      const challenge = Challenge.fromResponse(response)
-      const method = clientCharge({
-        account: payer,
-        getClient: () => createSigningClient(),
-      })
-      return method.createCredential({ challenge: challenge as never, context: {} })
-    }
-
-    async function bootstrapResponse(
-      route: ReturnType<typeof createBootstrapRoute>,
-      authorization?: string,
-    ) {
-      const result = await route(
-        new Request('https://api.example.com/resource', {
-          method: 'HEAD',
-          ...(authorization ? { headers: { Authorization: authorization } } : {}),
-        }),
-      )
-      if (result.status === 402) return result.challenge
-      return result.withReceipt(new Response(null, { status: 500 }))
-    }
-
-    test('HEAD without auth emits a zero-amount tempo charge challenge', async () => {
-      const route = createBootstrapRoute({ rawStore: Store.memory() })
-
-      const response = await bootstrapResponse(route)
-      const challenge = Challenge.fromResponse(response)
-
-      expect(response.status).toBe(402)
-      expect(challenge.method).toBe('tempo')
-      expect(challenge.intent).toBe('charge')
-      expect(challenge.request.amount).toBe('0')
-    })
-
-    test('valid proof resolves channel by source and returns snapshot headers', async () => {
-      const rawStore = Store.memory()
-      const store = channelStore(rawStore)
-      const openPayload = await createOpenPayload({ initialAmount: 1n })
-      const highestVoucher = await ClientOps.createVoucherPayload(
-        createSigningClient(),
-        payer,
-        openPayload.descriptor,
-        Types.uint96(5n),
-        chainId,
-      )
-      if (highestVoucher.action !== 'voucher') throw new Error('expected voucher payload')
-      await persistPrecompileChannel(store, openPayload, {
-        highestVoucherAmount: 5n,
-        highestVoucher: {
-          channelId: openPayload.channelId,
-          cumulativeAmount: 5n,
-          signature: highestVoucher.signature,
-        },
-        spent: 3n,
-        units: 3,
-      })
-      const resolveChannelId = vi.fn(({ source }) => {
-        expect(source).toContain(payer.address)
-        return openPayload.channelId
-      })
-      const route = createBootstrapRoute({ rawStore, resolveChannelId })
-      const challengeResponse = await bootstrapResponse(route)
-      const authorization = await createBootstrapCredential(challengeResponse)
-
-      const response = await bootstrapResponse(route, authorization)
-
-      expect(response.status).toBe(204)
-      expect(resolveChannelId).toHaveBeenCalledOnce()
-      expect(response.headers.get(Constants.Headers.paymentSession)).toBe(openPayload.channelId)
-      const snapshot = session.deserializeSnapshot(
-        response.headers.get(Constants.Headers.paymentSessionSnapshot)!,
-      )
-      expect(snapshot).toMatchObject({
-        channelId: openPayload.channelId,
-        acceptedCumulative: '5',
-        highestVoucher: {
-          channelId: openPayload.channelId,
-          cumulativeAmount: '5',
-        },
-        requiredCumulative: '3',
-        spent: '3',
-      })
-    })
-
-    test('valid proof with no resolved channel returns empty 204', async () => {
-      const rawStore = Store.memory()
-      const route = createBootstrapRoute({
-        rawStore,
-        resolveChannelId: () => undefined,
-      })
-      const authorization = await createBootstrapCredential(await bootstrapResponse(route))
-
-      const response = await bootstrapResponse(route, authorization)
-
-      expect(response.status).toBe(204)
-      expect(response.headers.get(Constants.Headers.paymentSession)).toBeNull()
-      expect(response.headers.get(Constants.Headers.paymentSessionSnapshot)).toBeNull()
-    })
-
-    test('valid proof does not return snapshots for channels with different payment fields', async () => {
-      const rawStore = Store.memory()
-      const store = channelStore(rawStore)
-      const openPayload = await createOpenPayload({ initialAmount: 1n })
-      await persistPrecompileChannel(store, openPayload)
-      const route = createBootstrapRoute({
-        rawStore,
-        recipient: '0x0000000000000000000000000000000000000004',
-        resolveChannelId: () => openPayload.channelId,
-      })
-      const authorization = await createBootstrapCredential(await bootstrapResponse(route))
-
-      const response = await bootstrapResponse(route, authorization)
-
-      expect(response.status).toBe(204)
-      expect(response.headers.get(Constants.Headers.paymentSession)).toBeNull()
-      expect(response.headers.get(Constants.Headers.paymentSessionSnapshot)).toBeNull()
-    })
-
-    test('replayed proof is rejected before channel resolution', async () => {
-      const rawStore = Store.memory()
-      const resolveChannelId = vi.fn(() => undefined)
-      const route = createBootstrapRoute({ rawStore, resolveChannelId })
-      const authorization = await createBootstrapCredential(await bootstrapResponse(route))
-
-      expect((await bootstrapResponse(route, authorization)).status).toBe(204)
-      const replay = await bootstrapResponse(route, authorization)
-
-      expect(replay.status).toBe(402)
-      expect(resolveChannelId).toHaveBeenCalledOnce()
-    })
-  })
-
-  describe('SSE parity', () => {
-    function createManagedSseFetch(
-      options: {
-        amount?: string
-        chunkDelayMs?: number
-        maxDeposit?: bigint
-        onSessionSettlement?: session.Parameters['onSessionSettlement']
-        settlementSchedule?: session.Parameters['settlementSchedule']
-        unitType?: 'request' | 'token'
-      } = {},
-    ) {
-      const rawStore = Store.memory()
-      let activeChannelId: Hex | undefined
-      let currentPayload: SessionCredentialPayload | undefined
-      let voucherPosts = 0
-      const amount = options.amount ?? '1'
-      const maxDeposit = options.maxDeposit ?? 3n
-      let deposit = maxDeposit
-      let settled = 0n
-      const unitType = options.unitType ?? 'token'
-      const route = Mppx_server.create({
-        methods: [
-          tempo_server.session({
-            amount,
-            chainId,
-            currency: token,
-            decimals: 0,
-            recipient: payer.address,
-            onSessionSettlement: options.onSessionSettlement,
-            settlementSchedule: options.settlementSchedule,
-            sse: true,
-            store: rawStore,
-            unitType,
-            getClient: () => {
-              const payload = currentPayload
-              if (payload?.action === 'open') {
-                return createServerClient([], payer, payload.channelId, {
-                  descriptor: payload.descriptor,
-                  receipt: transactionReceipt([openedLog(payload, maxDeposit)]),
-                  state: { settled: 0n, deposit: maxDeposit, closeRequestedAt: 0 },
-                })
-              }
-              if (payload?.action === 'close') {
-                return createServerClient([], payer, payload.channelId, {
-                  receipt: transactionReceipt([
-                    closedLog(payload.channelId, BigInt(payload.cumulativeAmount), 0n),
-                  ]),
-                  state: { settled, deposit, closeRequestedAt: 0 },
-                })
-              }
-              if (payload?.action === 'topUp') {
-                deposit += BigInt(payload.additionalDeposit)
-                return createServerClient([], payer, payload.channelId, {
-                  receipt: transactionReceipt([topUpLog(payload, deposit)]),
-                  state: { settled, deposit, closeRequestedAt: 0 },
-                })
-              }
-              return createServerClient([], payer, undefined, {
-                sentReceipt: async () => {
-                  if (!activeChannelId) throw new Error('missing channel context')
-                  const channel = await channelStore(rawStore).getChannel(activeChannelId)
-                  settled = channel?.highestVoucherAmount ?? settled
-                  return transactionReceipt([settledLog(activeChannelId, settled)])
-                },
-                state: () => ({ settled, deposit, closeRequestedAt: 0 }),
-              })
-            },
-          }),
-        ],
-        realm: 'api.example.com',
-        secretKey: 'test-secret-key-test-secret-key-32',
-      }).session({ amount, decimals: 0, suggestedDeposit: maxDeposit.toString(), unitType })
-
-      const handle = async (request: Request) => {
-        currentPayload = undefined
-        if (request.headers.has('Authorization')) {
-          try {
-            currentPayload = Credential.fromRequest<SessionCredentialPayload>(request).payload
-            activeChannelId = currentPayload.channelId
-            if (currentPayload.action === 'voucher') voucherPosts++
-          } catch {}
-        }
-
-        const result = await route(request)
-        if (result.status === 402) return result.challenge
-        if (request.method === 'POST') return result.withReceipt()
-
-        if (request.headers.get('Accept')?.includes('text/event-stream')) {
-          if (unitType === 'request') {
-            const encoder = new TextEncoder()
-            return result.withReceipt(
-              new Response(
-                new ReadableStream({
-                  start(controller) {
-                    controller.enqueue(encoder.encode('event: message\ndata: chunk-1\n\n'))
-                    controller.enqueue(encoder.encode('event: message\ndata: chunk-2\n\n'))
-                    controller.enqueue(encoder.encode('event: message\ndata: chunk-3\n\n'))
-                    controller.close()
-                  },
-                }),
-                { headers: { 'Content-Type': 'text/event-stream; charset=utf-8' } },
-              ),
-            )
-          }
-
-          currentPayload = undefined
-          return result.withReceipt(async function* (stream) {
-            await stream.charge()
-            yield 'chunk-1'
-            if (options.chunkDelayMs)
-              await new Promise((resolve) => setTimeout(resolve, options.chunkDelayMs))
-            await stream.charge()
-            yield 'chunk-2'
-            await stream.charge()
-            yield 'chunk-3'
-          })
-        }
-
-        return result.withReceipt(new Response('ok'))
-      }
-
-      const fetch = async (input: RequestInfo | URL, init?: RequestInit) =>
-        handle(new Request(input, init))
-
-      return {
-        fetch,
-        handle,
-        rawStore,
-        get voucherPosts() {
-          return voucherPosts
-        },
-      }
-    }
-
-    test('open -> stream -> need-voucher -> resume -> close', async () => {
-      const harness = createManagedSseFetch({ maxDeposit: 3n })
-      const manager = precompileSessionManager({
-        account: payer,
-        client: createSigningClient(),
-        decimals: 0,
-        fetch: harness.fetch,
-        maxDeposit: '3',
-      })
-
-      const chunks: string[] = []
-      const stream = await manager.sse('https://api.example.com/stream')
-      for await (const chunk of stream) chunks.push(chunk)
-
-      expect(chunks).toEqual(['chunk-1', 'chunk-2', 'chunk-3'])
-      expect(harness.voucherPosts).toBeGreaterThan(0)
-
-      const closeReceipt = await manager.close()
-      expect(closeReceipt?.status).toBe('success')
-      expect(closeReceipt?.spent).toBe('3')
-
-      const channelId = manager.channelId
-      expect(channelId).toBeTruthy()
-      const persisted = await channelStore(harness.rawStore).getChannel(channelId!)
-      expect(persisted?.finalized).toBe(true)
-    })
-
-    test.each([
-      ['unit', { units: 2 }, 0],
-      ['amount', { amount: '2' }, 0],
-      ['interval', { intervalMs: 500 }, 750],
-    ] as const)(
-      'applies the %s settlement schedule after SSE charges',
-      async (_label, settlementSchedule, chunkDelayMs) => {
-        const settlements: Array<{ delta: bigint; trigger: string }> = []
-        const harness = createManagedSseFetch({
-          chunkDelayMs,
-          maxDeposit: 3n,
-          settlementSchedule,
-          onSessionSettlement(context) {
-            settlements.push({ delta: context.delta, trigger: context.trigger })
-          },
-        })
-        const manager = precompileSessionManager({
-          account: payer,
-          client: createSigningClient(),
-          decimals: 0,
-          fetch: harness.fetch,
-          maxDeposit: '3',
-        })
-
-        const chunks: string[] = []
-        for await (const chunk of await manager.sse('https://api.example.com/stream')) {
-          chunks.push(chunk)
-        }
-
-        expect(chunks).toEqual(['chunk-1', 'chunk-2', 'chunk-3'])
-        expect(harness.voucherPosts).toBeGreaterThan(0)
-        expect(settlements).toEqual([{ delta: 2n, trigger: 'scheduled' }])
-        const persisted = await channelStore(harness.rawStore).getChannel(manager.channelId!)
-        expect(persisted?.lastSettlementUnits).toBe(2)
-
-        await manager.close()
-        expect(settlements).toEqual([
-          { delta: 2n, trigger: 'scheduled' },
-          { delta: 1n, trigger: 'close' },
-        ])
-      },
-    )
-
-    test('handles empty management POST streams through a Node adapter', async () => {
-      const harness = createManagedSseFetch({ maxDeposit: 1n })
-      const managementPosts: Array<{
-        action: SessionCredentialPayload['action']
-        contentLength: string | null
-        hasBody: boolean
-        hasReceipt: boolean
-        status: number
-      }> = []
-      const app = new Hono()
-      app.all('*', async (c) => {
-        const request = c.req.raw
-        const payload = request.headers.has('Authorization')
-          ? Credential.fromRequest<SessionCredentialPayload>(request).payload
-          : undefined
-        const response = await harness.handle(request)
-        if (request.method === 'POST' && payload)
-          managementPosts.push({
-            action: payload.action,
-            contentLength: request.headers.get('content-length'),
-            hasBody: request.body !== null,
-            hasReceipt: response.headers.has(Constants.Headers.paymentReceipt),
-            status: response.status,
-          })
-        return response
-      })
-      const server = serve({ fetch: app.fetch, port: 0 })
-      await new Promise<void>((resolve) => server.once('listening', resolve))
-      const address = server.address()
-      if (!address || typeof address === 'string') throw new Error('expected TCP address')
-
-      try {
-        const fetch: typeof globalThis.fetch = async (input, init) => {
-          const response = await globalThis.fetch(input, init)
-          return new Response(response.body, response)
-        }
-        const manager = precompileSessionManager({
-          account: payer,
-          client: createSigningClient(),
-          decimals: 0,
-          fetch,
-          maxDeposit: '3',
-        })
-
-        const chunks: string[] = []
-        const stream = await manager.sse(`http://localhost:${address.port}/stream`)
-        for await (const chunk of stream) chunks.push(chunk)
-
-        expect(chunks).toEqual(['chunk-1', 'chunk-2', 'chunk-3'])
-        const closeReceipt = await manager.close()
-        expect(closeReceipt?.spent).toBe('3')
-        expect(managementPosts).toEqual(
-          expect.arrayContaining([
-            {
-              action: 'topUp',
-              contentLength: '0',
-              hasBody: true,
-              hasReceipt: true,
-              status: 204,
-            },
-            {
-              action: 'voucher',
-              contentLength: '0',
-              hasBody: true,
-              hasReceipt: true,
-              status: 204,
-            },
-            {
-              action: 'close',
-              contentLength: '0',
-              hasBody: true,
-              hasReceipt: true,
-              status: 204,
-            },
-          ]),
-        )
-        expect(managementPosts.every(({ status }) => status === 204)).toBe(true)
-
-        const persisted = await channelStore(harness.rawStore).getChannel(manager.channelId!)
-        expect(persisted?.finalized).toBe(true)
-      } finally {
-        server.close()
-      }
-    })
-
-    test('unitType=request auto-metered SSE responses charge once across the stream', async () => {
-      const harness = createManagedSseFetch({ maxDeposit: 1n, unitType: 'request' })
-      const manager = precompileSessionManager({
-        account: payer,
-        client: createSigningClient(),
-        decimals: 0,
-        fetch: harness.fetch,
-        maxDeposit: '1',
-      })
-
-      const chunks: string[] = []
-      const stream = await manager.sse('https://api.example.com/stream')
-      for await (const chunk of stream) chunks.push(chunk)
-
-      expect(chunks).toEqual(['chunk-1', 'chunk-2', 'chunk-3'])
-      expect(harness.voucherPosts).toBe(0)
-
-      const closeReceipt = await manager.close()
-      expect(closeReceipt?.status).toBe('success')
-      expect(closeReceipt?.spent).toBe('1')
-    })
-  })
-
-  describe('WebSocket parity', () => {
-    async function createManagedWsHarness(
-      options: {
-        challengeTtlMs?: number
-        maxDeposit?: bigint
-        onSessionSettlement?: session.Parameters['onSessionSettlement']
-        settlementSchedule?: session.Parameters['settlementSchedule']
-      } = {},
-    ) {
-      const rawStore = Store.memory()
-      let activeChannelId: Hex | undefined
-      let challengeRequests = 0
-      let currentPayload: SessionCredentialPayload | undefined
-      let settled = 0n
-      let voucherPosts = 0
-      const maxDeposit = options.maxDeposit ?? 3n
-      const payment = Mppx_server.create({
-        methods: [
-          tempo_server.session({
-            amount: '1',
-            chainId,
-            currency: token,
-            decimals: 0,
-            onSessionSettlement: options.onSessionSettlement,
-            recipient: payer.address,
-            settlementSchedule: options.settlementSchedule,
-            store: rawStore,
-            unitType: 'token',
-            getClient: () => {
-              const payload = currentPayload
-              if (payload?.action === 'open') {
-                return createServerClient([], payer, payload.channelId, {
-                  descriptor: payload.descriptor,
-                  receipt: transactionReceipt([openedLog(payload, maxDeposit)]),
-                  state: { settled: 0n, deposit: maxDeposit, closeRequestedAt: 0 },
-                })
-              }
-              if (payload?.action === 'close') {
-                return createServerClient([], payer, payload.channelId, {
-                  receipt: transactionReceipt([
-                    closedLog(payload.channelId, BigInt(payload.cumulativeAmount), 0n),
-                  ]),
-                  state: { settled, deposit: maxDeposit, closeRequestedAt: 0 },
-                })
-              }
-              return createServerClient([], payer, undefined, {
-                sentReceipt: async () => {
-                  if (!activeChannelId) throw new Error('missing channel context')
-                  const channel = await channelStore(rawStore).getChannel(activeChannelId)
-                  settled = channel?.highestVoucherAmount ?? settled
-                  return transactionReceipt([settledLog(activeChannelId, settled)])
-                },
-                state: () => ({ settled, deposit: maxDeposit, closeRequestedAt: 0 }),
-              })
-            },
-          }),
-        ],
-        realm: 'api.example.com',
-        secretKey: 'test-secret-key-test-secret-key-32',
-      })
-
-      const routeOptions = () => ({
-        amount: '1',
-        decimals: 0,
-        suggestedDeposit: maxDeposit.toString(),
-        ...(options.challengeTtlMs === undefined
-          ? {}
-          : { expires: new Date(Date.now() + options.challengeTtlMs) }),
-      })
-      const route = async (request: Request) => {
-        currentPayload = undefined
-        if (request.headers.has('Authorization')) {
-          try {
-            currentPayload = Credential.fromRequest<SessionCredentialPayload>(request).payload
-            activeChannelId = currentPayload.channelId
-            if (currentPayload.action === 'voucher') voucherPosts++
-          } catch {}
-        } else challengeRequests++
-        const result = await payment.session(routeOptions())(request)
-        currentPayload = undefined
-        return result
-      }
-
-      const httpHandler = NodeRequest.toNodeListener(async (request) => {
-        const result = await route(request)
-        if (result.status === 402) return result.challenge
-        return result.withReceipt(new Response('ok'))
-      })
-
-      const nodeServer = node_http.createServer(httpHandler)
-      const wsServer = new WebSocketServer({ noServer: true })
-
-      await new Promise<void>((resolve) => nodeServer.listen(0, resolve))
-      const { port } = nodeServer.address() as { port: number }
-      const server = Http.wrapServer(nodeServer, {
-        port,
-        url: `http://localhost:${port}`,
-      })
-
-      nodeServer.on('upgrade', (req, socket, head) => {
-        if (req.url !== '/ws') {
-          socket.destroy()
-          return
-        }
-        wsServer.handleUpgrade(req, socket, head, (websocket) => {
-          wsServer.emit('connection', websocket, req)
-        })
-      })
-
-      return {
-        rawStore,
-        route,
-        serveWebSocket: payment.session.serveWebSocket,
-        server,
-        wsServer,
-        get port() {
-          return port
-        },
-        get challengeRequests() {
-          return challengeRequests
-        },
-        get voucherPosts() {
-          return voucherPosts
-        },
-        close() {
-          wsServer.close()
-          server.close()
-        },
-      }
-    }
-
-    test('refreshes an expired challenge before sending a later websocket voucher', async () => {
-      const harness = await createManagedWsHarness({ challengeTtlMs: 2_000, maxDeposit: 2n })
-      harness.wsServer.on('connection', (socket: import('ws').WebSocket) => {
-        void harness.serveWebSocket({
-          socket,
-          url: `${harness.server.url}/ws`,
-          route: harness.route,
-          generate: async function* (stream: TempoWs.SessionController) {
-            await stream.charge()
-            yield 'chunk-1'
-            await new Promise((resolve) => setTimeout(resolve, 2_200))
-            await stream.charge()
-            yield 'chunk-2'
-          },
-        })
-      })
-
-      try {
-        const manager = precompileSessionManager({
-          account: payer,
-          client: createSigningClient(),
-          decimals: 0,
-          fetch: globalThis.fetch,
-          maxDeposit: '2',
-          webSocket: WebSocket as never,
-        })
-        const ws = await manager.ws(`ws://localhost:${harness.port}/ws`)
-        const chunks: string[] = []
-
-        await new Promise<void>((resolve, reject) => {
-          ws.addEventListener('message', (event) => {
-            if (typeof event.data === 'string') chunks.push(event.data)
-          })
-          ws.addEventListener('close', () => resolve(), { once: true })
-          ws.addEventListener('error', () => reject(new Error('websocket stream failed')), {
-            once: true,
-          })
-        })
-
-        expect(chunks).toEqual(['chunk-1', 'chunk-2'])
-        expect(harness.challengeRequests).toBeGreaterThan(1)
-        expect(harness.voucherPosts).toBe(1)
-      } finally {
-        harness.close()
-      }
-    })
-
-    test('open -> stream -> need-voucher -> resume -> close', async () => {
-      const harness = await createManagedWsHarness({ maxDeposit: 3n })
-      harness.wsServer.on('connection', (socket: import('ws').WebSocket) => {
-        void harness.serveWebSocket({
-          socket,
-          url: `${harness.server.url}/ws`,
-          route: harness.route,
-          generate: async function* (stream: TempoWs.SessionController) {
-            await stream.charge()
-            yield 'chunk-1'
-            await stream.charge()
-            yield 'chunk-2'
-            await stream.charge()
-            yield 'chunk-3'
-          },
-        })
-      })
-
-      try {
-        const manager = precompileSessionManager({
-          account: payer,
-          client: createSigningClient(),
-          decimals: 0,
-          fetch: globalThis.fetch,
-          maxDeposit: '3',
-          webSocket: WebSocket as never,
-        })
-
-        const ws = await manager.ws(`ws://localhost:${harness.port}/ws`)
-        const chunks: string[] = []
-
-        await new Promise<void>((resolve, reject) => {
-          ws.addEventListener('message', (event) => {
-            if (typeof event.data !== 'string') return
-            chunks.push(event.data)
-          })
-          ws.addEventListener('close', () => resolve(), { once: true })
-          ws.addEventListener('error', () => reject(new Error('websocket stream failed')), {
-            once: true,
-          })
-        })
-
-        expect(chunks).toEqual(['chunk-1', 'chunk-2', 'chunk-3'])
-        expect(harness.voucherPosts).toBeGreaterThan(0)
-
-        const closeReceipt = await manager.close()
-        expect(closeReceipt?.status).toBe('success')
-        expect(closeReceipt?.spent).toBe('3')
-
-        const channelId = manager.channelId
-        expect(channelId).toBeTruthy()
-        const persisted = await channelStore(harness.rawStore).getChannel(channelId!)
-        expect(persisted?.finalized).toBe(true)
-      } finally {
-        harness.close()
-      }
-    })
-
-    test.each([
-      ['unit', { units: 2 }, 0],
-      ['amount', { amount: '2' }, 0],
-      ['interval', { intervalMs: 500 }, 750],
-    ] as const)(
-      'applies the %s settlement schedule after websocket charges',
-      async (_label, settlementSchedule, chunkDelayMs) => {
-        const settlements: Array<{ delta: bigint; trigger: string }> = []
-        const harness = await createManagedWsHarness({
-          maxDeposit: 3n,
-          settlementSchedule,
-          onSessionSettlement(context) {
-            settlements.push({ delta: context.delta, trigger: context.trigger })
-          },
-        })
-        harness.wsServer.on('connection', (socket: import('ws').WebSocket) => {
-          void harness.serveWebSocket({
-            socket,
-            url: `${harness.server.url}/ws`,
-            route: harness.route,
-            generate: async function* (stream: TempoWs.SessionController) {
-              for (const chunk of ['chunk-1', 'chunk-2', 'chunk-3']) {
-                if (chunk === 'chunk-2' && chunkDelayMs)
-                  await new Promise((resolve) => setTimeout(resolve, chunkDelayMs))
-                await stream.charge()
-                yield chunk
-              }
-            },
-          })
-        })
-
-        try {
-          const manager = precompileSessionManager({
-            account: payer,
-            client: createSigningClient(),
-            decimals: 0,
-            fetch: globalThis.fetch,
-            maxDeposit: '3',
-            webSocket: WebSocket as never,
-          })
-          const ws = await manager.ws(`ws://localhost:${harness.port}/ws`)
-          const chunks: string[] = []
-
-          await new Promise<void>((resolve, reject) => {
-            ws.addEventListener('message', (event) => {
-              if (typeof event.data === 'string') chunks.push(event.data)
-            })
-            ws.addEventListener('close', () => resolve(), { once: true })
-            ws.addEventListener('error', () => reject(new Error('websocket stream failed')), {
-              once: true,
-            })
-          })
-
-          expect(chunks).toEqual(['chunk-1', 'chunk-2', 'chunk-3'])
-          expect(harness.voucherPosts).toBeGreaterThan(0)
-          expect(settlements).toEqual([{ delta: 2n, trigger: 'scheduled' }])
-          await manager.close()
-          expect(settlements).toEqual([
-            { delta: 2n, trigger: 'scheduled' },
-            { delta: 1n, trigger: 'close' },
-          ])
-          const persisted = await channelStore(harness.rawStore).getChannel(manager.channelId!)
-          expect(persisted?.lastSettlementUnits).toBe(2)
-        } finally {
-          harness.close()
-        }
-      },
-    )
-
-    test('treats control-shaped application payloads as content', async () => {
-      const harness = await createManagedWsHarness({ maxDeposit: 1n })
-      const controlLookingChunk = JSON.stringify({
-        mpp: 'payment-need-voucher',
-        data: {
-          channelId: `0x${'aa'.repeat(32)}`,
-          requiredCumulative: '9',
-          acceptedCumulative: '0',
-          deposit: '9',
-        },
-      })
-      harness.wsServer.on('connection', (socket: import('ws').WebSocket) => {
-        void harness.serveWebSocket({
-          socket,
-          url: `${harness.server.url}/ws`,
-          route: harness.route,
-          generate: async function* (stream: TempoWs.SessionController) {
-            await stream.charge()
-            yield controlLookingChunk
-          },
-        })
-      })
-
-      try {
-        const manager = precompileSessionManager({
-          account: payer,
-          client: createSigningClient(),
-          decimals: 0,
-          fetch: globalThis.fetch,
-          maxDeposit: '1',
-          webSocket: WebSocket as never,
-        })
-
-        const ws = await manager.ws(`ws://localhost:${harness.port}/ws`)
-        const chunks: string[] = []
-
-        await new Promise<void>((resolve, reject) => {
-          ws.addEventListener('message', (event) => {
-            if (typeof event.data !== 'string') return
-            chunks.push(event.data)
-          })
-          ws.addEventListener('close', () => resolve(), { once: true })
-          ws.addEventListener('error', () => reject(new Error('websocket stream failed')), {
-            once: true,
-          })
-        })
-
-        expect(chunks).toEqual([controlLookingChunk])
-        expect(harness.voucherPosts).toBe(0)
-
-        const closeReceipt = await manager.close()
-        expect(closeReceipt?.status).toBe('success')
-        expect(closeReceipt?.spent).toBe('1')
-      } finally {
-        harness.close()
-      }
-    })
-
-    test('refuses websocket voucher requests beyond local maxDeposit', async () => {
-      const harness = await createManagedWsHarness({ maxDeposit: 1n })
-      harness.wsServer.on('connection', (socket: import('ws').WebSocket) => {
-        void harness.serveWebSocket({
-          socket,
-          url: `${harness.server.url}/ws`,
-          route: harness.route,
-          generate: async function* (stream: TempoWs.SessionController) {
-            await stream.charge()
-            yield 'chunk-1'
-            await stream.charge()
-            yield 'chunk-2'
-          },
-        })
-      })
-
-      try {
-        const manager = precompileSessionManager({
-          account: payer,
-          client: createSigningClient(),
-          decimals: 0,
-          fetch: globalThis.fetch,
-          maxDeposit: '1',
-          webSocket: WebSocket as never,
-        })
-
-        const ws = await manager.ws(`ws://localhost:${harness.port}/ws`)
-        const closeEvent = await new Promise<{ code: number; reason: string }>(
-          (resolve, reject) => {
-            ws.addEventListener(
-              'close',
-              (event) => resolve({ code: event.code, reason: event.reason }),
-              { once: true },
-            )
-            ws.addEventListener('error', () => reject(new Error('websocket stream failed')), {
-              once: true,
-            })
-          },
-        )
-
-        expect(closeEvent.code).toBe(3008)
-        expect(closeEvent.reason).toBe('requested voucher amount 2 exceeds local maxDeposit 1')
-      } finally {
-        harness.close()
-      }
-    })
-
-    test('rejects websocket receipts bound to a different channel', async () => {
-      const harness = await createManagedWsHarness({ maxDeposit: 1n })
-      const wrongChannelId = `0x${'11'.repeat(32)}` as Hex
-      harness.wsServer.on('connection', (socket: import('ws').WebSocket) => {
-        socket.once('message', (data) => {
-          const message = TempoWs.parseMessage(data.toString())
-          if (!message || message.mpp !== 'authorization') return
-
-          const credential = Credential.deserialize<SessionCredentialPayload>(message.authorization)
-          socket.send(
-            TempoWs.formatReceiptMessage({
-              method: 'tempo',
-              intent: 'session',
-              status: 'success',
-              timestamp: new Date().toISOString(),
-              reference: wrongChannelId,
-              challengeId: credential.challenge.id,
-              channelId: wrongChannelId,
-              acceptedCumulative: '1',
-              spent: '0',
-              units: 0,
-            }),
-          )
-        })
-      })
-
-      try {
-        const manager = precompileSessionManager({
-          account: payer,
-          client: createSigningClient(),
-          decimals: 0,
-          fetch: globalThis.fetch,
-          maxDeposit: '1',
-          webSocket: WebSocket as never,
-        })
-
-        await expect(manager.ws(`ws://localhost:${harness.port}/ws`)).rejects.toThrow(
-          'received mismatched payment-receipt frame',
-        )
-      } finally {
-        harness.close()
-      }
-    })
-
-    test('rejects close-ready receipts beyond local voucher state', async () => {
-      const harness = await createManagedWsHarness({ maxDeposit: 1n })
-      harness.wsServer.on('connection', (socket: import('ws').WebSocket) => {
-        let openCredential: Credential.Credential<SessionCredentialPayload> | undefined
-
-        socket.on('message', (data) => {
-          const message = TempoWs.parseMessage(data.toString())
-          if (!message) return
-
-          if (message.mpp === 'authorization') {
-            openCredential = Credential.deserialize<SessionCredentialPayload>(message.authorization)
-            const payload = openCredential.payload
-            if (payload.action !== 'open') return
-            socket.send(
-              TempoWs.formatReceiptMessage({
-                method: 'tempo',
-                intent: 'session',
-                status: 'success',
-                timestamp: new Date().toISOString(),
-                reference: payload.channelId,
-                challengeId: openCredential.challenge.id,
-                channelId: payload.channelId,
-                acceptedCumulative: payload.cumulativeAmount,
-                spent: '0',
-                units: 0,
-              }),
-            )
-            return
-          }
-
-          if (message.mpp !== 'payment-close-request' || !openCredential) return
-          const payload = openCredential.payload
-          socket.send(
-            TempoWs.formatCloseReadyMessage({
-              method: 'tempo',
-              intent: 'session',
-              status: 'success',
-              timestamp: new Date().toISOString(),
-              reference: payload.channelId,
-              challengeId: openCredential.challenge.id,
-              channelId: payload.channelId,
-              acceptedCumulative: '1',
-              spent: '9',
-              units: 1,
-            }),
-          )
-        })
-      })
-
-      try {
-        const manager = precompileSessionManager({
-          account: payer,
-          client: createSigningClient(),
-          decimals: 0,
-          fetch: globalThis.fetch,
-          maxDeposit: '1',
-          webSocket: WebSocket as never,
-        })
-
-        await manager.ws(`ws://localhost:${harness.port}/ws`)
-        await expect(manager.close()).rejects.toThrow(
-          'received payment-close-ready beyond local voucher state',
-        )
-      } finally {
-        harness.close()
-      }
-    })
-
-    test('fallback close after socket death signs for delivered amount, not full voucher', async () => {
-      const harness = await createManagedWsHarness({ maxDeposit: 3n })
-      let serverSocket: import('ws').WebSocket | null = null
-      harness.wsServer.on('connection', (socket: import('ws').WebSocket) => {
-        serverSocket = socket
-        void harness.serveWebSocket({
-          socket,
-          url: `${harness.server.url}/ws`,
-          route: harness.route,
-          generate: async function* (stream: TempoWs.SessionController) {
-            await stream.charge()
-            yield 'chunk-1'
-            await stream.charge()
-            yield 'chunk-2'
-            await new Promise((resolve) => setTimeout(resolve, 60_000))
-          },
-        })
-      })
-
-      try {
-        const manager = precompileSessionManager({
-          account: payer,
-          client: createSigningClient(),
-          decimals: 0,
-          fetch: globalThis.fetch,
-          maxDeposit: '3',
-          webSocket: WebSocket as never,
-        })
-
-        const ws = await manager.ws(`ws://localhost:${harness.port}/ws`)
-        const chunks: string[] = []
-
-        await new Promise<void>((resolve) => {
-          ws.addEventListener('message', (event) => {
-            if (typeof event.data !== 'string') return
-            chunks.push(event.data)
-            if (chunks.length === 2) serverSocket?.terminate()
-          })
-          ws.addEventListener('close', () => resolve(), { once: true })
-        })
-
-        expect(chunks).toEqual(['chunk-1', 'chunk-2'])
-
-        const closeReceipt = await manager.close()
-        expect(closeReceipt).toBeDefined()
-        expect(BigInt(closeReceipt!.spent)).toBeLessThanOrEqual(2n)
-        expect(BigInt(closeReceipt!.spent)).toBeGreaterThan(0n)
-        expect(BigInt(closeReceipt!.spent)).toBeLessThan(3n)
-      } finally {
-        harness.close()
-      }
-    })
-
-    test('rejects tx-bearing open receipts replayed during websocket close', async () => {
-      const harness = await createManagedWsHarness({ maxDeposit: 1n })
-      harness.wsServer.on('connection', (socket: import('ws').WebSocket) => {
-        let openCredential: Credential.Credential<SessionCredentialPayload> | undefined
-        let openReceipt: SessionReceipt | undefined
-
-        socket.on('message', (data) => {
-          const message = TempoWs.parseMessage(data.toString())
-          if (!message) return
-
-          if (message.mpp === 'authorization') {
-            const credential = Credential.deserialize<SessionCredentialPayload>(
-              message.authorization,
-            )
-            const payload = credential.payload
-            if (payload.action === 'close') {
-              if (openReceipt) socket.send(TempoWs.formatReceiptMessage(openReceipt))
-              return
-            }
-            if (payload.action !== 'open') return
-
-            openCredential = credential
-            openReceipt = {
-              method: 'tempo',
-              intent: 'session',
-              status: 'success',
-              timestamp: new Date().toISOString(),
-              reference: payload.channelId,
-              challengeId: credential.challenge.id,
-              channelId: payload.channelId,
-              acceptedCumulative: payload.cumulativeAmount,
-              spent: '0',
-              units: 0,
-              txHash: `0x${'12'.repeat(32)}` as Hex,
-            }
-            socket.send(TempoWs.formatReceiptMessage(openReceipt))
-            return
-          }
-
-          if (message.mpp !== 'payment-close-request' || !openCredential) return
-          const payload = openCredential.payload
-          socket.send(
-            TempoWs.formatCloseReadyMessage({
-              method: 'tempo',
-              intent: 'session',
-              status: 'success',
-              timestamp: new Date().toISOString(),
-              reference: payload.channelId,
-              challengeId: openCredential.challenge.id,
-              channelId: payload.channelId,
-              acceptedCumulative: '1',
-              spent: '0',
-              units: 0,
-            }),
-          )
-        })
-      })
-
-      try {
-        const manager = precompileSessionManager({
-          account: payer,
-          client: createSigningClient(),
-          decimals: 0,
-          fetch: globalThis.fetch,
-          maxDeposit: '1',
-          webSocket: WebSocket as never,
-        })
-
-        await manager.ws(`ws://localhost:${harness.port}/ws`)
-        await expect(manager.close()).rejects.toThrow(
-          'received mismatched payment-close receipt frame',
-        )
-      } finally {
-        harness.close()
-      }
-    })
-  })
-
-  test('does not let a racing lower voucher regress highest accepted precompile voucher', async () => {
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    const lowerVoucher = await ClientOps.createVoucherPayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(200n),
-      chainId,
-    )
-    const higherVoucher = await ClientOps.createVoucherPayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(500n),
-      chainId,
-    )
-    if (higherVoucher.action !== 'voucher') throw new Error('expected voucher payload')
-
-    const seedStore = channelStore(Store.memory())
-    await persistPrecompileChannel(seedStore, openPayload, {
-      highestVoucherAmount: 100n,
-      highestVoucher: {
-        channelId: openPayload.channelId,
-        cumulativeAmount: 100n,
-        signature: openPayload.signature,
-      },
-    })
-    const stale = (await seedStore.getChannel(openPayload.channelId))!
-    let stored: ChannelStore.State = {
-      ...stale,
-      highestVoucherAmount: 500n,
-      highestVoucher: {
-        channelId: openPayload.channelId,
-        cumulativeAmount: 500n,
-        signature: higherVoucher.signature,
-      },
-    }
-    const racingStore = {
-      async get(_key: string) {
-        return stale as never
-      },
-      async put(_key: string, value: unknown) {
-        stored = value as ChannelStore.State
-      },
-      async delete(_key: string) {},
-      async update<result>(
-        _key: string,
-        fn: (current: unknown | null) => Store.Change<unknown, result>,
-      ): Promise<result> {
-        const change = fn(stored)
-        if (change.op === 'set') stored = change.value as ChannelStore.State
-        return change.result
-      },
-    } as Store.AtomicStore
-    const method = session({
-      account: payer,
-      amount: '1',
-      chainId,
-      channelStateTtl: Number.MAX_SAFE_INTEGER,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: racingStore,
-      unitType: 'request',
-      getClient: () => createStateClient(payer),
-    })
-
-    const receipt = await method.verify({
-      credential: voucherCredential(lowerVoucher, openPayload.channelId),
-      request: verifyRequest(openPayload.channelId),
-    })
-
-    expect((receipt as SessionReceipt).acceptedCumulative).toBe('500')
-    expect(stored.highestVoucherAmount).toBe(500n)
-    expect(stored.highestVoucher?.signature).toBe(higherVoucher.signature)
-  })
-
-  test('marks pending precompile close before broadcast and restores it when broadcast fails', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload()
-    await persistPrecompileChannel(store, openPayload, {
-      payee: payer.address,
-    })
-    let observedPending = false
-    const method = session({
-      account: payer,
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () =>
-        createClient({
-          account: payer,
-          chain: testChain,
-          transport: custom({
-            async request(args) {
-              if (args.method === 'eth_chainId') return `0x${chainId.toString(16)}`
-              if (args.method === 'eth_call')
-                return encodeFunctionResult({
-                  abi: escrowAbi,
-                  functionName: 'getChannelState',
-                  result: { settled: 0n, deposit: 1_000n, closeRequestedAt: 0 },
-                })
-              if (args.method === 'eth_getTransactionCount') {
-                observedPending =
-                  (await store.getChannel(openPayload.channelId))!.closeRequestedAt !== 0n
-                throw new Error('broadcast failed')
-              }
-              if (args.method === 'eth_estimateGas') return '0x5208'
-              if (args.method === 'eth_maxPriorityFeePerGas') return '0x1'
-              if (args.method === 'eth_getBlockByNumber') return { baseFeePerGas: '0x1' }
-              throw new Error(`unexpected rpc request: ${args.method}`)
-            },
-          }),
-        }),
-    })
-    const payload = await ClientOps.createClosePayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(100n),
-      chainId,
-    )
-
-    await expect(
-      method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload,
-        },
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(/broadcast failed/)
-    expect(observedPending).toBe(true)
-    expect((await store.getChannel(openPayload.channelId))!.closeRequestedAt).toBe(0n)
-  })
-
-  test('precompile settle returns txHash when channel disappears before final write', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    await persistPrecompileChannel(store, openPayload, { payee: payer.address })
-    const client = createServerClient([], payer, openPayload.channelId, {
-      receipt: transactionReceipt([settledLog(openPayload.channelId, 100n)]),
-      state: { settled: 100n, deposit: 1_000n, closeRequestedAt: 0 },
-    })
-    let deleted = false
-    const disappearingStore = {
-      async get(key: string) {
-        return rawStore.get(key)
-      },
-      async put(key: string, value: unknown) {
-        return rawStore.put(key, value)
-      },
-      async delete(key: string) {
-        return rawStore.delete(key)
-      },
-      async update<result>(
-        key: string,
-        fn: (current: unknown | null) => Store.Change<unknown, result>,
-      ): Promise<result> {
-        if (!deleted) {
-          deleted = true
-          return rawStore.update(key, fn)
-        }
-        const change = fn(null)
-        return change.result
-      },
-    } as Store.AtomicStore
-
-    const { settle } = await import('./Session.js')
-    await expect(settle(disappearingStore, client, openPayload.channelId)).resolves.toBe(
-      `0x${'aa'.repeat(32)}`,
-    )
-  })
-
-  test('precompile close still returns receipt when channel disappears before final write', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    await persistPrecompileChannel(store, openPayload, { payee: payer.address, spent: 100n })
-    const closeSignature = await Voucher.signVoucher(
-      createSigningClient(),
-      payer,
-      { channelId: openPayload.channelId, cumulativeAmount: 100n },
-      tip20ChannelEscrow,
-      chainId,
-    )
-    const method = session({
-      account: payer,
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () =>
-        createServerClient([], payer, openPayload.channelId, {
-          receipt: transactionReceipt([closedLog(openPayload.channelId, 100n, 900n)]),
-          state: { settled: 0n, deposit: 1_000n, closeRequestedAt: 0 },
-        }),
-    })
-    let deleteBeforeFinalWrite = false
-    const originalUpdate = store.updateChannel.bind(store)
-    store.updateChannel = (async (channelId, fn) => {
-      if (deleteBeforeFinalWrite) return fn(null as never) as never
-      const result = await originalUpdate(channelId, fn)
-      deleteBeforeFinalWrite = true
-      return result
-    }) as typeof store.updateChannel
-
-    const receipt = (await method.verify({
-      credential: {
-        challenge: makeChallenge(openPayload.channelId),
-        payload: {
-          action: 'close',
-          channelId: openPayload.channelId,
-          cumulativeAmount: '100',
-          descriptor: openPayload.descriptor,
-          signature: closeSignature,
-        },
-      },
-      request: verifyRequest(openPayload.channelId),
-    })) as SessionReceipt
-
-    expect(receipt.txHash).toBe(`0x${'aa'.repeat(32)}`)
-    expect(receipt.spent).toBe('100')
-  })
-
-  test('rejects close when precompile channel is finalized on-chain', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    await persistPrecompileChannel(store, openPayload, { payee: payer.address, spent: 100n })
-    const closeSignature = await Voucher.signVoucher(
-      createSigningClient(),
-      payer,
-      { channelId: openPayload.channelId, cumulativeAmount: 100n },
-      tip20ChannelEscrow,
-      chainId,
-    )
-    const method = session({
-      account: payer,
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () => createStateClient(payer, { settled: 0n, deposit: 0n, closeRequestedAt: 0 }),
-    })
-
-    await expect(
-      method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload: {
-            action: 'close',
-            channelId: openPayload.channelId,
-            cumulativeAmount: '100',
-            descriptor: openPayload.descriptor,
-            signature: closeSignature,
-          },
-        },
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(/channel deposit is zero/)
-  })
-
-  test('pending precompile close blocks concurrent charges', async () => {
-    const { store } = createServer()
-    const openPayload = await createOpenPayload({ initialAmount: 100n })
-    await persistPrecompileChannel(store, openPayload, {
-      closeRequestedAt: 1n,
-      highestVoucherAmount: 500n,
-      spent: 100n,
-    })
-
-    await expect(charge(store, openPayload.channelId, 1n)).rejects.toThrow(/pending close request/)
-  })
-
-  test('rejects server-driven close when no account is available', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload()
-    await persistPrecompileChannel(store, openPayload)
-    const method = session({
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () => createStateClient(null),
-    })
-    const payload = await ClientOps.createClosePayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(100n),
-      chainId,
-    )
-
-    await expect(
-      method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload,
-        },
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(/no account available/)
-  })
-
-  test('accepts server-driven close account override matching the channel payee', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload()
-    await persistPrecompileChannel(store, openPayload, {
-      payee: wrongPayer.address,
-    })
-    const method = session({
-      account: wrongPayer,
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () => createStateClient(payer),
-    })
-    const payload = await ClientOps.createClosePayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(100n),
-      chainId,
-    )
-
-    await expect(
-      method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload,
-        },
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(/eth_sendRawTransaction/)
-  })
-
-  test('uses request-specified fee payer account for server-driven precompile close', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload()
-    await persistPrecompileChannel(store, openPayload, {
-      payee: wrongPayer.address,
-    })
-    const method = session({
-      account: wrongPayer,
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      feeToken: token,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () => createStateClient(payer),
-    })
-    const payload = await ClientOps.createClosePayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(100n),
-      chainId,
-    )
-
-    await expect(
-      method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload,
-        },
-        request: verifyRequestWithFeePayer(openPayload.channelId, payer),
-      }),
-    ).rejects.toThrow(/eth_sendRawTransaction/)
-  })
-
-  test('accepts server-driven close sender matching a nonzero precompile operator', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload({
-      operator: wrongPayer.address,
-    })
-    await persistPrecompileChannel(store, openPayload)
-    const method = session({
-      account: wrongPayer,
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      operator: wrongPayer.address,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () => createStateClient(payer),
-    })
-    const payload = await ClientOps.createClosePayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(100n),
-      chainId,
-    )
-
-    await expect(
-      method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId, { operator: wrongPayer.address }),
-          payload,
-        },
-        request: verifyRequest(openPayload.channelId, { operator: wrongPayer.address }),
-      }),
-    ).rejects.toThrow(/eth_sendRawTransaction/)
-  })
-
-  test('rejects server-driven close when sender is not the channel payee or operator', async () => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload()
-    await persistPrecompileChannel(store, openPayload)
-    const method = session({
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () => createStateClient(wrongPayer),
-    })
-    const payload = await ClientOps.createClosePayload(
-      createSigningClient(),
-      payer,
-      openPayload.descriptor,
-      Types.uint96(100n),
-      chainId,
-    )
-
-    await expect(
-      method.verify({
-        credential: {
-          challenge: makeChallenge(openPayload.channelId),
-          payload,
-        },
-        request: verifyRequest(openPayload.channelId),
-      }),
-    ).rejects.toThrow(/tx sender .* is not the channel payee/)
-  })
-})
-
-describe('session settlement extensions', () => {
-  test.each([
-    ['no schedule is configured', undefined],
-    ['the configured threshold is not due', { units: 11 }],
-  ] as const)('does not resolve a client when %s', async (_label, settlementSchedule) => {
-    const rawStore = Store.memory()
-    const store = channelStore(rawStore)
-    const openPayload = await createOpenPayload()
-    let clientResolutions = 0
-    await persistPrecompileChannel(store, openPayload, {
-      highestVoucherAmount: 500n,
-      highestVoucher: {
-        channelId: openPayload.channelId,
-        cumulativeAmount: 500n,
-        signature: '0x1234',
-      },
-      spent: 500n,
-      units: 10,
-    })
-
-    const payment = Mppx_server.create({
-      methods: [
-        tempo_server.session({
-          account: payer,
-          amount: '1',
-          chainId,
-          currency: token,
-          decimals: 0,
-          getClient() {
-            clientResolutions++
-            throw new Error('client should not be resolved')
-          },
-          recipient: payee,
-          settlementSchedule,
-          store: rawStore,
-          unitType: 'token',
-        }),
-      ],
-      realm: 'api.example.com',
-      secretKey: 'test-secret-key-test-secret-key-32',
-    })
-    const channel = await store.getChannel(openPayload.channelId)
-
-    await expect(payment.session.settleScheduled(channel!)).resolves.toBeUndefined()
-    expect(clientResolutions).toBe(0)
-  })
-})
-
-describe('onSessionSettlement', () => {
-  function createSettleClient(channelId: Hex, settledAmount: bigint) {
-    return createClient({
-      account: payer,
-      chain: testChain,
-      transport: custom({
-        async request(args) {
-          if (args.method === 'eth_chainId') return `0x${chainId.toString(16)}`
-          if (args.method === 'eth_getTransactionCount') return '0x0'
-          if (args.method === 'eth_estimateGas') return '0x5208'
-          if (args.method === 'eth_maxPriorityFeePerGas') return '0x1'
-          if (args.method === 'eth_getBlockByNumber') return { baseFeePerGas: '0x1' }
-          if (args.method === 'eth_sendRawTransaction') return `0x${'cc'.repeat(32)}`
-          if (args.method === 'eth_sendTransaction') return `0x${'cc'.repeat(32)}`
-          if (args.method === 'eth_getTransactionReceipt')
-            return transactionReceipt([settledLog(channelId, settledAmount)])
-          if (args.method === 'eth_call') {
-            return encodeFunctionResult({
-              abi: escrowAbi,
-              functionName: 'getChannelState',
-              result: { settled: settledAmount, deposit: 1_000n, closeRequestedAt: 0 },
-            })
-          }
-          throw new Error(`unexpected rpc request: ${args.method}`)
-        },
-      }),
-    })
-  }
-
-  test('fires onSessionSettlement for explicit settle() calls', async () => {
-    const events: { trigger: string; txHash: string; amount: bigint; delta: bigint }[] = []
-    const store = Store.memory()
-    const openPayload = await createOpenPayload()
-    await persistPrecompileChannel(channelStore(store), openPayload, {
-      payee: payer.address,
-      spent: 100n,
-      highestVoucherAmount: 100n,
-      highestVoucher: {
-        channelId: openPayload.channelId,
-        cumulativeAmount: 100n,
-        signature: '0x1234',
-      },
-    })
-
-    const { settle } = await import('./Session.js')
-    const client = createSettleClient(openPayload.channelId, 100n)
-    await settle(store, client, openPayload.channelId, {
-      onSessionSettlement: (ctx) => {
-        events.push({
-          trigger: ctx.trigger,
-          txHash: ctx.txHash,
-          amount: ctx.amount,
-          delta: ctx.delta,
-        })
-      },
-    })
-
-    expect(events).toHaveLength(1)
-    expect(events[0]).toMatchObject({
-      trigger: 'settle',
-      txHash: `0x${'cc'.repeat(32)}`,
-      amount: 100n,
-      delta: 100n,
-    })
-  })
-
-  test('fires onSessionSettlement for auto-scheduled settlements', async () => {
-    const events: { trigger: string; channelId: string; amount: bigint; delta: bigint }[] = []
-    const rawStore = Store.memory()
-    const openPayload = await createOpenPayload()
-    const store = channelStore(rawStore)
-    await persistPrecompileChannel(store, openPayload, {
-      payee: payer.address,
-      spent: 500n,
-      units: 10,
-      highestVoucherAmount: 500n,
-      highestVoucher: {
-        channelId: openPayload.channelId,
-        cumulativeAmount: 500n,
-        signature: '0x1234',
-      },
-    })
-
-    const { maybeSettleScheduled } = await import('./Settlement.js')
-    const client = createSettleClient(openPayload.channelId, 500n)
-    const channel = await store.getChannel(openPayload.channelId)
-
-    await maybeSettleScheduled({
-      account: payer,
-      channel: channel!,
-      client,
-      schedule: { units: 5 },
-      store,
-      onSessionSettlement: (ctx) => {
-        events.push({
-          trigger: ctx.trigger,
-          channelId: ctx.channelId,
-          amount: ctx.amount,
-          delta: ctx.delta,
-        })
-      },
-    })
-
-    expect(events).toHaveLength(1)
-    expect(events[0]).toMatchObject({
-      trigger: 'scheduled',
-      channelId: openPayload.channelId,
-      amount: 500n,
-      delta: 500n,
-    })
-  })
-
-  test('delta reflects incremental scheduled settlement with prior on-chain settlement', async () => {
-    const events: { trigger: string; amount: bigint; delta: bigint }[] = []
-    const rawStore = Store.memory()
-    const openPayload = await createOpenPayload()
-    const store = channelStore(rawStore)
-    await persistPrecompileChannel(store, openPayload, {
-      payee: payer.address,
-      spent: 500n,
-      units: 10,
-      settledOnChain: 200n,
-      highestVoucherAmount: 500n,
-      highestVoucher: {
-        channelId: openPayload.channelId,
-        cumulativeAmount: 500n,
-        signature: '0x1234',
-      },
-    })
-
-    const { maybeSettleScheduled } = await import('./Settlement.js')
-    const client = createSettleClient(openPayload.channelId, 500n)
-    const channel = await store.getChannel(openPayload.channelId)
-
-    await maybeSettleScheduled({
-      account: payer,
-      channel: channel!,
-      client,
-      schedule: { units: 5 },
-      store,
-      onSessionSettlement: (ctx) => {
-        events.push({ trigger: ctx.trigger, amount: ctx.amount, delta: ctx.delta })
-      },
-    })
-
-    expect(events).toHaveLength(1)
-    expect(events[0]).toMatchObject({
-      trigger: 'scheduled',
-      amount: 500n,
-      delta: 300n,
-    })
-  })
-
-  test('fires onSessionSettlement for cooperative close', async () => {
-    const events: { trigger: string; txHash: string; amount: bigint; delta: bigint }[] = []
-    const openPayload = await createOpenPayload()
-    const closedAmount = 100n
-    const refundedAmount = 900n
-    const rawStore = Store.memory()
-
-    const closeClient = createClient({
-      account: payer,
-      chain: testChain,
-      transport: custom({
-        async request(args) {
-          if (args.method === 'eth_chainId') return `0x${chainId.toString(16)}`
-          if (args.method === 'eth_getTransactionCount') return '0x0'
-          if (args.method === 'eth_estimateGas') return '0x5208'
-          if (args.method === 'eth_maxPriorityFeePerGas') return '0x1'
-          if (args.method === 'eth_getBlockByNumber') return { baseFeePerGas: '0x1' }
-          if (args.method === 'eth_sendRawTransaction') return `0x${'dd'.repeat(32)}`
-          if (args.method === 'eth_sendTransaction') return `0x${'dd'.repeat(32)}`
-          if (args.method === 'eth_getTransactionReceipt')
-            return transactionReceipt([
-              closedLog(openPayload.channelId, closedAmount, refundedAmount),
-            ])
-          if (args.method === 'eth_call') {
-            return encodeFunctionResult({
-              abi: escrowAbi,
-              functionName: 'getChannelState',
-              result: { settled: 0n, deposit: 1_000n, closeRequestedAt: 0 },
-            })
-          }
-          throw new Error(`unexpected rpc request: ${args.method}`)
-        },
-      }),
-    })
-
-    const method = session({
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () => closeClient,
-      onSessionSettlement: (ctx) => {
-        events.push({
-          trigger: ctx.trigger,
-          txHash: ctx.txHash,
-          amount: ctx.amount,
-          delta: ctx.delta,
-        })
-      },
-    })
-
-    await persistPrecompileChannel(channelStore(rawStore), openPayload, {
-      payee: payer.address,
-      spent: 100n,
-      highestVoucherAmount: 100n,
-      highestVoucher: {
-        channelId: openPayload.channelId,
-        cumulativeAmount: 100n,
-        signature: '0x1234',
-      },
-    })
-
-    const closeSignature = await Voucher.signVoucher(
-      createSigningClient(),
-      payer,
-      { channelId: openPayload.channelId, cumulativeAmount: 100n },
-      tip20ChannelEscrow,
-      chainId,
-    )
-
-    await method.verify({
-      credential: {
-        challenge: makeChallenge(openPayload.channelId),
-        payload: {
-          action: 'close',
-          channelId: openPayload.channelId,
-          descriptor: openPayload.descriptor,
-          cumulativeAmount: '100',
-          signature: closeSignature,
-        },
-      },
-      request: verifyRequest(openPayload.channelId),
-    })
-
-    expect(events).toHaveLength(1)
-    expect(events[0]).toMatchObject({
-      trigger: 'close',
-      txHash: `0x${'dd'.repeat(32)}`,
-      amount: closedAmount,
-      delta: closedAmount,
-    })
-  })
-
-  test('delta reflects incremental settlement when channel has prior on-chain settlement', async () => {
-    const events: { trigger: string; amount: bigint; delta: bigint }[] = []
-    const store = Store.memory()
-    const openPayload = await createOpenPayload()
-    await persistPrecompileChannel(channelStore(store), openPayload, {
-      payee: payer.address,
-      spent: 300n,
-      settledOnChain: 200n,
-      highestVoucherAmount: 300n,
-      highestVoucher: {
-        channelId: openPayload.channelId,
-        cumulativeAmount: 300n,
-        signature: '0x1234',
-      },
-    })
-
-    const { settle } = await import('./Session.js')
-    const client = createSettleClient(openPayload.channelId, 300n)
-    await settle(store, client, openPayload.channelId, {
-      onSessionSettlement: (ctx) => {
-        events.push({ trigger: ctx.trigger, amount: ctx.amount, delta: ctx.delta })
-      },
-    })
-
-    expect(events).toHaveLength(1)
-    expect(events[0]).toMatchObject({
-      trigger: 'settle',
-      amount: 300n,
-      delta: 100n,
-    })
-  })
-
-  test('delta reflects incremental close when channel has prior on-chain settlement', async () => {
-    const events: { trigger: string; amount: bigint; delta: bigint }[] = []
-    const openPayload = await createOpenPayload()
-    const priorSettled = 50n
-    const closedAmount = 100n
-    const refundedAmount = 900n
-    const rawStore = Store.memory()
-
-    const closeClient = createClient({
-      account: payer,
-      chain: testChain,
-      transport: custom({
-        async request(args) {
-          if (args.method === 'eth_chainId') return `0x${chainId.toString(16)}`
-          if (args.method === 'eth_getTransactionCount') return '0x0'
-          if (args.method === 'eth_estimateGas') return '0x5208'
-          if (args.method === 'eth_maxPriorityFeePerGas') return '0x1'
-          if (args.method === 'eth_getBlockByNumber') return { baseFeePerGas: '0x1' }
-          if (args.method === 'eth_sendRawTransaction') return `0x${'dd'.repeat(32)}`
-          if (args.method === 'eth_sendTransaction') return `0x${'dd'.repeat(32)}`
-          if (args.method === 'eth_getTransactionReceipt')
-            return transactionReceipt([
-              closedLog(openPayload.channelId, closedAmount, refundedAmount),
-            ])
-          if (args.method === 'eth_call') {
-            return encodeFunctionResult({
-              abi: escrowAbi,
-              functionName: 'getChannelState',
-              result: { settled: priorSettled, deposit: 1_000n, closeRequestedAt: 0 },
-            })
-          }
-          throw new Error(`unexpected rpc request: ${args.method}`)
-        },
-      }),
-    })
-
-    const method = session({
-      amount: '1',
-      chainId,
-      currency: token,
-      decimals: 0,
-      recipient: payee,
-      store: rawStore,
-      unitType: 'request',
-      getClient: () => closeClient,
-      onSessionSettlement: (ctx) => {
-        events.push({ trigger: ctx.trigger, amount: ctx.amount, delta: ctx.delta })
-      },
-    })
-
-    await persistPrecompileChannel(channelStore(rawStore), openPayload, {
-      payee: payer.address,
-      spent: 100n,
-      settledOnChain: priorSettled,
-      highestVoucherAmount: 100n,
-      highestVoucher: {
-        channelId: openPayload.channelId,
-        cumulativeAmount: 100n,
-        signature: '0x1234',
-      },
-    })
-
-    const closeSignature = await Voucher.signVoucher(
-      createSigningClient(),
-      payer,
-      { channelId: openPayload.channelId, cumulativeAmount: 100n },
-      tip20ChannelEscrow,
-      chainId,
-    )
-
-    await method.verify({
-      credential: {
-        challenge: makeChallenge(openPayload.channelId),
-        payload: {
-          action: 'close',
-          channelId: openPayload.channelId,
-          descriptor: openPayload.descriptor,
-          cumulativeAmount: '100',
-          signature: closeSignature,
-        },
-      },
-      request: verifyRequest(openPayload.channelId),
-    })
-
-    expect(events).toHaveLength(1)
-    expect(events[0]).toMatchObject({
-      trigger: 'close',
-      amount: closedAmount,
-      delta: closedAmount - priorSettled,
-    })
-  })
-
-  test('isolates errors in onSessionSettlement handler', async () => {
-    const store = Store.memory()
-    const openPayload = await createOpenPayload()
-    await persistPrecompileChannel(channelStore(store), openPayload, {
-      payee: payer.address,
-      spent: 100n,
-      highestVoucherAmount: 100n,
-      highestVoucher: {
-        channelId: openPayload.channelId,
-        cumulativeAmount: 100n,
-        signature: '0x1234',
-      },
-    })
-
-    const { settle } = await import('./Session.js')
-    const client = createSettleClient(openPayload.channelId, 100n)
-
-    await expect(
-      settle(store, client, openPayload.channelId, {
-        onSessionSettlement: () => {
-          throw new Error('observer exploded')
-        },
-      }),
-    ).resolves.toBe(`0x${'cc'.repeat(32)}`)
-  })
-})