mppx 0.8.4 → 0.8.6

package/src/x402/client/Exact.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 Chains from '../../evm/Chains.js'
@@ -78,6 +79,134 @@ describe('x402 exact credential helper', () => {
     ).rejects.toThrow('x402 exact raw currency allowlists require networks.')
   })
 
+  test('uses known asset metadata for currency policy and maxAmount decimals', async () => {
+    const signTypedData = vi.fn(async () => '0x1234')
+
+    const credential = await createCredential({
+      challenge: challenge(),
+      config: {
+        account: {
+          ...account,
+          signTypedData,
+        } as unknown as Account,
+        currencies: [Assets.baseSepolia.USDC],
+        maxAmount: '0.01',
+      },
+      context: {},
+    })
+    const paymentPayload = Header.decodePaymentSignature(credential)
+
+    expect(signTypedData).toHaveBeenCalledOnce()
+    expect(paymentPayload.accepted.asset).toBe(Assets.baseSepolia.USDC.address)
+  })
+
+  test('pins known asset currency policy to its network', async () => {
+    const signTypedData = vi.fn(async () => '0x1234')
+
+    await expect(
+      createCredential({
+        challenge: challenge({ network: 'eip155:8453' }),
+        config: {
+          account: {
+            ...account,
+            signTypedData,
+          } as unknown as Account,
+          currencies: [Assets.baseSepolia.USDC],
+          maxAmount: '0.01',
+        },
+        context: {},
+      }),
+    ).rejects.toThrow(
+      'x402 exact currency is not allowed: 0x036CbD53842c5426634e7929541eC2318f3dCF7e.',
+    )
+    expect(signTypedData).not.toHaveBeenCalled()
+  })
+
+  test('accepts viem token sets for currency policy and decimals', async () => {
+    const signTypedData = vi.fn(async () => '0x1234')
+
+    const credential = await createCredential({
+      challenge: challenge({ amount: '1000000' }),
+      config: {
+        account: {
+          ...account,
+          signTypedData,
+        } as unknown as Account,
+        currencies: tokens.popular,
+        maxAmount: '1',
+      },
+      context: {},
+    })
+    const paymentPayload = Header.decodePaymentSignature(credential)
+
+    expect(signTypedData).toHaveBeenCalledOnce()
+    expect(paymentPayload.accepted.asset).toBe(Assets.baseSepolia.USDC.address)
+  })
+
+  test('uses viem token decimals for maxAmount policy', async () => {
+    const signTypedData = vi.fn(async () => '0x1234')
+
+    await expect(
+      createCredential({
+        challenge: challenge({ amount: '1000001' }),
+        config: {
+          account: {
+            ...account,
+            signTypedData,
+          } as unknown as Account,
+          currencies: tokens.popular,
+          maxAmount: '1',
+        },
+        context: {},
+      }),
+    ).rejects.toThrow('x402 exact amount exceeds maxAmount.')
+    expect(signTypedData).not.toHaveBeenCalled()
+  })
+
+  test('accepts viem token sets through legacy assets policy', async () => {
+    const signTypedData = vi.fn(async () => '0x1234')
+
+    const credential = await createCredential({
+      challenge: challenge({ amount: '1000000' }),
+      config: {
+        account: {
+          ...account,
+          signTypedData,
+        } as unknown as Account,
+        assets: tokens.popular,
+        maxAmount: '1',
+      },
+      context: {},
+    })
+
+    expect(signTypedData).toHaveBeenCalledOnce()
+    expect(Header.decodePaymentSignature(credential).accepted.asset).toBe(
+      Assets.baseSepolia.USDC.address,
+    )
+  })
+
+  test('pins viem token currency policy to available networks', async () => {
+    const signTypedData = vi.fn(async () => '0x1234')
+
+    await expect(
+      createCredential({
+        challenge: challenge({ network: 'eip155:999999' }),
+        config: {
+          account: {
+            ...account,
+            signTypedData,
+          } as unknown as Account,
+          currencies: tokens.popular,
+          maxAmount: '1',
+        },
+        context: {},
+      }),
+    ).rejects.toThrow(
+      'x402 exact currency is not allowed: 0x036CbD53842c5426634e7929541eC2318f3dCF7e.',
+    )
+    expect(signTypedData).not.toHaveBeenCalled()
+  })
+
   test('signs EIP-3009 exact payment payloads', async () => {
     const signTypedData = vi.fn(async () => '0x1234')
     const config = {

package/src/x402/client/Exact.ts

@@ -99,9 +99,9 @@ export type Config = {
   /** 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
 }
 
 const authorizationTypes = {
@@ -125,12 +125,12 @@ function assertPolicy(parameters: Config, accepted: Types.PaymentRequirements) {
     throw new Error(`x402 exact 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('x402 exact raw currency allowlists require networks.')
   if (currencies) {
     const acceptedCurrency = getAddress(accepted.asset as `0x${string}`)
     const allowed = currencies.some((currency) =>
-      currencyMatches(currency, acceptedCurrency, accepted.network),
+      Assets.matches(currency, acceptedCurrency, accepted.network),
     )
     if (!allowed) throw new Error(`x402 exact currency is not allowed: ${acceptedCurrency}.`)
   }
@@ -149,19 +149,6 @@ function assertPolicy(parameters: Config, accepted: Types.PaymentRequirements) {
   }
 }
 
-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: Config,
   accepted: Types.PaymentRequirements,
@@ -169,9 +156,10 @@ function decimalsOfAcceptedCurrency(
   const currencies = parameters.currencies ?? parameters.assets
   const acceptedCurrency = getAddress(accepted.asset as `0x${string}`)
   const currency = currencies?.find((currency) =>
-    currencyMatches(currency, acceptedCurrency, accepted.network),
+    Assets.matches(currency, acceptedCurrency, accepted.network),
   )
-  if (currency && Assets.isAsset(currency)) return currency.decimals
+  const resolved = currency ? Assets.resolve(currency, accepted.network) : undefined
+  if (resolved?.decimals !== undefined) return resolved.decimals
   return parameters.decimals
 }