mppx 0.8.17 → 0.8.18

package/src/x402/client/Exact.ts

@@ -1,186 +0,0 @@
-import type { Account } from 'viem'
-import { getAddress, parseUnits } from 'viem'
-
-import type * as Challenge from '../../Challenge.js'
-import * as Assets from '../Assets.js'
-import * as Header from '../Header.js'
-import * as RouteBinding from '../internal/RouteBinding.js'
-import * as Types from '../Types.js'
-
-/**
- * Creates an x402 exact `PAYMENT-SIGNATURE` credential.
- */
-export async function createCredential(parameters: createCredential.Parameters): Promise<string> {
-  const account = (parameters.context?.account ?? parameters.config.account) as Signer
-  if (!account.signTypedData) throw new Error('x402 exact requires a typed-data signer.')
-
-  const request = parameters.challenge.request as Types.ExactRequest
-  const accepted = Types.toPaymentRequirements(request)
-  assertPolicy(parameters.config, accepted)
-  if (!request.resource || !request.extensions?.mppx)
-    throw new Error('x402 exact EIP-3009 requires route binding.')
-  const extensions = withNonceSalt(request.extensions)
-  const transferMethod = accepted.extra?.assetTransferMethod ?? 'eip3009'
-  if (transferMethod !== 'eip3009')
-    throw new Error(`x402 exact ${String(transferMethod)} signing is not implemented yet.`)
-
-  const name = accepted.extra?.name
-  const version = accepted.extra?.version
-  if (typeof name !== 'string' || typeof version !== 'string')
-    throw new Error('x402 exact EIP-3009 requires token name and version.')
-
-  const now = Math.floor(Date.now() / 1000)
-  const authorization: Types.ExactEip3009Payload['authorization'] = {
-    from: getAddress(account.address),
-    nonce: RouteBinding.nonce({
-      accepted,
-      extensions,
-      resource: request.resource,
-    }),
-    to: getAddress(accepted.payTo),
-    validAfter: (now - 600).toString(),
-    validBefore: (now + accepted.maxTimeoutSeconds).toString(),
-    value: accepted.amount,
-  }
-  const signature = await account.signTypedData({
-    domain: {
-      chainId: chainIdOf(accepted.network),
-      name,
-      verifyingContract: getAddress(accepted.asset),
-      version,
-    },
-    message: {
-      ...authorization,
-      value: BigInt(authorization.value),
-      validAfter: BigInt(authorization.validAfter),
-      validBefore: BigInt(authorization.validBefore),
-    },
-    primaryType: 'TransferWithAuthorization',
-    types: authorizationTypes,
-  })
-
-  return Header.encodePaymentSignature({
-    accepted,
-    extensions,
-    payload: {
-      authorization,
-      signature,
-    },
-    ...(request.resource ? { resource: request.resource } : {}),
-    x402Version: 2,
-  })
-}
-
-export declare namespace createCredential {
-  type Parameters = {
-    challenge: Challenge.Challenge<Types.ExactRequest>
-    config: Config
-    context?: Context | undefined
-  }
-}
-
-export type Context = {
-  account?: Account | undefined
-}
-
-export type Signer = Account & {
-  signTypedData?: (parameters: any) => Promise<`0x${string}`>
-}
-
-export type Config = {
-  /** Account used to sign exact EVM payment payloads. */
-  account: Account
-  /** Optional token decimals used to parse `maxAmount` when currency metadata is not provided. */
-  decimals?: number | undefined
-  /** Optional maximum display-unit amount the client is willing to pay. */
-  maxAmount?: string | undefined
-  /** Optional maximum atomic amount the client is willing to pay. */
-  maxAtomicAmount?: string | undefined
-  /** Optional allowlist of supported EVM chain IDs. */
-  networks?: readonly number[] | undefined
-  /** Optional allowlist of supported currencies. */
-  currencies?: readonly Assets.Currency[] | undefined
-  /** Legacy alias for `currencies`. */
-  assets?: readonly Assets.Currency[] | undefined
-}
-
-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
-
-function chainIdOf(network: Types.EvmNetwork): number {
-  return Number(network.slice(Types.evmNetworkPrefix.length))
-}
-
-function assertPolicy(parameters: Config, accepted: Types.PaymentRequirements) {
-  const chainId = chainIdOf(accepted.network)
-  if (parameters.networks && !parameters.networks.includes(chainId))
-    throw new Error(`x402 exact chain ID is not allowed: ${chainId}.`)
-
-  const currencies = parameters.currencies ?? parameters.assets
-  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) =>
-      Assets.matches(currency, acceptedCurrency, accepted.network),
-    )
-    if (!allowed) throw new Error(`x402 exact currency is not allowed: ${acceptedCurrency}.`)
-  }
-
-  if (
-    parameters.maxAtomicAmount !== undefined &&
-    BigInt(accepted.amount) > BigInt(parameters.maxAtomicAmount)
-  )
-    throw new Error('x402 exact amount exceeds maxAtomicAmount.')
-
-  if (parameters.maxAmount !== undefined) {
-    const decimals = decimalsOfAcceptedCurrency(parameters, accepted)
-    if (decimals === undefined) throw new Error('x402 exact maxAmount requires currency decimals.')
-    if (BigInt(accepted.amount) > parseUnits(parameters.maxAmount, decimals))
-      throw new Error('x402 exact amount exceeds maxAmount.')
-  }
-}
-
-function decimalsOfAcceptedCurrency(
-  parameters: Config,
-  accepted: Types.PaymentRequirements,
-): number | undefined {
-  const currencies = parameters.currencies ?? parameters.assets
-  const acceptedCurrency = getAddress(accepted.asset as `0x${string}`)
-  const currency = currencies?.find((currency) =>
-    Assets.matches(currency, acceptedCurrency, accepted.network),
-  )
-  const resolved = currency ? Assets.resolve(currency, accepted.network) : undefined
-  if (resolved?.decimals !== undefined) return resolved.decimals
-  return parameters.decimals
-}
-
-function withNonceSalt(extensions: Types.Extensions): Types.Extensions {
-  const mppx = extensions.mppx
-  if (!mppx) return extensions
-  return {
-    ...extensions,
-    mppx: {
-      ...mppx,
-      info: {
-        ...mppx.info,
-        nonce: randomNonceSalt(),
-      },
-    },
-  }
-}
-
-function randomNonceSalt(): string {
-  const crypto = globalThis.crypto
-  if (!crypto?.getRandomValues) throw new Error('x402 exact requires crypto randomness.')
-  const bytes = crypto.getRandomValues(new Uint8Array(32))
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('')
-}

