mppx 0.8.17 → 0.8.18

package/src/evm/PublicInterface.test-d.ts

@@ -1,134 +0,0 @@
-import * as evmRoot from 'mppx/evm'
-import {
-  assets as clientAssets,
-  chains as clientChains,
-  charge as clientCharge,
-  evm as clientEvm,
-} from 'mppx/evm/client'
-import { assets as serverAssets, charge as serverCharge, evm as serverEvm } from 'mppx/evm/server'
-import type { Account } from 'viem'
-import { tokens, usdc } from 'viem/tokens'
-import { describe, expectTypeOf, test } from 'vp/test'
-
-import { Mppx as ClientMppx } from '../client/index.js'
-import { Mppx as ServerMppx } from '../server/index.js'
-
-const account = {} as Account
-const recipient = '0x209693Bc6afc0C5328bA36FaF03C514EF312287C'
-const secretKey = 'test-secret-key-test-secret-key-32'
-const settle = async () => ({
-  reference: `0x${'1'.repeat(64)}` as `0x${string}`,
-})
-const facilitator = {
-  settle: async () => ({
-    network: 'eip155:8453',
-    success: true,
-    transaction: `0x${'1'.repeat(64)}` as `0x${string}`,
-  }),
-  verify: async () => ({ isValid: true }),
-}
-
-describe('evm public interface', () => {
-  test('exports EVM asset metadata from root and subpaths', () => {
-    expectTypeOf(evmRoot.assets.base.USDC).toMatchTypeOf<typeof serverAssets.base.USDC>()
-    expectTypeOf(
-      evmRoot.assets.fromToken(usdc, {
-        chainId: clientChains.base,
-        transfer: { type: 'eip3009', version: '2' },
-      }),
-    ).toMatchTypeOf<typeof serverAssets.base.USDC>()
-    expectTypeOf(clientAssets.baseSepolia.USDC).toMatchTypeOf<
-      typeof serverAssets.baseSepolia.USDC
-    >()
-    expectTypeOf(evmRoot.assets.celo.USDC).toMatchTypeOf<typeof serverAssets.celo.USDC>()
-    expectTypeOf(evmRoot.assets.celo.USDT).toMatchTypeOf<typeof serverAssets.celo.USDT>()
-    expectTypeOf(clientAssets.celoSepolia.USDC).toMatchTypeOf<
-      typeof serverAssets.celoSepolia.USDC
-    >()
-    expectTypeOf(evmRoot.chains.base).toMatchTypeOf<number>()
-    expectTypeOf(clientChains.baseSepolia).toMatchTypeOf<number>()
-    expectTypeOf(evmRoot.chains.celo).toMatchTypeOf<number>()
-    expectTypeOf(clientChains.celoSepolia).toMatchTypeOf<number>()
-  })
-
-  test('exports root EVM charge method definition', () => {
-    expectTypeOf(evmRoot.charge.name).toEqualTypeOf<'evm'>()
-    expectTypeOf(evmRoot.charge.intent).toEqualTypeOf<'charge'>()
-  })
-
-  test('server charge works through subpath exports and tuple helper', () => {
-    const direct = serverCharge({
-      currency: serverAssets.base.USDC,
-      recipient,
-      x402: { facilitator },
-    })
-    expectTypeOf(direct.name).toEqualTypeOf<'evm'>()
-    expectTypeOf(direct.intent).toEqualTypeOf<'charge'>()
-
-    const mppx = ServerMppx.create({
-      methods: [
-        serverEvm({
-          authorization: { name: 'USD Coin', version: '2' },
-          chainId: clientChains.base,
-          currency: usdc,
-          recipient,
-          x402: { facilitator },
-        }),
-        serverEvm({
-          currency: serverAssets.base.USDC,
-          recipient,
-          x402: { facilitator },
-        }),
-      ],
-      secretKey,
-    })
-
-    expectTypeOf(mppx.evm.charge).toBeFunction()
-    expectTypeOf(mppx.evm.charge({ amount: '0.01' })).toBeFunction()
-  })
-
-  test('server charge accepts a custom settlement override', () => {
-    const direct = serverCharge({
-      currency: serverAssets.base.USDC,
-      recipient,
-      settle,
-    })
-    expectTypeOf(direct.name).toEqualTypeOf<'evm'>()
-    expectTypeOf(direct.intent).toEqualTypeOf<'charge'>()
-  })
-
-  test('client charge works through subpath exports and tuple helper', () => {
-    const direct = clientCharge({
-      account,
-      currencies: [clientAssets.baseSepolia.USDC],
-      maxAmount: '0.01',
-      networks: [clientChains.baseSepolia],
-    })
-    expectTypeOf(direct.name).toEqualTypeOf<'evm'>()
-    expectTypeOf(direct.intent).toEqualTypeOf<'charge'>()
-
-    const mppx = ClientMppx.create({
-      methods: [
-        clientEvm({
-          account,
-          currencies: tokens.popular,
-          maxAmount: '0.01',
-        }),
-      ],
-      polyfill: false,
-    })
-
-    expectTypeOf(mppx.createCredential).toBeFunction()
-  })
-
-  test('server charge rejects x402 exact config shape', () => {
-    serverCharge({
-      // @ts-expect-error evm.charge takes shared charge config, not x402 exact config.
-      config: {
-        currency: serverAssets.base.USDC,
-        recipient,
-        x402: { facilitator },
-      },
-    })
-  })
-})

