mppx 0.8.17 → 0.8.18

package/src/x402/server/Facilitator.test.ts

@@ -1,111 +0,0 @@
-import { afterEach, describe, expect, test, vi } from 'vp/test'
-
-import type * as Types from '../Types.js'
-import * as Facilitator from './Facilitator.js'
-
-const paymentRequirements = {
-  amount: '10000',
-  asset: '0x036CbD53842c5426634e7929541eC2318f3dCF7e',
-  extra: {
-    assetTransferMethod: 'eip3009',
-    name: 'USDC',
-    version: '2',
-  },
-  maxTimeoutSeconds: 60,
-  network: 'eip155:84532',
-  payTo: '0x209693Bc6afc0C5328bA36FaF03C514EF312287C',
-  scheme: 'exact',
-} satisfies Types.PaymentRequirements
-
-const paymentPayload = {
-  accepted: paymentRequirements,
-  payload: {
-    authorization: {
-      from: '0x857b06519E91e3A54538791bDbb0E22373e36b66',
-      nonce: '0xf3746613c2d920b5fdabc0856f2aeb2d4f88ee6037b8cc5d04a71a4462f13480',
-      to: paymentRequirements.payTo,
-      validAfter: '1740672089',
-      validBefore: '1740672154',
-      value: paymentRequirements.amount,
-    },
-    signature:
-      '0x2d6a7588d6acca505cbf0d9a4a227e0c52c6c34008c8e8986a1283259764173608a2ce6496642e377d6da8dbbf5836e9bd15092f9ecab05ded3d6293af148b571c',
-  },
-  x402Version: 2,
-} satisfies Types.PaymentPayload
-
-afterEach(() => {
-  vi.unstubAllGlobals()
-})
-
-describe('x402 facilitator http client', () => {
-  test('sends v2 verify envelopes', async () => {
-    const calls: { init?: RequestInit | undefined; input: RequestInfo | URL }[] = []
-    const fetchMock = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
-      calls.push({ init, input })
-      return new Response(JSON.stringify({ isValid: true }), {
-        headers: { 'Content-Type': 'application/json' },
-      })
-    })
-    vi.stubGlobal('fetch', fetchMock)
-
-    const facilitator = Facilitator.http('https://facilitator.example')
-    await facilitator.verify(paymentPayload, paymentRequirements)
-
-    expect(fetchMock).toHaveBeenCalledOnce()
-    const { init } = calls[0]!
-    expect(JSON.parse(init!.body as string)).toEqual({
-      paymentPayload,
-      paymentRequirements,
-      x402Version: 2,
-    })
-  })
-
-  test('sends v2 settle envelopes', async () => {
-    const calls: { init?: RequestInit | undefined; input: RequestInfo | URL }[] = []
-    const fetchMock = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
-      calls.push({ init, input })
-      return new Response(
-        JSON.stringify({
-          network: paymentRequirements.network,
-          success: true,
-          transaction: `0x${'1'.repeat(64)}`,
-        }),
-        { headers: { 'Content-Type': 'application/json' } },
-      )
-    })
-    vi.stubGlobal('fetch', fetchMock)
-
-    const facilitator = Facilitator.http('https://facilitator.example/')
-    await facilitator.settle(paymentPayload, paymentRequirements)
-
-    expect(fetchMock).toHaveBeenCalledOnce()
-    expect(calls[0]!.input).toBe('https://facilitator.example/settle')
-    const { init } = calls[0]!
-    expect(JSON.parse(init!.body as string)).toEqual({
-      paymentPayload,
-      paymentRequirements,
-      x402Version: 2,
-    })
-  })
-
-  test('unwraps mppx fetch wrappers', async () => {
-    const rawFetch = vi.fn(async () => {
-      return new Response(JSON.stringify({ isValid: true }), {
-        headers: { 'Content-Type': 'application/json' },
-      })
-    })
-    const wrappedFetch = vi.fn(async () => {
-      throw new Error('wrapped fetch should not be called')
-    }) as unknown as typeof globalThis.fetch & {
-      [key: symbol]: typeof globalThis.fetch
-    }
-    wrappedFetch[Symbol.for('mppx.fetch.wrapper')] = rawFetch as typeof globalThis.fetch
-
-    const facilitator = Facilitator.http('https://facilitator.example', { fetch: wrappedFetch })
-    await facilitator.verify(paymentPayload, paymentRequirements)
-
-    expect(wrappedFetch).not.toHaveBeenCalled()
-    expect(rawFetch).toHaveBeenCalledOnce()
-  })
-})

