mppx 0.8.3 → 0.8.5

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

@@ -1,5 +1,6 @@
 import { Challenge } from 'mppx'
 import type { Account } from 'viem'
+import { tokens } from 'viem/tokens'
 import { describe, expect, test, vi } from 'vp/test'
 
 import * as Assets from '../Assets.js'
@@ -96,4 +97,251 @@ describe('evm charge client', () => {
       'EVM raw currency allowlists require networks.',
     )
   })
+
+  test('accepts viem token sets for currency policy and decimals', async () => {
+    const signTypedData = vi.fn(async () => '0x1234')
+    const client = charge({
+      account: {
+        ...account,
+        signTypedData,
+      } as unknown as Account,
+      authorization: { name: 'USD Coin', version: '2' },
+      currencies: tokens.popular,
+      maxAmount: '1',
+    })
+    const challenge = Challenge.from({
+      id: 'native',
+      intent: 'charge',
+      method: 'evm',
+      realm: 'api.example.com',
+      request: {
+        amount: '1000000',
+        currency: Assets.baseSepolia.USDC.address,
+        methodDetails: {
+          chainId: 84532,
+          credentialTypes: ['authorization'],
+          decimals: 18,
+        },
+        recipient: '0x2222222222222222222222222222222222222222',
+      },
+    })
+
+    await client.createCredential({ challenge } as never)
+
+    expect(signTypedData).toHaveBeenCalledWith(
+      expect.objectContaining({
+        domain: expect.objectContaining({
+          name: 'USD Coin',
+          verifyingContract: Assets.baseSepolia.USDC.address,
+          version: '2',
+        }),
+      }),
+    )
+  })
+
+  test('uses viem token decimals for native authorization maxAmount policy', async () => {
+    const signTypedData = vi.fn(async () => '0x1234')
+    const client = charge({
+      account: {
+        ...account,
+        signTypedData,
+      } as unknown as Account,
+      authorization: { name: 'USD Coin', version: '2' },
+      currencies: tokens.popular,
+      maxAmount: '1',
+    })
+    const challenge = Challenge.from({
+      id: 'native',
+      intent: 'charge',
+      method: 'evm',
+      realm: 'api.example.com',
+      request: {
+        amount: '1000001',
+        currency: Assets.baseSepolia.USDC.address,
+        methodDetails: {
+          chainId: 84532,
+          credentialTypes: ['authorization'],
+          decimals: 18,
+        },
+        recipient: '0x2222222222222222222222222222222222222222',
+      },
+    })
+
+    await expect(client.createCredential({ challenge } as never)).rejects.toThrow(
+      'EVM charge amount exceeds maxAmount.',
+    )
+    expect(signTypedData).not.toHaveBeenCalled()
+  })
+
+  test('requires authorization metadata when signing viem token currencies', async () => {
+    const signTypedData = vi.fn(async () => '0x1234')
+    const client = charge({
+      account: {
+        ...account,
+        signTypedData,
+      } as unknown as Account,
+      currencies: tokens.popular,
+      maxAmount: '1',
+    })
+    const challenge = Challenge.from({
+      id: 'native',
+      intent: 'charge',
+      method: 'evm',
+      realm: 'api.example.com',
+      request: {
+        amount: '1000000',
+        currency: Assets.baseSepolia.USDC.address,
+        methodDetails: {
+          chainId: 84532,
+          credentialTypes: ['authorization'],
+          decimals: 18,
+        },
+        recipient: '0x2222222222222222222222222222222222222222',
+      },
+    })
+
+    await expect(client.createCredential({ challenge } as never)).rejects.toThrow(
+      'EVM authorization requires token name and version.',
+    )
+    expect(signTypedData).not.toHaveBeenCalled()
+  })
+
+  test('accepts viem token sets through legacy assets policy', async () => {
+    const signTypedData = vi.fn(async () => '0x1234')
+    const client = charge({
+      account: {
+        ...account,
+        signTypedData,
+      } as unknown as Account,
+      assets: tokens.popular,
+      authorization: { name: 'USD Coin', version: '2' },
+      maxAmount: '1',
+    })
+    const challenge = Challenge.from({
+      id: 'native',
+      intent: 'charge',
+      method: 'evm',
+      realm: 'api.example.com',
+      request: {
+        amount: '1000000',
+        currency: Assets.baseSepolia.USDC.address,
+        methodDetails: {
+          chainId: 84532,
+          credentialTypes: ['authorization'],
+          decimals: 18,
+        },
+        recipient: '0x2222222222222222222222222222222222222222',
+      },
+    })
+
+    await client.createCredential({ challenge } as never)
+
+    expect(signTypedData).toHaveBeenCalledOnce()
+  })
+
+  test('uses known asset metadata for native authorization policy and signing domain', async () => {
+    const signTypedData = vi.fn(async () => '0x1234')
+    const client = charge({
+      account: {
+        ...account,
+        signTypedData,
+      } as unknown as Account,
+      currencies: [Assets.baseSepolia.USDC],
+      maxAmount: '0.01',
+    })
+    const challenge = Challenge.from({
+      id: 'native',
+      intent: 'charge',
+      method: 'evm',
+      realm: 'api.example.com',
+      request: {
+        amount: '10000',
+        currency: Assets.baseSepolia.USDC.address,
+        methodDetails: {
+          chainId: 84532,
+          credentialTypes: ['authorization'],
+          decimals: 18,
+        },
+        recipient: '0x2222222222222222222222222222222222222222',
+      },
+    })
+
+    await client.createCredential({ challenge } as never)
+
+    expect(signTypedData).toHaveBeenCalledOnce()
+    expect(signTypedData).toHaveBeenCalledWith(
+      expect.objectContaining({
+        domain: expect.objectContaining({
+          name: 'USDC',
+          version: '2',
+        }),
+      }),
+    )
+  })
+
+  test('uses known asset decimals for native authorization maxAmount policy', async () => {
+    const signTypedData = vi.fn(async () => '0x1234')
+    const client = charge({
+      account: {
+        ...account,
+        signTypedData,
+      } as unknown as Account,
+      currencies: [Assets.baseSepolia.USDC],
+      maxAmount: '0.01',
+    })
+    const challenge = Challenge.from({
+      id: 'native',
+      intent: 'charge',
+      method: 'evm',
+      realm: 'api.example.com',
+      request: {
+        amount: '10001',
+        currency: Assets.baseSepolia.USDC.address,
+        methodDetails: {
+          chainId: 84532,
+          credentialTypes: ['authorization'],
+          decimals: 18,
+        },
+        recipient: '0x2222222222222222222222222222222222222222',
+      },
+    })
+
+    await expect(client.createCredential({ challenge } as never)).rejects.toThrow(
+      'EVM charge amount exceeds maxAmount.',
+    )
+    expect(signTypedData).not.toHaveBeenCalled()
+  })
+
+  test('pins known asset native authorization policy to its network', async () => {
+    const signTypedData = vi.fn(async () => '0x1234')
+    const client = charge({
+      account: {
+        ...account,
+        signTypedData,
+      } as unknown as Account,
+      currencies: [Assets.baseSepolia.USDC],
+      maxAmount: '0.01',
+    })
+    const challenge = Challenge.from({
+      id: 'native',
+      intent: 'charge',
+      method: 'evm',
+      realm: 'api.example.com',
+      request: {
+        amount: '10000',
+        currency: Assets.baseSepolia.USDC.address,
+        methodDetails: {
+          chainId: 8453,
+          credentialTypes: ['authorization'],
+          decimals: 6,
+        },
+        recipient: '0x2222222222222222222222222222222222222222',
+      },
+    })
+
+    await expect(client.createCredential({ challenge } as never)).rejects.toThrow(
+      'EVM currency is not allowed: 0x036CbD53842c5426634e7929541eC2318f3dCF7e.',
+    )
+    expect(signTypedData).not.toHaveBeenCalled()
+  })
 })

