mppx 0.8.15 → 0.8.18

package/src/discovery/Validate.test.ts

@@ -1,305 +0,0 @@
-import { validate } from './Validate.js'
-
-function makeDoc(overrides: Record<string, unknown> = {}) {
-  return {
-    info: { title: 'Test', version: '1.0.0' },
-    openapi: '3.1.0',
-    paths: {
-      '/search': {
-        post: {
-          'x-payment-info': {
-            amount: '100',
-            intent: 'charge',
-            method: 'tempo',
-          },
-          requestBody: {
-            content: { 'application/json': { schema: { type: 'object' } } },
-          },
-          responses: {
-            '200': { description: 'OK' },
-            '402': { description: 'Payment Required' },
-          },
-        },
-      },
-    },
-    ...overrides,
-  }
-}
-
-describe('validate', () => {
-  test('returns no errors for a valid document', () => {
-    const errors = validate(makeDoc())
-    expect(errors.filter((error) => error.severity === 'error')).toHaveLength(0)
-  })
-
-  test('accepts offers-based x-payment-info', () => {
-    const errors = validate(
-      makeDoc({
-        paths: {
-          '/search': {
-            post: {
-              'x-payment-info': {
-                offers: [{ amount: '100', intent: 'charge', method: 'tempo' }],
-              },
-              requestBody: {
-                content: { 'application/json': { schema: { type: 'object' } } },
-              },
-              responses: {
-                '200': { description: 'OK' },
-                '402': { description: 'Payment Required' },
-              },
-            },
-          },
-        },
-      }),
-    )
-
-    expect(errors.filter((error) => error.severity === 'error')).toHaveLength(0)
-  })
-
-  test('returns error for missing 402 response', () => {
-    const errors = validate(
-      makeDoc({
-        paths: {
-          '/search': {
-            post: {
-              'x-payment-info': {
-                amount: '100',
-                intent: 'charge',
-                method: 'tempo',
-              },
-              requestBody: {},
-              responses: {
-                '200': { description: 'OK' },
-              },
-            },
-          },
-        },
-      }),
-    )
-
-    expect(errors.find((error) => error.severity === 'error')?.message).toContain('402')
-  })
-
-  test('returns warning for missing requestBody', () => {
-    const errors = validate(
-      makeDoc({
-        paths: {
-          '/search': {
-            post: {
-              'x-payment-info': {
-                amount: '100',
-                intent: 'charge',
-                method: 'tempo',
-              },
-              responses: {
-                '200': { description: 'OK' },
-                '402': { description: 'Payment Required' },
-              },
-            },
-          },
-        },
-      }),
-    )
-
-    expect(errors.find((error) => error.severity === 'warning')?.message).toContain('requestBody')
-  })
-
-  test('returns structural errors for invalid top-level document', () => {
-    const errors = validate({ openapi: '3.1.0' })
-    expect(errors.length).toBeGreaterThan(0)
-    expect(errors[0]!.severity).toBe('error')
-  })
-
-  test('returns errors for invalid extension values', () => {
-    const errors = validate(
-      makeDoc({
-        'x-service-info': {
-          docs: { homepage: 'not-a-uri' },
-        },
-        paths: {
-          '/search': {
-            post: {
-              'x-payment-info': {
-                amount: '01',
-                intent: 'subscribe',
-                method: 'tempo',
-              },
-              responses: {
-                '402': { description: 'Payment Required' },
-              },
-            },
-          },
-        },
-      }),
-    )
-
-    expect(errors.some((error) => error.severity === 'error')).toBe(true)
-  })
-
-  test('returns errors for mixed shorthand and offers shapes', () => {
-    const errors = validate(
-      makeDoc({
-        paths: {
-          '/search': {
-            post: {
-              'x-payment-info': {
-                amount: '100',
-                offers: [{ amount: '100', intent: 'charge', method: 'tempo' }],
-              },
-              requestBody: {
-                content: { 'application/json': { schema: { type: 'object' } } },
-              },
-              responses: {
-                '200': { description: 'OK' },
-                '402': { description: 'Payment Required' },
-              },
-            },
-          },
-        },
-      }),
-    )
-
-    expect(errors).toContainEqual(
-      expect.objectContaining({
-        message: 'Cannot mix offers with flat payment info fields',
-        path: 'paths./search.post.x-payment-info',
-        severity: 'error',
-      }),
-    )
-  })
-
-  test('returns errors for empty offers arrays', () => {
-    const errors = validate(
-      makeDoc({
-        paths: {
-          '/search': {
-            post: {
-              'x-payment-info': {
-                offers: [],
-              },
-              requestBody: {
-                content: { 'application/json': { schema: { type: 'object' } } },
-              },
-              responses: {
-                '200': { description: 'OK' },
-                '402': { description: 'Payment Required' },
-              },
-            },
-          },
-        },
-      }),
-    )
-
-    expect(errors).toContainEqual(
-      expect.objectContaining({
-        path: 'paths./search.post.x-payment-info.offers',
-        severity: 'error',
-      }),
-    )
-  })
-
-  test('returns errors for malformed offers', () => {
-    const errors = validate(
-      makeDoc({
-        paths: {
-          '/search': {
-            post: {
-              'x-payment-info': {
-                offers: [{ amount: '01', intent: 'charge', method: 'tempo' }],
-              },
-              requestBody: {
-                content: { 'application/json': { schema: { type: 'object' } } },
-              },
-              responses: {
-                '200': { description: 'OK' },
-                '402': { description: 'Payment Required' },
-              },
-            },
-          },
-        },
-      }),
-    )
-
-    expect(errors).toContainEqual(
-      expect.objectContaining({
-        path: 'paths./search.post.x-payment-info.offers.0.amount',
-        severity: 'error',
-      }),
-    )
-  })
-
-  test('ignores path-item-level fields like summary and parameters', () => {
-    const errors = validate(
-      makeDoc({
-        paths: {
-          '/search': {
-            summary: 'Search endpoints',
-            parameters: [{ name: 'q', in: 'query' }],
-            'x-custom': 'value',
-            post: {
-              'x-payment-info': {
-                amount: '100',
-                intent: 'charge',
-                method: 'tempo',
-              },
-              requestBody: {
-                content: { 'application/json': { schema: { type: 'object' } } },
-              },
-              responses: {
-                '200': { description: 'OK' },
-                '402': { description: 'Payment Required' },
-              },
-            },
-          },
-        },
-      }),
-    )
-
-    expect(errors.filter((e) => e.severity === 'error')).toHaveLength(0)
-  })
-
-  test('validates proxy-generated docs with relative llms path', () => {
-    const errors = validate({
-      info: { title: 'API Proxy', version: '1.0.0' },
-      openapi: '3.1.0',
-      paths: {},
-      'x-service-info': {
-        categories: ['gateway'],
-        docs: {
-          apiReference: 'https://example.com/api',
-          homepage: 'https://example.com',
-          llms: '/llms.txt',
-        },
-      },
-    })
-
-    expect(errors.filter((e) => e.severity === 'error')).toHaveLength(0)
-  })
-
-  test('accepts x-payment-info with unknown fields', () => {
-    const errors = validate({
-      info: { title: 'Test', version: '1.0.0' },
-      openapi: '3.1.0',
-      paths: {
-        '/api/call': {
-          post: {
-            'x-payment-info': {
-              price: '0.54',
-              pricingMode: 'fixed',
-              protocols: ['x402', 'mpp'],
-            },
-            requestBody: {
-              content: { 'application/json': { schema: { type: 'object' } } },
-            },
-            responses: {
-              '200': { description: 'OK' },
-              '402': { description: 'Payment Required' },
-            },
-          },
-        },
-      },
-    })
-    expect(errors.filter((e) => e.severity === 'error')).toHaveLength(0)
-  })
-})