package/src/x402/index.ts

@@ -1,6 +0,0 @@
-/** @deprecated Use `assets` instead. */
-export * as Assets from './Assets.js'
-export * as Header from './Header.js'
-export * as Types from './Types.js'
-export * as assets from './Assets.js'
-export * from './Types.js'

package/src/x402/internal/ChallengeBrand.ts

@@ -1,14 +0,0 @@
-const x402Challenge = Symbol.for('mppx.x402.challenge')
-
-/** Marks a synthetic challenge as originating from an x402 `PAYMENT-REQUIRED` response. */
-export function mark<const challenge extends object>(challenge: challenge): challenge {
-  Object.defineProperty(challenge, x402Challenge, {
-    value: true,
-  })
-  return challenge
-}
-
-/** Returns whether a challenge originated from an x402 `PAYMENT-REQUIRED` response. */
-export function is(challenge: unknown): boolean {
-  return Boolean((challenge as { [x402Challenge]?: true } | undefined)?.[x402Challenge])
-}

package/src/x402/internal/RouteBinding.ts

@@ -1,18 +0,0 @@
-import { Bytes, Hash } from 'ox'
-
-import * as PaymentRequest from '../../PaymentRequest.js'
-import type * as Types from '../Types.js'
-
-/** Computes the route-bound EIP-3009 nonce for an x402 exact payment. */
-export function nonce(parameters: {
-  accepted: Types.PaymentRequirements
-  extensions: Types.Extensions
-  resource: Types.ResourceInfo
-}): `0x${string}` {
-  const input = [
-    PaymentRequest.serialize(parameters.accepted),
-    PaymentRequest.serialize(parameters.resource),
-    PaymentRequest.serialize(parameters.extensions),
-  ].join('|')
-  return Hash.sha256(Bytes.fromString(input), { as: 'Hex' }) as `0x${string}`
-}