package/src/evm/Types.ts

@@ -1,140 +0,0 @@
-import { Bytes, Hash } from 'ox'
-
-import * as z from '../zod.js'
-
-/** Payment method name for Payment-auth EVM challenges. */
-export const paymentMethod = 'evm' as const
-
-/** Payment intent name for one-time EVM charges. */
-export const chargeIntent = 'charge' as const
-
-/** CAIP-2 namespace prefix for EVM networks. */
-export const evmNetworkPrefix = 'eip155:' as const
-
-/** EIP-3009 transfer authorization method identifier. */
-export const eip3009 = 'eip3009' as const
-
-/** EVM charge credential types supported by this package. */
-export const credentialTypes = ['authorization'] as const
-
-const atomicAmount = z.string().check(z.regex(/^\d+$/, 'Invalid atomic amount'))
-
-/** EIP-3009 domain metadata for `transferWithAuthorization` signatures. */
-export const AuthorizationConfigSchema = z.object({
-  name: z.string().check(z.minLength(1)),
-  version: z.string().check(z.minLength(1)),
-})
-export type AuthorizationConfig = z.infer<typeof AuthorizationConfigSchema>
-
-/** CAIP-2 EVM network identifier. */
-export type EvmNetwork = `${typeof evmNetworkPrefix}${number}`
-
-/** EVM-specific charge method details. */
-export const MethodDetailsSchema = z.object({
-  chainId: z.number(),
-  credentialTypes: z.optional(z.array(z.enum(credentialTypes)).check(z.minLength(1))),
-  decimals: z.optional(z.number()),
-  permit2Address: z.optional(z.address()),
-  splits: z.optional(
-    z.array(
-      z.object({
-        amount: atomicAmount,
-        recipient: z.address(),
-      }),
-    ),
-  ),
-})
-export type MethodDetails = z.infer<typeof MethodDetailsSchema>
-
-/** Canonical Payment-auth EVM charge request. */
-export const ChargeRequestSchema = z.object({
-  amount: atomicAmount,
-  currency: z.address(),
-  description: z.optional(z.string()),
-  externalId: z.optional(z.string()),
-  methodDetails: MethodDetailsSchema,
-  recipient: z.address(),
-})
-export type ChargeRequest = z.infer<typeof ChargeRequestSchema>
-
-/** Public route input before display-unit amounts are converted to atomic units. */
-export const ChargeRequestInputSchema = z.object({
-  amount: z.amount(),
-  chainId: z.number(),
-  currency: z.address(),
-  credentialTypes: z.optional(z.array(z.enum(credentialTypes)).check(z.minLength(1))),
-  decimals: z.number(),
-  description: z.optional(z.string()),
-  externalId: z.optional(z.string()),
-  permit2Address: z.optional(z.address()),
-  recipient: z.address(),
-  splits: z.optional(
-    z.array(
-      z.object({
-        amount: atomicAmount,
-        recipient: z.address(),
-      }),
-    ),
-  ),
-})
-export type ChargeRequestInput = z.infer<typeof ChargeRequestInputSchema>
-
-/** Payment-auth EVM authorization credential payload. */
-export const AuthorizationPayloadSchema = z.object({
-  from: z.address(),
-  nonce: z.hash(),
-  signature: z.signature(),
-  to: z.address(),
-  type: z.literal('authorization'),
-  validAfter: atomicAmount,
-  validBefore: atomicAmount,
-  value: atomicAmount,
-})
-export type AuthorizationPayload = z.infer<typeof AuthorizationPayloadSchema>
-
-/** Payment-auth EVM charge credential payload. */
-export const ChargePayloadSchema = AuthorizationPayloadSchema
-export type ChargePayload = z.infer<typeof ChargePayloadSchema>
-
-/** EIP-712 type definition for EIP-3009 `transferWithAuthorization`. */
-export const authorizationTypes = {
-  TransferWithAuthorization: [
-    { name: 'from', type: 'address' },
-    { name: 'to', type: 'address' },
-    { name: 'value', type: 'uint256' },
-    { name: 'validAfter', type: 'uint256' },
-    { name: 'validBefore', type: 'uint256' },
-    { name: 'nonce', type: 'bytes32' },
-  ],
-} as const
-
-/** Returns the EIP-712 domain for an EIP-3009 authorization signature. */
-export function authorizationDomain(parameters: {
-  authorization: AuthorizationConfig
-  chainId: number
-  currency: `0x${string}`
-}) {
-  return {
-    chainId: parameters.chainId,
-    name: parameters.authorization.name,
-    verifyingContract: parameters.currency,
-    version: parameters.authorization.version,
-  } as const
-}
-
-/** Computes the Payment-auth EVM challenge hash used as the EIP-3009 nonce. */
-export function challengeHash(challenge: { id: string; realm: string }): `0x${string}` {
-  return Hash.keccak256(Bytes.fromString(`${challenge.id}${challenge.realm}`), {
-    as: 'Hex',
-  }) as `0x${string}`
-}
-
-/** Converts a chain ID to the CAIP-2 EVM network identifier. */
-export function networkOf(chainId: number): EvmNetwork {
-  return `${evmNetworkPrefix}${chainId}`
-}
-
-/** Formats an EVM address as a did:pkh source identifier. */
-export function toSource(parameters: { address: `0x${string}`; chainId: number }) {
-  return `did:pkh:eip155:${parameters.chainId}:${parameters.address}` as const
-}

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