package/src/evm/client/Charge.ts

@@ -106,9 +106,9 @@ export declare namespace charge {
     /** Optional allowlist of supported EVM chain IDs. */
     networks?: readonly number[] | undefined
     /** Optional allowlist of supported currencies. */
-    currencies?: readonly (`0x${string}` | Assets.KnownAsset)[] | undefined
+    currencies?: readonly Assets.Currency[] | undefined
     /** Legacy alias for `currencies`. */
-    assets?: readonly (`0x${string}` | Assets.KnownAsset)[] | undefined
+    assets?: readonly Assets.Currency[] | undefined
   }
 }
 
@@ -127,12 +127,12 @@ function assertPolicy(parameters: charge.Parameters, request: Types.ChargeReques
     throw new Error(`EVM chain ID is not allowed: ${chainId}.`)
 
   const currencies = parameters.currencies ?? parameters.assets
-  if (currencies?.some((currency) => !Assets.isAsset(currency)) && !parameters.networks?.length)
+  if (currencies?.some((currency) => Assets.isRawAddress(currency)) && !parameters.networks?.length)
     throw new Error('EVM raw currency allowlists require networks.')
   if (currencies) {
     const acceptedCurrency = getAddress(request.currency as `0x${string}`)
     const allowed = currencies.some((currency) =>
-      currencyMatches(currency, acceptedCurrency, network),
+      Assets.matches(currency, acceptedCurrency, network),
     )
     if (!allowed) throw new Error(`EVM currency is not allowed: ${acceptedCurrency}.`)
   }
@@ -159,30 +159,18 @@ function resolveAuthorization(
   const acceptedCurrency = getAddress(request.currency as `0x${string}`)
   const network = Types.networkOf(request.methodDetails.chainId)
   const currency = currencies?.find((currency) =>
-    currencyMatches(currency, acceptedCurrency, network),
+    Assets.matches(currency, acceptedCurrency, network),
   )
-  if (currency && Assets.isAsset(currency) && currency.transfer.type === Types.eip3009)
+  const resolved = currency ? Assets.resolve(currency, network) : undefined
+  if (resolved?.transfer?.type === Types.eip3009)
     return {
-      name: currency.transfer.name,
-      version: currency.transfer.version,
+      name: resolved.transfer.name,
+      version: resolved.transfer.version,
     }
   if (parameters.authorization) return parameters.authorization
   throw new Error('EVM authorization requires token name and version.')
 }
 
-function addressOf(currency: `0x${string}` | Assets.KnownAsset): `0x${string}` {
-  return Assets.isAsset(currency) ? currency.address : currency
-}
-
-function currencyMatches(
-  currency: `0x${string}` | Assets.KnownAsset,
-  acceptedCurrency: `0x${string}`,
-  network: Types.EvmNetwork,
-): boolean {
-  if (getAddress(addressOf(currency)) !== acceptedCurrency) return false
-  return !Assets.isAsset(currency) || currency.network === network
-}
-
 function decimalsOfAcceptedCurrency(
   parameters: charge.Parameters,
   request: Types.ChargeRequest,
@@ -191,8 +179,9 @@ function decimalsOfAcceptedCurrency(
   const acceptedCurrency = getAddress(request.currency as `0x${string}`)
   const network = Types.networkOf(request.methodDetails.chainId)
   const currency = currencies?.find((currency) =>
-    currencyMatches(currency, acceptedCurrency, network),
+    Assets.matches(currency, acceptedCurrency, network),
   )
-  if (currency && Assets.isAsset(currency)) return currency.decimals
+  const resolved = currency ? Assets.resolve(currency, network) : undefined
+  if (resolved?.decimals !== undefined) return resolved.decimals
   return parameters.decimals
 }

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/internal/auto-swap.test.ts

@@ -109,18 +109,24 @@ describe('findCalls', () => {
     const tokenOut = '0x2222222222222222222222222222222222222222' as Address
     const tokenIn = '0x3333333333333333333333333333333333333333' as Address
     const client = { chain: { id: 42431 } }
-    const tokenCalls: { client: unknown; name: string; parameters: Record<string, unknown> }[] = []
+    const builderCalls: { client: unknown; name: string; parameters: Record<string, unknown> }[] =
+      []
 
     function getBalanceCall(client: unknown, parameters: Record<string, unknown>) {
-      tokenCalls.push({ client, name: 'getBalance', parameters })
+      builderCalls.push({ client, name: 'getBalance', parameters })
       return { kind: parameters.token === tokenOut ? 'targetBalance' : 'candidateBalance' }
     }
 
     function approveCall(client: unknown, parameters: Record<string, unknown>) {
-      tokenCalls.push({ client, name: 'approve', parameters })
+      builderCalls.push({ client, name: 'approve', parameters })
       return { kind: 'approve' }
     }
 
+    function buyCall(client: unknown, parameters: Record<string, unknown>) {
+      builderCalls.push({ client, name: 'buy', parameters })
+      return { kind: 'buy' }
+    }
+
     vi.doMock('viem/actions', () => ({
       readContract: vi.fn(async (_client, call: { kind: string }) =>
         call.kind === 'targetBalance' ? 0n : 2_000_000n,
@@ -129,7 +135,7 @@ describe('findCalls', () => {
     vi.doMock('viem/tempo', () => ({
       Actions: {
         dex: {
-          buy: { call: vi.fn((parameters) => ({ kind: 'buy', parameters })) },
+          buy: { call: buyCall },
           getBuyQuote: vi.fn(async () => 1_000_000n),
         },
         token: {
@@ -152,15 +158,26 @@ describe('findCalls', () => {
       })
 
       expect(calls).toHaveLength(2)
-      expect(tokenCalls.map((call) => call.client)).toEqual([client, client, client])
-      expect(tokenCalls.map((call) => call.name)).toEqual(['getBalance', 'getBalance', 'approve'])
-      expect(tokenCalls[0]!.parameters).toMatchObject({ account, token: tokenOut })
-      expect(tokenCalls[1]!.parameters).toMatchObject({ account, token: tokenIn })
-      expect(tokenCalls[2]!.parameters).toMatchObject({
+      expect(builderCalls.map((call) => call.client)).toEqual([client, client, client, client])
+      expect(builderCalls.map((call) => call.name)).toEqual([
+        'getBalance',
+        'getBalance',
+        'approve',
+        'buy',
+      ])
+      expect(builderCalls[0]!.parameters).toMatchObject({ account, token: tokenOut })
+      expect(builderCalls[1]!.parameters).toMatchObject({ account, token: tokenIn })
+      expect(builderCalls[2]!.parameters).toMatchObject({
         amount: 1_010_000n,
         spender: '0x4444444444444444444444444444444444444444',
         token: tokenIn,
       })
+      expect(builderCalls[3]!.parameters).toMatchObject({
+        amountOut: 1_000_000n,
+        maxAmountIn: 1_010_000n,
+        tokenIn,
+        tokenOut,
+      })
     } finally {
       vi.doUnmock('viem/actions')
       vi.doUnmock('viem/tempo')

package/src/tempo/internal/auto-swap.ts

@@ -1,7 +1,7 @@
 import type { Address, Client } from 'viem'
 import { readContract } from 'viem/actions'
 import { Actions, Addresses } from 'viem/tempo'
-import type { token as viem_token } from 'viem/tempo/actions'
+import type { dex as viem_dex, token as viem_token } from 'viem/tempo/actions'
 
 import * as TempoAddress from './address.js'
 import * as defaults from './defaults.js'
@@ -47,6 +47,19 @@ function getApproveCall(
   return call.length >= 2 ? call(client, parameters) : call(parameters)
 }
 
+// TODO: Remove once the minimum viem version is >=2.54.0, which uses client-first Tempo call builders.
+function getBuyCall(
+  client: Client,
+  parameters: viem_dex.buy.Args,
+): ReturnType<typeof viem_dex.buy.call> {
+  const call = Actions.dex.buy.call as unknown as {
+    length: number
+    (parameters: viem_dex.buy.Args): ReturnType<typeof viem_dex.buy.call>
+    (client: Client, parameters: viem_dex.buy.Args): ReturnType<typeof viem_dex.buy.call>
+  }
+  return call.length >= 2 ? call(client, parameters) : call(parameters)
+}
+
 /**
  * Finds the optimal swap calls to acquire `amountOut` of `tokenOut`,
  * returning an approve + buy call sequence if a viable route is found.
@@ -100,7 +113,7 @@ export async function findCalls(
             spender: Addresses.stablecoinDex,
             token: tokenIn,
           }),
-          Actions.dex.buy.call({
+          getBuyCall(client, {
             tokenIn,
             tokenOut,
             amountOut,