package/src/x402/server/Facilitator.ts

@@ -1,56 +0,0 @@
-import * as Types from '../Types.js'
-
-const mppxFetchWrapper = Symbol.for('mppx.fetch.wrapper')
-
-type WrappedFetch = typeof globalThis.fetch & {
-  [mppxFetchWrapper]?: typeof globalThis.fetch
-}
-
-export type HttpOptions = {
-  /** Fetch implementation used for facilitator RPCs. */
-  fetch?: typeof globalThis.fetch | undefined
-}
-
-/** Resolves an x402 facilitator URL or client into a facilitator client. */
-export function resolve(
-  facilitator: string | Types.Facilitator,
-  errorMessage = 'x402 exact requires `facilitator`.',
-  options?: HttpOptions | undefined,
-): Types.Facilitator {
-  if (typeof facilitator === 'object' && facilitator !== null) return facilitator
-  if (typeof facilitator === 'string') return http(facilitator, options)
-  throw new Error(errorMessage)
-}
-
-/** Creates an x402 facilitator client from an HTTP base URL. */
-export function http(url: string, options?: HttpOptions | undefined): Types.Facilitator {
-  const base = url.replace(/\/$/, '')
-  const fetch = unwrapFetch(options?.fetch ?? globalThis.fetch)
-  return {
-    async verify(paymentPayload, paymentRequirements) {
-      const response = await fetch(`${base}/verify`, {
-        body: JSON.stringify({ paymentPayload, paymentRequirements, x402Version: 2 }),
-        headers: { 'Content-Type': 'application/json' },
-        method: 'POST',
-      })
-      return Types.VerifyResponseSchema.parse(await response.json())
-    },
-    async settle(paymentPayload, paymentRequirements) {
-      const response = await fetch(`${base}/settle`, {
-        body: JSON.stringify({ paymentPayload, paymentRequirements, x402Version: 2 }),
-        headers: { 'Content-Type': 'application/json' },
-        method: 'POST',
-      })
-      return Types.SettleResponseSchema.parse(await response.json())
-    },
-  }
-}
-
-/** Returns the underlying raw fetch implementation when given an mppx wrapper. */
-export function unwrapFetch(fetch: typeof globalThis.fetch): typeof globalThis.fetch {
-  let current = fetch as WrappedFetch
-  while (current[mppxFetchWrapper]) {
-    current = current[mppxFetchWrapper] as WrappedFetch
-  }
-  return current as typeof globalThis.fetch
-}

package/src/zod.test.ts

