mppx 0.8.8 → 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,54 @@ 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 () => {
+    const rpcMethods: string[] = []
+    const serializedTransaction = await createOpenTransaction({ signed: true })
+    const transaction = Transaction.deserialize(
+      serializedTransaction as Transaction.TransactionSerializedTempo,
+    )
+    const payer = transaction.from!
+    const expiringNonceHash = Channel.computeExpiringNonceHash(
+      Channel.transactionForExpiringNonceHash({ feePayer: true, transaction }),
+      { sender: payer },
+    )
+    const expectedDescriptor = { ...descriptor, payer, expiringNonceHash }
+    const channelId = Channel.computeId({
+      ...expectedDescriptor,
+      chainId,
+      escrow: tip20ChannelEscrow,
+    })
+    const state = { settled: 0n, deposit, closeRequestedAt: 0 }
+
+    await Chain.broadcastOpenTransaction({
+      chainId,
+      client: createMockClient({
+        channel: { descriptor: expectedDescriptor, state },
+        receipt: receipt([openedLog({ channelId, expiringNonceHash })]),
+        rpcMethods,
+      }),
+      escrowContract: tip20ChannelEscrow,
+      expectedAuthorizedSigner: descriptor.authorizedSigner,
+      expectedChannelId: channelId,
+      expectedCurrency: descriptor.token,
+      expectedExpiringNonceHash: expiringNonceHash,
+      expectedOperator: descriptor.operator,
+      expectedPayee: descriptor.payee,
+      expectedPayer: payer,
+      feePayer: true,
+      serializedTransaction,
+    })
+
+    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 () => {
@@ -929,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

@@ -406,7 +406,7 @@ type ParsedPrecompileCredentialTransaction = {
 
 function parsePrecompileCredentialTransaction(parameters: {
   escrowContract: Address
-  feePayer?: Account | undefined
+  feePayer?: Account | true | undefined
   label: 'open' | 'topUp'
   serializedTransaction: Hex
 }): ParsedPrecompileCredentialTransaction {
@@ -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> {
@@ -668,8 +663,8 @@ export type SendCredentialTransactionParameters = {
   allowedFeeTokens?: readonly Address[] | undefined
   /** Human-readable transaction details used by fee-payer policy hooks. */
   details: Record<string, string>
-  /** Fee-payer account used to co-sign Tempo transactions. */
-  feePayer?: Account | undefined
+  /** Fee-payer account, or `true` when the client transport delegates co-signing to a hosted relay. */
+  feePayer?: Account | true | undefined
   /** Optional fee-payer policy enforced before co-signing. */
   feePayerPolicy?: Partial<FeePayer.Policy> | undefined
   /** Management transaction kind, used for validation errors. */
@@ -704,21 +699,39 @@ export async function sendCredentialTransaction(parameters: SendCredentialTransa
     throw new BadRequestError({ reason: 'Only Tempo (0x76/0x78) transactions are supported' })
   assertSenderSigned(transaction)
 
-  await simulateTempoTransaction(client, 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)
+  }
 
-  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,
   })
@@ -771,8 +784,8 @@ export type BroadcastOpenTransactionParameters = {
   expectedPayee: Address
   /** Payer expected to have signed the open transaction. */
   expectedPayer: Address
-  /** Fee-payer account used to co-sign sponsored open transactions. */
-  feePayer?: Account | undefined
+  /** Fee-payer account, or `true` when the client transport delegates co-signing to a hosted relay. */
+  feePayer?: Account | true | undefined
   /** Optional fee-payer policy enforced before co-signing. */
   feePayerPolicy?: Partial<FeePayer.Policy> | undefined
   /** Client-signed serialized open transaction. */
@@ -895,8 +908,8 @@ export type BroadcastTopUpTransactionParameters = {
   expectedChannelId: Hex
   /** Payment token expected for sponsored transaction fee token checks. */
   expectedCurrency: Address
-  /** Fee-payer account used to co-sign sponsored top-up transactions. */
-  feePayer?: Account | undefined
+  /** Fee-payer account, or `true` when the client transport delegates co-signing to a hosted relay. */
+  feePayer?: Account | true | undefined
   /** Optional fee-payer policy enforced before co-signing. */
   feePayerPolicy?: Partial<FeePayer.Policy> | undefined
   /** Client-signed serialized top-up transaction. */

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

@@ -334,8 +334,8 @@ export type VerifyCredentialPayloadParameters = {
   escrow: Address
   /** Operator address advertised in the HMAC-bound challenge details. */
   expectedOperator?: Address | undefined
-  /** Optional fee-payer account for fee-sponsored management transactions. */
-  feePayer?: viem_Account | undefined
+  /** Fee-payer account, or `true` when the client transport delegates co-signing to a hosted relay. */
+  feePayer?: viem_Account | true | undefined
   /** Optional policy for fee-sponsored close/open/top-up transactions. */
   feePayerPolicy?: Partial<FeePayer.Policy> | undefined
   /** Optional fee token override for close transactions. */
@@ -714,7 +714,7 @@ async function handleCloseCredential(
       account
         ? {
             account,
-            ...(parameters.feePayer ? { feePayer: parameters.feePayer } : {}),
+            ...(typeof parameters.feePayer === 'object' ? { feePayer: parameters.feePayer } : {}),
             ...(parameters.feePayerPolicy ? { feePayerPolicy: parameters.feePayerPolicy } : {}),
             ...(parameters.feeToken ? { feeToken: parameters.feeToken } : {}),
             candidateFeeTokens: [channel.token],

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

@@ -27,6 +27,7 @@ import {
   resolveCredentialFeePayer,
   resolveRequestFeePayer,
   type ParameterFeePayer,
+  type ResolvedFeePayer,
 } from './Settlement.js'
 
 /** Inputs used to build server bootstrap hints for a reusable session channel. */
@@ -267,8 +268,8 @@ export type ResolveSessionPaymentRequestParameters = {
 
 /** Inputs used to resolve shared context for credential verification. */
 export type ResolveCredentialVerificationContextParameters = {
-  /** Default configured fee-payer account, when enabled. */
-  feePayer?: viem_Account | undefined
+  /** Configured local fee payer, hosted relay URL, or sponsorship flag. */
+  feePayer?: ParameterFeePayer
   /** Resolves a viem client for the challenge chain ID. */
   getClient(parameters: {
     chainId: number
@@ -294,7 +295,7 @@ export type CredentialVerificationContext = {
   /** Client for precompile reads and transaction broadcasts. */
   client: PrecompileChain.TransactionClient
   /** Fee payer authorized for this credential, when allowed. */
-  feePayer?: viem_Account | undefined
+  feePayer?: ResolvedFeePayer
   /** Minimum allowed voucher delta in raw token units. */
   minVoucherDelta: bigint
 }

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/Session.ts

@@ -315,9 +315,11 @@ export function session<const parameters extends session.Parameters>(
 
   const store = ChannelStore.fromStore(rawStore)
   const lastOnChainVerified = new Map<Hex, number>()
-  const { account, feePayer, recipient } = Account.resolve(parameters)
+  const { account, feePayer, feePayerUrl, recipient } = Account.resolve(parameters)
+  const configuredFeePayer = feePayer ?? feePayerUrl
   const getClient = Client.getResolver({
     chain: tempo_chain,
+    feePayerUrl,
     getClient: parameters.getClient,
     rpcUrl: defaults.rpcUrl,
   })
@@ -326,6 +328,7 @@ export function session<const parameters extends session.Parameters>(
     chainId: parameters.chainId,
     currency,
     decimals,
+    feePayer: parameters.feePayer,
     getClient: parameters.getClient,
     recipient,
     store: rawStore,
@@ -401,7 +404,7 @@ export function session<const parameters extends session.Parameters>(
       const payload = requireSessionCredentialPayload(credential.payload)
       const context = await resolveCredentialVerificationContext({
         decimals,
-        feePayer,
+        feePayer: configuredFeePayer,
         getClient,
         minVoucherDelta: parameters.minVoucherDelta,
         request,
@@ -438,7 +441,7 @@ export function session<const parameters extends session.Parameters>(
           maybeSettleScheduled({
             account,
             client: context.client,
-            feePayer: context.feePayer,
+            ...(typeof context.feePayer === 'object' ? { feePayer: context.feePayer } : {}),
             feePayerPolicy: parameters.feePayerPolicy,
             feeToken: parameters.feeToken,
             schedule: settlementSchedule,

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

@@ -23,6 +23,7 @@ describe('FeePayerResolution', () => {
   const requestFeePayer = privateKeyToAccount(
     '0x5de4111a56d1f1ad3c74c8a3be6fba32114d0f9f8e9e4b0d4d4f5a7833f1b6c9',
   )
+  const feePayerUrl = 'https://fee-payer.example/relay'
 
   function credential(): Credential.Credential {
     return {
@@ -60,6 +61,13 @@ describe('FeePayerResolution', () => {
           parameterFeePayer: true,
         }),
       ).toBe(true)
+
+      expect(
+        resolveRequestFeePayer({
+          credential: null,
+          parameterFeePayer: feePayerUrl,
+        }),
+      ).toBe(true)
     })
 
     test('does not advertise fee-payer support when request disables it', () => {
@@ -106,6 +114,14 @@ describe('FeePayerResolution', () => {
         }),
       ).toBe(defaultFeePayer)
 
+      expect(
+        resolveCredentialFeePayer({
+          feePayer: feePayerUrl,
+          methodDetails: { feePayer: true },
+          request: { feePayer: true },
+        }),
+      ).toBe(true)
+
       expect(
         resolveCredentialFeePayer({
           feePayer: defaultFeePayer,

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

@@ -32,6 +32,9 @@ import * as ChannelStore from './ChannelStore.js'
 /** Fee-payer parameter accepted by the server session method. */
 export type ParameterFeePayer = viem_Account | string | true | undefined
 
+/** Resolved fee-payer mode for credential-time transaction submission. */
+export type ResolvedFeePayer = viem_Account | true | undefined
+
 /** Minimum method details needed to decide credential-time fee sponsorship. */
 export type CredentialFeePayerMethodDetails = {
   /** Whether the challenge advertised fee-payer support. */
@@ -56,8 +59,8 @@ export type ResolveCredentialFeePayerParameters = {
   request: unknown
   /** Challenge method details echoed by the credential. */
   methodDetails: CredentialFeePayerMethodDetails
-  /** Default fee-payer account resolved from server parameters. */
-  feePayer?: viem_Account | undefined
+  /** Configured local fee payer, hosted relay URL, or sponsorship flag. */
+  feePayer?: ParameterFeePayer
 }
 
 /** Fee-payer value read from an untrusted credential challenge request. */
@@ -89,20 +92,28 @@ export function resolveRequestFeePayer(
 
   const account = typeof requestFeePayer === 'object' ? requestFeePayer : defaultFeePayer
   if (credential) return account ?? undefined
-  if (account || defaultFeePayer || parameterFeePayer === true) return true
+  if (
+    account ||
+    defaultFeePayer ||
+    parameterFeePayer === true ||
+    typeof parameterFeePayer === 'string'
+  )
+    return true
   return undefined
 }
 
 /** Resolves the fee-payer account allowed for an incoming credential. */
 export function resolveCredentialFeePayer(
   parameters: ResolveCredentialFeePayerParameters,
-): viem_Account | undefined {
+): ResolvedFeePayer {
   const { feePayer, methodDetails, request } = parameters
   const requestFeePayer = readRequestFeePayer(request)
   const requestAllowsFeePayer =
     requestFeePayer === undefined || requestFeePayer === true || typeof requestFeePayer === 'object'
   if (methodDetails.feePayer !== true || !requestAllowsFeePayer) return undefined
-  return typeof requestFeePayer === 'object' ? requestFeePayer : feePayer
+  if (typeof requestFeePayer === 'object') return requestFeePayer
+  if (typeof feePayer === 'object') return feePayer
+  return typeof feePayer === 'string' ? true : undefined
 }
 
 /** Declarative server-side settlement cadence for automatic session settlement. */

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,