mppx 0.8.9 → 0.8.11

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

@@ -329,9 +329,13 @@ describe('Session', () => {
       expect(posted[0]).toMatchObject({ action: 'voucher', channelId: storedChannelId })
     })
 
-    test('seeds a same-route HEAD snapshot into the entry index and resumes it', async () => {
+    test('seeds a same-route HEAD snapshot and resolves the account when resuming it', async () => {
       const { store, set } = makeChannelStore()
       const posted: SessionCredentialPayload[] = []
+      const resolveAccount = vi.fn(
+        (info: Parameters<NonNullable<sessionManager.Parameters['resolveAccount']>>[0]) =>
+          info.account,
+      )
       const mockFetch = vi.fn().mockImplementation((_input, init?: RequestInit) => {
         const headers = new Headers(init?.headers)
         if (init?.method === 'HEAD' && !headers.get(Constants.Headers.authorization)) {
@@ -377,6 +381,7 @@ describe('Session', () => {
         client,
         fetch: mockFetch as typeof globalThis.fetch,
         channelStore: store,
+        resolveAccount,
       })
 
       const response = await s.fetch('https://api.example.com/data')
@@ -384,6 +389,12 @@ describe('Session', () => {
       expect(response.status).toBe(200)
       expect(set).toHaveBeenCalledWith(expect.objectContaining({ channelId: storedChannelId }))
       expect(posted[0]).toMatchObject({ action: 'voucher', channelId: storedChannelId })
+      expect(resolveAccount).toHaveBeenCalledOnce()
+      expect(resolveAccount).toHaveBeenCalledWith({
+        account,
+        chainId: 4217,
+        operation: { authority: account.address, kind: 'authorizePaymentChannel' },
+      })
       const contentCall = mockFetch.mock.calls.find((call) => call[1]?.method !== 'HEAD')
       expect(new Headers(contentCall?.[1]?.headers).get('Payment-Session')).toBeNull()
     })

package/src/tempo/session/client/SessionManager.ts

@@ -274,6 +274,7 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
   const method = sessionPlugin({
     account: parameters.account,
     getClient: parameters.client ? () => parameters.client! : parameters.getClient,
+    resolveAccount: parameters.resolveAccount,
     escrow: parameters.escrow,
     decimals: config.decimals,
     maxDeposit: parameters.maxDeposit,
@@ -787,6 +788,8 @@ export namespace sessionManager {
       fetch?: typeof globalThis.fetch | undefined
       /** Maximum deposit in human-readable units (e.g. `'10'` for 10 tokens). Converted to raw units via `decimals`. */
       maxDeposit?: string | undefined
+      /** Selects the account that signs session credentials. */
+      resolveAccount?: sessionPlugin.ResolveAccount | undefined
       /** Store for reusable session channels. Defaults to in-memory. */
       channelStore?: ChannelStore | undefined
       /** Optional websocket constructor for runtimes without a global WebSocket. */

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

@@ -19,6 +19,7 @@ import {
   applyTopUpResult,
   closeHttpSession,
   createActiveSocketSession,
+  driveSseResponse,
   isExpectedSocketReceipt,
   managementInput,
   postTopUp,
@@ -640,6 +641,39 @@ describe('VoucherManagement', () => {
   })
 })
 
+describe('SseDriver', () => {
+  test('preserves application frames and consumes payment receipts', async () => {
+    const receipt = createSessionReceipt({
+      acceptedCumulative: 2n,
+      challengeId: 'challenge-1',
+      channelId: `0x${'01'.repeat(32)}`,
+      spent: 2n,
+    })
+    const acceptReceipt = vi.fn()
+    const response = new Response(
+      [
+        ': keepalive\n\n',
+        'event: custom\ndata: hello\n\n',
+        `event: payment-receipt\ndata: ${JSON.stringify(receipt)}\n\n`,
+      ].join(''),
+    )
+
+    const frames = []
+    for await (const frame of driveSseResponse({
+      async onNeedVoucher() {},
+      onReceipt: acceptReceipt,
+      response,
+    }))
+      frames.push(frame)
+
+    expect(frames).toEqual([
+      { raw: ': keepalive\n\n' },
+      { data: 'hello', raw: 'event: custom\ndata: hello\n\n' },
+    ])
+    expect(acceptReceipt).toHaveBeenCalledWith(receipt)
+  })
+})
+
 describe('WsDriver', () => {
   const channelId = '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex.Hex
   const challenge: TempoSessionChallenge = {

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

@@ -777,29 +777,49 @@ export async function openSseSession(
   if (!isEventStream(response)) throw new Error('SSE response is not an event stream.')
   if (!response.body) throw new Error('Response has no body.')
 
-  return iterateSseResponse({
-    challenge,
-    driver,
-    input,
-    onReceipt,
+  return iterateSseMessages({
+    onNeedVoucher: (event) => handleSseNeedVoucher({ challenge, driver, input }, event),
+    onReceipt(receipt) {
+      driver.acceptReceipt(receipt)
+      onReceipt?.(receipt)
+    },
     response,
     signal,
   })
 }
 
-type IterateSseResponseParameters = {
-  challenge: TempoSessionChallenge | null
-  driver: OpenSseSessionParameters
-  input: RequestInfo | URL
-  onReceipt?: ((receipt: SessionReceipt) => void) | undefined
+/** Application SSE frame emitted after session payment events are handled. */
+export type SseResponseFrame = {
+  /** Parsed application data, when present. */
+  data?: string | undefined
+  /** Original frame text, including its separator. */
+  raw: string
+}
+
+/** Inputs for driving an open paid SSE response. */
+export type DriveSseResponseParameters = {
+  /** Handles a request for the stream's next cumulative voucher. */
+  onNeedVoucher(event: NeedVoucherEvent): Promise<void>
+  /** Handles a payment receipt emitted by the stream. */
+  onReceipt(receipt: SessionReceipt): void
+  /** Open SSE response to drive. */
   response: Response
+  /** Abort signal used to stop reading the response. */
   signal?: AbortSignal | undefined
 }
 
-async function* iterateSseResponse(
-  parameters: IterateSseResponseParameters,
-): AsyncGenerator<string> {
-  const reader = parameters.response.body!.getReader()
+async function* iterateSseMessages(parameters: DriveSseResponseParameters): AsyncGenerator<string> {
+  for await (const frame of driveSseResponse(parameters)) {
+    if (frame.data !== undefined) yield frame.data
+  }
+}
+
+/** Handles session payment events and yields application SSE frames unchanged. */
+export async function* driveSseResponse(
+  parameters: DriveSseResponseParameters,
+): AsyncGenerator<SseResponseFrame> {
+  if (!parameters.response.body) throw new Error('Response has no body.')
+  const reader = parameters.response.body.getReader()
   const decoder = new TextDecoder()
   let buffer = ''
 
@@ -817,18 +837,21 @@ async function* iterateSseResponse(
       for (const part of parts) {
         if (!part.trim()) continue
         const event = parseEvent(part)
-        if (!event) continue
+        const raw = `${part}\n\n`
+        if (!event) {
+          yield { raw }
+          continue
+        }
 
         switch (event.type) {
           case 'message':
-            yield event.data
+            yield { data: event.data, raw }
             break
           case 'payment-need-voucher':
-            await handleSseNeedVoucher(parameters, event.data)
+            await parameters.onNeedVoucher(event.data)
             break
           case 'payment-receipt':
-            parameters.driver.acceptReceipt(event.data)
-            parameters.onReceipt?.(event.data)
+            parameters.onReceipt(event.data)
             break
         }
       }
@@ -839,7 +862,11 @@ async function* iterateSseResponse(
 }
 
 async function handleSseNeedVoucher(
-  parameters: IterateSseResponseParameters,
+  parameters: {
+    challenge: TempoSessionChallenge | null
+    driver: OpenSseSessionParameters
+    input: RequestInfo | URL
+  },
   event: NeedVoucherEvent,
 ) {
   const channel = parameters.driver.getChannel()

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

@@ -611,6 +611,9 @@ describe('precompile broadcastOpenTransaction', () => {
     expect(broadcastIndex).toBeGreaterThan(-1)
     expect(simulationIndex).toBeGreaterThan(-1)
     expect(simulationIndex).toBeLessThan(broadcastIndex)
+    expect(
+      rpcMethods.slice(0, broadcastIndex).filter((method) => method === 'eth_call'),
+    ).toHaveLength(2)
   })
 
   test('hosted fee-payer relays a sender-signed open without local co-signing', async () => {
@@ -653,6 +656,9 @@ describe('precompile broadcastOpenTransaction', () => {
 
     expect(rpcMethods).toContain('eth_sendRawTransaction')
     expect(rpcMethods).not.toContain('eth_sendRawTransactionSync')
+    expect(rpcMethods.indexOf('eth_call')).toBeLessThan(
+      rpcMethods.indexOf('eth_sendRawTransaction'),
+    )
   })
 
   test('rejects expiring nonce hash mismatches before broadcasting', async () => {
@@ -971,6 +977,9 @@ describe('precompile broadcastTopUpTransaction', () => {
     expect(broadcastIndex).toBeGreaterThan(-1)
     expect(simulationIndex).toBeGreaterThan(-1)
     expect(simulationIndex).toBeLessThan(broadcastIndex)
+    expect(
+      rpcMethods.slice(0, broadcastIndex).filter((method) => method === 'eth_call'),
+    ).toHaveLength(2)
   })
 
   test('rejects top-up calldata amount mismatches before broadcasting', async () => {

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

@@ -434,15 +434,10 @@ function parsePrecompileCredentialTransaction(parameters: {
   return { transaction, call: { ...call, data: call.data, to: call.to } }
 }
 
-async function simulateTempoTransaction(client: Client, transaction: Transaction.TransactionTempo) {
+async function simulateTempoTransaction(client: Client, request: unknown) {
   // viem's public `call` type does not yet model Tempo's multi-call and
   // fee-payer fields together. Keep that compatibility cast in one place.
-  await call(client, {
-    ...transaction,
-    account: transaction.from,
-    calls: transaction.calls ?? [],
-    feePayerSignature: undefined,
-  } as never)
+  await call(client, request as never)
 }
 
 async function signTempoTransaction(client: Client, transaction: unknown): Promise<Hex> {
@@ -705,25 +700,38 @@ export async function sendCredentialTransaction(parameters: SendCredentialTransa
   assertSenderSigned(transaction)
 
   if (feePayer === true) {
+    // The transport owns hosted completion, so mppx can only preflight call
+    // execution as the sender. It intentionally omits fee fields here; the
+    // transport is responsible for validating its final sponsored envelope.
+    await simulateTempoTransaction(
+      client,
+      FeePayer.simulationTransaction(transaction, { feePayer: true }),
+    )
     const txHash = await sendTransaction(client, serializedTransaction)
     return waitForSuccessfulReceipt(client, txHash)
   }
 
-  await simulateTempoTransaction(client, transaction)
-
-  const sponsored = FeePayer.prepareSponsoredTransaction({
-    account: feePayer,
-    allowedFeeTokens,
-    challengeExpires,
-    chainId,
-    details,
-    policy: feePayerPolicy,
-    transaction: {
-      ...transaction,
-      ...(allowedFeeTokens?.[0] ? { feeToken: transaction.feeToken ?? allowedFeeTokens[0] } : {}),
+  const sponsorshipTransaction = {
+    ...transaction,
+    ...(allowedFeeTokens?.[0] ? { feeToken: transaction.feeToken ?? allowedFeeTokens[0] } : {}),
+  }
+  const completed = await FeePayer.preflightSponsorship({
+    transaction: sponsorshipTransaction,
+    simulate: (request) => simulateTempoTransaction(client, request),
+    async complete() {
+      const sponsored = FeePayer.prepareSponsoredTransaction({
+        account: feePayer,
+        allowedFeeTokens,
+        challengeExpires,
+        chainId,
+        details,
+        policy: feePayerPolicy,
+        transaction: sponsorshipTransaction,
+      })
+      return { feePayer: feePayer.address, transaction: sponsored }
     },
   })
-  const serialized = await signTempoTransaction(client, sponsored)
+  const serialized = await signTempoTransaction(client, completed.transaction)
   const receipt = await sendRawTransactionSync(client, {
     serializedTransaction: serialized as Transaction.TransactionSerializedTempo,
   })

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

@@ -2257,6 +2257,7 @@ describe('precompile server session unit guardrails', () => {
         action: SessionCredentialPayload['action']
         contentLength: string | null
         hasBody: boolean
+        hasReceipt: boolean
         status: number
       }> = []
       const app = new Hono()
@@ -2271,6 +2272,7 @@ describe('precompile server session unit guardrails', () => {
             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
@@ -2302,9 +2304,27 @@ describe('precompile server session unit guardrails', () => {
         expect(closeReceipt?.spent).toBe('3')
         expect(managementPosts).toEqual(
           expect.arrayContaining([
-            { action: 'topUp', contentLength: '0', hasBody: true, status: 204 },
-            { action: 'voucher', contentLength: '0', hasBody: true, status: 204 },
-            { action: 'close', contentLength: '0', hasBody: true, status: 204 },
+            {
+              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)

package/src/tempo/session/server/index.ts

@@ -1,4 +1,6 @@
 export { charge, session, settle, settleBatch } from './Session.js'
+/** SSE helpers and types for Tempo session streams. */
+export * as Sse from './Sse.js'
 /** Server-side automatic settlement schedule. */
 export type {
   ResolveSessionChannelId,

package/src/validation/core.ts

@@ -25,6 +25,7 @@ export type ValidateOptions = {
   endpoint?: string | undefined
   body?: string | undefined
   query?: string[] | undefined
+  headers?: string[] | undefined
   verbose?: boolean | undefined
   yes?: boolean | undefined
   skipPayment?: boolean | undefined
@@ -92,12 +93,14 @@ export async function* validateStream(options: ValidateOptions): AsyncGenerator<
     yield { phase: 'endpoint', endpoint }
 
     let body: string | undefined
+    let bodyIsAutogenerated = false
     if (options.endpoint) {
       body = options.body
     } else {
       body = resolveBodyForEndpoint(options.body, endpoint.path)
       if (!body && discovery.doc) {
         body = extractRequestBodyFromDiscovery(discovery.doc, endpoint)
+        bodyIsAutogenerated = !!body
       }
     }
 
@@ -107,7 +110,9 @@ export async function* validateStream(options: ValidateOptions): AsyncGenerator<
       challenges: parsedChallenges,
     } = await validateChallenge(baseUrl, endpoint, verbose, {
       body,
+      bodyIsAutogenerated,
       query: options.query,
+      extraHeaders: options.headers,
       discoveryDoc: discovery.doc ?? undefined,
     })
     const effectiveBody = resolvedBody ?? body
@@ -156,6 +161,7 @@ export async function* validateStream(options: ValidateOptions): AsyncGenerator<
         const paymentResults = await validatePaymentFlow(baseUrl, endpoint, verbose, {
           body: effectiveBody,
           query: options.query,
+          extraHeaders: options.headers,
           yes: options.yes,
           silent: !onResults,
           interactive: options.interactive,

package/src/x402/Header.ts

@@ -68,7 +68,7 @@ const parsePaymentRequiredEnvelope = (value: unknown): PaymentRequiredEnvelope =
 
   const resource = ResourceInfoSchema.parse(record.resource)
   const extensions =
-    record.extensions === undefined ? undefined : ExtensionsSchema.parse(record.extensions)
+    record.extensions !== undefined ? ExtensionsSchema.safeParse(record.extensions).data : undefined
 
   return {
     accepts: record.accepts,