@@ -1,347 +0,0 @@
-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'
-import * as Chains from '../Chains.js'
-import { charge } from './Charge.js'
-
-const account = {
-  address: '0x1111111111111111111111111111111111111111',
-  signTypedData: vi.fn(async () => '0x1234'),
-} as unknown as Account
-
-describe('evm charge client', () => {
-  test('does not sign x402 payloads from unbranded Payment-auth challenges', async () => {
-    const signTypedData = vi.fn(async () => '0x1234')
-    const client = charge({
-      account: {
-        ...account,
-        signTypedData,
-      } as unknown as Account,
-      currencies: [Assets.baseSepolia.USDC],
-      maxAmount: '0.01',
-      networks: [Chains.baseSepolia],
-    })
-    const challenge = Challenge.from({
-      id: 'attacker-controlled',
-      intent: 'charge',
-      method: 'evm',
-      realm: 'api.example.com',
-      request: {
-        amount: '10000',
-        asset: Assets.baseSepolia.USDC.address,
-        maxTimeoutSeconds: 60,
-        network: 'eip155:84532',
-        payTo: '0x2222222222222222222222222222222222222222',
-        scheme: 'exact',
-      },
-    })
-
-    await expect(client.createCredential({ challenge } as never)).rejects.toThrow()
-    expect(signTypedData).not.toHaveBeenCalled()
-  })
-
-  test('does not use server-supplied decimals for maxAmount policy', async () => {
-    const client = charge({
-      account,
-      maxAmount: '1',
-    })
-    const challenge = Challenge.from({
-      id: 'native',
-      intent: 'charge',
-      method: 'evm',
-      realm: 'api.example.com',
-      request: {
-        amount: '1000000000000000000',
-        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 maxAmount requires currency decimals.',
-    )
-  })
-
-  test('requires network policy for raw hex currencies', async () => {
-    const client = charge({
-      account,
-      currencies: [Assets.baseSepolia.USDC.address],
-      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: 6,
-        },
-        recipient: '0x2222222222222222222222222222222222222222',
-      },
-    })
-
-    await expect(client.createCredential({ challenge } as never)).rejects.toThrow(
-      '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()
-  })
-})