package/src/x402/server/EvmCharge.ts

@@ -1,410 +0,0 @@
-import { isDeepStrictEqual } from 'node:util'
-
-import { Bytes, Hash } from 'ox'
-import { getAddress } from 'viem'
-
-import * as BodyDigest from '../../BodyDigest.js'
-import * as Challenge from '../../Challenge.js'
-import type * as Credential from '../../Credential.js'
-import * as Credential_ from '../../Credential.js'
-import { VerificationFailedError } from '../../Errors.js'
-import * as Types from '../../evm/Types.js'
-import * as PaymentRequest from '../../PaymentRequest.js'
-import * as Scope from '../../server/internal/scope.js'
-import * as ServerTransport from '../../server/Transport.js'
-import * as x402_Header from '../Header.js'
-import * as x402_RouteBinding from '../internal/RouteBinding.js'
-import * as x402_Types from '../Types.js'
-import * as x402_Facilitator from './Facilitator.js'
-
-const pendingX402Credential = Symbol('mppx.evm.pendingX402Credential')
-const x402Credential = Symbol('mppx.evm.x402Credential')
-const mppxExtensionKey = 'mppx'
-const mppxRouteBindingSchema = {
-  additionalProperties: false,
-  properties: {
-    [Scope.reservedMetaKey]: { type: 'string' },
-    digest: { type: 'string' },
-    method: { type: 'string' },
-    nonce: { type: 'string' },
-    opaque: { type: 'string' },
-  },
-  required: ['method'],
-  type: 'object',
-}
-
-export type Options = {
-  /** Facilitator client or base URL used for x402-compatible settlement. */
-  facilitator?: string | x402_Types.Facilitator | undefined
-  /** Fetch implementation used for facilitator RPCs. */
-  fetch?: typeof globalThis.fetch | undefined
-  /** Maximum time in seconds allowed for x402-compatible payment completion. @default 300 */
-  maxTimeoutSeconds?: number | undefined
-}
-
-export type ResolvedOptions = {
-  authorization: Types.AuthorizationConfig
-  facilitator?: x402_Types.Facilitator | undefined
-  maxTimeoutSeconds: number
-}
-
-export type Path = {
-  bindCredential: NonNullable<ServerTransport.Http['bindCredential']>
-  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
-}
-
-/** Resolves optional x402 compatibility options for an EVM charge. */
-export function resolveOptions(parameters: {
-  authorization: Types.AuthorizationConfig
-  options?: Options | undefined
-}): ResolvedOptions {
-  return {
-    authorization: parameters.authorization,
-    ...(parameters.options?.facilitator
-      ? {
-          facilitator: x402_Facilitator.resolve(
-            parameters.options.facilitator,
-            'EVM authorization x402 requires `facilitator`.',
-            { fetch: parameters.options.fetch },
-          ),
-        }
-      : {}),
-    maxTimeoutSeconds: parameters.options?.maxTimeoutSeconds ?? 300,
-  }
-}
-
-/** Creates the x402 wire path for an EVM charge method. */
-export function createPath(config: ResolvedOptions): Path {
-  return {
-    getCredential(request) {
-      const paymentSignature = request.headers.get(x402_Types.paymentSignatureHeader)
-      if (!paymentSignature) return null
-      const paymentPayload = x402_Header.decodePaymentSignature(paymentSignature)
-
-      return markPendingCredential(
-        Credential_.from({
-          challenge: pendingChallenge(paymentPayload),
-          payload: paymentPayload,
-        }),
-      )
-    },
-
-    async bindCredential({ challenge, credential, input }) {
-      const paymentPayload = parsePaymentPayload(credential.payload)
-      if (!paymentPayload) return credential
-      if (!isPendingCredential(credential)) return credential
-      await assertBodyDigest(challenge, input)
-
-      const request = challenge.request as Types.ChargeRequest
-      const paymentRequirements = toPaymentRequirements(request, config)
-      if (!isDeepStrictEqual(paymentPayload.accepted, paymentRequirements))
-        throw new VerificationFailedError({
-          reason: 'x402 payment payload does not match route requirements',
-        })
-
-      const expectedResource = { url: input.url }
-      const clientNonce = paymentPayload.extensions?.[mppxExtensionKey]?.info.nonce
-      const isRouteBound = clientNonce !== undefined
-      const routeRequiresBinding =
-        challenge.digest !== undefined ||
-        challenge.opaque !== undefined ||
-        challenge.meta !== undefined
-      if (routeRequiresBinding && !isRouteBound)
-        throw new VerificationFailedError({
-          reason: 'x402 payment payload does not bind required route metadata',
-        })
-
-      if (isRouteBound) {
-        if (!isDeepStrictEqual(paymentPayload.resource, expectedResource))
-          throw new VerificationFailedError({
-            reason: 'x402 payment payload resource does not match route resource',
-          })
-
-        const expectedExtensions = routeExtensions(challenge, input)
-        if (!containsExtensions(paymentPayload.extensions, expectedExtensions))
-          throw new VerificationFailedError({
-            reason: 'x402 payment payload extensions do not match route binding',
-          })
-      } else if (
-        paymentPayload.resource !== undefined &&
-        paymentPayload.resource.url !== expectedResource.url
-      )
-        throw new VerificationFailedError({
-          reason: 'x402 payment payload resource does not match route resource',
-        })
-
-      const payload = payloadToAuthorization(paymentPayload)
-      if (isRouteBound) {
-        const expectedNonce = x402_RouteBinding.nonce({
-          accepted: paymentRequirements,
-          extensions: paymentPayload.extensions!,
-          resource: expectedResource,
-        })
-        if (payload.nonce !== expectedNonce)
-          throw new VerificationFailedError({
-            reason: 'x402 authorization nonce does not match route binding',
-          })
-      }
-
-      return markCredential(
-        Credential_.from({
-          challenge,
-          payload,
-          source: Types.toSource({
-            address: getAddress(payload.from),
-            chainId: request.methodDetails.chainId,
-          }),
-        }),
-      )
-    },
-
-    respondChallenge(options, response) {
-      if (!response) throw new Error('x402 path requires a base challenge response.')
-      const headers = new Headers(response.headers)
-      const request = options.challenge.request as Types.ChargeRequest
-      headers.set(
-        x402_Types.paymentRequiredHeader,
-        x402_Header.encodePaymentRequired({
-          accepts: [toPaymentRequirements(request, config)],
-          error:
-            options.error?.message ?? `${x402_Types.paymentSignatureHeader} header is required`,
-          extensions: routeExtensions(options.challenge, options.input),
-          resource: { url: options.input.url },
-          x402Version: 2,
-        }),
-      )
-      return new Response(response.body, {
-        headers,
-        status: response.status,
-        statusText: response.statusText,
-      })
-    },
-
-    respondReceipt(options, response) {
-      if (!options.input.headers.has(x402_Types.paymentSignatureHeader)) return response
-
-      const payload = Types.AuthorizationPayloadSchema.parse(options.credential.payload)
-      const request = options.credential.challenge.request as Types.ChargeRequest
-      const headers = new Headers(response.headers)
-      headers.set(
-        x402_Types.paymentResponseHeader,
-        x402_Header.encodePaymentResponse({
-          network: Types.networkOf(request.methodDetails.chainId),
-          payer: payload.from,
-          success: true,
-          transaction: options.receipt.reference,
-        }),
-      )
-      return new Response(response.body, {
-        headers,
-        status: response.status,
-        statusText: response.statusText,
-      })
-    },
-  }
-}
-
-/** Settles a verified EVM authorization through an x402 facilitator. */
-export function settleWithFacilitator(parameters: ResolvedOptions): SettleWithFacilitator {
-  const { facilitator, maxTimeoutSeconds } = parameters
-  if (!facilitator) throw new Error('EVM authorization x402 requires `facilitator`.')
-
-  return async ({ payload, request }) => {
-    const paymentRequirements = toPaymentRequirements(request, {
-      ...parameters,
-      maxTimeoutSeconds,
-    })
-    const paymentPayload: x402_Types.PaymentPayload = {
-      accepted: paymentRequirements,
-      payload: {
-        authorization: {
-          from: payload.from,
-          nonce: payload.nonce,
-          to: payload.to,
-          validAfter: payload.validAfter,
-          validBefore: payload.validBefore,
-          value: payload.value,
-        },
-        signature: payload.signature,
-      },
-      x402Version: 2,
-    }
-
-    const verified = await facilitator.verify(paymentPayload, paymentRequirements)
-    if (!verified.isValid)
-      throw new VerificationFailedError({
-        reason:
-          verified.invalidMessage ?? verified.invalidReason ?? 'EVM facilitator verify failed',
-      })
-
-    const settled = await facilitator.settle(paymentPayload, paymentRequirements)
-    if (!settled.success)
-      throw new VerificationFailedError({
-        reason: settled.errorMessage ?? settled.errorReason ?? 'EVM facilitator settlement failed',
-      })
-
-    return {
-      reference: settled.transaction,
-    }
-  }
-}
-
-export type SettleWithFacilitator = (parameters: {
-  credential: Credential.Credential<Types.AuthorizationPayload>
-  payload: Types.AuthorizationPayload
-  request: Types.ChargeRequest
-  source: ReturnType<typeof Types.toSource>
-}) => Promise<{
-  reference: string
-  timestamp?: string | undefined
-}>
-
-/** Returns whether a credential was converted from an x402 payment payload. */
-export function isCredential(credential: Credential.Credential): boolean {
-  return (credential as { [x402Credential]?: true })[x402Credential] === true
-}
-
-/** Returns whether a credential was parsed from the x402 payment header. */
-export function isPendingCredential(credential: Credential.Credential): boolean {
-  return (credential as { [pendingX402Credential]?: true })[pendingX402Credential] === true
-}
-
-/** Converts a native EVM charge request to x402 exact payment requirements. */
-export function toPaymentRequirements(
-  request: Types.ChargeRequest,
-  config: Pick<ResolvedOptions, 'authorization' | 'maxTimeoutSeconds'>,
-): x402_Types.PaymentRequirements {
-  return {
-    amount: request.amount,
-    asset: request.currency,
-    extra: {
-      assetTransferMethod: Types.eip3009,
-      name: config.authorization.name,
-      version: config.authorization.version,
-    },
-    maxTimeoutSeconds: config.maxTimeoutSeconds,
-    network: Types.networkOf(request.methodDetails.chainId),
-    payTo: request.recipient,
-    scheme: 'exact',
-  }
-}
-
-function parsePaymentPayload(payload: unknown): x402_Types.PaymentPayload | undefined {
-  const parsed = x402_Types.PaymentPayloadSchema.safeParse(payload)
-  return parsed.success ? parsed.data : undefined
-}
-
-/** Converts an x402 EIP-3009 payment payload to the native EVM authorization payload. */
-export function payloadToAuthorization(
-  paymentPayload: x402_Types.PaymentPayload,
-): Types.AuthorizationPayload {
-  if (!('authorization' in paymentPayload.payload))
-    throw new VerificationFailedError({
-      reason: 'EVM charge only supports x402 EIP-3009 authorization payloads',
-    })
-
-  return Types.AuthorizationPayloadSchema.parse({
-    ...paymentPayload.payload.authorization,
-    signature: paymentPayload.payload.signature,
-    type: 'authorization',
-  })
-}
-
-function pendingChallenge(paymentPayload: x402_Types.PaymentPayload) {
-  // The route challenge is built after request normalization in bindCredential().
-  // Until then, this deterministic local ID only carries the x402 payload through
-  // the standard credential pipeline; it is never HMAC-verified.
-  return Challenge.from({
-    id: pendingChallengeId(paymentPayload),
-    intent: Types.chargeIntent,
-    method: Types.paymentMethod,
-    realm: 'x402',
-    request: paymentPayload.accepted,
-  })
-}
-
-function pendingChallengeId(paymentPayload: x402_Types.PaymentPayload): string {
-  const hash = Hash.sha256(Bytes.fromString(JSON.stringify(paymentPayload)), { as: 'Hex' })
-  return `${x402_Types.syntheticChallengeIdPrefix}${hash}`
-}
-
-function routeExtensions(challenge: Challenge.Challenge, input: Request): x402_Types.Extensions {
-  const binding: Record<string, unknown> = { method: input.method }
-  const scope = Scope.read(challenge.meta)
-  if (scope !== undefined) binding[Scope.reservedMetaKey] = scope
-  if (challenge.digest !== undefined) binding.digest = challenge.digest
-  const opaque =
-    challenge.opaque ?? (challenge.meta ? PaymentRequest.serialize(challenge.meta) : undefined)
-  if (opaque !== undefined) binding.opaque = opaque
-  return {
-    [mppxExtensionKey]: {
-      info: binding,
-      schema: mppxRouteBindingSchema,
-    },
-  }
-}
-
-function containsExtensions(
-  actual: x402_Types.Extensions | undefined,
-  expected: x402_Types.Extensions,
-): boolean {
-  if (!actual) return false
-  return Object.entries(expected).every(([key, expectedExtension]) => {
-    const actualExtension = actual[key]
-    return (
-      actualExtension !== undefined &&
-      isDeepStrictEqual(actualExtension.schema, expectedExtension.schema) &&
-      isDeepStrictEqual(stripClientNonce(actualExtension.info), expectedExtension.info)
-    )
-  })
-}
-
-function stripClientNonce(info: Record<string, unknown>): Record<string, unknown> {
-  const { nonce, ...rest } = info
-  if (nonce !== undefined && typeof nonce !== 'string') return info
-  return rest
-}
-
-async function assertBodyDigest(challenge: Challenge.Challenge, input: Request): Promise<void> {
-  if (input.body === null || challenge.digest === undefined) return
-  let body: string
-  try {
-    body = await input.clone().text()
-  } catch {
-    throw new VerificationFailedError({
-      reason: 'x402 payment cannot bind streaming request body',
-    })
-  }
-  if (!BodyDigest.verify(challenge.digest as BodyDigest.BodyDigest, body))
-    throw new VerificationFailedError({
-      reason: 'x402 payment body digest mismatch',
-    })
-}
-
-function markPendingCredential<const credential extends Credential.Credential>(
-  credential: credential,
-): credential {
-  Object.defineProperty(credential, pendingX402Credential, {
-    enumerable: true,
-    value: true,
-  })
-  return credential
-}
-
-function markCredential<const credential extends Credential.Credential>(
-  credential: credential,
-): credential {
-  Object.defineProperty(credential, x402Credential, {
-    enumerable: true,
-    value: true,
-  })
-  return credential
-}