package/src/discovery/Validate.ts

@@ -1,77 +0,0 @@
-import { DiscoveryDocument, PaymentInfo } from './Discovery.js'
-
-export type ValidationError = {
-  message: string
-  path: string
-  severity: 'error' | 'warning'
-}
-
-/**
- * Validates a discovery document structurally and semantically.
- */
-export function validate(doc: unknown): ValidationError[] {
-  const errors: ValidationError[] = []
-
-  const result = DiscoveryDocument.safeParse(doc)
-  if (!result.success) {
-    for (const issue of result.error.issues) {
-      errors.push({
-        message: issue.message,
-        path: issue.path.map(String).join('.') || '(root)',
-        severity: 'error',
-      })
-    }
-    return errors
-  }
-
-  const parsed = result.data
-  const paths = parsed.paths
-  if (!paths) return errors
-
-  for (const [pathKey, pathItem] of Object.entries(paths)) {
-    for (const [method, operation] of Object.entries(pathItem as Record<string, unknown>)) {
-      if (!operation || typeof operation !== 'object' || Array.isArray(operation)) continue
-      const op = operation as Record<string, unknown>
-
-      const opPath = `paths.${pathKey}.${method}`
-      const rawPaymentInfo = op['x-payment-info']
-      if (!rawPaymentInfo) continue
-
-      const paymentResult = PaymentInfo.safeParse(rawPaymentInfo)
-      if (!paymentResult.success) {
-        for (const issue of paymentResult.error.issues) {
-          const issuePath = issue.path.length > 0 ? `.${issue.path.map(String).join('.')}` : ''
-          errors.push({
-            message: issue.message,
-            path: `${opPath}.x-payment-info${issuePath}`,
-            severity: 'error',
-          })
-        }
-        continue
-      }
-
-      const responses = op.responses as Record<string, unknown> | undefined
-      if (!responses || !('402' in responses)) {
-        errors.push({
-          message: 'Operation with x-payment-info MUST have a 402 response',
-          path: `${opPath}.responses`,
-          severity: 'error',
-        })
-      }
-
-      const methodUpper = method.toUpperCase()
-      if (
-        !op.requestBody &&
-        (methodUpper === 'POST' || methodUpper === 'PUT' || methodUpper === 'PATCH')
-      ) {
-        errors.push({
-          message: 'Operation with x-payment-info has no requestBody',
-          path: opPath,
-          severity: 'warning',
-        })
-      }
-    }
-  }
-
-  return errors
-}

