mppx 0.8.15 → 0.8.18

package/src/evm/index.ts

@@ -1,16 +0,0 @@
-/** @deprecated Use `assets` instead. */
-export * as Assets from './Assets.js'
-/** @deprecated Use `chains` instead. */
-export * as Chains from './Chains.js'
-export * as Methods from './Methods.js'
-export * as Types from './Types.js'
-export * as assets from './Assets.js'
-export * as chains from './Chains.js'
-export { charge } from './Methods.js'
-export * from './Types.js'
-export type {
-  ExactEip3009Transfer,
-  ExactPermit2Transfer,
-  ExactTransfer,
-  ResourceInfo,
-} from '../x402/Types.js'

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

@@ -1,339 +0,0 @@
-import { Challenge, Credential, Receipt } from 'mppx'
-import { evm as evm_client, Mppx as ClientMppx } from 'mppx/client'
-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'
-const recipient = '0x209693Bc6afc0C5328bA36FaF03C514EF312287C'
-const transaction = `0x${'1'.repeat(64)}`
-const account = privateKeyToAccount(
-  '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
-)
-
-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:
-      | {
-          paymentPayload: PaymentPayload
-          paymentRequirements: x402_Types.PaymentRequirements
-        }
-      | undefined
-
-    const mppx = Mppx.create({
-      methods: [
-        evm({
-          currency: evm.assets.baseSepolia.USDC,
-          recipient,
-          x402: {
-            facilitator: {
-              async verify(paymentPayload, paymentRequirements) {
-                facilitated = { paymentPayload, paymentRequirements }
-                return { isValid: true }
-              },
-              async settle(paymentPayload, paymentRequirements) {
-                facilitated = { paymentPayload, paymentRequirements }
-                return {
-                  network: paymentRequirements.network,
-                  success: true,
-                  transaction,
-                }
-              },
-            },
-          },
-        }),
-      ],
-      secretKey: 'test-secret-key-test-secret-key-32',
-    })
-    const client = ClientMppx.create({
-      methods: [
-        evm_client({
-          account,
-          currencies: [evm_client.assets.baseSepolia.USDC],
-          maxAmount: '0.25',
-        }),
-      ],
-      polyfill: false,
-    })
-    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.method).toBe('evm')
-    expect(challenge.intent).toBe('charge')
-    expect(challenge.request).toEqual({
-      amount: '250000',
-      currency,
-      methodDetails: {
-        chainId: 84532,
-        credentialTypes: ['authorization'],
-        decimals: 6,
-      },
-      recipient,
-    })
-
-    const authorization = await client.createCredential(first.challenge)
-    const credential = Credential.deserialize<evm_Types.AuthorizationPayload>(authorization)
-    expect(credential.payload.type).toBe('authorization')
-    expect(credential.payload.nonce).toBe(evm_Types.challengeHash(challenge))
-    expect(credential.payload.to).toBe(recipient)
-    expect(credential.payload.value).toBe('250000')
-
-    const result = await route(
-      new Request('https://example.com/paid', {
-        headers: { Authorization: authorization },
-      }),
-    )
-
-    expect(result.status).toBe(200)
-    if (result.status !== 200) throw new Error()
-    const response = result.withReceipt(Response.json({ ok: true }))
-    const receipt = Receipt.fromResponse(response)
-    expect(receipt).toMatchObject({
-      method: 'evm',
-      reference: transaction,
-      status: 'success',
-    })
-    expect(facilitated?.paymentRequirements).toEqual({
-      amount: '250000',
-      asset: currency,
-      extra: {
-        assetTransferMethod: evm_Types.eip3009,
-        name: 'USDC',
-        version: '2',
-      },
-      maxTimeoutSeconds: 300,
-      network: evm_Types.networkOf(84532),
-      payTo: recipient,
-      scheme: 'exact',
-    })
-    expect(facilitated?.paymentPayload.payload).toEqual({
-      authorization: {
-        from: credential.payload.from,
-        nonce: credential.payload.nonce,
-        to: credential.payload.to,
-        validAfter: credential.payload.validAfter,
-        validBefore: credential.payload.validBefore,
-        value: credential.payload.value,
-      },
-      signature: credential.payload.signature,
-    })
-
-    const forgedPayload: evm_Types.AuthorizationPayload = {
-      ...credential.payload,
-      nonce: `0x${'2'.repeat(64)}`,
-      signature: await account.signTypedData({
-        domain: evm_Types.authorizationDomain({
-          authorization: { name: 'USDC', version: '2' },
-          chainId: 84532,
-          currency,
-        }),
-        message: {
-          from: credential.payload.from as `0x${string}`,
-          nonce: `0x${'2'.repeat(64)}` as `0x${string}`,
-          to: credential.payload.to as `0x${string}`,
-          validAfter: BigInt(credential.payload.validAfter),
-          validBefore: BigInt(credential.payload.validBefore),
-          value: BigInt(credential.payload.value),
-        },
-        primaryType: 'TransferWithAuthorization',
-        types: evm_Types.authorizationTypes,
-      }),
-    }
-    const forgedAuthorization = Credential.serialize(
-      Credential.from({
-        challenge,
-        payload: forgedPayload,
-        ...(credential.source ? { source: credential.source } : {}),
-      }),
-    )
-
-    const forgedResult = await route(
-      new Request('https://example.com/paid', {
-        headers: {
-          Authorization: forgedAuthorization,
-          [x402_Types.paymentSignatureHeader]: 'ignored-for-native-authorization',
-        },
-      }),
-    )
-    expect(forgedResult.status).toBe(402)
-
-    const paymentRequired = x402_Header.decodePaymentRequired(
-      first.challenge.headers.get(x402_Types.paymentRequiredHeader)!,
-    )
-    const x402Authorization = Credential.serialize(
-      Credential.from({
-        challenge,
-        payload: {
-          accepted: paymentRequired.accepts[0]!,
-          extensions: paymentRequired.extensions,
-          payload: {
-            authorization: {
-              from: account.address,
-              nonce: `0x${'3'.repeat(64)}`,
-              to: recipient,
-              validAfter: '0',
-              validBefore: '9999999999',
-              value: paymentRequired.accepts[0]!.amount,
-            },
-            signature: `0x${'4'.repeat(130)}`,
-          },
-          resource: paymentRequired.resource,
-          x402Version: 2,
-        } satisfies PaymentPayload,
-      }),
-    )
-
-    const x402InAuthorizationResult = await route(
-      new Request('https://example.com/paid', {
-        headers: { Authorization: x402Authorization },
-      }),
-    )
-    expect(x402InAuthorizationResult.status).toBe(402)
-  })
-})

