mppx 0.6.31 → 0.8.0

package/src/tempo/internal/fee-payer.test.ts

@@ -1,11 +1,18 @@
-import { encodeFunctionData, maxUint256 } from 'viem'
-import { Abis, Addresses } from 'viem/tempo'
-import { describe, expect, test } from 'vp/test'
+import { Address, Secp256k1 } from 'ox'
+import { TxEnvelopeTempo } from 'ox/tempo'
+import { encodeFunctionData, maxUint256, toHex } from 'viem'
+import { Abis, Addresses, Transaction } from 'viem/tempo'
+import { afterEach, describe, expect, test, vi } from 'vp/test'
 
+import * as defaults from './defaults.js'
 import {
+  assertAllowedFeeToken,
   callScopes,
+  defaultAllowedFeeTokens,
   FeePayerValidationError,
+  fillHostedFeePayerTransaction,
   prepareSponsoredTransaction,
+  simulationTransaction,
   validateCalls,
 } from './fee-payer.js'
 import * as Selectors from './selectors.js'
@@ -19,8 +26,17 @@ const swapData = encodeFunctionData({
   functionName: 'swapExactAmountOut',
   args: [swapTokenIn, swapTokenOut, 100n, 100n],
 })
+const feePayerSignature = {
+  r: '0x0000000000000000000000000000000000000000000000000000000000000002',
+  s: '0x0000000000000000000000000000000000000000000000000000000000000003',
+  yParity: 1,
+}
 const sponsor = { address: bogus, type: 'local' } as any
 
