mppx 0.3.9 → 0.3.12

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

@@ -0,0 +1,223 @@
+import { encodeFunctionData } from 'viem'
+import { Abis, Addresses } from 'viem/tempo'
+import { describe, expect, test } from 'vitest'
+import { callScopes, FeePayerValidationError, validateCalls } from './fee-payer.js'
+import * as Selectors from './selectors.js'
+
+const details = { amount: '1', currency: '0x01', recipient: '0x02' }
+const bogus = '0x0000000000000000000000000000000000000001' as const
+
+describe('callScopes', () => {
+  test('has 4 allowed patterns', () => {
+    expect(callScopes).toHaveLength(4)
+  })
+
+  test('patterns use correct selectors', () => {
+    expect(callScopes).toEqual([
+      [Selectors.transfer],
+      [Selectors.transferWithMemo],
+      [Selectors.approve, Selectors.swapExactAmountOut, Selectors.transfer],
+      [Selectors.approve, Selectors.swapExactAmountOut, Selectors.transferWithMemo],
+    ])
+  })
+})
+
+describe('validateCalls', () => {
+  test('accepts single transfer', () => {
+    expect(() =>
+      validateCalls(
+        [
+          {
+            data: encodeFunctionData({
+              abi: Abis.tip20,
+              functionName: 'transfer',
+              args: [bogus, 100n],
+            }),
+          },
+        ],
+        details,
+      ),
+    ).not.toThrow()
+  })
+
+  test('accepts approve + buy + transfer', () => {
+    const swapSelector = Selectors.swapExactAmountOut
+    expect(() =>
+      validateCalls(
+        [
+          {
+            data: encodeFunctionData({
+              abi: Abis.tip20,
+              functionName: 'approve',
+              args: [Addresses.stablecoinDex, 100n],
+            }),
+          },
+          {
+            to: Addresses.stablecoinDex,
+            data: `${swapSelector}${'00'.repeat(128)}` as `0x${string}`,
+          },
+          {
+            data: encodeFunctionData({
+              abi: Abis.tip20,
+              functionName: 'transfer',
+              args: [bogus, 100n],
+            }),
+          },
+        ],
+        details,
+      ),
+    ).not.toThrow()
+  })
+
+  test('error: rejects empty calls', () => {
+    expect(() => validateCalls([], details)).toThrow(FeePayerValidationError)
+  })
+
+  test('error: rejects unknown selector', () => {
+    expect(() => validateCalls([{ data: '0xdeadbeef' as `0x${string}` }], details)).toThrow(
+      'disallowed call pattern',
+    )
+  })
+
+  test('error: rejects extra calls beyond allowed patterns', () => {
+    const swapSelector = Selectors.swapExactAmountOut
+    expect(() =>
+      validateCalls(
+        [
+          {
+            data: encodeFunctionData({
+              abi: Abis.tip20,
+              functionName: 'approve',
+              args: [Addresses.stablecoinDex, 100n],
+            }),
+          },
+          {
+            to: Addresses.stablecoinDex,
+            data: `${swapSelector}${'00'.repeat(128)}` as `0x${string}`,
+          },
+          {
+            data: encodeFunctionData({
+              abi: Abis.tip20,
+              functionName: 'transfer',
+              args: [bogus, 100n],
+            }),
+          },
+          {
+            data: encodeFunctionData({
+              abi: Abis.tip20,
+              functionName: 'transfer',
+              args: [bogus, 100n],
+            }),
+          },
+        ],
+        details,
+      ),
+    ).toThrow('disallowed call pattern')
+  })
+
+  test('error: rejects wrong order (transfer before approve + buy)', () => {
+    const swapSelector = Selectors.swapExactAmountOut
+    expect(() =>
+      validateCalls(
+        [
+          {
+            data: encodeFunctionData({
+              abi: Abis.tip20,
+              functionName: 'transfer',
+              args: [bogus, 100n],
+            }),
+          },
+          {
+            data: encodeFunctionData({
+              abi: Abis.tip20,
+              functionName: 'approve',
+              args: [Addresses.stablecoinDex, 100n],
+            }),
+          },
+          {
+            to: Addresses.stablecoinDex,
+            data: `${swapSelector}${'00'.repeat(128)}` as `0x${string}`,
+          },
+        ],
+        details,
+      ),
+    ).toThrow('disallowed call pattern')
+  })
+
+  test('error: rejects approve with non-DEX spender', () => {
+    const swapSelector = Selectors.swapExactAmountOut
+    expect(() =>
+      validateCalls(
+        [
+          {
+            data: encodeFunctionData({
+              abi: Abis.tip20,
+              functionName: 'approve',
+              args: [bogus, 100n],
+            }),
+          },
+          {
+            to: Addresses.stablecoinDex,
+            data: `${swapSelector}${'00'.repeat(128)}` as `0x${string}`,
+          },
+          {
+            data: encodeFunctionData({
+              abi: Abis.tip20,
+              functionName: 'transfer',
+              args: [bogus, 100n],
+            }),
+          },
+        ],
+        details,
+      ),
+    ).toThrow('approve spender is not the DEX')
+  })
+
+  test('error: rejects buy targeting non-DEX address', () => {
+    const swapSelector = Selectors.swapExactAmountOut
+    expect(() =>
+      validateCalls(
+        [
+          {
+            data: encodeFunctionData({
+              abi: Abis.tip20,
+              functionName: 'approve',
+              args: [Addresses.stablecoinDex, 100n],
+            }),
+          },
+          { to: bogus, data: `${swapSelector}${'00'.repeat(128)}` as `0x${string}` },
+          {
+            data: encodeFunctionData({
+              abi: Abis.tip20,
+              functionName: 'transfer',
+              args: [bogus, 100n],
+            }),
+          },
+        ],
+        details,
+      ),
+    ).toThrow('buy target is not the DEX')
+  })
+
+  test('error: rejects approve + buy without transfer', () => {
+    const swapSelector = Selectors.swapExactAmountOut
+    expect(() =>
+      validateCalls(
+        [
+          {
+            data: encodeFunctionData({
+              abi: Abis.tip20,
+              functionName: 'approve',
+              args: [Addresses.stablecoinDex, 100n],
+            }),
+          },
+          {
+            to: Addresses.stablecoinDex,
+            data: `${swapSelector}${'00'.repeat(128)}` as `0x${string}`,
+          },
+        ],
+        details,
+      ),
+    ).toThrow('disallowed call pattern')
+  })
+})

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