package/src/evm/server/Charge.ts

@@ -1,290 +0,0 @@
-import { getAddress, recoverTypedDataAddress } from 'viem'
-
-import type * as Credential from '../../Credential.js'
-import { VerificationFailedError } from '../../Errors.js'
-import * as Method from '../../Method.js'
-import * as Receipt from '../../Receipt.js'
-import * as ServerTransport from '../../server/Transport.js'
-import * as X402 from '../../x402/server/EvmCharge.js'
-import * as Assets from '../Assets.js'
-import * as Methods from '../Methods.js'
-import * as Types from '../Types.js'
-
-/**
- * Creates an EVM charge server method.
- *
- * Speaks the native Payment-auth `evm/charge` wire format.
- */
-export function charge(
-  parameters: charge.NativeConfig,
-): Method.Server<typeof Methods.charge, charge.Defaults>
-export function charge(parameters: charge.NativeConfig): Method.AnyServer {
-  const config = resolveConfig(parameters)
-  const paths = createPaths(config)
-  const transport = httpTransport(paths)
-
-  return Method.toServer<typeof Methods.charge, charge.Defaults, typeof transport>(Methods.charge, {
-    defaults: {
-      chainId: config.chainId,
-      currency: config.currency,
-      credentialTypes: ['authorization'],
-      decimals: config.decimals,
-      recipient: config.recipient,
-    },
-    transport,
-    async verify({ credential }) {
-      const payload = credential.payload as Types.AuthorizationPayload
-      const request = credential.challenge.request as Types.ChargeRequest
-      const chainId = request.methodDetails.chainId
-      const isX402Credential = X402.isCredential(credential)
-
-      if (!request.methodDetails.credentialTypes?.includes('authorization')) {
-        throw new VerificationFailedError({
-          reason: 'EVM authorization credentials are not supported for this challenge',
-        })
-      }
-
-      if (request.methodDetails.splits?.length) {
-        throw new VerificationFailedError({
-          reason: 'EVM authorization credentials do not support splits',
-        })
-      }
-
-      assertAddressEqual(payload.to, request.recipient, 'EVM authorization recipient mismatch')
-      if (payload.value !== request.amount)
-        throw new VerificationFailedError({ reason: 'EVM authorization amount mismatch' })
-      if (!isX402Credential && payload.nonce !== Types.challengeHash(credential.challenge))
-        throw new VerificationFailedError({ reason: 'EVM authorization challenge hash mismatch' })
-      const now = BigInt(Math.floor(Date.now() / 1000))
-      if (BigInt(payload.validAfter) > now)
-        throw new VerificationFailedError({ reason: 'EVM authorization is not valid yet' })
-      if (BigInt(payload.validBefore) <= now)
-        throw new VerificationFailedError({ reason: 'EVM authorization has expired' })
-
-      const signer = await recoverTypedDataAddress({
-        domain: Types.authorizationDomain({
-          authorization: config.authorization,
-          chainId,
-          currency: request.currency as `0x${string}`,
-        }),
-        message: {
-          from: getAddress(payload.from),
-          nonce: payload.nonce as `0x${string}`,
-          to: getAddress(payload.to),
-          validAfter: BigInt(payload.validAfter),
-          validBefore: BigInt(payload.validBefore),
-          value: BigInt(payload.value),
-        },
-        primaryType: 'TransferWithAuthorization',
-        signature: payload.signature as `0x${string}`,
-        types: Types.authorizationTypes,
-      })
-      assertAddressEqual(signer, payload.from, 'EVM authorization signature mismatch')
-
-      const source = Types.toSource({ address: getAddress(payload.from), chainId })
-      if (credential.source && credential.source !== source) {
-        throw new VerificationFailedError({ reason: 'EVM authorization source mismatch' })
-      }
-
-      const settled = await config.settle({
-        credential,
-        payload,
-        request,
-        source,
-      })
-
-      return Receipt.from({
-        method: Types.paymentMethod,
-        reference: settled.reference,
-        status: 'success',
-        timestamp: settled.timestamp ?? new Date().toISOString(),
-      })
-    },
-  })
-}
-
-export declare namespace charge {
-  type Parameters = NativeConfig
-  type Native = Method.Server<typeof Methods.charge, Defaults>
-
-  type NativeConfig = BaseConfig & CurrencyConfig & RecipientConfig
-
-  type BaseConfig = {
-    /** 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 raw addresses and viem tokens; inferred for known assets. */
-    chainId?: number | undefined
-    /** 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
-    /** x402 compatibility options. */
-    x402?: X402.Options | undefined
-  }
-
-  type CurrencyConfig = {
-    /** Token contract address, known EVM asset metadata, or viem token definition. */
-    currency: Assets.Currency
-  }
-
-  type RecipientConfig = {
-    /** Recipient wallet address. */
-    recipient: `0x${string}`
-  }
-
-  type RouteOptions = {
-    /** Required display-unit token amount. */
-    amount: string
-    /** Optional human-readable payment description. */
-    description?: string | undefined
-    /** Optional external correlation ID. */
-    externalId?: string | undefined
-  }
-
-  type SettleAuthorization = (parameters: {
-    credential: Credential.Credential<Types.AuthorizationPayload>
-    payload: Types.AuthorizationPayload
-    request: Types.ChargeRequest
-    source: ReturnType<typeof Types.toSource>
-  }) => Promise<{
-    reference: string
-    timestamp?: string | undefined
-  }>
-
-  type Defaults = {
-    chainId: number
-    currency: `0x${string}`
-    credentialTypes: ['authorization']
-    decimals: number
-    recipient: `0x${string}`
-  }
-}
-
-type ResolvedConfig = {
-  authorization: Types.AuthorizationConfig
-  chainId: number
-  currency: `0x${string}`
-  decimals: number
-  recipient: `0x${string}`
-  settle: charge.SettleAuthorization
-  x402: X402.ResolvedOptions
-}
-
-type HttpPath = {
-  bindCredential: NonNullable<ServerTransport.Http['bindCredential']>
-  captureRequest?: ServerTransport.Http['captureRequest'] | undefined
-  getCredential: ServerTransport.Http['getCredential']
-  respondChallenge: (
-    options: Parameters<ServerTransport.Http['respondChallenge']>[0],
-    response?: Response | undefined,
-  ) => Response | Promise<Response>
-  respondReceipt: (
-    options: Parameters<ServerTransport.Http['respondReceipt']>[0],
-    response: Response,
-  ) => Response
-}
-
-type HttpPaths = {
-  mpp: HttpPath
-  x402: HttpPath
-}
-
-function resolveConfig(config: charge.NativeConfig): ResolvedConfig {
-  const { currency, recipient } = config
-  let address: `0x${string}`
-  let authorization = config.authorization
-  let chainId = config.chainId
-  let decimals = config.decimals
-
-  if (Assets.isAsset(currency)) {
-    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: resolved.transfer.name,
-        version: resolved.transfer.version,
-      }
-    }
-  } 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.')
-  if (chainId === undefined) throw new Error('EVM authorization requires `chainId`.')
-  if (decimals === undefined) throw new Error('EVM authorization requires `decimals`.')
-
-  const x402 = X402.resolveOptions({
-    authorization,
-    options: config.x402,
-  })
-  const settle = config.settle ?? (x402?.facilitator ? X402.settleWithFacilitator(x402) : undefined)
-  if (!settle) throw new Error('EVM authorization requires `settle` or `x402.facilitator`.')
-
-  return {
-    authorization,
-    chainId,
-    currency: getAddress(address),
-    decimals,
-    recipient: getAddress(recipient),
-    settle,
-    x402,
-  }
-}
-
-function createPaths(config: ResolvedConfig): HttpPaths {
-  return {
-    mpp: createMppPath(),
-    x402: X402.createPath(config.x402),
-  }
-}
-
-function createMppPath(): HttpPath {
-  const transport = ServerTransport.http()
-  return {
-    bindCredential: (options) => transport.bindCredential?.(options) ?? options.credential,
-    captureRequest: transport.captureRequest,
-    getCredential: transport.getCredential,
-    respondChallenge: (options) => transport.respondChallenge(options),
-    respondReceipt: (options, response) => transport.respondReceipt({ ...options, response }),
-  }
-}
-
-function httpTransport(paths: HttpPaths): ServerTransport.Http {
-  return ServerTransport.from<Request, Response>({
-    name: 'evm-http',
-
-    captureRequest: paths.mpp.captureRequest,
-
-    getCredential(input) {
-      return paths.mpp.getCredential(input) ?? paths.x402.getCredential(input)
-    },
-
-    bindCredential(options) {
-      if (X402.isPendingCredential(options.credential)) return paths.x402.bindCredential(options)
-      return paths.mpp.bindCredential?.(options) ?? options.credential
-    },
-
-    async respondChallenge(options) {
-      const response = await paths.mpp.respondChallenge(options)
-      return paths.x402.respondChallenge(options, response)
-    },
-
-    respondReceipt(options) {
-      const response = paths.mpp.respondReceipt(options, options.response)
-      return paths.x402.respondReceipt(options, response)
-    },
-  })
-}
-
-function assertAddressEqual(actual: string, expected: string, reason: string) {
-  if (getAddress(actual) === getAddress(expected)) return
-  throw new VerificationFailedError({ reason })
-}

