mppx 0.8.9 → 0.8.11

package/src/tempo/server/Charge.test.ts

@@ -1619,8 +1619,10 @@ describe('tempo', () => {
       httpServer.close()
     })
 
-    test('behavior: fee payer pre-broadcast simulation targets the co-signed transaction', async () => {
-      // The pre-broadcast simulation must reflect the FINAL co-signed envelope
+    test('behavior: fee payer simulates the sender and final sponsored envelopes', async () => {
+      // First simulate execution as the sender with fee fields omitted. This
+      // catches call-level reverts without requiring the sender to fund fees.
+      // The second simulation must reflect the FINAL co-signed envelope
       // (concrete sponsor fee payer), not the pre-cosign 0x78 (`feePayer: true`).
       const callRequests: any[] = []
       const interceptingClient = createClient({
@@ -1628,7 +1630,8 @@ describe('tempo', () => {
         chain: client.chain,
         transport: custom({
           async request(args: any) {
-            if (args.method === 'eth_call') callRequests.push(args.params?.[0])
+            if (args.method === 'eth_call' && args.params?.[0]?.calls)
+              callRequests.push(args.params[0])
             return client.transport.request(args)
           },
         }),
@@ -1682,14 +1685,16 @@ describe('tempo', () => {
       })
       expect(authResponse.status).toBe(200)
 
-      expect(callRequests.length).toBeGreaterThan(0)
-      const simRequest = callRequests[0]
+      expect(callRequests).toHaveLength(2)
+      expect(callRequests[0]).not.toHaveProperty('feePayer')
+      const simRequest = callRequests[1]
       // The co-signed envelope names a concrete sponsor as fee payer. The
       // pre-cosign 0x78 instead carries `feePayer: true`; asserting the address
       // proves we simulate the transaction the sponsor actually broadcasts.
       expect(simRequest.feePayer).not.toBe(true)
       expect(typeof simRequest.feePayer).toBe('string')
       expect((simRequest.feePayer as string).toLowerCase()).toBe(accounts[0].address.toLowerCase())
+      expect(simRequest.feeToken?.toLowerCase()).toBe(defaults.tokens.pathUsd.toLowerCase())
       // Execution runs as the sender, not the sponsor.
       expect((simRequest.from as string).toLowerCase()).toBe(accounts[1].address.toLowerCase())
       expect(simRequest.calls?.length).toBeGreaterThan(0)
@@ -1770,6 +1775,77 @@ describe('tempo', () => {
       httpServer.close()
     })
 
+    test('behavior: fee payer does not broadcast when final simulation reverts', async () => {
+      const rpcMethods: string[] = []
+      let simulations = 0
+      const interceptingClient = createClient({
+        account: accounts[0],
+        chain: client.chain,
+        transport: custom({
+          async request(args: any) {
+            rpcMethods.push(args.method)
+            if (args.method === 'eth_call' && ++simulations >= 2)
+              throw new Error('execution reverted: final simulation fixture')
+            return client.transport.request(args)
+          },
+        }),
+      })
+
+      const serverWithRevert = Mppx_server.create({
+        methods: [
+          tempo_server.charge({
+            getClient() {
+              return interceptingClient
+            },
+            currency: asset,
+            account: accounts[0],
+          }),
+        ],
+        realm,
+        secretKey,
+      })
+
+      const mppx = Mppx_client.create({
+        polyfill: false,
+        methods: [
+          tempo_client({
+            account: accounts[1],
+            getClient() {
+              return client
+            },
+          }),
+        ],
+      })
+
+      const httpServer = await Http.createServer(async (req, res) => {
+        const result = await Mppx_server.toNodeListener(
+          serverWithRevert.charge({
+            feePayer: accounts[0],
+            amount: '1',
+            currency: asset,
+            recipient: accounts[0].address,
+          }),
+        )(req, res)
+        if (result.status === 402) return
+        res.end('OK')
+      })
+
+      const challengeResponse = await fetch(httpServer.url)
+      const credential = await mppx.createCredential(challengeResponse)
+      rpcMethods.length = 0
+
+      const authResponse = await fetch(httpServer.url, {
+        headers: { Authorization: credential },
+      })
+
+      expect(authResponse.status).not.toBe(200)
+      expect(simulations).toBeGreaterThanOrEqual(2)
+      expect(rpcMethods).not.toContain('eth_sendRawTransactionSync')
+      expect(rpcMethods).not.toContain('eth_sendRawTransaction')
+
+      httpServer.close()
+    })
+
     test('behavior: fee payer fails closed when simulation reverts (optimistic mode)', async () => {
       const rpcMethods: string[] = []
       const interceptingClient = createClient({
@@ -2054,11 +2130,30 @@ describe('tempo', () => {
 
     test('behavior: fee payer URL (withFeePayer transport)', async () => {
       const feePayerRequests: any[] = []
+      const sequence: string[] = []
+      let rejectFinalSimulation = false
+      let simulations = 0
+      const interceptingClient = createClient({
+        account: accounts[0],
+        chain: client.chain,
+        transport: custom({
+          async request(args: any) {
+            if (args.method === 'eth_call' && args.params?.[0]?.calls) {
+              sequence.push('simulate')
+              if (rejectFinalSimulation && ++simulations >= 2)
+                throw new Error('hosted final simulation reverted')
+            }
+            if (args.method === 'eth_sendRawTransactionSync') sequence.push('broadcast')
+            return client.transport.request(args)
+          },
+        }),
+      })
       const feePayerServer = await Http.createServer(async (req, res) => {
         let requestBody = ''
         for await (const chunk of req) requestBody += chunk
         const request = JSON.parse(requestBody)
         feePayerRequests.push(request)
+        sequence.push('complete')
 
         const transaction = request.params[0]
         const quantity = (value: unknown) =>
@@ -2116,7 +2211,7 @@ describe('tempo', () => {
         methods: [
           tempo_server.charge({
             feePayer: feePayerServer.url,
-            getClient: () => client,
+            getClient: () => interceptingClient,
             currency: asset,
           }),
         ],
@@ -2149,6 +2244,7 @@ describe('tempo', () => {
       const response = await mppx.fetch(httpServer.url)
       expect(response.status).toBe(200)
       expect(feePayerRequests.map(({ method }) => method)).toEqual(['eth_fillTransaction'])
+      expect(sequence).toEqual(['simulate', 'complete', 'simulate', 'broadcast'])
 
       const receipt = Receipt.fromResponse(response)
       expect(receipt.status).toBe('success')
@@ -2158,10 +2254,29 @@ describe('tempo', () => {
       })
       expect((txReceipt as any).feePayer).toBe(accounts[0].address.toLowerCase())
 
+      sequence.length = 0
+      simulations = 0
+      rejectFinalSimulation = true
+      const rejected = await mppx.fetch(httpServer.url)
+
+      expect(rejected.status).not.toBe(200)
+      expect(feePayerRequests).toHaveLength(2)
+      expect(sequence.slice(0, 2)).toEqual(['simulate', 'complete'])
+      expect(sequence).not.toContain('broadcast')
+
       httpServer.close()
       feePayerServer.close()
     })
 
+    test('error: rejects a fee token configured for a remote fee payer', () => {
+      expect(() =>
+        tempo_server.charge({
+          feePayer: 'https://fee-payer.example',
+          feeToken: defaults.tokens.pathUsd,
+        }),
+      ).toThrow('`feeToken` can only be configured for a local fee payer.')
+    })
+
     test('behavior: access keys', async () => {
       const rootAccount = accounts[1]
       const accessKey = Account.fromSecp256k1(Secp256k1.randomPrivateKey(), {

package/src/tempo/server/Charge.ts

@@ -31,6 +31,7 @@ import * as TempoAddress from '../internal/address.js'
 import * as Charge_internal from '../internal/charge.js'
 import * as defaults from '../internal/defaults.js'
 import * as FeePayer from '../internal/fee-payer.js'
+import { resolveFeeToken } from '../internal/fee-token.js'
 import * as Proof from '../internal/proof.js'
 import * as Selectors from '../internal/selectors.js'
 import type * as types from '../internal/types.js'
@@ -59,6 +60,7 @@ export function charge<const parameters extends charge.Parameters>(
     decimals = defaults.decimals,
     description,
     externalId,
+    feeToken: configuredFeeToken,
     feePayerPolicy,
     html,
     memo,
@@ -79,6 +81,8 @@ export function charge<const parameters extends charge.Parameters>(
     : undefined
 
   const { recipient, feePayer, feePayerUrl } = Account.resolve(parameters)
+  if (configuredFeeToken && feePayerUrl)
+    throw new Error('`feeToken` can only be configured for a local fee payer.')
 
   const getClient = Client.getResolver({
     chain: { ...tempo_chain, experimental_preconfirmationTime: 500 },
@@ -405,67 +409,68 @@ export function charge<const parameters extends charge.Parameters>(
 
             const allowedFeeTokens = FeePayer.defaultAllowedFeeTokens(chainId)
             if (isFeePayerTx) FeePayer.assertAllowedFeeToken(transaction, allowedFeeTokens)
-
-            // Request for the pre-broadcast simulation; for sponsored payments
-            // this is overwritten below with the co-signed shape.
-            let simulationRequest: Record<string, unknown> = FeePayer.simulationTransaction(
-              transaction,
-              { feePayer: isFeePayerTx },
-            )
+            const selectableFeeTokens = allowedFeeTokens as readonly `0x${string}`[]
 
             const serializedTransaction_final = await (async () => {
               if (feePayerAccount && methodDetails?.feePayer !== false) {
-                const sponsored = FeePayer.prepareSponsoredTransaction({
-                  account: feePayerAccount,
-                  allowedFeeTokens,
-                  challengeExpires: expires,
-                  chainId: chainId ?? client.chain!.id,
-                  details: { amount, currency, recipient },
-                  policy: feePayerPolicy,
-                  transaction: {
-                    ...transaction,
-                    feeToken: transaction.feeToken ?? defaults.tokens.pathUsd,
+                const completed = await FeePayer.preflightSponsorship({
+                  transaction,
+                  simulate: (request) => viem_call(client, request as never),
+                  async complete() {
+                    const feeToken =
+                      configuredFeeToken ??
+                      (await resolveFeeToken({
+                        account: feePayerAccount.address,
+                        allowedTokens: selectableFeeTokens,
+                        candidateTokens: selectableFeeTokens,
+                        client,
+                        prioritizeCandidates: true,
+                      }))
+                    const sponsored = FeePayer.prepareSponsoredTransaction({
+                      account: feePayerAccount,
+                      allowedFeeTokens,
+                      challengeExpires: expires,
+                      chainId: chainId ?? client.chain!.id,
+                      details: { amount, currency, recipient },
+                      policy: feePayerPolicy,
+                      transaction: {
+                        ...transaction,
+                        ...(feeToken ? { feeToken } : {}),
+                      },
+                    })
+                    return { feePayer: feePayerAccount.address, transaction: sponsored }
                   },
                 })
-                // `account` is the sender (eth_call `from`); `feePayer` is the
-                // sponsor that pays gas.
-                simulationRequest = {
-                  ...sponsored,
-                  account: transaction.from,
-                  feePayer: feePayerAccount.address,
-                  feePayerSignature: undefined,
-                  signature: undefined,
-                }
-                return signTransaction(client, sponsored as never)
+                return signTransaction(client, completed.transaction as never)
               }
               if (feePayerUrl && isFeePayerTx) {
-                const hosted = await FeePayer.fillHostedFeePayerTransaction({
-                  allowedFeeTokens,
-                  challengeExpires: expires,
-                  chainId: chainId ?? client.chain!.id,
-                  details: { amount, currency, recipient },
-                  policy: feePayerPolicy,
+                const completed = await FeePayer.preflightSponsorship({
                   transaction,
-                  url: feePayerUrl,
+                  simulate: (request) => viem_call(client, request as never),
+                  async complete() {
+                    const hosted = await FeePayer.fillHostedFeePayerTransaction({
+                      allowedFeeTokens,
+                      challengeExpires: expires,
+                      chainId: chainId ?? client.chain!.id,
+                      details: { amount, currency, recipient },
+                      policy: feePayerPolicy,
+                      transaction,
+                      url: feePayerUrl,
+                    })
+                    return { ...hosted, transaction }
+                  },
                 })
-                // Simulate the co-signed envelope (concrete fee payer + chosen
-                // fee token), mirroring the local-sponsor path.
-                simulationRequest = {
-                  ...transaction,
-                  account: transaction.from,
-                  feePayer: hosted.feePayer,
-                  feePayerSignature: undefined,
-                  feeToken: hosted.feeToken,
-                  signature: undefined,
-                }
-                return hosted.serializedTransaction
+                return completed.serializedTransaction
               }
               return serializedTransaction
             })()
 
-            // Pre-broadcast simulation: fail closed before broadcast so the
-            // sponsor never pays gas for a transaction that would revert.
-            await viem_call(client, simulationRequest as never)
+            // Pre-broadcast simulation for non-sponsored transactions.
+            if (!isFeePayerTx)
+              await viem_call(
+                client,
+                FeePayer.simulationTransaction(transaction, { feePayer: false }) as never,
+              )
 
             if (waitForConfirmation) {
               const receipt = await sendRawTransactionSync(client, {
@@ -563,6 +568,14 @@ export declare namespace charge {
      * `maxTotalFee` so the combined fee budget remains valid.
      */
     feePayerPolicy?: FeePayerPolicy | undefined
+    /**
+     * Token a local fee payer uses to pay gas. If omitted, mppx selects a
+     * funded allowed token, preferring pathUSD.
+     *
+     * This option is not supported with a remote fee-payer URL, which selects
+     * its own token.
+     */
+    feeToken?: `0x${string}` | undefined
     /** Testnet mode. */
     testnet?: boolean | undefined
     /**

package/src/tempo/server/Methods.ts

@@ -5,6 +5,7 @@ import {
   settle as settle_,
   settleBatch as settleBatch_,
 } from '../session/server/Session.js'
+import type { SessionController as SessionController_ } from '../session/server/Sse.js'
 import * as Ws_ from '../session/server/Ws.js'
 import { charge as charge_ } from './Charge.js'
 import { renew as renewSubscription_, subscription as subscription_ } from './Subscription.js'
@@ -83,6 +84,11 @@ export namespace tempo {
   export const settle = settle_
   /** Batch-settle precompile-backed session channels. */
   export const settleBatch = settleBatch_
+  /** Types for Tempo session streams. */
+  export namespace Sse {
+    /** Controller passed to manual-charge SSE generators. */
+    export type SessionController = SessionController_
+  }
   /** Experimental websocket helpers for Tempo sessions. */
   export const Ws = Ws_
 }

package/src/tempo/server/Subscription.test.ts

@@ -112,22 +112,76 @@ async function createCredential(
   })
 }
 
-function createBillingClient(hashes: readonly string[]) {
+function createBillingClient(
+  hashes: readonly string[],
+  options: { account?: typeof rootAccount; failSimulation?: number | undefined } = {},
+) {
+  const callRequests: Record<string, unknown>[] = []
   const rpcMethods: string[] = []
   let nextHash = 0
+  let simulations = 0
   const client = createClient({
+    account: options.account,
     chain: { ...tempo_chain, id: chainId },
     transport: custom({
-      async request({ method }) {
+      async request({ method, params }) {
         rpcMethods.push(method)
         if (method === 'eth_chainId') return `0x${chainId.toString(16)}`
-        if (method === 'eth_call') return '0x'
+        if (method === 'eth_getTransactionCount') return '0x0'
+        if (method === 'eth_estimateGas') return '0x5208'
+        if (method === 'eth_maxPriorityFeePerGas') return '0x1'
+        if (method === 'eth_getBlockByNumber') return { baseFeePerGas: '0x1' }
+        if (method === 'eth_call') {
+          callRequests.push((params as [Record<string, unknown>])[0])
+          if (options.failSimulation !== undefined && ++simulations >= options.failSimulation)
+            throw new Error('final sponsored simulation reverted')
+          return '0x'
+        }
         if (method === 'eth_sendRawTransaction') return hashes[nextHash++] ?? hashActivate
         throw new Error(`unexpected rpc method: ${method}`)
       },
     }),
   })
-  return { client, rpcMethods }
+  return { callRequests, client, rpcMethods }
+}
+
+async function activateFeeSponsoredSubscription(options?: { failSimulation?: number | undefined }) {
+  const store = Store.memory()
+  const billing = createBillingClient([hashActivate], {
+    account: rootAccount,
+    ...options,
+  })
+  const method = subscription({
+    amount: subscriptionAmount,
+    chainId,
+    currency: subscriptionCurrency,
+    feePayer: rootAccount,
+    getClient: async () => billing.client,
+    periodCount: subscriptionPeriodCount,
+    periodUnit: subscriptionPeriodUnit,
+    recipient: subscriptionRecipient,
+    resolve: async () => ({ key: subscriptionKey }),
+    store,
+    subscriptionExpires: activeSubscriptionExpires,
+    waitForConfirmation: false,
+  })
+  const mppx = Mppx.create({ methods: [method], realm, secretKey })
+  const challengeResult = await mppx.tempo.subscription({})(
+    new Request('https://example.com/resource'),
+  )
+  if (challengeResult.status !== 402) throw new Error('expected activation challenge')
+  const challenge = Challenge.fromResponse(challengeResult.challenge)
+  const accessKey = (
+    challenge.request as ReturnType<typeof Methods.subscription.schema.request.parse>
+  ).methodDetails?.accessKey
+  if (!accessKey) throw new Error('expected generated access key')
+  const credential = await createCredential(challenge, rootAccount.address, accessKey)
+  const result = await mppx.tempo.subscription({})(
+    new Request('https://example.com/resource', {
+      headers: { Authorization: Credential.serialize(credential) },
+    }),
+  )
+  return { ...billing, result }
 }
 
 const confirmedBlockHash = `0x${'f'.repeat(64)}` as const
@@ -234,6 +288,27 @@ function createConfirmingBillingClient(options?: {
 }
 
 describe('tempo.subscription', () => {
+  test('preflights sender and final envelopes for fee-sponsored activation', async () => {
+    const { callRequests, result, rpcMethods } = await activateFeeSponsoredSubscription()
+
+    expect(result.status).toBe(200)
+    expect(callRequests).toHaveLength(2)
+    expect(callRequests[0]).not.toHaveProperty('feePayer')
+    expect(callRequests[1]?.feePayer).toBe(rootAccount.address)
+    expect(rpcMethods).toContain('eth_sendRawTransaction')
+  })
+
+  test('does not broadcast a fee-sponsored activation after final simulation failure', async () => {
+    const { callRequests, result, rpcMethods } = await activateFeeSponsoredSubscription({
+      failSimulation: 2,
+    })
+
+    expect(result.status).not.toBe(200)
+    expect(callRequests.length).toBeGreaterThanOrEqual(2)
+    expect(rpcMethods).not.toContain('eth_sendRawTransaction')
+    expect(rpcMethods).not.toContain('eth_sendRawTransactionSync')
+  })
+
   test('stores an activated subscription and reuses it on later requests', async () => {
     const store = Store.memory()
     let activationCount = 0

package/src/tempo/server/Subscription.ts

@@ -965,28 +965,36 @@ async function submitSubscriptionPayment(parameters: {
     const userTransaction = Transaction.deserialize(
       userSerialized as Transaction.TransactionSerializedTempo,
     )
-    const sponsored = FeePayer.prepareSponsoredTransaction({
-      account: feePayer,
-      chainId: chainId ?? client.chain!.id,
-      details: {
-        amount: String(request.amount),
-        currency: String(request.currency),
-        recipient: String(request.recipient),
+    const completed = await FeePayer.preflightSponsorship({
+      transaction: userTransaction,
+      simulate: (request) => viem_call(client, request as never),
+      async complete() {
+        const sponsored = FeePayer.prepareSponsoredTransaction({
+          account: feePayer,
+          chainId: chainId ?? client.chain!.id,
+          details: {
+            amount: String(request.amount),
+            currency: String(request.currency),
+            recipient: String(request.recipient),
+          },
+          ...(feePayerPolicy ? { policy: feePayerPolicy } : {}),
+          transaction: userTransaction as never,
+        })
+        return { feePayer: feePayer.address, transaction: sponsored }
       },
-      ...(feePayerPolicy ? { policy: feePayerPolicy } : {}),
-      transaction: userTransaction as never,
     })
-    return await signTransaction(client, sponsored as never)
+    return await signTransaction(client, completed.transaction as never)
   })()
   const transaction = Transaction.deserialize(
     serializedTransaction as Transaction.TransactionSerializedTempo,
   )
-  await viem_call(client, {
-    ...transaction,
-    account: transaction.from,
-    calls: transaction.calls,
-    feePayerSignature: undefined,
-  } as never)
+  if (!feePayer)
+    await viem_call(client, {
+      ...transaction,
+      account: transaction.from,
+      calls: transaction.calls,
+      feePayerSignature: undefined,
+    } as never)
 
   if (!waitForConfirmation) {
     // Optimistic mode has no receipt to inspect, so it cannot detect a T6