+afterEach(() => {
+  vi.unstubAllGlobals()
+})
+
 describe('callScopes', () => {
   test('has 4 allowed patterns', () => {
     expect(callScopes).toHaveLength(4)
@@ -423,6 +439,269 @@ describe('validateCalls', () => {
   })
 })
 
+describe('fee token allowlist', () => {
+  test('includes pathUSD and the chain default currency', () => {
+    expect(defaultAllowedFeeTokens(defaults.chainId.mainnet)).toEqual([
+      defaults.tokens.pathUsd,
+      defaults.tokens.usdc,
+    ])
+  })
+
+  test('dedupes when pathUSD is the chain default currency', () => {
+    expect(defaultAllowedFeeTokens(defaults.chainId.testnet)).toEqual([defaults.tokens.pathUsd])
+  })
+
+  test('accepts allowlisted fee tokens', () => {
+    expect(() =>
+      assertAllowedFeeToken(
+        { feeToken: defaults.tokens.usdc },
+        defaultAllowedFeeTokens(defaults.chainId.mainnet),
+      ),
+    ).not.toThrow()
+  })
+
+  test('error: rejects non-string fee tokens', () => {
+    expect(() =>
+      assertAllowedFeeToken({ feeToken: 1n }, defaultAllowedFeeTokens(defaults.chainId.mainnet)),
+    ).toThrow('feeToken is invalid')
+  })
+
+  test('error: rejects fee tokens outside the allowlist', () => {
+    expect(() =>
+      assertAllowedFeeToken(
+        { feeToken: swapTokenIn },
+        defaultAllowedFeeTokens(defaults.chainId.mainnet),
+      ),
+    ).toThrow('feeToken is not allowed')
+  })
+})
+
+describe('fillHostedFeePayerTransaction', () => {
+  const hostedTransaction = {
+    accessList: [],
+    calls: [
+      {
+        data: encodeFunctionData({
+          abi: Abis.tip20,
+          functionName: 'transfer',
+          args: [bogus, 100n],
+        }),
+        to: bogus,
+      },
+    ],
+    chainId: defaults.chainId.mainnet,
+    from: bogus,
+    gas: 150_000n,
+    maxFeePerGas: 1_000_000_000n,
+    maxPriorityFeePerGas: 0n,
+    nonce: 1n,
+    nonceKey: maxUint256,
+    signature: { r: 1n, s: 1n, yParity: 0 } as any,
+    validBefore: Math.floor(Date.now() / 1_000) + 300,
+  } as const
+
+  test('uses hosted fillTransaction and preserves sender-committed fields', async () => {
+    // Sign over the payload built from the actual RPC request body so this
+    // verifies recovery parity with the real request shape.
+    const sponsorPrivateKey =
+      '0x0000000000000000000000000000000000000000000000000000000000000042' as const
+    const sponsorAddress = Address.fromPublicKey(
+      Secp256k1.getPublicKey({ privateKey: sponsorPrivateKey }),
+    )
+    let realFeePayerSignature: ReturnType<typeof Secp256k1.sign> | undefined
+
+    const calls: { init?: RequestInit | undefined; input: RequestInfo | URL }[] = []
+    const fetchMock = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
+      calls.push({ init, input })
+      const rpc = JSON.parse(init!.body as string).params[0]
+      const quantity = (value: unknown) =>
+        value === undefined ? undefined : BigInt(value as string)
+      realFeePayerSignature = Secp256k1.sign({
+        payload: TxEnvelopeTempo.getFeePayerSignPayload(
+          TxEnvelopeTempo.from({
+            accessList: rpc.accessList,
+            calls: rpc.calls.map(({ value, ...call }: any) => ({
+              ...call,
+              ...(value && value !== '0x' ? { value: BigInt(value) } : {}),
+            })),
+            chainId: hostedTransaction.chainId,
+            feeToken: defaults.tokens.pathUsd,
+            from: rpc.from,
+            ...(quantity(rpc.gas) !== undefined ? { gas: quantity(rpc.gas) } : {}),
+            ...(rpc.keyAuthorization !== undefined
+              ? { keyAuthorization: rpc.keyAuthorization }
+              : {}),
+            ...(quantity(rpc.maxFeePerGas) !== undefined
+              ? { maxFeePerGas: quantity(rpc.maxFeePerGas) }
+              : {}),
+            ...(quantity(rpc.maxPriorityFeePerGas) !== undefined
+              ? { maxPriorityFeePerGas: quantity(rpc.maxPriorityFeePerGas) }
+              : {}),
+            ...(quantity(rpc.nonce) !== undefined ? { nonce: quantity(rpc.nonce) } : {}),
+            ...(quantity(rpc.nonceKey) !== undefined ? { nonceKey: quantity(rpc.nonceKey) } : {}),
+            type: 'tempo',
+            ...(rpc.validAfter !== undefined ? { validAfter: Number(BigInt(rpc.validAfter)) } : {}),
+            ...(rpc.validBefore !== undefined
+              ? { validBefore: Number(BigInt(rpc.validBefore)) }
+              : {}),
+          } as any) as any,
+          { sender: rpc.from },
+        ),
+        privateKey: sponsorPrivateKey,
+      })
+      return new Response(
+        JSON.stringify(
+          {
+            result: {
+              tx: {
+                feePayerSignature: realFeePayerSignature,
+                feeToken: defaults.tokens.pathUsd,
+                gas: '0x1',
+                maxFeePerGas: '0x2',
+              },
+            },
+          },
+          (_key, value) => (typeof value === 'bigint' ? toHex(value) : value),
+        ),
+      )
+    })
+    vi.stubGlobal('fetch', fetchMock)
+
+    const result = await fillHostedFeePayerTransaction({
+      allowedFeeTokens: defaultAllowedFeeTokens(defaults.chainId.mainnet),
+      transaction: hostedTransaction as any,
+      url: 'https://sponsor.example/tp_key',
+    })
+
+    expect(result.feeToken).toBe(defaults.tokens.pathUsd)
+    expect(result.feePayer.toLowerCase()).toBe(sponsorAddress.toLowerCase())
+    const serialized = result.serializedTransaction
+
+    expect(fetchMock).toHaveBeenCalledOnce()
+    expect(calls[0]!.input).toBe('https://sponsor.example/tp_key')
+    const body = JSON.parse(calls[0]!.init!.body as string)
+    expect(body).toMatchObject({
+      jsonrpc: '2.0',
+      method: 'eth_fillTransaction',
+    })
+    expect(body.params[0]).toMatchObject({
+      calls: hostedTransaction.calls.map((call) => ({
+        data: call.data,
+        to: call.to,
+        value: '0x',
+      })),
+      feePayer: true,
+      from: hostedTransaction.from,
+      gas: toHex(hostedTransaction.gas),
+      maxFeePerGas: toHex(hostedTransaction.maxFeePerGas),
+      maxPriorityFeePerGas: toHex(hostedTransaction.maxPriorityFeePerGas),
+      nonce: toHex(hostedTransaction.nonce),
+      nonceKey: toHex(hostedTransaction.nonceKey),
+      type: '0x76',
+      validBefore: toHex(hostedTransaction.validBefore),
+    })
+
+    const transaction: Transaction.TransactionSerializableTempo = Transaction.deserialize(
+      serialized as Transaction.TransactionSerializedTempo,
+    )
+    expect(transaction.gas).toBe(hostedTransaction.gas)
+    expect(transaction.maxFeePerGas).toBe(hostedTransaction.maxFeePerGas)
+    expect(transaction.calls).toEqual(hostedTransaction.calls)
+    expect(transaction.feeToken).toBe(defaults.tokens.pathUsd)
+    expect(BigInt(transaction.feePayerSignature!.r)).toBe(realFeePayerSignature!.r)
+    expect(BigInt(transaction.feePayerSignature!.s)).toBe(realFeePayerSignature!.s)
+  })
+
+  test('error: requires hosted fee payer to return a feeToken', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async () => new Response(JSON.stringify({ result: { tx: { feePayerSignature } } }))),
+    )
+
+    await expect(
+      fillHostedFeePayerTransaction({
+        allowedFeeTokens: defaultAllowedFeeTokens(defaults.chainId.mainnet),
+        transaction: hostedTransaction as any,
+        url: 'https://sponsor.example/tp_key',
+      }),
+    ).rejects.toThrow('did not return a feeToken')
+  })
+
+  test('error: rejects hosted feeToken outside the allowlist', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(
+        async () =>
+          new Response(
+            JSON.stringify({
+              result: { tx: { feePayerSignature, feeToken: swapTokenIn } },
+            }),
+          ),
+      ),
+    )
+
+    await expect(
+      fillHostedFeePayerTransaction({
+        allowedFeeTokens: defaultAllowedFeeTokens(defaults.chainId.mainnet),
+        transaction: hostedTransaction as any,
+        url: 'https://sponsor.example/tp_key',
+      }),
+    ).rejects.toThrow('feeToken is not allowed')
+  })
+
+  test('error: surfaces hosted fee payer errors', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(
+        async () =>
+          new Response(JSON.stringify({ error: { message: 'Invalid or revoked API key' } }), {
+            status: 401,
+          }),
+      ),
+    )
+
+    await expect(
+      fillHostedFeePayerTransaction({
+        allowedFeeTokens: defaultAllowedFeeTokens(defaults.chainId.mainnet),
+        transaction: hostedTransaction as any,
+        url: 'https://sponsor.example/tp_key',
+      }),
+    ).rejects.toThrow('Invalid or revoked API key')
+  })
+})
+
+describe('simulationTransaction', () => {
+  test('strips signed fee-payer fields for sponsored preflight simulation', () => {
+    const transaction = {
+      calls: [{ to: bogus }],
+      feePayerSignature,
+      from: bogus,
+    }
+
+    expect(simulationTransaction(transaction as any, { feePayer: true })).toEqual({
+      account: bogus,
+      calls: transaction.calls,
+    })
+  })
+
+  test('preserves non-sponsored transaction fields except feePayerSignature', () => {
+    const transaction = {
+      calls: [{ to: bogus }],
+      feePayerSignature,
+      from: bogus,
+      gas: 1n,
+    }
+
+    expect(simulationTransaction(transaction as any, { feePayer: false })).toEqual({
+      account: bogus,
+      calls: transaction.calls,
+      from: bogus,
+      gas: 1n,
+      feePayerSignature: undefined,
+    })
+  })
+})
+
 describe('prepareSponsoredTransaction', () => {
   const baseTransaction = {
     accessList: [],
@@ -454,7 +733,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 42431,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         transaction: baseTransaction as any,
       }),
     ).not.toThrow()