package/src/evm/server/Methods.ts

@@ -1,22 +0,0 @@
-import type { NoExtraKeys } from '../../internal/types.js'
-import * as Assets from '../Assets.js'
-import * as Chains from '../Chains.js'
-import { charge as charge_ } from './Charge.js'
-
-/** Creates EVM server methods from shared charge parameters. */
-export function evm<const parameters extends evm.Parameters>(
-  parameters: NoExtraKeys<parameters, evm.Parameters>,
-) {
-  return [evm.charge(parameters)] as const
-}
-
-export namespace evm {
-  export type Parameters = charge_.Parameters
-
-  /** Creates an EVM `charge` server method. */
-  export const charge = charge_
-  /** Known EVM asset metadata for public config. */
-  export const assets = Assets
-  /** Common EVM chain IDs for public config. */
-  export const chains = Chains
-}

package/src/evm/server/index.ts

@@ -1,6 +0,0 @@
-export * as assets from '../Assets.js'
-/** @deprecated Use `chains` instead. */
-export * as Chains from '../Chains.js'
-export * as chains from '../Chains.js'
-export { charge } from './Charge.js'
-export { evm } from './Methods.js'

package/src/index.ts

@@ -1,14 +0,0 @@
-export * as BodyDigest from './BodyDigest.js'
-export * as Challenge from './Challenge.js'
-export * as Constants from './Constants.js'
-export * as Credential from './Credential.js'
-export * as Errors from './Errors.js'
-export * as Expires from './Expires.js'
-export * as evm from './evm/index.js'
-export * as Mcp from './Mcp.js'
-export * as Method from './Method.js'
-export * as PaymentRequest from './PaymentRequest.js'
-export * as Receipt from './Receipt.js'
-export * as Store from './Store.js'
-export * as x402 from './x402/index.js'
-export * as z from './zod.js'