mppx 0.6.13 → 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/Sse.test.ts

@@ -258,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)

package/src/tempo/session/Sse.ts

@@ -141,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,
@@ -157,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
@@ -207,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
   }
 }