mppx 0.6.12 → 0.6.14

package/src/tempo/server/internal/request-body.test.ts

@@ -82,6 +82,17 @@ describe('request-body', () => {
         }),
       ).toBe(false)
     })
+
+    test('treats bodyless POST requests with query parameters as content requests', () => {
+      expect(
+        isSessionContentRequest({
+          hasBody: false,
+          headers: new Headers(),
+          method: 'POST',
+          url: new URL('https://api.example.com/search?q=paid'),
+        }),
+      ).toBe(true)
+    })
   })
 
   describe('shouldChargePlainResponse', () => {
@@ -121,6 +132,20 @@ describe('request-body', () => {
         ),
       ).toBe(false)
     })
+
+    test('charges bodyless POST query requests', () => {
+      expect(
+        shouldChargePlainResponse(
+          {
+            hasBody: false,
+            headers: new Headers(),
+            method: 'POST',
+            url: new URL('https://api.example.com/search?q=paid'),
+          },
+          { action: 'voucher' },
+        ),
+      ).toBe(true)
+    })
   })
 
   describe('captureRequestBodyProbe', () => {
@@ -136,6 +161,7 @@ describe('request-body', () => {
         headers: request.headers,
         hasBody: true,
         method: 'POST',
+        url: new URL('https://example.com/'),
       })
     })
   })

package/src/tempo/server/internal/request-body.ts

@@ -1,13 +1,15 @@
 import type * as Method from '../../../Method.js'
 import type { SessionCredentialPayload } from '../../session/Types.js'
 
-export type RequestBodyProbe = Pick<Method.CapturedRequest, 'headers' | 'hasBody' | 'method'>
+export type RequestBodyProbe = Pick<Method.CapturedRequest, 'headers' | 'hasBody' | 'method'> &
+  Partial<Pick<Method.CapturedRequest, 'url'>>
 
 export function captureRequestBodyProbe(input: Request): RequestBodyProbe {
   return {
     headers: input.headers,
     hasBody: input.body !== null,
     method: input.method,
+    url: new URL(input.url),
   }
 }
 
