mppx 0.8.17 → 0.8.18

package/src/x402/Assets.ts

@@ -1,221 +0,0 @@
-import { getAddress } from 'viem'
-import type { Token } from 'viem/tokens'
-
-import type { Asset, EvmNetwork, ExactTransfer } from './Types.js'
-
-const knownAsset = Symbol('mppx.x402.asset')
-
-/** Known x402 asset metadata. */
-export type KnownAsset = Asset & {
-  readonly [knownAsset]: true
-  network: EvmNetwork
-}
-
-/** Viem token metadata from `viem/tokens`. */
-export type ViemToken = Token
-
-/** Currency metadata accepted by EVM and x402 payment config. */
-export type Currency = `0x${string}` | KnownAsset | ViemToken
-
-/** Creates typed x402 asset metadata for custom tokens. */
-export function define(parameters: define.Parameters): KnownAsset {
-  return {
-    [knownAsset]: true,
-    address: parameters.address,
-    decimals: parameters.decimals,
-    network: parameters.network,
-    transfer: parameters.transfer,
-  }
-}
-
-export declare namespace define {
-  type Parameters = {
-    address: `0x${string}`
-    decimals: number
-    network: EvmNetwork
-    transfer: ExactTransfer
-  }
-}
-
-/** Creates x402 asset metadata from a `viem/tokens` token definition. */
-export function fromToken(token: ViemToken, parameters: fromToken.Parameters): KnownAsset {
-  const resolved = token(parameters.chainId)
-  return define({
-    address: resolved.address,
-    decimals: resolved.decimals,
-    network: toNetwork(parameters.chainId),
-    transfer: withTokenDefaults(parameters.transfer, resolved),
-  })
-}
-
-export declare namespace fromToken {
-  type Parameters = {
-    chainId: number
-    transfer: Transfer
-  }
-
-  type Transfer =
-    | (Omit<Extract<ExactTransfer, { type: 'eip3009' }>, 'name'> & {
-        name?: string | undefined
-      })
-    | Extract<ExactTransfer, { type: 'permit2' }>
-}
-
-/** Base network known assets. */
-export const base = {
-  USDC: define({
-    address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
-    decimals: 6,
-    network: 'eip155:8453',
-    transfer: {
-      // USDC's EIP-712 domain name differs between Base and Base Sepolia.
-      name: 'USD Coin',
-      type: 'eip3009',
-      version: '2',
-    },
-  }),
-} as const
-
-/** Base Sepolia known assets. */
-export const baseSepolia = {
-  USDC: define({
-    address: '0x036CbD53842c5426634e7929541eC2318f3dCF7e',
-    decimals: 6,
-    network: 'eip155:84532',
-    transfer: {
-      // Base Sepolia test USDC signs with the shorter EIP-712 domain name.
-      name: 'USDC',
-      type: 'eip3009',
-      version: '2',
-    },
-  }),
-} as const
-
-/** Celo network known assets. */
-export const celo = {
-  USDC: define({
-    address: '0xcebA9300f2b948710d2653dD7B07f33A8B32118C',
-    decimals: 6,
-    network: 'eip155:42220',
-    transfer: {
-      // Celo USDC signs with the shorter EIP-712 domain name.
-      name: 'USDC',
-      type: 'eip3009',
-      version: '2',
-    },
-  }),
-  USDT: define({
-    address: '0x48065fbBE25f71C9282ddf5e1cD6D6A887483D5e',
-    decimals: 6,
-    network: 'eip155:42220',
-    transfer: {
-      // Celo USDT signs with domain version "1", unlike Circle's FiatToken "2".
-      name: 'Tether USD',
-      type: 'eip3009',
-      version: '1',
-    },
-  }),
-} as const
-
-/** Celo Sepolia known assets. */
-export const celoSepolia = {
-  USDC: define({
-    address: '0x01C5C0122039549AD1493B8220cABEdD739BC44E',
-    decimals: 6,
-    network: 'eip155:11142220',
-    transfer: {
-      name: 'USDC',
-      type: 'eip3009',
-      version: '2',
-    },
-  }),
-} as const
-
-/** Returns true when a value is known x402 asset metadata. */
-export function isAsset(value: unknown): value is KnownAsset {
-  if (typeof value !== 'object' || value === null) return false
-  return (value as Partial<KnownAsset>)[knownAsset] === true
-}
-
-/** Returns true when a value is a `viem/tokens` token definition. */
-export function isToken(value: unknown): value is ViemToken {
-  return (
-    typeof value === 'function' &&
-    typeof (value as Partial<ViemToken>).addresses === 'object' &&
-    typeof (value as Partial<ViemToken>).decimals === 'number'
-  )
-}
-
-/** Returns true when a currency is a raw address without chain metadata. */
-export function isRawAddress(currency: Currency): currency is `0x${string}` {
-  return typeof currency === 'string'
-}
-
-/** Resolves currency metadata for an EVM network. */
-export function resolve(currency: Currency, network: EvmNetwork): resolve.Result | undefined {
-  if (isAsset(currency)) {
-    if (currency.network !== network) return undefined
-    return {
-      address: currency.address,
-      decimals: currency.decimals,
-      transfer: currency.transfer,
-    }
-  }
-
-  if (isToken(currency)) {
-    const address = currency.addresses[toChainId(network)]
-    if (!address) return undefined
-    return {
-      address,
-      decimals: currency.decimals,
-      name: currency.name,
-    }
-  }
-
-  return {
-    address: currency,
-  }
-}
-
-export declare namespace resolve {
-  type Result = {
-    address: `0x${string}`
-    decimals?: number | undefined
-    name?: string | undefined
-    transfer?: ExactTransfer | undefined
-  }
-}
-
-/** Returns true when a currency resolves to the accepted address on the network. */
-export function matches(
-  currency: Currency,
-  acceptedCurrency: `0x${string}`,
-  network: EvmNetwork,
-): boolean {
-  const resolved = resolve(currency, network)
-  if (!resolved) return false
-  return getAddress(resolved.address) === getAddress(acceptedCurrency)
-}
-
-/** Converts an EVM chain ID to a CAIP-2 network identifier. */
-export function toNetwork(chainId: number): EvmNetwork {
-  return `eip155:${chainId}`
-}
-
-/** Converts a CAIP-2 EVM network identifier to a chain ID. */
-export function toChainId(network: EvmNetwork): number {
-  return Number(network.slice('eip155:'.length))
-}
-
-function withTokenDefaults(
-  transfer: fromToken.Transfer,
-  token: ReturnType<ViemToken>,
-): ExactTransfer {
-  if (transfer.type !== 'eip3009') return transfer
-  if (transfer.name) return { ...transfer, name: transfer.name }
-  if (!token.name) throw new Error('EIP-3009 token assets require a token name.')
-  return {
-    ...transfer,
-    name: token.name,
-  }
-}

