mppx 0.8.4 → 0.8.6

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

@@ -4,6 +4,7 @@ import { Types as evm_Types } from 'mppx/evm'
 import { evm, Mppx } from 'mppx/server'
 import { Header as x402_Header, Types as x402_Types, type PaymentPayload } from 'mppx/x402'
 import { privateKeyToAccount } from 'viem/accounts'
+import { usdc } from 'viem/tokens'
 import { describe, expect, test } from 'vp/test'
 
 const currency = '0x036CbD53842c5426634e7929541eC2318f3dCF7e'
@@ -14,6 +15,145 @@ const account = privateKeyToAccount(
 )
 
 describe('evm charge server', () => {
+  test('resolves viem token currency config', async () => {
+    const mppx = Mppx.create({
+      methods: [
+        evm({
+          authorization: { name: 'USD Coin', version: '2' },
+          chainId: 84532,
+          currency: usdc,
+          recipient,
+          x402: {
+            facilitator: {
+              async verify() {
+                return { isValid: true }
+              },
+              async settle() {
+                return {
+                  network: evm_Types.networkOf(84532),
+                  success: true,
+                  transaction,
+                }
+              },
+            },
+          },
+        }),
+      ],
+      secretKey: 'test-secret-key-test-secret-key-32',
+    })
+    const route = mppx.evm.charge({ amount: '0.25' })
+
+    const first = await route(new Request('https://example.com/paid'))
+
+    expect(first.status).toBe(402)
+    if (first.status !== 402) throw new Error()
+    const challenge = Challenge.fromResponse(first.challenge)
+    expect(challenge.request).toEqual({
+      amount: '250000',
+      currency,
+      methodDetails: {
+        chainId: 84532,
+        credentialTypes: ['authorization'],
+        decimals: 6,
+      },
+      recipient,
+    })
+  })
+
+  test('requires chain ID for viem token currency config', () => {
+    expect(() =>
+      evm({
+        authorization: { name: 'USD Coin', version: '2' },
+        currency: usdc,
+        recipient,
+        settle: async () => ({ reference: transaction }),
+      }),
+    ).toThrow('EVM authorization requires `chainId`.')
+  })
+
+  test('rejects viem token currency unavailable on configured chain', () => {
+    expect(() =>
+      evm({
+        authorization: { name: 'USD Coin', version: '2' },
+        chainId: 999_999,
+        currency: usdc,
+        recipient,
+        settle: async () => ({ reference: transaction }),
+      }),
+    ).toThrow('EVM currency is not available on chain ID 999999.')
+  })
+
+  test('requires authorization metadata for viem token currency config', () => {
+    expect(() =>
+      evm({
+        chainId: 84532,
+        currency: usdc,
+        recipient,
+        settle: async () => ({ reference: transaction }),
+      }),
+    ).toThrow('EVM authorization requires `authorization` metadata.')
+  })
+
+  test('rejects known asset currency configured for a different chain', () => {
+    expect(() =>
+      evm({
+        chainId: 8453,
+        currency: evm.assets.baseSepolia.USDC,
+        recipient,
+        settle: async () => ({ reference: transaction }),
+      }),
+    ).toThrow('EVM currency is not available on chain ID 8453.')
+  })
+
+  test('infers native charge defaults from known asset metadata', async () => {
+    const mppx = Mppx.create({
+      methods: [
+        evm({
+          currency: evm.assets.base.USDC,
+          recipient,
+          settle: async () => ({ reference: transaction }),
+        }),
+      ],
+      secretKey: 'test-secret-key-test-secret-key-32',
+    })
+    const route = mppx.evm.charge({ amount: '0.25' })
+
+    const response = await route(new Request('https://example.com/paid'))
+
+    expect(response.status).toBe(402)
+    if (response.status !== 402) throw new Error()
+    const challenge = Challenge.fromResponse(response.challenge)
+    expect(challenge.request).toEqual({
+      amount: '250000',
+      currency: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+      methodDetails: {
+        chainId: 8453,
+        credentialTypes: ['authorization'],
+        decimals: 6,
+      },
+      recipient,
+    })
+  })
+
+  test('requires authorization metadata for known assets without EIP-3009 transfer metadata', () => {
+    const permit2Asset = evm.assets.define({
+      address: currency,
+      decimals: 6,
+      network: 'eip155:84532',
+      transfer: {
+        type: 'permit2',
+      },
+    })
+
+    expect(() =>
+      evm({
+        currency: permit2Asset,
+        recipient,
+        settle: async () => ({ reference: transaction }),
+      }),
+    ).toThrow('EVM authorization requires `authorization` metadata.')
+  })
+
   test('settles native Payment-auth authorization credentials', async () => {
     let facilitated:
       | {

package/src/evm/server/Charge.ts

@@ -110,11 +110,11 @@ export declare namespace charge {
   type NativeConfig = BaseConfig & CurrencyConfig & RecipientConfig
 
   type BaseConfig = {
-    /** EIP-3009 token domain metadata. Required for custom currency addresses; inferred for known assets. */
+    /** EIP-3009 token domain metadata. Required for raw addresses and viem tokens; inferred for known assets. */
     authorization?: Types.AuthorizationConfig | undefined
-    /** EVM chain ID. Required for custom currency addresses; inferred for known assets. */
+    /** EVM chain ID. Required for raw addresses and viem tokens; inferred for known assets. */
     chainId?: number | undefined
-    /** Token decimal places. Required for custom currency addresses; inferred for known assets. */
+    /** Token decimal places. Required for raw addresses; inferred for known assets and viem tokens. */
     decimals?: number | undefined
     /** Custom settlement override. If omitted, `x402.facilitator` is used. */
     settle?: SettleAuthorization | undefined
@@ -123,8 +123,8 @@ export declare namespace charge {
   }
 
   type CurrencyConfig = {
-    /** Token contract address or known EVM asset metadata. */
-    currency: `0x${string}` | Assets.KnownAsset
+    /** Token contract address, known EVM asset metadata, or viem token definition. */
+    currency: Assets.Currency
   }
 
   type RecipientConfig = {
@@ -197,17 +197,24 @@ function resolveConfig(config: charge.NativeConfig): ResolvedConfig {
   let decimals = config.decimals
 
   if (Assets.isAsset(currency)) {
-    address = currency.address
-    chainId ??= Number(currency.network.slice('eip155:'.length))
-    decimals ??= currency.decimals
-    if (currency.transfer.type === Types.eip3009) {
+    chainId ??= Assets.toChainId(currency.network)
+  }
+
+  if (chainId !== undefined) {
+    const resolved = Assets.resolve(currency, Types.networkOf(chainId))
+    if (!resolved) throw new Error(`EVM currency is not available on chain ID ${chainId}.`)
+    address = resolved.address
+    decimals ??= resolved.decimals
+    if (resolved.transfer?.type === Types.eip3009) {
       authorization ??= {
-        name: currency.transfer.name,
-        version: currency.transfer.version,
+        name: resolved.transfer.name,
+        version: resolved.transfer.version,
       }
     }
-  } else {
+  } else if (Assets.isRawAddress(currency)) {
     address = currency
+  } else {
+    throw new Error('EVM authorization requires `chainId`.')
   }
 
   if (!authorization) throw new Error('EVM authorization requires `authorization` metadata.')

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

@@ -353,6 +353,67 @@ describe('tempo.charge client', () => {
     }
   })
 
+  test('normalizes sponsored pull transactions before signing', async () => {
+    vi.resetModules()
+    const prepared = {
+      feePayerSignature: { r: '0x1', s: '0x2', yParity: 0 },
+      feeToken: currency,
+      gas: 100n,
+    }
+    const prepareTransactionRequest = vi.fn(async () => prepared)
+    const signTransaction = vi.fn(
+      async (_client: unknown, _transaction: Record<string, unknown>) => '0xdeadbeef',
+    )
+    vi.doMock('viem/actions', () => ({
+      prepareTransactionRequest,
+      sendCallsSync: vi.fn(),
+      signTransaction,
+      signTypedData: vi.fn(),
+    }))
+
+    try {
+      const { charge: chargeWithMockedActions } = await import('./Charge.js')
+      const chainId = 42431
+      const client = createClient({
+        account,
+        chain: tempoLocalnet,
+        transport: http('http://127.0.0.1'),
+      })
+      const method = chargeWithMockedActions({
+        account,
+        getClient: () => client,
+      })
+
+      await method.createCredential({
+        challenge: createChallenge({
+          amount: '1',
+          chainId,
+          feePayer: true,
+          supportedModes: ['pull'],
+        }),
+        context: {},
+      })
+
+      expect(prepareTransactionRequest).toHaveBeenCalledWith(
+        client,
+        expect.not.objectContaining({ feePayer: true }),
+      )
+      expect(signTransaction).toHaveBeenCalledWith(
+        client,
+        expect.objectContaining({
+          feePayer: true,
+          gas: 5_100n,
+        }),
+      )
+      const signed = signTransaction.mock.calls[0]?.[1] as Record<string, unknown>
+      expect(signed).not.toHaveProperty('feePayerSignature')
+      expect(signed).not.toHaveProperty('feeToken')
+    } finally {
+      vi.doUnmock('viem/actions')
+      vi.resetModules()
+    }
+  })
+
   describe('chain pinning', () => {
     const client = createClient({
       account,

package/src/tempo/client/Charge.ts

@@ -226,7 +226,12 @@ export function charge(parameters: charge.Parameters = {}) {
       // Estimate before enabling fee-payer mode so Tempo includes sender
       // signature and access-key verification costs in the gas budget.
       prepared.gas = (prepared.gas ?? 0n) + 5_000n
-      if (methodDetails?.feePayer) (prepared as Record<string, unknown>).feePayer = true
+      if (methodDetails?.feePayer) {
+        const sponsored = prepared as Record<string, unknown>
+        delete sponsored.feePayerSignature
+        delete sponsored.feeToken
+        sponsored.feePayer = true
+      }
       const signature = await signTransaction(client, prepared as never)
 
       return Credential.serialize({