@@ -466,7 +745,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 42431,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         transaction: {
           ...baseTransaction,
           nonceKey: maxUint256,
@@ -481,7 +760,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 42431,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         transaction: {
           ...baseTransaction,
           nonceKey: 1n,
@@ -496,7 +775,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 42431,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         transaction: {
           ...baseTransaction,
           gas: 626_497n,
@@ -513,7 +792,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 4217,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         policy: { maxPriorityFeePerGas: 50_000_000_000n },
         transaction: {
           ...baseTransaction,
@@ -532,7 +811,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 4217,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         policy: { maxPriorityFeePerGas: 20_000_000_000n },
         transaction: {
           ...baseTransaction,
@@ -551,7 +830,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 4217,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         policy: { maxPriorityFeePerGas: undefined } as any,
         transaction: {
           ...baseTransaction,
@@ -578,7 +857,7 @@ describe('prepareSponsoredTransaction', () => {
       account: sponsor,
       chainId: 42431,
       details,
-      expectedFeeToken: bogus,
+      allowedFeeTokens: [bogus],
       transaction: { ...baseTransaction, keyAuthorization } as any,
     }) as { keyAuthorization?: unknown }
 
@@ -591,7 +870,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 42431,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         transaction: { ...baseTransaction, unexpectedField: 'ignored' } as any,
       }),
     ).toThrow('contains unsupported fields')
@@ -603,7 +882,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 42431,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         transaction: {
           ...baseTransaction,
           feePayerSignature: { r: 2n, s: 3n, yParity: 1 },
@@ -618,7 +897,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 42431,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         transaction: {
           ...baseTransaction,
           maxFeePerGas: 200_000_000_000n,
@@ -633,7 +912,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 42431,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         transaction: {
           ...baseTransaction,
           gas: 1_500_000n,
@@ -649,7 +928,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 42431,
         details,
-        expectedFeeToken: '0x0000000000000000000000000000000000000002',
+        allowedFeeTokens: ['0x0000000000000000000000000000000000000002'],
         transaction: baseTransaction as any,
       }),
     ).toThrow('feeToken is not allowed')
@@ -661,7 +940,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 42431,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         transaction: {
           ...baseTransaction,
           validBefore: Math.floor(Date.now() / 1_000) + 3_600,

package/src/tempo/internal/fee-payer.ts

@@ -1,8 +1,9 @@
+import { Secp256k1 } from 'ox'
 import type { TempoAddress } from 'ox/tempo'
 import { TxEnvelopeTempo } from 'ox/tempo'
 import type { Hex } from 'viem'
 import type { Account } from 'viem'
-import { decodeFunctionData, maxUint256 } from 'viem'
+import { decodeFunctionData, maxUint256, toHex } from 'viem'
 import { Abis, Addresses, Transaction } from 'viem/tempo'
 
 import * as TempoAddress_internal from './address.js'
@@ -43,6 +44,16 @@ export type Policy = {
 // Tempo transaction fields.
 type SponsoredTransaction = ReturnType<(typeof Transaction)['deserialize']>
 
+type HostedFeePayerFillResponse = {
+  error?: { message?: string | undefined } | undefined
+  result?: {
+    tx?: {
+      feePayerSignature?: unknown
+      feeToken?: unknown
+    }
+  }
+}
+
 type ExpectedTransfer = {
   amount: string
   allowAnyMemo?: boolean | undefined
@@ -92,6 +103,172 @@ const supportedTransactionKeys = new Set<string>([
   ...rewrittenTransactionKeys,
 ])
 
+function pushAllowedFeeToken(tokens: TempoAddress.Address[], token: string | undefined) {
+  if (!token) return
+  const normalized = token as TempoAddress.Address
+  if (tokens.some((existing) => TempoAddress_internal.isEqual(existing, normalized))) return
+  tokens.push(normalized)
+}
+
+/** Returns fee tokens that mppx allows sponsored transactions to charge. */
+export function defaultAllowedFeeTokens(chainId: number | undefined) {
+  const tokens: TempoAddress.Address[] = []
+  pushAllowedFeeToken(tokens, defaults.tokens.pathUsd)
+  pushAllowedFeeToken(tokens, defaults.currency[chainId as keyof typeof defaults.currency])
+  return tokens
+}
+
+/** Rejects a sponsored fee token outside the server's allowlist. */
+export function assertAllowedFeeToken(
+  transaction: { feeToken?: unknown },
+  allowedFeeTokens: readonly TempoAddress.Address[],
+) {
+  const { feeToken } = transaction
+  if (feeToken === undefined) return
+  if (typeof feeToken !== 'string')
+    throw new FeePayerValidationError('fee-sponsored transaction feeToken is invalid', {})
+  const normalized = feeToken as TempoAddress.Address
+  if (!allowedFeeTokens.some((allowed) => TempoAddress_internal.isEqual(allowed, normalized)))
+    throw new FeePayerValidationError('fee-sponsored transaction feeToken is not allowed', {
+      feeToken,
+    })
+}
+
+function hostedFeePayerRequest(transaction: SponsoredTransaction) {
+  return {
+    ...(transaction.accessList?.length ? { accessList: transaction.accessList } : {}),
+    calls: transaction.calls.map(
+      (call: {
+        data?: `0x${string}` | undefined
+        to?: TempoAddress.Address | undefined
+        value?: bigint | undefined
+      }) => ({
+        ...(call.to ? { to: call.to } : {}),
+        ...(call.data ? { data: call.data } : {}),
+        value: call.value === undefined ? '0x' : toHex(call.value),
+      }),
+    ),
+    feePayer: true,
+    from: transaction.from,
+    ...(transaction.gas !== undefined ? { gas: toHex(transaction.gas) } : {}),
+    ...(transaction.keyAuthorization !== undefined
+      ? { keyAuthorization: transaction.keyAuthorization }
+      : {}),
+    ...(transaction.maxFeePerGas !== undefined
+      ? { maxFeePerGas: toHex(transaction.maxFeePerGas) }
+      : {}),
+    ...(transaction.maxPriorityFeePerGas !== undefined
+      ? { maxPriorityFeePerGas: toHex(transaction.maxPriorityFeePerGas) }
+      : {}),
+    nonce: toHex(transaction.nonce ?? 0),
+    ...(transaction.nonceKey !== undefined ? { nonceKey: toHex(transaction.nonceKey) } : {}),
+    type: '0x76',
+    ...(transaction.validAfter !== undefined ? { validAfter: toHex(transaction.validAfter) } : {}),
+    ...(transaction.validBefore !== undefined
+      ? { validBefore: toHex(transaction.validBefore) }
+      : {}),
+  }
+}
+
+/**
+ * Co-signs a sender-signed partial sponsorship envelope using a hosted
+ * fee-payer endpoint without letting the endpoint mutate sender-committed
+ * transaction fields.
+ *
+ * @returns The serialized co-signed transaction plus the sponsor's recovered
+ *   `feePayer` address and chosen `feeToken`, so callers can pre-broadcast
+ *   simulate the exact transaction the sponsor broadcasts.
+ */
+export async function fillHostedFeePayerTransaction(parameters: {
+  allowedFeeTokens: readonly TempoAddress.Address[]
+  transaction: SponsoredTransaction
+  url: string
+}) {
+  const { allowedFeeTokens, transaction, url } = parameters
+  const response = await fetch(url, {
+    body: JSON.stringify(
+      {
+        id: 1,
+        jsonrpc: '2.0',
+        method: 'eth_fillTransaction',
+        params: [hostedFeePayerRequest(transaction)],
+      },
+      (_key, value) => (typeof value === 'bigint' ? toHex(value) : value),
+    ),
+    headers: { 'content-type': 'application/json' },
+    method: 'POST',
+  })
+  const payload = (await response.json().catch(async () => ({
+    error: { message: await response.text() },
+  }))) as HostedFeePayerFillResponse
+  const filled = payload.result?.tx
+  if (!response.ok || payload.error || !filled?.feePayerSignature)
+    throw new FeePayerValidationError(
+      payload.error?.message ?? 'hosted fee payer failed to sponsor transaction',
+      {},
+    )
+  if (typeof filled.feeToken !== 'string')
+    throw new FeePayerValidationError('hosted fee payer did not return a feeToken', {})
+
+  assertAllowedFeeToken({ feeToken: filled.feeToken }, allowedFeeTokens)
+
+  const feePayerSignature = filled.feePayerSignature
+  const feeToken = filled.feeToken
+
+  // Recover the concrete sponsor address so the simulation can use a concrete
+  // `feePayer` (the node rejects `eth_call` with `feePayer: true`).
+  const feePayer = (() => {
+    try {
+      return Secp256k1.recoverAddress({
+        payload: TxEnvelopeTempo.getFeePayerSignPayload(
+          TxEnvelopeTempo.from({
+            ...transaction,
+            feePayerSignature: undefined,
+            feeToken,
+            signature: undefined,
+          } as never),
+          { sender: transaction.from as never },
+        ),
+        signature: feePayerSignature as never,
+      })
+    } catch {
+      throw new FeePayerValidationError(
+        'hosted fee payer returned an invalid feePayerSignature',
+        {},
+      )
+    }
+  })()
+
+  return {
+    feePayer,
+    feeToken,
+    serializedTransaction: await Transaction.serialize({
+      ...transaction,
+      feePayer: true,
+      feePayerSignature,
+      feeToken,
+    } as never),
+  }
+}
+
+/** Returns a transaction shape suitable for pre-broadcast simulation. */
+export function simulationTransaction(
+  transaction: SponsoredTransaction,
+  options: { feePayer: boolean },
+) {
+  if (options.feePayer)
+    return {
+      account: transaction.from,
+      calls: transaction.calls,
+    }
+  return {
+    ...transaction,
+    account: transaction.from,
+    calls: transaction.calls,
+    feePayerSignature: undefined,
+  }
+}
+
 /**
  * maxTotalFee must be high enough to cover `transferWithMemo` and
  * swap transactions at peak gas prices. Bumped from 0.01 ETH in #327.
@@ -258,20 +435,20 @@ export function validateCalls(
 
 export function prepareSponsoredTransaction(parameters: {
   account: Account
+  allowedFeeTokens?: readonly TempoAddress.Address[] | undefined
   challengeExpires?: string | undefined
   chainId: number
   details: Record<string, string>
-  expectedFeeToken?: TempoAddress.Address | undefined
   now?: Date | undefined
   policy?: Partial<Policy> | undefined
   transaction: SponsoredTransaction
 }) {
   const {
     account,
+    allowedFeeTokens,
     challengeExpires,
     chainId,
     details,
-    expectedFeeToken,
     now = new Date(),
     policy: policyOverrides,
     transaction,
@@ -392,7 +569,12 @@ export function prepareSponsoredTransaction(parameters: {
   })()
 
   if (normalizedFeeToken !== undefined) {
-    if (expectedFeeToken && !TempoAddress_internal.isEqual(normalizedFeeToken, expectedFeeToken))
+    if (
+      allowedFeeTokens &&
+      !allowedFeeTokens.some((allowed) =>
+        TempoAddress_internal.isEqual(normalizedFeeToken, allowed),
+      )
+    )
       fail('fee-sponsored transaction feeToken is not allowed', {
         feeToken: normalizedFeeToken,
       })