package/src/discovery/index.ts

@@ -1,3 +0,0 @@
-export * from './Discovery.js'
-export * from './OpenApi.js'
-export * from './Validate.js'

package/src/env.d.ts

@@ -1,12 +0,0 @@
-/// <reference types="vite/client" />
-
-interface ImportMetaEnv {
-  readonly MODE: 'test' | 'production'
-  readonly VITE_TEMPO_NETWORK: 'localnet' | 'moderato' | 'devnet'
-  readonly VITE_HTTP_LOG: 'true' | 'false'
-  readonly VITE_RPC_CREDENTIALS: string
-}
-
-interface ImportMeta {
-  readonly env: ImportMetaEnv
-}

package/src/evm/Assets.ts

@@ -1 +0,0 @@
-export * from '../x402/Assets.js'

package/src/evm/Chains.ts

@@ -1,11 +0,0 @@
-/** Base mainnet EVM chain ID. */
-export const base = 8453
-
-/** Base Sepolia testnet EVM chain ID. */
-export const baseSepolia = 84532
-
-/** Celo mainnet EVM chain ID. */
-export const celo = 42220
-
-/** Celo Sepolia testnet EVM chain ID. */
-export const celoSepolia = 11142220

package/src/evm/Methods.ts

@@ -1,44 +0,0 @@
-import { getAddress, parseUnits } from 'viem'
-
-import * as Method from '../Method.js'
-import * as z from '../zod.js'
-import * as Types from './Types.js'
-
-/** Native Payment-auth EVM charge method. */
-export const charge = Method.from({
-  name: Types.paymentMethod,
-  intent: Types.chargeIntent,
-  schema: {
-    credential: {
-      payload: Types.ChargePayloadSchema,
-    },
-    request: z.pipe(
-      Types.ChargeRequestInputSchema,
-      z.transform(
-        ({
-          amount,
-          chainId,
-          credentialTypes = ['authorization'],
-          currency,
-          decimals,
-          permit2Address,
-          recipient,
-          splits,
-          ...request
-        }) => ({
-          ...request,
-          amount: parseUnits(amount, decimals).toString(),
-          currency: getAddress(currency),
-          methodDetails: {
-            chainId,
-            credentialTypes,
-            decimals,
-            ...(permit2Address ? { permit2Address: getAddress(permit2Address) } : {}),
-            ...(splits ? { splits } : {}),
-          },
-          recipient: getAddress(recipient),
-        }),
-      ),
-    ),
-  },
-})

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 },
-      },
-    })
-  })
-})