@@ -25,6 +27,7 @@ export function hasCapturedRequestBody(
 export function isSessionContentRequest(input: RequestBodyProbe): boolean {
   if (input.method === 'HEAD') return false
   if (input.method !== 'POST') return true
+  if (input.url?.search) return true
   return hasCapturedRequestBody(input)
 }
 

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

@@ -7,7 +7,8 @@ import { chainId, escrowContract as escrowContractDefaults } from '../../interna
 import * as ChannelStore from '../../session/ChannelStore.js'
 import { deserializeSessionReceipt } from '../../session/Receipt.js'
 import { parseEvent } from '../../session/Sse.js'
-import { sse } from './transport.js'
+import type { SessionReceipt } from '../../session/Types.js'
+import { markPrepaidSessionTick, sse } from './transport.js'
 
 const channelId = '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex
 const challengeId = 'challenge-1'
@@ -129,7 +130,7 @@ type ReceiptOverrides = Partial<{
   units: number
 }>
 
-function makeReceipt(overrides: ReceiptOverrides = {}) {
+function makeReceipt(overrides: ReceiptOverrides = {}): SessionReceipt {
   return {
     method: 'tempo',
     intent: 'session' as const,
@@ -666,6 +667,31 @@ describe('sse transport', () => {
     expect(response.headers.get('Payment-Receipt')).toBeTruthy()
   })
 
+  test('respondReceipt with prepaid plain Response does not deduct again', async () => {
+    const store = memoryStore()
+    await seedChannel(store, 10000000n)
+    const transport = sse({ store })
+
+    const response = transport.respondReceipt({
+      credential: makeCredential(),
+      input: makeAuthorizedRequest(),
+      receipt: markPrepaidSessionTick(makeReceipt({ spent: '1000000', units: 1 })),
+      response: new Response('ok', {
+        headers: { 'Content-Type': 'application/json' },
+      }),
+      challengeId,
+    })
+
+    expect(await response.text()).toBe('ok')
+    const receipt = deserializeSessionReceipt(response.headers.get('Payment-Receipt')!)
+    const channel = await store.getChannel(channelId)
+
+    expect(channel!.spent).toBe(0n)
+    expect(channel!.units).toBe(0)
+    expect(receipt.spent).toBe('1000000')
+    expect(receipt.units).toBe(1)
+  })
+
   test('respondReceipt no longer depends on prior getCredential side effects', async () => {
     const store = memoryStore()
     await seedChannel(store, 10000000n)

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

@@ -13,9 +13,28 @@ import * as Sse_core from '../../session/Sse.js'
 import type { SessionCredentialPayload, SessionReceipt } from '../../session/Types.js'
 import { captureRequestBodyProbe, shouldChargePlainResponse } from './request-body.js'
 
+const prepaidSessionTick = Symbol('mppx.prepaidSessionTick')
+
 /** SSE transport with Tempo session controller. */
 export type Sse = Transport.Sse<Sse_core.SessionController>
 
+export type PrepaidSessionReceipt = SessionReceipt & {
+  [prepaidSessionTick]?: true | undefined
+}
+
+export function markPrepaidSessionTick(receipt: SessionReceipt): SessionReceipt {
+  Object.defineProperty(receipt, prepaidSessionTick, {
+    configurable: false,
+    enumerable: false,
+    value: true,
+  })
+  return receipt
+}
+
+function hasPrepaidSessionTick(receipt: SessionReceipt): boolean {
+  return (receipt as PrepaidSessionReceipt)[prepaidSessionTick] === true
+}
+
 /**
  * Creates a Tempo-metered SSE transport.
  *
@@ -93,6 +112,7 @@ export function sse(options: sse.Options & { store: ChannelStore.ChannelStore })
           tickCost,
           pollIntervalMs: pollingInterval,
           generate,
+          prepaidUnits: hasPrepaidSessionTick(receipt as SessionReceipt) ? 1 : 0,
           signal: input.signal,
         })
         return Sse_core.toResponse(stream)
@@ -113,6 +133,9 @@ export function sse(options: sse.Options & { store: ChannelStore.ChannelStore })
       }
 
       const currentReceipt = receipt as SessionReceipt
+      if (hasPrepaidSessionTick(currentReceipt)) {
+        return baseResponse
+      }
       const available = BigInt(currentReceipt.acceptedCumulative) - BigInt(currentReceipt.spent)
       if (available < tickCost) {
         const error = new Errors.InsufficientBalanceError({

package/src/tempo/session/Chain.test.ts

@@ -1,4 +1,12 @@
-import { type Address, encodeFunctionData, erc20Abi, type Hex, zeroAddress } from 'viem'
+import {
+  type Address,
+  createClient,
+  custom,
+  encodeFunctionData,
+  erc20Abi,
+  type Hex,
+  zeroAddress,
+} from 'viem'
 import { prepareTransactionRequest, signTransaction, waitForTransactionReceipt } from 'viem/actions'
 import { Addresses, Transaction } from 'viem/tempo'
 import { beforeAll, describe, expect, test } from 'vp/test'
@@ -450,6 +458,70 @@ describe.runIf(isLocalnet)('on-chain', () => {
       ).rejects.toThrow('gas exceeds sponsor policy')
     })
 
+    test('fee-payer: simulates open before broadcasting', async () => {
+      const rpcMethods: string[] = []
+      const interceptingClient = createClient({
+        account: accounts[0],
+        chain: client.chain,
+        transport: custom({
+          async request(args: any) {
+            rpcMethods.push(args.method)
+            return client.transport.request(args)
+          },
+        }),
+      })
+
+      const salt = nextSalt()
+      const deposit = 5_000_000n
+      const approveData = encodeFunctionData({
+        abi: erc20Abi,
+        functionName: 'approve',
+        args: [escrowContract, deposit],
+      })
+      const openData = encodeFunctionData({
+        abi: escrowAbi,
+        functionName: 'open',
+        args: [recipient, currency, deposit, salt, zeroAddress],
+      })
+      const channelId = Channel.computeId({
+        authorizedSigner: zeroAddress,
+        chainId: chain.id,
+        escrowContract,
+        payee: recipient,
+        payer: payer.address,
+        salt,
+        token: currency,
+      }) as Hex
+      const prepared = await prepareTransactionRequest(client, {
+        account: payer,
+        calls: [
+          { to: currency, data: approveData },
+          { to: escrowContract, data: openData },
+        ],
+        feePayer: true,
+        feeToken: currency,
+      } as never)
+      prepared.gas = prepared.gas! + 5_000n
+      const serializedTransaction = await signTransaction(client, prepared as never)
+
+      await broadcastOpenTransaction({
+        client: interceptingClient,
+        serializedTransaction,
+        escrowContract,
+        channelId,
+        recipient,
+        currency,
+        feePayer: accounts[0],
+      })
+
+      const broadcastIndex = rpcMethods.indexOf('eth_sendRawTransactionSync')
+      const simulationIndex = rpcMethods.indexOf('eth_call')
+
+      expect(broadcastIndex).toBeGreaterThan(-1)
+      expect(simulationIndex).toBeGreaterThan(-1)
+      expect(simulationIndex).toBeLessThan(broadcastIndex)
+    })
+
     test('fee-payer: rejects smuggled second open call', async () => {
       const deposit = 5_000_000n
       const smuggledDeposit = 7_000_000n
@@ -892,6 +964,73 @@ describe.runIf(isLocalnet)('on-chain', () => {
       ).rejects.toThrow('gas exceeds sponsor policy')
     })
 
+    test('fee-payer: simulates topUp before broadcasting', async () => {
+      const rpcMethods: string[] = []
+      const interceptingClient = createClient({
+        account: accounts[0],
+        chain: client.chain,
+        transport: custom({
+          async request(args: any) {
+            rpcMethods.push(args.method)
+            return client.transport.request(args)
+          },
+        }),
+      })
+
+      const salt = nextSalt()
+      const deposit = 5_000_000n
+      const topUpAmount = 3_000_000n
+
+      const { channelId } = await openChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit,
+        salt,
+      })
+
+      const approveData = encodeFunctionData({
+        abi: erc20Abi,
+        functionName: 'approve',
+        args: [escrowContract, topUpAmount],
+      })
+      const topUpData = encodeFunctionData({
+        abi: escrowAbi,
+        functionName: 'topUp',
+        args: [channelId, topUpAmount],
+      })
+      const prepared = await prepareTransactionRequest(client, {
+        account: payer,
+        calls: [
+          { to: currency, data: approveData },
+          { to: escrowContract, data: topUpData },
+        ],
+        feePayer: true,
+        feeToken: currency,
+      } as never)
+      prepared.gas = prepared.gas! + 5_000n
+      const serializedTransaction = await signTransaction(client, prepared as never)
+
+      await broadcastTopUpTransaction({
+        client: interceptingClient,
+        serializedTransaction,
+        escrowContract,
+        channelId,
+        currency: asset,
+        declaredDeposit: topUpAmount,
+        previousDeposit: deposit,
+        feePayer: accounts[0],
+      })
+
+      const broadcastIndex = rpcMethods.indexOf('eth_sendRawTransactionSync')
+      const simulationIndex = rpcMethods.indexOf('eth_call')
+
+      expect(broadcastIndex).toBeGreaterThan(-1)
+      expect(simulationIndex).toBeGreaterThan(-1)
+      expect(simulationIndex).toBeLessThan(broadcastIndex)
+    })
+
     test('fee-payer: rejects smuggled second topUp call', async () => {
       const salt = nextSalt()
       const deposit = 5_000_000n

package/src/tempo/session/Chain.ts

@@ -449,6 +449,7 @@ export async function broadcastOpenTransaction(parameters: {
   challengeExpires?: string | undefined
   feePayerPolicy?: Partial<FeePayer.Policy> | undefined
   feePayer?: Account | undefined
+  beforeBroadcast?: ((onChain: OnChainChannel) => Promise<void> | void) | undefined
   /** When false, simulates instead of waiting for confirmation and returns derived on-chain state. @default true */
   waitForConfirmation?: boolean | undefined
 }): Promise<BroadcastResult> {
@@ -462,6 +463,7 @@ export async function broadcastOpenTransaction(parameters: {
     challengeExpires,
     feePayerPolicy,
     feePayer,
+    beforeBroadcast,
     waitForConfirmation = true,
   } = parameters
 
@@ -551,6 +553,19 @@ export async function broadcastOpenTransaction(parameters: {
   const resolvedFeeToken =
     transaction.feeToken ?? defaults.currency[client.chain?.id as keyof typeof defaults.currency]
 
+  const pendingOnChain = {
+    finalized: false,
+    closeRequestedAt: 0n,
+    payer: transaction.from,
+    payee,
+    token,
+    authorizedSigner,
+    deposit,
+    settled: 0n,
+  } as OnChainChannel
+
+  await beforeBroadcast?.(pendingOnChain)
+
   const serializedTransaction_final = await (async () => {
     if (feePayer) {
       if (!sponsoredOpenCall)
@@ -588,21 +603,20 @@ export async function broadcastOpenTransaction(parameters: {
 
     return {
       txHash,
-      onChain: {
-        finalized: false,
-        closeRequestedAt: 0n,
-        payer: transaction.from,
-        payee,
-        token,
-        authorizedSigner,
-        deposit,
-        settled: 0n,
-      } as OnChainChannel,
+      onChain: pendingOnChain,
     }
   }
 
   let txHash: Hex | undefined
   try {
+    if (feePayer)
+      await call(client, {
+        ...transaction,
+        account: transaction.from,
+        feeToken: resolvedFeeToken,
+        calls,
+      } as never)
+
     const receipt = await sendRawTransactionSync(client, {
       serializedTransaction: serializedTransaction_final as Transaction.TransactionSerializedTempo,
     })
@@ -732,6 +746,16 @@ export async function broadcastTopUpTransaction(parameters: {
     return serializedTransaction
   })()
 
+  if (feePayer)
+    await call(client, {
+      ...transaction,
+      account: transaction.from,
+      feeToken:
+        transaction.feeToken ??
+        defaults.currency[client.chain?.id as keyof typeof defaults.currency],
+      calls,
+    } as never)
+
   const receipt = await sendRawTransactionSync(client, {
     serializedTransaction: serializedTransaction_final as Transaction.TransactionSerializedTempo,
   })

package/src/tempo/session/ChannelStore.test.ts

@@ -292,6 +292,27 @@ describe('ChannelStore.deductFromChannel', () => {
     expect(result.channel.spent).toBe(0n)
   })
 
+  test.each([
+    { label: 'atomic backend', create: () => ChannelStore.fromStore(Store.memory()) },
+    {
+      label: 'mutex fallback',
+      create: () => ChannelStore.fromStore(stripUpdateMethod(Store.memory())),
+    },
+  ])('rejects deduction when channel close has been requested ($label)', async ({ create }) => {
+    const cs = create()
+    await seedChannel(cs, {
+      highestVoucherAmount: 10_000_000n,
+      spent: 0n,
+      closeRequestedAt: 1n,
+    })
+
+    const result = await ChannelStore.deductFromChannel(cs, channelId, 1_000_000n)
+    expect(result.ok).toBe(false)
+    expect(result.channel.closeRequestedAt).toBe(1n)
+    expect(result.channel.spent).toBe(0n)
+    expect(result.channel.units).toBe(0)
+  })
+
   test('exact balance succeeds', async () => {
     const cs = ChannelStore.fromStore(Store.memory())
     await seedChannel(cs, { highestVoucherAmount: 1_000_000n, spent: 0n })

package/src/tempo/session/ChannelStore.ts

@@ -140,6 +140,8 @@ export async function deductFromChannel(
         if (!current) return { op: 'noop', result: null }
         if (current.finalized)
           return { op: 'noop', result: { ok: false, channel: current } as const }
+        if (current.closeRequestedAt !== 0n)
+          return { op: 'noop', result: { ok: false, channel: current } as const }
         if (current.highestVoucherAmount - current.spent >= amount) {
           const next = { ...current, spent: current.spent + amount, units: current.units + 1 }
           return { op: 'set', value: next, result: { ok: true, channel: next } as const }
@@ -158,6 +160,10 @@ export async function deductFromChannel(
       result = { ok: false, channel: current }
       return current
     }
+    if (current.closeRequestedAt !== 0n) {
+      result = { ok: false, channel: current }
+      return current
+    }
     if (current.highestVoucherAmount - current.spent >= amount) {
       const next = { ...current, spent: current.spent + amount, units: current.units + 1 }
       result = { ok: true, channel: next }

package/src/tempo/session/Sse.test.ts

@@ -1,6 +1,7 @@
 import type { Address, Hex } from 'viem'
 import { describe, expect, test } from 'vp/test'
 
+import { ChannelClosedError } from '../../Errors.js'
 import { chainId, escrowContract as escrowContractDefaults } from '../internal/defaults.js'
 import type * as ChannelStore from './ChannelStore.js'
 import { formatNeedVoucherEvent, formatReceiptEvent, parseEvent, serve } from './Sse.js'
@@ -257,6 +258,31 @@ describe('serve', () => {
     expect(channel!.units).toBe(3)
   })
 
+  test('uses a prepaid unit for the first generated value', async () => {
+    const storage = memoryStore()
+    await seedChannel(storage, 3000000n)
+    await storage.updateChannel(channelId, (current) =>
+      current ? { ...current, spent: 1000000n, units: 1 } : current,
+    )
+
+    const stream = serve({
+      store: storage,
+      channelId,
+      challengeId,
+      tickCost: 1000000n,
+      generate: generate(['hello', 'world']),
+      prepaidUnits: 1,
+    })
+
+    const output = await readStream(stream)
+    expect(output).toContain('event: message\ndata: hello\n\n')
+    expect(output).toContain('event: message\ndata: world\n\n')
+
+    const channel = await storage.getChannel(channelId)
+    expect(channel!.spent).toBe(2000000n)
+    expect(channel!.units).toBe(2)
+  })
+
   test('emits multiline message values as a single SSE message event', async () => {
     const storage = memoryStore()
     await seedChannel(storage, 1000000n)
@@ -468,4 +494,30 @@ describe('serve', () => {
     const reader = stream.getReader()
     await expect(reader.read()).rejects.toThrow('channel not found')
   })
+
+  test('rejects a reserved charge when channel close is requested before commit', async () => {
+    const storage = memoryStore()
+    await seedChannel(storage, 1000000n)
+
+    const stream = serve({
+      store: storage,
+      channelId,
+      challengeId,
+      tickCost: 1000000n,
+      generate: async function* (stream) {
+        await stream.charge()
+        await storage.updateChannel(channelId, (current) =>
+          current ? { ...current, closeRequestedAt: 1n } : null,
+        )
+        yield 'blocked'
+      },
+    })
+
+    const reader = stream.getReader()
+    await expect(reader.read()).rejects.toThrow(ChannelClosedError)
+
+    const channel = await storage.getChannel(channelId)
+    expect(channel!.spent).toBe(0n)
+    expect(channel!.units).toBe(0)
+  })
 })

package/src/tempo/session/Sse.ts

@@ -9,6 +9,7 @@
 import type { Hex } from 'viem'
 
 import * as Credential from '../../Credential.js'
+import { ChannelClosedError } from '../../Errors.js'
 import * as ChannelStore from './ChannelStore.js'
 import { createSessionReceipt } from './Receipt.js'
 import type { NeedVoucherEvent, SessionCredentialPayload, SessionReceipt } from './Types.js'
@@ -140,11 +141,16 @@ export function serve(options: serve.Options): ReadableStream<Uint8Array> {
     async start(controller) {
       const aborted = () => signal?.aborted ?? false
       const emit = (event: string) => controller.enqueue(encoder.encode(event))
+      let prepaidUnits = options.prepaidUnits ?? 0
       let reservedAmount = 0n
       let reservedUnits = 0
 
-      const charge = () =>
-        reserveChargeOrWait({
+      const charge = () => {
+        if (prepaidUnits > 0) {
+          prepaidUnits -= 1
+          return Promise.resolve()
+        }
+        return reserveChargeOrWait({
           store,
           channelId,
           amount: tickCost,
@@ -156,6 +162,7 @@ export function serve(options: serve.Options): ReadableStream<Uint8Array> {
           reservedAmount += tickCost
           reservedUnits += 1
         })
+      }
 
       const iterable: AsyncIterable<string> =
         typeof generate === 'function' ? generate({ charge }) : generate
@@ -206,6 +213,7 @@ export declare namespace serve {
     tickCost: bigint
     generate: AsyncIterable<string> | ((stream: SessionController) => AsyncIterable<string>)
     pollIntervalMs?: number | undefined
+    prepaidUnits?: number | undefined
     signal?: AbortSignal | undefined
   }
 }
@@ -274,6 +282,7 @@ async function reserveChargeOrWait(options: {
 
   let channel = await store.getChannel(channelId)
   if (!channel) throw new Error('channel not found')
+  throwIfChannelClosed(channel)
 
   const hasHeadroom = (state: ChannelStore.State) =>
     state.highestVoucherAmount - state.spent - reservedAmount >= amount
@@ -297,6 +306,7 @@ async function reserveChargeOrWait(options: {
     await waitForUpdate(store, channelId, pollIntervalMs, signal)
     channel = await store.getChannel(channelId)
     if (!channel) throw new Error('channel not found')
+    throwIfChannelClosed(channel)
   }
 }
 
@@ -313,6 +323,7 @@ async function commitReservedCharges(options: {
   const channel = await store.updateChannel(channelId, (current) => {
     if (!current) return null
     if (current.finalized) return current
+    if (current.closeRequestedAt !== 0n) return current
     if (current.highestVoucherAmount - current.spent < amount) return current
     committed = true
     return {
@@ -323,9 +334,18 @@ async function commitReservedCharges(options: {
   })
 
   if (!channel) throw new Error('channel not found')
+  if (channel.finalized) throw new ChannelClosedError({ reason: 'channel is finalized' })
+  if (channel.closeRequestedAt !== 0n)
+    throw new ChannelClosedError({ reason: 'channel has a pending close request' })
   if (!committed) throw new Error('reserved voucher coverage is no longer available')
 }
 
+function throwIfChannelClosed(channel: ChannelStore.State): void {
+  if (channel.finalized) throw new ChannelClosedError({ reason: 'channel is finalized' })
+  if (channel.closeRequestedAt !== 0n)
+    throw new ChannelClosedError({ reason: 'channel has a pending close request' })
+}
+
 async function waitForUpdate(
   store: ChannelStore.ChannelStore,
   channelId: Hex,