mppx 0.8.14 → 0.8.17

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

@@ -4,6 +4,8 @@ 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,
@@ -14,6 +16,7 @@ import {
   encodeFunctionData,
   encodeFunctionResult,
   type Hex,
+  maxUint256,
   zeroAddress,
 } from 'viem'
 import { privateKeyToAccount } from 'viem/accounts'
@@ -40,9 +43,8 @@ import * as ChannelStore from './ChannelStore.js'
 import { charge, session, type ResolveSessionChannelId } from './Session.js'
 import * as TempoWs from './Ws.js'
 
-const payer = privateKeyToAccount(
-  '0xac0974bec39a17e36ba6a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
-)
+const payerPrivateKey = '0xac0974bec39a17e36ba6a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80'
+const payer = privateKeyToAccount(payerPrivateKey)
 const wrongPayer = privateKeyToAccount(
   '0x59c6995e998f97a5a0044966f094538a009d74290f5811cfba6a6b4d238ff944',
 )
@@ -88,10 +90,16 @@ function createServerClient(
   _eventChannelId: Hex = `0x${'00'.repeat(32)}` as Hex,
   options: {
     descriptor?: Channel.ChannelDescriptor
-    receipt?: Record<string, unknown>
-    state?: ChainState
+    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,
@@ -103,11 +111,24 @@ function createServerClient(
         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${'aa'.repeat(32)}`
-        if (args.method === 'eth_getTransactionReceipt') return options.receipt ?? null
-        if (args.method === 'eth_sendTransaction') return `0x${'bb'.repeat(32)}`
+        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 state = options.state ?? { settled: 100n, deposit: 1_000n, closeRequestedAt: 0 }
+          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({
@@ -315,6 +336,52 @@ async function createOpenPayload(
   }
 }
 
+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)}`,
@@ -757,6 +824,133 @@ describe('precompile server session unit guardrails', () => {
     ).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 })
@@ -1409,7 +1603,7 @@ describe('precompile server session unit guardrails', () => {
     expect(stored?.units).toBe(4)
   })
 
-  test('rejects precompile top-up when on-chain state has pending close', async () => {
+  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 })
@@ -1431,7 +1625,7 @@ describe('precompile server session unit guardrails', () => {
     })
 
     await expect(
-      method.verify({
+      method.validate!({
         credential: {
           challenge: makeChallenge(openPayload.channelId),
           payload: topUpPayload,
@@ -2172,14 +2366,23 @@ describe('precompile server session unit guardrails', () => {
 
   describe('SSE parity', () => {
     function createManagedSseFetch(
-      options: { amount?: string; maxDeposit?: bigint; unitType?: 'request' | 'token' } = {},
+      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: [
@@ -2189,6 +2392,8 @@ describe('precompile server session unit guardrails', () => {
             currency: token,
             decimals: 0,
             recipient: payer.address,
+            onSessionSettlement: options.onSessionSettlement,
+            settlementSchedule: options.settlementSchedule,
             sse: true,
             store: rawStore,
             unitType,
@@ -2206,20 +2411,24 @@ describe('precompile server session unit guardrails', () => {
                   receipt: transactionReceipt([
                     closedLog(payload.channelId, BigInt(payload.cumulativeAmount), 0n),
                   ]),
-                  state: { settled: 0n, deposit, closeRequestedAt: 0 },
+                  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: 0n, deposit, closeRequestedAt: 0 },
+                  state: { settled, deposit, closeRequestedAt: 0 },
                 })
               }
-              return createStateClient(payer, {
-                settled: 0n,
-                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 }),
               })
             },
           }),
@@ -2233,6 +2442,7 @@ describe('precompile server session unit guardrails', () => {
         if (request.headers.has('Authorization')) {
           try {
             currentPayload = Credential.fromRequest<SessionCredentialPayload>(request).payload
+            activeChannelId = currentPayload.channelId
             if (currentPayload.action === 'voucher') voucherPosts++
           } catch {}
         }
@@ -2259,9 +2469,12 @@ describe('precompile server session unit guardrails', () => {
             )
           }
 
+          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()
@@ -2312,6 +2525,49 @@ describe('precompile server session unit guardrails', () => {
       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<{
@@ -2421,19 +2677,31 @@ describe('precompile server session unit guardrails', () => {
   })
 
   describe('WebSocket parity', () => {
-    async function createManagedWsHarness(options: { maxDeposit?: bigint } = {}) {
+    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 routeHandler = Mppx_server.create({
+      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: () => {
@@ -2450,30 +2718,45 @@ describe('precompile server session unit guardrails', () => {
                   receipt: transactionReceipt([
                     closedLog(payload.channelId, BigInt(payload.cumulativeAmount), 0n),
                   ]),
-                  state: { settled: 0n, deposit: maxDeposit, closeRequestedAt: 0 },
+                  state: { settled, deposit: maxDeposit, closeRequestedAt: 0 },
                 })
               }
-              return createStateClient(payer, {
-                settled: 0n,
-                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',
-      }).session({ amount: '1', decimals: 0, suggestedDeposit: maxDeposit.toString() })
+      })
 
+      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 {}
-        }
-        return routeHandler(request)
+        } else challengeRequests++
+        const result = await payment.session(routeOptions())(request)
+        currentPayload = undefined
+        return result
       }
 
       const httpHandler = NodeRequest.toNodeListener(async (request) => {
@@ -2505,11 +2788,15 @@ describe('precompile server session unit guardrails', () => {
       return {
         rawStore,
         route,
+        serveWebSocket: payment.session.serveWebSocket,
         server,
         wsServer,
         get port() {
           return port
         },
+        get challengeRequests() {
+          return challengeRequests
+        },
         get voucherPosts() {
           return voucherPosts
         },
@@ -2520,12 +2807,58 @@ describe('precompile server session unit guardrails', () => {
       }
     }
 
+    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 TempoWs.serve({
+        void harness.serveWebSocket({
           socket,
-          store: harness.rawStore,
           url: `${harness.server.url}/ws`,
           route: harness.route,
           generate: async function* (stream: TempoWs.SessionController) {
@@ -2579,6 +2912,75 @@ describe('precompile server session unit guardrails', () => {
       }
     })
 
+    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({
@@ -2591,9 +2993,8 @@ describe('precompile server session unit guardrails', () => {
         },
       })
       harness.wsServer.on('connection', (socket: import('ws').WebSocket) => {
-        void TempoWs.serve({
+        void harness.serveWebSocket({
           socket,
-          store: harness.rawStore,
           url: `${harness.server.url}/ws`,
           route: harness.route,
           generate: async function* (stream: TempoWs.SessionController) {
@@ -2641,9 +3042,8 @@ describe('precompile server session unit guardrails', () => {
     test('refuses websocket voucher requests beyond local maxDeposit', async () => {
       const harness = await createManagedWsHarness({ maxDeposit: 1n })
       harness.wsServer.on('connection', (socket: import('ws').WebSocket) => {
-        void TempoWs.serve({
+        void harness.serveWebSocket({
           socket,
-          store: harness.rawStore,
           url: `${harness.server.url}/ws`,
           route: harness.route,
           generate: async function* (stream: TempoWs.SessionController) {
@@ -2803,9 +3203,8 @@ describe('precompile server session unit guardrails', () => {
       let serverSocket: import('ws').WebSocket | null = null
       harness.wsServer.on('connection', (socket: import('ws').WebSocket) => {
         serverSocket = socket
-        void TempoWs.serve({
+        void harness.serveWebSocket({
           socket,
-          store: harness.rawStore,
           url: `${harness.server.url}/ws`,
           route: harness.route,
           generate: async function* (stream: TempoWs.SessionController) {
@@ -3399,6 +3798,54 @@ describe('precompile server session unit guardrails', () => {
   })
 })
 
+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({