@@ -0,0 +1,53 @@
+import { decodeFunctionData, isAddressEqual } from 'viem'
+import { Abis, Addresses } from 'viem/tempo'
+import * as Selectors from './selectors.js'
+
+/**
+ * Allowed call patterns for fee-payer sponsored transactions.
+ * Each inner array is an ordered list of function selectors.
+ */
+export const callScopes = [
+  [Selectors.transfer],
+  [Selectors.transferWithMemo],
+  [Selectors.approve, Selectors.swapExactAmountOut, Selectors.transfer],
+  [Selectors.approve, Selectors.swapExactAmountOut, Selectors.transferWithMemo],
+]
+
+/** Validates that a set of transaction calls matches an allowed fee-payer pattern. */
+export function validateCalls(
+  calls: readonly { data?: `0x${string}` | undefined; to?: `0x${string}` | undefined }[],
+  details: Record<string, string>,
+) {
+  const callSelectors = calls.map((c) => c.data?.slice(0, 10))
+  const allowed = callScopes.some(
+    (pattern) =>
+      pattern.length === callSelectors.length &&
+      pattern.every((sel, i) => sel === callSelectors[i]),
+  )
+  if (!allowed)
+    throw new FeePayerValidationError('disallowed call pattern in fee-payer transaction', details)
+
+  // Validate approve spender and buy target are the DEX.
+  const approveCall = calls.find((c) => c.data?.slice(0, 10) === Selectors.approve)
+  if (approveCall) {
+    const { args } = decodeFunctionData({ abi: Abis.tip20, data: approveCall.data! })
+    if (!isAddressEqual((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 || !isAddressEqual(buyCall.to, Addresses.stablecoinDex)))
+    throw new FeePayerValidationError('buy target is not the DEX', details)
+}
+
+export class FeePayerValidationError extends Error {
+  override readonly name = 'FeePayerValidationError'
+
+  constructor(reason: string, details: Record<string, string>) {
+    super(
+      [
+        `Invalid transaction: ${reason}`,
+        ...Object.entries(details).map(([k, v]) => `  - ${k}: ${v}`),
+      ].join('\n'),
+    )
+  }
+}

package/src/tempo/internal/selectors.ts

@@ -0,0 +1,10 @@
+import { AbiItem } from 'ox'
+import { Abis } from 'viem/tempo'
+
+export const approve = /*#__PURE__*/ AbiItem.getSelector(Abis.tip20, 'approve')
+export const transfer = /*#__PURE__*/ AbiItem.getSelector(Abis.tip20, 'transfer')
+export const transferWithMemo = /*#__PURE__*/ AbiItem.getSelector(Abis.tip20, 'transferWithMemo')
+export const swapExactAmountOut = /*#__PURE__*/ AbiItem.getSelector(
+  Abis.stablecoinDex,
+  'swapExactAmountOut',
+)

package/src/tempo/internal/simulate.ts

@@ -0,0 +1,49 @@
+import type { Address, Client } from 'viem'
+
+/**
+ * Simulate a Tempo transaction via `eth_estimateGas` to catch reverts
+ * (e.g. insufficient balance, invalid calls) before broadcasting.
+ */
+export async function simulateTransaction(
+  client: Client,
+  transaction: {
+    from: Address
+    chainId: number
+    nonce?: number | bigint | undefined
+    maxFeePerGas?: bigint | undefined
+    maxPriorityFeePerGas?: bigint | undefined
+    feeToken?: string | bigint | undefined
+    nonceKey?: bigint | undefined
+    validBefore?: number | undefined
+    calls?: readonly {
+      to?: string | undefined
+      value?: bigint | undefined
+      data?: string | undefined
+    }[]
+  },
+): Promise<void> {
+  const simCalls = (transaction.calls ?? []).map((c) => ({
+    to: c.to,
+    value: c.value ? `0x${c.value.toString(16)}` : '0x0',
+    input: c.data ?? '0x',
+  }))
+  await client.request({
+    method: 'eth_estimateGas' as never,
+    params: [
+      {
+        from: transaction.from,
+        chainId: `0x${transaction.chainId.toString(16)}`,
+        nonce: `0x${BigInt(transaction.nonce ?? 0).toString(16)}`,
+        gas: '0x2dc6c0', // 3M cap
+        maxFeePerGas: `0x${(transaction.maxFeePerGas ?? 0n).toString(16)}`,
+        maxPriorityFeePerGas: `0x${(transaction.maxPriorityFeePerGas ?? 0n).toString(16)}`,
+        feeToken: transaction.feeToken,
+        nonceKey: `0x${(transaction.nonceKey ?? 0n).toString(16)}`,
+        calls: simCalls,
+        ...(transaction.validBefore
+          ? { validBefore: `0x${transaction.validBefore.toString(16)}` }
+          : {}),
+      },
+    ] as never,
+  })
+}