mppx 0.6.31 → 0.7.0

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

@@ -1,11 +1,16 @@
-import { encodeFunctionData, maxUint256 } from 'viem'
-import { Abis, Addresses } from 'viem/tempo'
-import { describe, expect, test } from 'vp/test'
+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 +24,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 +437,216 @@ 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 () => {
+    const calls: { init?: RequestInit | undefined; input: RequestInfo | URL }[] = []
+    const fetchMock = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
+      calls.push({ init, input })
+      return new Response(
+        JSON.stringify({
+          result: {
+            tx: {
+              feePayerSignature,
+              feeToken: defaults.tokens.pathUsd,
+              gas: '0x1',
+              maxFeePerGas: '0x2',
+            },
+          },
+        }),
+      )
+    })
+    vi.stubGlobal('fetch', fetchMock)
+
+    const serialized = await fillHostedFeePayerTransaction({
+      allowedFeeTokens: defaultAllowedFeeTokens(defaults.chainId.mainnet),
+      transaction: hostedTransaction as any,
+      url: 'https://sponsor.example/tp_key',
+    })
+
+    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(transaction.feePayerSignature).toEqual(feePayerSignature)
+  })
+
+  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 +678,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 42431,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         transaction: baseTransaction as any,
       }),
     ).not.toThrow()
@@ -466,7 +690,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 42431,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         transaction: {
           ...baseTransaction,
           nonceKey: maxUint256,
@@ -481,7 +705,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 42431,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         transaction: {
           ...baseTransaction,
           nonceKey: 1n,
@@ -496,7 +720,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 42431,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         transaction: {
           ...baseTransaction,
           gas: 626_497n,
@@ -513,7 +737,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 4217,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         policy: { maxPriorityFeePerGas: 50_000_000_000n },
         transaction: {
           ...baseTransaction,
@@ -532,7 +756,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 4217,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         policy: { maxPriorityFeePerGas: 20_000_000_000n },
         transaction: {
           ...baseTransaction,
@@ -551,7 +775,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 4217,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         policy: { maxPriorityFeePerGas: undefined } as any,
         transaction: {
           ...baseTransaction,
@@ -578,7 +802,7 @@ describe('prepareSponsoredTransaction', () => {
       account: sponsor,
       chainId: 42431,
       details,
-      expectedFeeToken: bogus,
+      allowedFeeTokens: [bogus],
       transaction: { ...baseTransaction, keyAuthorization } as any,
     }) as { keyAuthorization?: unknown }
 
@@ -591,7 +815,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 42431,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         transaction: { ...baseTransaction, unexpectedField: 'ignored' } as any,
       }),
     ).toThrow('contains unsupported fields')
@@ -603,7 +827,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 42431,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         transaction: {
           ...baseTransaction,
           feePayerSignature: { r: 2n, s: 3n, yParity: 1 },
@@ -618,7 +842,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 42431,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         transaction: {
           ...baseTransaction,
           maxFeePerGas: 200_000_000_000n,
@@ -633,7 +857,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 42431,
         details,
-        expectedFeeToken: bogus,
+        allowedFeeTokens: [bogus],
         transaction: {
           ...baseTransaction,
           gas: 1_500_000n,
@@ -649,7 +873,7 @@ describe('prepareSponsoredTransaction', () => {
         account: sponsor,
         chainId: 42431,
         details,
-        expectedFeeToken: '0x0000000000000000000000000000000000000002',
+        allowedFeeTokens: ['0x0000000000000000000000000000000000000002'],
         transaction: baseTransaction as any,
       }),
     ).toThrow('feeToken is not allowed')
@@ -661,7 +885,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

@@ -2,7 +2,7 @@ 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 +43,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 +102,137 @@ 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.
+ */
+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)
+
+  return Transaction.serialize({
+    ...transaction,
+    feePayer: true,
+    feePayerSignature: filled.feePayerSignature,
+    feeToken: filled.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 +399,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 +533,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,
       })

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

@@ -1,13 +1,14 @@
 import type { Account } from 'viem'
 import { createClient } from 'viem'
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
 import { Actions, Addresses } from 'viem/tempo'
 import { describe, expect, test } from 'vp/test'
-import { nodeEnv } from '~test/config.js'
-import { accounts, asset, chain, fundAccount, http } from '~test/tempo/viem.js'
+import { tempoNetwork } from '~test/config.js'
+import { asset, chain, fundAccount, http } from '~test/tempo/viem.js'
 
 import { resolveFeeToken } from './fee-token.js'
 
-const isLocalnet = nodeEnv === 'localnet'
+const isLocalnet = tempoNetwork === 'localnet'
 
 function clientFor(account: Account) {
   return createClient({
@@ -21,9 +22,13 @@ function expectAddress(actual: string | undefined, expected: string) {
   expect(actual?.toLowerCase()).toBe(expected.toLowerCase())
 }
 
+function testAccount() {
+  return privateKeyToAccount(generatePrivateKey())
+}
+
 describe.runIf(isLocalnet)('resolveFeeToken', () => {
   test('uses the funded account fee preference first', async () => {
-    const account = accounts[11]
+    const account = testAccount()
     const client = clientFor(account)
     await fundAccount({ address: account.address, token: asset })
     await Actions.fee.setUserTokenSync(client, {
@@ -41,7 +46,7 @@ describe.runIf(isLocalnet)('resolveFeeToken', () => {
   })
 
   test('falls through to the first funded candidate token', async () => {
-    const account = accounts[12]
+    const account = testAccount()
     const client = clientFor(account)
     await fundAccount({ address: account.address, token: asset })
 
@@ -55,7 +60,7 @@ describe.runIf(isLocalnet)('resolveFeeToken', () => {
   })
 
   test('falls through from an unfunded account fee preference', async () => {
-    const account = accounts[13]
+    const account = testAccount()
     const client = clientFor(account)
     await fundAccount({ address: account.address, token: asset })
     await Actions.fee.setUserTokenSync(client, {
@@ -73,7 +78,7 @@ describe.runIf(isLocalnet)('resolveFeeToken', () => {
   })
 
   test('uses a funded chain fee token when configured', async () => {
-    const account = accounts[14]
+    const account = testAccount()
     const client = createClient({
       account,
       chain: { ...chain, feeToken: asset },
@@ -91,7 +96,7 @@ describe.runIf(isLocalnet)('resolveFeeToken', () => {
   })
 
   test('falls through from an unfunded chain fee token', async () => {
-    const account = accounts[15]
+    const account = testAccount()
     const client = createClient({
       account,
       chain: { ...chain, feeToken: Addresses.pathUsd },
@@ -109,7 +114,7 @@ describe.runIf(isLocalnet)('resolveFeeToken', () => {
   })
 
   test('falls back to the first known token when none are funded', async () => {
-    const account = accounts[16]
+    const account = testAccount()
     const client = clientFor(account)
 
     const feeToken = await resolveFeeToken({