package/src/x402/Exact.e2e.test.ts

@@ -1,488 +0,0 @@
-import { evm as evmClient, Mppx as ClientMppx, tempo as tempoClient } from 'mppx/client'
-import { evm, Mppx as ServerMppx, NodeListener, Request as ServerRequest, tempo } from 'mppx/server'
-import { describe, expect, test } from 'vp/test'
-import * as Http from '~test/Http.js'
-import { accounts, asset, client } from '~test/tempo/viem.js'
-
-import * as evm_Types from '../evm/Types.js'
-import * as Header from './Header.js'
-import * as RouteBinding from './internal/RouteBinding.js'
-import * as Types from './Types.js'
-
-const secretKey = 'test-secret-key-test-secret-key-32'
-const transaction = `0x${'1'.repeat(64)}`
-
-describe('x402 exact e2e', () => {
-  test('serves tempo and x402 paid routes from a live server', async () => {
-    const tempoPayment = ServerMppx.create({
-      methods: [
-        tempo.charge({
-          account: accounts[0],
-          currency: asset,
-          getClient: () => client,
-          recipient: accounts[0].address,
-        }),
-      ],
-      secretKey,
-    })
-
-    const facilitator: Types.Facilitator = {
-      async verify(paymentPayload) {
-        return {
-          isValid: true,
-          payer: payerOf(paymentPayload),
-        }
-      },
-      async settle(paymentPayload) {
-        return {
-          network: paymentPayload.accepted.network,
-          payer: payerOf(paymentPayload),
-          success: true,
-          transaction,
-        }
-      },
-    }
-    const x402Payment = ServerMppx.create({
-      methods: [
-        evm.charge({
-          currency: evm.assets.baseSepolia.USDC,
-          recipient: accounts[0].address,
-          x402: { facilitator },
-        }),
-      ],
-      secretKey,
-    })
-
-    const server = await Http.createServer(async (req, res) => {
-      const request = ServerRequest.fromNodeListener(req, res)
-
-      if (req.url === '/tempo') {
-        const result = await tempoPayment.tempo.charge({
-          amount: '0',
-          chainId: client.chain!.id,
-        })(request)
-        if (result.status === 402) return NodeListener.sendResponse(res, result.challenge)
-        return NodeListener.sendResponse(res, result.withReceipt(new Response('tempo ok')))
-      }
-
-      if (req.url === '/x402') {
-        const result = await x402Payment.evm.charge({
-          amount: '0.01',
-        })(request)
-        if (result.status === 402) return NodeListener.sendResponse(res, result.challenge)
-        return NodeListener.sendResponse(res, result.withReceipt(new Response('x402 ok')))
-      }
-
-      return NodeListener.sendResponse(res, new Response('not found', { status: 404 }))
-    })
-
-    try {
-      const tempoClientPayment = ClientMppx.create({
-        methods: [
-          tempoClient.charge({
-            account: accounts[0],
-            getClient: () => client,
-          }),
-        ],
-        polyfill: false,
-      })
-      const tempoResponse = await tempoClientPayment.fetch(`${server.url}/tempo`)
-      expect(tempoResponse.status).toBe(200)
-      expect(await tempoResponse.text()).toBe('tempo ok')
-      expect(tempoResponse.headers.has('Payment-Receipt')).toBe(true)
-
-      const x402ClientPayment = ClientMppx.create({
-        methods: [
-          evmClient.charge({
-            account: accounts[0],
-          }),
-        ],
-        polyfill: false,
-      })
-      const x402Required = await x402ClientPayment.rawFetch(`${server.url}/x402`)
-      expect(x402Required.status).toBe(402)
-      expect(x402Required.headers.has(Types.paymentRequiredHeader)).toBe(true)
-
-      const paymentSignature = await x402ClientPayment.createCredential(
-        pureX402Challenge(x402Required),
-      )
-      const paymentPayload = Header.decodePaymentSignature(paymentSignature)
-      expect(paymentPayload.accepted.scheme).toBe('exact')
-
-      const x402Response = await x402ClientPayment.rawFetch(`${server.url}/x402`, {
-        headers: { [Types.paymentSignatureHeader]: paymentSignature },
-      })
-      expect(x402Response.status).toBe(200)
-      expect(await x402Response.text()).toBe('x402 ok')
-
-      const paymentResponseHeader = x402Response.headers.get(Types.paymentResponseHeader)
-      expect(paymentResponseHeader).toBeTruthy()
-      expect(Header.decodePaymentResponse(paymentResponseHeader!).transaction).toBe(transaction)
-    } finally {
-      server.close()
-    }
-  })
-
-  test('rejects x402 payment payload replayed across resources with same requirements', async () => {
-    let verifyCalls = 0
-    const payment = ServerMppx.create({
-      methods: [
-        evm.charge({
-          currency: evm.assets.baseSepolia.USDC,
-          recipient: accounts[0].address,
-          x402: {
-            facilitator: {
-              async verify() {
-                verifyCalls++
-                return { isValid: true }
-              },
-              async settle(paymentPayload: Types.PaymentPayload) {
-                return {
-                  network: paymentPayload.accepted.network,
-                  success: true,
-                  transaction,
-                }
-              },
-            },
-          },
-        }),
-      ],
-      secretKey,
-    })
-    const route = payment.evm.charge({ amount: '0.01' })
-
-    const routeAChallenge = await route(new Request('https://example.com/a'))
-    expect(routeAChallenge.status).toBe(402)
-    if (routeAChallenge.status !== 402) throw new Error()
-
-    const paymentRequired = Header.decodePaymentRequired(
-      routeAChallenge.challenge.headers.get(Types.paymentRequiredHeader)!,
-    )
-    const paymentSignature = await standardPaymentSignature(paymentRequired, {
-      nonce: `0x${'1'.repeat(64)}`,
-    })
-
-    const result = await route(
-      new Request('https://example.com/b', {
-        headers: { [Types.paymentSignatureHeader]: paymentSignature },
-      }),
-    )
-
-    expect(result.status).toBe(402)
-    expect(verifyCalls).toBe(0)
-  })
-
-  test('rejects invalid x402 route bindings', async () => {
-    let verifyCalls = 0
-    const payment = ServerMppx.create({
-      methods: [
-        evm.charge({
-          currency: evm.assets.baseSepolia.USDC,
-          recipient: accounts[0].address,
-          x402: {
-            facilitator: {
-              async verify() {
-                verifyCalls++
-                return { isValid: true }
-              },
-              async settle(paymentPayload: Types.PaymentPayload) {
-                return {
-                  network: paymentPayload.accepted.network,
-                  success: true,
-                  transaction,
-                }
-              },
-            },
-          },
-        }),
-      ],
-      secretKey,
-    })
-    const route = payment.evm.charge({ amount: '0.01' })
-
-    const first = await route(new Request('https://example.com/a'))
-    expect(first.status).toBe(402)
-    if (first.status !== 402) throw new Error()
-
-    const paymentRequired = Header.decodePaymentRequired(
-      first.challenge.headers.get(Types.paymentRequiredHeader)!,
-    )
-    const accepted = paymentRequired.accepts[0]!
-    const mppxExtension = paymentRequired.extensions!.mppx
-    if (!mppxExtension) throw new Error()
-    const extensionsWithExtra: Types.Extensions = {
-      ...paymentRequired.extensions!,
-      mppx: {
-        schema: mppxExtension.schema,
-        info: {
-          ...mppxExtension.info,
-          extra: 'not allowed',
-          nonce: '1'.repeat(64),
-        },
-      },
-    }
-    const extensionsWithNonce: Types.Extensions = {
-      ...paymentRequired.extensions!,
-      mppx: {
-        schema: mppxExtension.schema,
-        info: {
-          ...mppxExtension.info,
-          nonce: 'client-salt',
-        },
-      },
-    }
-    const paymentSignatures = await Promise.all([
-      standardPaymentSignature(paymentRequired, {
-        extensions: extensionsWithExtra,
-        nonce: RouteBinding.nonce({
-          accepted,
-          extensions: extensionsWithExtra,
-          resource: paymentRequired.resource,
-        }),
-      }),
-      standardPaymentSignature(paymentRequired, {
-        extensions: extensionsWithNonce,
-        nonce: `0x${'5'.repeat(64)}`,
-      }),
-    ])
-
-    for (const paymentSignature of paymentSignatures) {
-      const result = await route(
-        new Request('https://example.com/a', {
-          headers: { [Types.paymentSignatureHeader]: paymentSignature },
-        }),
-      )
-      expect(result.status).toBe(402)
-    }
-    expect(verifyCalls).toBe(0)
-  })
-
-  test('accepts standard x402 payments for body-bearing requests without a digest', async () => {
-    let verifyCalls = 0
-    const payment = ServerMppx.create({
-      methods: [
-        evm.charge({
-          currency: evm.assets.baseSepolia.USDC,
-          recipient: accounts[0].address,
-          x402: {
-            facilitator: {
-              async verify() {
-                verifyCalls++
-                return { isValid: true }
-              },
-              async settle(paymentPayload: Types.PaymentPayload) {
-                return {
-                  network: paymentPayload.accepted.network,
-                  success: true,
-                  transaction,
-                }
-              },
-            },
-          },
-        }),
-      ],
-      secretKey,
-    })
-    const route = payment.evm.charge({ amount: '0.01' })
-    const body = JSON.stringify({ a: 1 })
-
-    const first = await route(
-      new Request('https://example.com/body', {
-        body,
-        method: 'POST',
-      }),
-    )
-
-    expect(first.status).toBe(402)
-    if (first.status !== 402) throw new Error()
-    expect(first.challenge.headers.has('WWW-Authenticate')).toBe(true)
-    expect(first.challenge.headers.has(Types.paymentRequiredHeader)).toBe(true)
-    const paymentRequired = Header.decodePaymentRequired(
-      first.challenge.headers.get(Types.paymentRequiredHeader)!,
-    )
-
-    const paymentSignatures = await Promise.all([
-      standardPaymentSignature(paymentRequired, {
-        nonce: `0x${'3'.repeat(64)}`,
-      }),
-      standardPaymentSignature(paymentRequired, {
-        extensions: paymentRequired.extensions,
-        nonce: `0x${'4'.repeat(64)}`,
-      }),
-    ])
-    for (const paymentSignature of paymentSignatures) {
-      const result = await route(
-        new Request('https://example.com/body', {
-          body,
-          headers: { [Types.paymentSignatureHeader]: paymentSignature },
-          method: 'POST',
-        }),
-      )
-      expect(result.status).toBe(200)
-    }
-    expect(verifyCalls).toBe(2)
-
-    const scopedRoute = payment.evm.charge({
-      amount: '0.01',
-      scope: 'POST /body',
-    })
-    const scopedResult = await scopedRoute(
-      new Request('https://example.com/body', {
-        body,
-        headers: { [Types.paymentSignatureHeader]: paymentSignatures[0]! },
-        method: 'POST',
-      }),
-    )
-    expect(scopedResult.status).toBe(402)
-    expect(verifyCalls).toBe(2)
-  })
-
-  test('serves tempo and x402 from one composed live endpoint', async () => {
-    const payment = ServerMppx.create({
-      methods: [
-        tempo.charge({
-          account: accounts[0],
-          currency: asset,
-          getClient: () => client,
-          recipient: accounts[0].address,
-        }),
-        evm.charge({
-          currency: evm.assets.baseSepolia.USDC,
-          recipient: accounts[0].address,
-          x402: {
-            facilitator: {
-              async verify(paymentPayload: Types.PaymentPayload) {
-                return {
-                  isValid: true,
-                  payer: payerOf(paymentPayload),
-                }
-              },
-              async settle(paymentPayload: Types.PaymentPayload) {
-                return {
-                  network: paymentPayload.accepted.network,
-                  payer: payerOf(paymentPayload),
-                  success: true,
-                  transaction,
-                }
-              },
-            },
-          },
-        }),
-      ],
-      secretKey,
-    })
-    const paid = payment.compose(
-      [payment.tempo.charge, { amount: '0', chainId: client.chain!.id }],
-      [payment.evm.charge, { amount: '0.01' }],
-    )
-
-    const server = await Http.createServer(async (req, res) => {
-      const request = ServerRequest.fromNodeListener(req, res)
-      const result = await paid(request)
-      if (result.status === 402) return NodeListener.sendResponse(res, result.challenge)
-      return NodeListener.sendResponse(res, result.withReceipt(new Response('paid ok')))
-    })
-
-    try {
-      const challenge = await fetch(server.url)
-      expect(challenge.status).toBe(402)
-      expect(challenge.headers.has('WWW-Authenticate')).toBe(true)
-      expect(challenge.headers.has(Types.paymentRequiredHeader)).toBe(true)
-
-      const tempoClientPayment = ClientMppx.create({
-        methods: [
-          tempoClient.charge({
-            account: accounts[0],
-            getClient: () => client,
-          }),
-        ],
-        polyfill: false,
-      })
-      const tempoResponse = await tempoClientPayment.fetch(server.url)
-      expect(tempoResponse.status).toBe(200)
-      expect(await tempoResponse.text()).toBe('paid ok')
-      expect(tempoResponse.headers.has('Payment-Receipt')).toBe(true)
-
-      const x402ClientPayment = ClientMppx.create({
-        methods: [
-          evmClient.charge({
-            account: accounts[0],
-          }),
-        ],
-        polyfill: false,
-      })
-      const paymentSignature = await x402ClientPayment.createCredential(
-        pureX402Challenge(challenge),
-      )
-      const x402Response = await x402ClientPayment.rawFetch(server.url, {
-        headers: { [Types.paymentSignatureHeader]: paymentSignature },
-      })
-      expect(x402Response.status).toBe(200)
-      expect(await x402Response.text()).toBe('paid ok')
-      expect(x402Response.headers.has(Types.paymentResponseHeader)).toBe(true)
-    } finally {
-      server.close()
-    }
-  })
-})
-
-function payerOf(paymentPayload: Types.PaymentPayload): string {
-  if ('authorization' in paymentPayload.payload) return paymentPayload.payload.authorization.from
-  return paymentPayload.payload.permit2Authorization.from
-}
-
-async function standardPaymentSignature(
-  paymentRequired: Types.PaymentRequired,
-  options: {
-    extensions?: Types.Extensions | undefined
-    nonce: `0x${string}`
-  },
-): Promise<string> {
-  const accepted = paymentRequired.accepts[0]!
-  const name = accepted.extra?.name
-  const version = accepted.extra?.version
-  if (typeof name !== 'string' || typeof version !== 'string') throw new Error()
-  const authorization = {
-    from: accounts[0].address,
-    nonce: options.nonce,
-    to: accepted.payTo as `0x${string}`,
-    validAfter: '0',
-    validBefore: '9999999999',
-    value: accepted.amount,
-  }
-  const signature = await accounts[0].signTypedData({
-    domain: {
-      chainId: Number(accepted.network.slice('eip155:'.length)),
-      name,
-      verifyingContract: accepted.asset as `0x${string}`,
-      version,
-    },
-    message: {
-      ...authorization,
-      validAfter: BigInt(authorization.validAfter),
-      validBefore: BigInt(authorization.validBefore),
-      value: BigInt(authorization.value),
-    },
-    primaryType: 'TransferWithAuthorization',
-    types: evm_Types.authorizationTypes,
-  })
-  return Header.encodePaymentSignature({
-    accepted,
-    ...(options.extensions ? { extensions: options.extensions } : {}),
-    payload: {
-      authorization,
-      signature,
-    },
-    resource: paymentRequired.resource,
-    x402Version: 2,
-  })
-}
-
-function pureX402Challenge(response: Response): Response {
-  const paymentRequired = response.headers.get(Types.paymentRequiredHeader)
-  if (!paymentRequired) throw new Error('Missing PAYMENT-REQUIRED header.')
-  return new Response(null, {
-    headers: { [Types.paymentRequiredHeader]: paymentRequired },
-    status: 402,
-  })
-}