mppx 0.5.12 → 0.5.14

package/src/tempo/Methods.test.ts

@@ -39,6 +39,31 @@ describe('charge', () => {
     expect(result.success).toBe(true)
   })
 
+  test('schema: validates request with supportedModes', () => {
+    const result = Methods.charge.schema.request.safeParse({
+      amount: '1',
+      currency: '0x20c0000000000000000000000000000000000001',
+      decimals: 6,
+      recipient: '0x1234567890abcdef1234567890abcdef12345678',
+      supportedModes: ['pull'],
+    })
+    expect(result.success).toBe(true)
+    if (!result.success) return
+
+    expect(result.data.methodDetails?.supportedModes).toEqual(['pull'])
+  })
+
+  test('schema: rejects empty supportedModes', () => {
+    const result = Methods.charge.schema.request.safeParse({
+      amount: '1',
+      currency: '0x20c0000000000000000000000000000000000001',
+      decimals: 6,
+      recipient: '0x1234567890abcdef1234567890abcdef12345678',
+      supportedModes: [],
+    })
+    expect(result.success).toBe(false)
+  })
+
   test('schema: validates request with memo', () => {
     const result = Methods.charge.schema.request.safeParse({
       amount: '1',

package/src/tempo/Methods.ts

@@ -4,6 +4,9 @@ import { parseUnits } from 'viem'
 import * as Method from '../Method.js'
 import * as z from '../zod.js'
 
+export const chargeModes = ['push', 'pull'] as const
+export type ChargeMode = (typeof chargeModes)[number]
+
 const split = z.object({
   amount: z.amount(),
   memo: z.optional(z.hash()),
@@ -47,6 +50,7 @@ export const charge = Method.from({
           memo: z.optional(z.hash()),
           recipient: z.optional(z.string()),
           splits: z.optional(z.array(split).check(z.minLength(1), z.maxLength(10))),
+          supportedModes: z.optional(z.array(z.enum(chargeModes)).check(z.minLength(1))),
         })
         .check(
           z.refine(({ amount, decimals, splits }) => {
@@ -64,28 +68,32 @@ export const charge = Method.from({
             )
           }, 'Invalid splits'),
         ),
-      z.transform(({ amount, chainId, decimals, feePayer, memo, splits, ...rest }) => ({
-        ...rest,
-        amount: parseUnits(amount, decimals).toString(),
-        ...(chainId !== undefined ||
-        feePayer !== undefined ||
-        memo !== undefined ||
-        splits !== undefined
-          ? {
-              methodDetails: {
-                ...(chainId !== undefined && { chainId }),
-                ...(feePayer !== undefined && { feePayer }),
-                ...(memo !== undefined && { memo }),
-                ...(splits !== undefined && {
-                  splits: splits.map((split) => ({
-                    ...split,
-                    amount: parseUnits(split.amount, decimals).toString(),
-                  })),
-                }),
-              },
-            }
-          : {}),
-      })),
+      z.transform(
+        ({ amount, chainId, decimals, feePayer, memo, splits, supportedModes, ...rest }) => ({
+          ...rest,
+          amount: parseUnits(amount, decimals).toString(),
+          ...(chainId !== undefined ||
+          feePayer !== undefined ||
+          memo !== undefined ||
+          splits !== undefined ||
+          supportedModes !== undefined
+            ? {
+                methodDetails: {
+                  ...(chainId !== undefined && { chainId }),
+                  ...(feePayer !== undefined && { feePayer }),
+                  ...(memo !== undefined && { memo }),
+                  ...(splits !== undefined && {
+                    splits: splits.map((split) => ({
+                      ...split,
+                      amount: parseUnits(split.amount, decimals).toString(),
+                    })),
+                  }),
+                  ...(supportedModes !== undefined && { supportedModes }),
+                },
+              }
+            : {}),
+        }),
+      ),
     ),
   },
 })

package/src/tempo/client/Charge.ts

@@ -47,7 +47,7 @@ export function charge(parameters: charge.Parameters = {}) {
     context: z.object({
       account: z.optional(z.custom<Account.getResolver.Parameters['account']>()),
       autoSwap: z.optional(z.custom<charge.AutoSwap>()),
-      mode: z.optional(z.enum(['push', 'pull'])),
+      mode: z.optional(z.enum(Methods.chargeModes)),
     }),
 
     async createCredential({ challenge, context }) {
@@ -74,11 +74,7 @@ export function charge(parameters: charge.Parameters = {}) {
         })
       }
 
-      const mode =
-        context?.mode ?? parameters.mode ?? (account.type === 'json-rpc' ? 'push' : 'pull')
-
       const currency = request.currency as Address
-
       if (parameters.expectedRecipients) {
         const allowed = new Set(parameters.expectedRecipients.map((a) => a.toLowerCase()))
         const splits = methodDetails?.splits as readonly { recipient: string }[] | undefined
@@ -89,6 +85,21 @@ export function charge(parameters: charge.Parameters = {}) {
           }
         }
       }
+      const supportedModes = (methodDetails?.supportedModes as
+        | readonly Methods.ChargeMode[]
+        | undefined) ?? ['pull', 'push']
+      const mode = (() => {
+        const explicitMode = context?.mode ?? parameters.mode
+        if (explicitMode) {
+          if (!supportedModes.includes(explicitMode))
+            throw new Error(`Challenge does not support ${explicitMode} mode.`)
+          return explicitMode
+        }
+
+        const preferredMode = account.type === 'json-rpc' ? 'push' : 'pull'
+        if (supportedModes.includes(preferredMode)) return preferredMode
+        return supportedModes[0]!
+      })()
 
       const memo = methodDetails?.memo
         ? (methodDetails.memo as Hex.Hex)
@@ -193,9 +204,12 @@ export declare namespace charge {
      * - `'push'`: Client broadcasts the transaction and sends the tx hash to the server.
      * - `'pull'`: Client signs the transaction and sends the serialized tx to the server for broadcast.
      *
+     * If the server advertises `supportedModes`, this setting must be one of
+     * the supported values for the challenge.
+     *
      * @default `'push'` for JSON-RPC accounts, `'pull'` for local accounts.
      */
-    mode?: 'push' | 'pull' | undefined
+    mode?: Methods.ChargeMode | undefined
   } & Account.getResolver.Parameters &
     Client.getResolver.Parameters
 }

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

@@ -12,6 +12,13 @@ import * as Selectors from './selectors.js'
 
 const details = { amount: '1', currency: '0x01', recipient: '0x02' }
 const bogus = '0x0000000000000000000000000000000000000001' as const
+const swapTokenIn = '0x0000000000000000000000000000000000000003' as const
+const swapTokenOut = '0x0000000000000000000000000000000000000004' as const
+const swapData = encodeFunctionData({
+  abi: Abis.stablecoinDex,
+  functionName: 'swapExactAmountOut',
+  args: [swapTokenIn, swapTokenOut, 100n, 100n],
+})
 const sponsor = { address: bogus, type: 'local' } as any
 
 describe('callScopes', () => {
@@ -48,11 +55,11 @@ describe('validateCalls', () => {
   })
 
   test('accepts approve + buy + transfer', () => {
-    const swapSelector = Selectors.swapExactAmountOut
     expect(() =>
       validateCalls(
         [
           {
+            to: swapTokenIn,
             data: encodeFunctionData({
               abi: Abis.tip20,
               functionName: 'approve',
@@ -61,7 +68,7 @@ describe('validateCalls', () => {
           },
           {
             to: Addresses.stablecoinDex,
-            data: `${swapSelector}${'00'.repeat(128)}` as `0x${string}`,
+            data: swapData,
           },
           {
             data: encodeFunctionData({
@@ -77,11 +84,11 @@ describe('validateCalls', () => {
   })
 
   test('accepts multiple transfers after swap prefix', () => {
-    const swapSelector = Selectors.swapExactAmountOut
     expect(() =>
       validateCalls(
         [
           {
+            to: swapTokenIn,
             data: encodeFunctionData({
               abi: Abis.tip20,
               functionName: 'approve',
@@ -90,7 +97,7 @@ describe('validateCalls', () => {
           },
           {
             to: Addresses.stablecoinDex,
-            data: `${swapSelector}${'00'.repeat(128)}` as `0x${string}`,
+            data: swapData,
           },
           {
             data: encodeFunctionData({
@@ -142,7 +149,6 @@ describe('validateCalls', () => {
   })
 
   test('error: rejects wrong order (transfer before approve + buy)', () => {
-    const swapSelector = Selectors.swapExactAmountOut
     expect(() =>
       validateCalls(
         [
@@ -154,6 +160,7 @@ describe('validateCalls', () => {
             }),
           },
           {
+            to: swapTokenIn,
             data: encodeFunctionData({
               abi: Abis.tip20,
               functionName: 'approve',
@@ -162,7 +169,7 @@ describe('validateCalls', () => {
           },
           {
             to: Addresses.stablecoinDex,
-            data: `${swapSelector}${'00'.repeat(128)}` as `0x${string}`,
+            data: swapData,
           },
         ],
         details,
@@ -171,11 +178,11 @@ describe('validateCalls', () => {
   })
 
   test('error: rejects approve with non-DEX spender', () => {
-    const swapSelector = Selectors.swapExactAmountOut
     expect(() =>
       validateCalls(
         [
           {
+            to: swapTokenIn,
             data: encodeFunctionData({
               abi: Abis.tip20,
               functionName: 'approve',
@@ -184,7 +191,7 @@ describe('validateCalls', () => {
           },
           {
             to: Addresses.stablecoinDex,
-            data: `${swapSelector}${'00'.repeat(128)}` as `0x${string}`,
+            data: swapData,
           },
           {
             data: encodeFunctionData({
@@ -199,19 +206,48 @@ describe('validateCalls', () => {
     ).toThrow('approve spender is not the DEX')
   })
 
+  test('behavior: rejects approve targeting a non-token contract', () => {
+    expect(() =>
+      validateCalls(
+        [
+          {
+            to: bogus,
+            data: encodeFunctionData({
+              abi: Abis.tip20,
+              functionName: 'approve',
+              args: [Addresses.stablecoinDex, 100n],
+            }),
+          },
+          {
+            to: Addresses.stablecoinDex,
+            data: swapData,
+          },
+          {
+            data: encodeFunctionData({
+              abi: Abis.tip20,
+              functionName: 'transfer',
+              args: [bogus, 100n],
+            }),
+          },
+        ],
+        details,
+      ),
+    ).toThrow(FeePayerValidationError)
+  })
+
   test('error: rejects buy targeting non-DEX address', () => {
-    const swapSelector = Selectors.swapExactAmountOut
     expect(() =>
       validateCalls(
         [
           {
+            to: swapTokenIn,
             data: encodeFunctionData({
               abi: Abis.tip20,
               functionName: 'approve',
               args: [Addresses.stablecoinDex, 100n],
             }),
           },
-          { to: bogus, data: `${swapSelector}${'00'.repeat(128)}` as `0x${string}` },
+          { to: bogus, data: swapData },
           {
             data: encodeFunctionData({
               abi: Abis.tip20,
@@ -226,11 +262,11 @@ describe('validateCalls', () => {
   })
 
   test('error: rejects approve + buy without transfer', () => {
-    const swapSelector = Selectors.swapExactAmountOut
     expect(() =>
       validateCalls(
         [
           {
+            to: swapTokenIn,
             data: encodeFunctionData({
               abi: Abis.tip20,
               functionName: 'approve',
@@ -239,7 +275,7 @@ describe('validateCalls', () => {
           },
           {
             to: Addresses.stablecoinDex,
-            data: `${swapSelector}${'00'.repeat(128)}` as `0x${string}`,
+            data: swapData,
           },
         ],
         details,
@@ -285,6 +321,80 @@ describe('prepareSponsoredTransaction', () => {
     ).not.toThrow()
   })
 
+  test('accepts higher Moderato priority fees by default', () => {
+    expect(() =>
+      prepareSponsoredTransaction({
+        account: sponsor,
+        chainId: 42431,
+        details,
+        expectedFeeToken: bogus,
+        transaction: {
+          ...baseTransaction,
+          gas: 626_497n,
+          maxFeePerGas: 24_000_000_000n,
+          maxPriorityFeePerGas: 24_000_000_000n,
+        } as any,
+      }),
+    ).not.toThrow()
+  })
+
+  test('accepts fee-payer policy overrides', () => {
+    expect(() =>
+      prepareSponsoredTransaction({
+        account: sponsor,
+        chainId: 4217,
+        details,
+        expectedFeeToken: bogus,
+        policy: { maxPriorityFeePerGas: 50_000_000_000n },
+        transaction: {
+          ...baseTransaction,
+          chainId: 4217,
+          gas: 626_497n,
+          maxFeePerGas: 24_000_000_000n,
+          maxPriorityFeePerGas: 24_000_000_000n,
+        } as any,
+      }),
+    ).not.toThrow()
+  })
+
+  test('error: rejects excessive priority fee under a custom policy override', () => {
+    expect(() =>
+      prepareSponsoredTransaction({
+        account: sponsor,
+        chainId: 4217,
+        details,
+        expectedFeeToken: bogus,
+        policy: { maxPriorityFeePerGas: 20_000_000_000n },
+        transaction: {
+          ...baseTransaction,
+          chainId: 4217,
+          gas: 626_497n,
+          maxFeePerGas: 24_000_000_000n,
+          maxPriorityFeePerGas: 24_000_000_000n,
+        } as any,
+      }),
+    ).toThrow('maxPriorityFeePerGas exceeds sponsor policy')
+  })
+
+  test('ignores undefined policy override values', () => {
+    expect(() =>
+      prepareSponsoredTransaction({
+        account: sponsor,
+        chainId: 4217,
+        details,
+        expectedFeeToken: bogus,
+        policy: { maxPriorityFeePerGas: undefined } as any,
+        transaction: {
+          ...baseTransaction,
+          chainId: 4217,
+          gas: 626_497n,
+          maxFeePerGas: 24_000_000_000n,
+          maxPriorityFeePerGas: 24_000_000_000n,
+        } as any,
+      }),
+    ).toThrow('maxPriorityFeePerGas exceeds sponsor policy')
+  })
+
   test('drops unknown top-level fields from the sponsored transaction', () => {
     const sponsored = prepareSponsoredTransaction({
       account: sponsor,

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

@@ -5,6 +5,7 @@ import { decodeFunctionData } from 'viem'
 import { Abis, Addresses, Transaction } from 'viem/tempo'
 
 import * as TempoAddress_internal from './address.js'
+import * as defaults from './defaults.js'
 import * as Selectors from './selectors.js'
 
 /** Returns true if the serialized transaction has a Tempo envelope prefix. */
@@ -26,17 +27,47 @@ export const callScopes = [
   [Selectors.approve, Selectors.swapExactAmountOut, Selectors.transferWithMemo],
 ]
 
+export type Policy = {
+  maxGas: bigint
+  maxFeePerGas: bigint
+  maxPriorityFeePerGas: bigint
+  maxTotalFee: bigint
+  maxValidityWindowSeconds: number
+}
+
 /**
  * maxTotalFee must be high enough to cover `transferWithMemo` and
  * swap transactions at peak gas prices. Bumped from 0.01 ETH in #327.
  */
-const policy = {
+const defaultPolicy: Policy = {
   maxGas: 2_000_000n,
   maxFeePerGas: 100_000_000_000n,
   maxPriorityFeePerGas: 10_000_000_000n,
   maxTotalFee: 50_000_000_000_000_000n,
   maxValidityWindowSeconds: 15 * 60,
-} as const
+}
+
+const policyByChainId = {
+  [defaults.chainId.mainnet]: defaultPolicy,
+  // Moderato regularly needs a higher priority fee than mainnet.
+  [defaults.chainId.testnet]: {
+    ...defaultPolicy,
+    maxPriorityFeePerGas: 50_000_000_000n,
+  },
+} as const satisfies Record<defaults.ChainId, Policy>
+
+function getPolicy(chainId: number, overrides: Partial<Policy> | undefined): Policy {
+  const base = policyByChainId[chainId as defaults.ChainId] ?? defaultPolicy
+  if (!overrides) return base
+
+  return {
+    maxGas: overrides.maxGas ?? base.maxGas,
+    maxFeePerGas: overrides.maxFeePerGas ?? base.maxFeePerGas,
+    maxPriorityFeePerGas: overrides.maxPriorityFeePerGas ?? base.maxPriorityFeePerGas,
+    maxTotalFee: overrides.maxTotalFee ?? base.maxTotalFee,
+    maxValidityWindowSeconds: overrides.maxValidityWindowSeconds ?? base.maxValidityWindowSeconds,
+  }
+}
 
 /** Validates that a set of transaction calls matches an allowed fee-payer pattern. */
 export function validateCalls(
@@ -67,14 +98,25 @@ export function validateCalls(
     throw new FeePayerValidationError('disallowed call pattern in fee-payer transaction', details)
   }
 
-  // Validate approve spender and buy target are the DEX.
+  // Bind the swap approval to the token the DEX call will actually spend.
+  const buyCall = calls.find((c) => c.data?.slice(0, 10) === Selectors.swapExactAmountOut)
+  const buyArgs = buyCall
+    ? (decodeFunctionData({ abi: Abis.stablecoinDex, data: buyCall.data! }).args as [
+        `0x${string}`,
+        `0x${string}`,
+        bigint,
+        bigint,
+      ])
+    : undefined
+
   const approveCall = calls.find((c) => c.data?.slice(0, 10) === Selectors.approve)
   if (approveCall) {
     const { args } = decodeFunctionData({ abi: Abis.tip20, data: approveCall.data! })
+    if (!approveCall.to || (buyArgs && !TempoAddress_internal.isEqual(approveCall.to, buyArgs[0])))
+      throw new FeePayerValidationError('approve target does not match swap tokenIn', details)
     if (!TempoAddress_internal.isEqual((args as [`0x${string}`])[0]!, Addresses.stablecoinDex))
       throw new FeePayerValidationError('approve spender is not the DEX', details)
   }
-  const buyCall = calls.find((c) => c.data?.slice(0, 10) === Selectors.swapExactAmountOut)
   if (
     buyCall &&
     (!buyCall.to || !TempoAddress_internal.isEqual(buyCall.to, Addresses.stablecoinDex))
@@ -89,6 +131,7 @@ export function prepareSponsoredTransaction(parameters: {
   details: Record<string, string>
   expectedFeeToken?: TempoAddress.Address | undefined
   now?: Date | undefined
+  policy?: Partial<Policy> | undefined
   transaction: ReturnType<(typeof Transaction)['deserialize']>
 }) {
   const {
@@ -98,8 +141,10 @@ export function prepareSponsoredTransaction(parameters: {
     details,
     expectedFeeToken,
     now = new Date(),
+    policy: policyOverrides,
     transaction,
   } = parameters
+  const policy = getPolicy(chainId, policyOverrides)
 
   const {
     accessList,