@@ -1,169 +0,0 @@
-import { describe, expect, test } from 'vp/test'
-
-import {
-  address,
-  amount,
-  datetime,
-  datetimeInput,
-  hash,
-  period,
-  signature,
-  unwrapOptional,
-  z,
-} from './zod.js'
-
-describe('amount', () => {
-  test.each([
-    { input: '1', expected: true, desc: 'integer' },
-    { input: '1000000', expected: true, desc: 'large integer' },
-    { input: '1.5', expected: true, desc: 'decimal' },
-    { input: '0', expected: true, desc: 'zero' },
-    { input: '007', expected: true, desc: 'leading zeros' },
-    { input: '-1', expected: false, desc: 'negative number' },
-    { input: '', expected: false, desc: 'empty string' },
-    { input: 'abc', expected: false, desc: 'alphabetic string' },
-    { input: '1.', expected: false, desc: 'trailing decimal point' },
-    { input: 123 as unknown as string, expected: false, desc: 'non-string type' },
-  ])('$desc ($input) → $expected', ({ input, expected }) => {
-    expect(amount().safeParse(input).success).toBe(expected)
-  })
-})
-
-describe('datetime', () => {
-  test.each([
-    { input: '2025-01-06T12:00:00Z', expected: true, desc: 'UTC with Z suffix' },
-    { input: '2025-01-06T12:00:00.123Z', expected: true, desc: 'fractional seconds' },
-    { input: '2025-01-06T12:00:00+05:30', expected: true, desc: 'positive UTC offset' },
-    { input: '2025-01-06T12:00:00-08:00', expected: true, desc: 'negative UTC offset' },
-    { input: '2025-01-06T12:00:00', expected: false, desc: 'missing timezone' },
-    { input: '2025-01-06', expected: false, desc: 'date only, no time' },
-    { input: '', expected: false, desc: 'empty string' },
-    { input: 'not-a-date', expected: false, desc: 'non-date string' },
-  ])('$desc ($input) → $expected', ({ input, expected }) => {
-    expect(datetime().safeParse(input).success).toBe(expected)
-  })
-})
-
-describe('datetimeInput', () => {
-  test('accepts Date objects', () => {
-    const result = datetimeInput().parse(new Date('2025-01-06T12:00:00Z'))
-
-    expect(result.toISOString()).toBe('2025-01-06T12:00:00.000Z')
-  })
-
-  test('rejects invalid Date objects', () => {
-    expect(datetimeInput().safeParse(new Date(Number.NaN)).success).toBe(false)
-  })
-})
-
-describe('address', () => {
-  test.each([
-    { input: '0x1234567890abcdef1234567890abcdef12345678', expected: true, desc: 'lowercase hex' },
-    { input: '0x1234567890ABCDEF1234567890ABCDEF12345678', expected: true, desc: 'uppercase hex' },
-    { input: '0xAbCdEf0123456789AbCdEf0123456789AbCdEf01', expected: true, desc: 'mixed case hex' },
-    { input: '0x1234', expected: false, desc: 'too short' },
-    {
-      input: '0x1234567890abcdef1234567890abcdef1234567890',
-      expected: false,
-      desc: 'too long (42 hex chars)',
-    },
-    {
-      input: '1234567890abcdef1234567890abcdef12345678',
-      expected: false,
-      desc: 'missing 0x prefix',
-    },
-    {
-      input: '0xGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG',
-      expected: false,
-      desc: 'non-hex characters',
-    },
-    { input: '', expected: false, desc: 'empty string' },
-  ])('$desc → $expected', ({ input, expected }) => {
-    expect(address().safeParse(input).success).toBe(expected)
-  })
-})
-
-describe('hash', () => {
-  test.each([
-    {
-      input: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
-      expected: true,
-      desc: 'valid 64 hex chars',
-    },
-    {
-      input: '0xABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890',
-      expected: true,
-      desc: 'uppercase hex',
-    },
-    {
-      input: '0x1234567890abcdef1234567890abcdef12345678',
-      expected: false,
-      desc: 'too short (address length)',
-    },
-    {
-      input: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef00',
-      expected: false,
-      desc: 'too long (66 hex chars)',
-    },
-    {
-      input: '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
-      expected: false,
-      desc: 'missing 0x prefix',
-    },
-    { input: '', expected: false, desc: 'empty string' },
-  ])('$desc → $expected', ({ input, expected }) => {
-    expect(hash().safeParse(input).success).toBe(expected)
-  })
-})
-
-describe('period', () => {
-  test.each([
-    { input: 'day', expected: true, desc: 'day keyword' },
-    { input: 'week', expected: true, desc: 'week keyword' },
-    { input: 'month', expected: true, desc: 'month keyword' },
-    { input: 'year', expected: true, desc: 'year keyword' },
-    { input: '3600', expected: true, desc: 'numeric seconds' },
-    { input: '', expected: false, desc: 'empty string' },
-    { input: 'hourly', expected: false, desc: 'unsupported keyword' },
-    { input: 'day1', expected: false, desc: 'keyword with trailing digits' },
-  ])('$desc ($input) → $expected', ({ input, expected }) => {
-    expect(period().safeParse(input).success).toBe(expected)
-  })
-})
-
-describe('signature', () => {
-  test.each([
-    { input: '0xabcdef', expected: true, desc: 'short hex' },
-    {
-      input:
-        '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1b',
-      expected: true,
-      desc: 'full 65-byte secp256k1 signature',
-    },
-    { input: '0x', expected: false, desc: 'bare 0x prefix with no data' },
-    { input: 'abcdef', expected: false, desc: 'missing 0x prefix' },
-    { input: '0xZZZZ', expected: false, desc: 'non-hex characters after 0x' },
-    { input: '', expected: false, desc: 'empty string' },
-  ])('$desc → $expected', ({ input, expected }) => {
-    expect(signature().safeParse(input).success).toBe(expected)
-  })
-})
-
-describe('unwrapOptional', () => {
-  test('unwraps optional string schema to inner type', () => {
-    const inner = z.string()
-    const result = unwrapOptional(z.optional(inner))
-    expect(result).toBe(inner)
-  })
-
-  test('returns non-optional schema unchanged', () => {
-    const schema = z.string()
-    expect(unwrapOptional(schema)).toBe(schema)
-  })
-
-  test('unwraps optional number schema to inner type', () => {
-    const inner = z.number()
-    const result = unwrapOptional(z.optional(inner))
-    expect(result).toBe(inner)
-  })
-})

package/src/zod.ts

@@ -1,71 +0,0 @@
-import { type ZodMiniOptional, type ZodMiniType, z } from 'zod/mini'
-
-export * from 'zod/mini'
-
-export type DatetimeInput = string | Date
-
-/** Numeric string amount (e.g., "1", "1.5", "1000000"). */
-export function amount() {
-  return z.string().check(z.regex(/^\d+(\.\d+)?$/, 'Invalid amount'))
-}
-
-/** ISO 8601 datetime string (e.g., "2025-01-06T12:00:00Z"). */
-export function datetime() {
-  return z
-    .string()
-    .check(
-      z.regex(
-        /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/,
-        'Invalid ISO 8601 datetime',
-      ),
-    )
-}
-
-/** ISO 8601 datetime string or Date object, transformed to a Date. */
-export function datetimeInput(message = 'Invalid ISO 8601 datetime') {
-  return z
-    .pipe(
-      z.union([datetime(), z.custom<Date>((value) => value instanceof Date)]),
-      z.transform(toDate),
-    )
-    .check(z.refine((value) => Number.isFinite(value.getTime()), message))
-}
-
-/** Converts an ISO 8601 datetime string or Date object to a Date. */
-export function toDate(value: DatetimeInput): Date {
-  return value instanceof Date ? value : new Date(value)
-}
-
-/** Serializes an ISO 8601 datetime string or Date object for wire output. */
-export function toDatetimeString(value: DatetimeInput): string {
-  if (!(value instanceof Date)) return value
-  if (!Number.isFinite(value.getTime())) return 'Invalid Date'
-  return value.toISOString()
-}
-
-/** Hex-encoded address string (0x-prefixed, 40 hex chars). */
-export function address() {
-  return z.string().check(z.regex(/^0x[0-9a-fA-F]{40}$/, 'Invalid address'))
-}
-
-/** Hex-encoded hash string (0x-prefixed, 64 hex chars). */
-export function hash() {
-  return z.string().check(z.regex(/^0x[0-9a-fA-F]{64}$/, 'Invalid hash'))
-}
-
-/** Billing period: "day", "week", "month", "year", or seconds as string. */
-export function period() {
-  return z.string().check(z.regex(/^(day|week|month|year|\d+)$/, 'Invalid period'))
-}
-
-/** Hex-encoded signature string (0x-prefixed). */
-export function signature() {
-  return z.string().check(z.regex(/^0x[0-9a-fA-F]+$/, 'Invalid signature'))
-}
-
-/** Checks if a schema is optional and returns the inner type if so. */
-export function unwrapOptional<schema extends ZodMiniType>(schema: schema): ZodMiniType {
-  if (schema._zod.def.type === 'optional')
-    return (schema as unknown as ZodMiniOptional)._zod.def.innerType as ZodMiniType
-  return schema
-}