mppx 0.8.17 → 0.8.18

package/src/validation/core.ts

@@ -1,386 +0,0 @@
-import type { Chain } from 'viem'
-import * as viemChains from 'viem/chains'
-
-import { validateChallenge, validateErrorHandling } from '../cli/validate/challenge.js'
-import {
-  buildUrl,
-  extractEndpointsFromDiscovery,
-  extractRequestBodyFromDiscovery,
-  fetchDiscoveryDoc,
-} from '../cli/validate/discovery.js'
-import type { CheckResult, EndpointSpec, PathParameter } from '../cli/validate/helpers.js'
-import {
-  isValidIntegerAmount,
-  parseEndpointArg,
-  resolveBodyForEndpoint,
-} from '../cli/validate/helpers.js'
-import { missingDiscoverySuggestion } from '../cli/validate/messages.js'
-import { validatePaymentFlow } from '../cli/validate/payment.js'
-import { validate as validateDiscoveryDoc } from '../discovery/Validate.js'
-
-export { buildUrl }
-export type { CheckResult, EndpointSpec, PathParameter }
-
-export type ValidateOptions = {
-  url: string
-  endpoint?: string | undefined
-  body?: string | undefined
-  query?: string[] | undefined
-  headers?: string[] | undefined
-  verbose?: boolean | undefined
-  yes?: boolean | undefined
-  skipPayment?: boolean | undefined
-  interactive?: boolean | undefined
-  discoveryPath?: string | undefined
-  onPaymentResults?: (results: CheckResult[]) => void
-}
-
-export type DiscoveryResult = {
-  found: boolean
-  valid: boolean
-  endpoints: EndpointSpec[]
-  checks: CheckResult[]
-  doc: Record<string, unknown> | null
-}
-
-export type EndpointValidationResult = {
-  method: string
-  path: string
-  challenge: CheckResult[]
-  errorHandling: CheckResult[]
-  payment: CheckResult[]
-}
-
-export type ValidateResult = {
-  url: string
-  discovery: DiscoveryResult
-  endpoints: EndpointValidationResult[]
-  summary: { passed: number; failed: number; warnings: number; skipped: number }
-  suggestions: string[]
-}
-
-export type ValidateEvent =
-  | { phase: 'discovery'; discovery: DiscoveryResult; results: CheckResult[] }
-  | { phase: 'endpoint'; endpoint: EndpointSpec }
-  | {
-      phase: 'challenge'
-      endpoint: EndpointSpec
-      results: CheckResult[]
-      isMpp: boolean
-      isTestnet: boolean
-      isMainnet: boolean
-      isNonMppPayment: boolean
-      isMalformedChallenge: boolean
-      methods: string[]
-    }
-  | { phase: 'errorHandling'; endpoint: EndpointSpec; results: CheckResult[] }
-  | {
-      phase: 'payment'
-      endpoint: EndpointSpec
-      results: CheckResult[]
-      succeeded: boolean
-      body?: string | undefined
-    }
-
-/** Streams validation results as each phase completes. */
-export async function* validateStream(options: ValidateOptions): AsyncGenerator<ValidateEvent> {
-  const baseUrl = options.url.replace(/\/$/, '').replace(/\/openapi\.json$/i, '')
-  const verbose = options.verbose ?? false
-
-  const discovery = await runDiscovery(baseUrl, options)
-  yield { phase: 'discovery', discovery, results: discovery.checks }
-
-  for (const endpoint of discovery.endpoints) {
-    yield { phase: 'endpoint', endpoint }
-
-    let body: string | undefined
-    let bodyIsAutogenerated = false
-    if (options.endpoint) {
-      body = options.body
-    } else {
-      body = resolveBodyForEndpoint(options.body, endpoint.path)
-      if (!body && discovery.doc) {
-        body = extractRequestBodyFromDiscovery(discovery.doc, endpoint)
-        bodyIsAutogenerated = !!body
-      }
-    }
-
-    const {
-      results: challengeResults,
-      resolvedBody,
-      challenges: parsedChallenges,
-    } = await validateChallenge(baseUrl, endpoint, verbose, {
-      body,
-      bodyIsAutogenerated,
-      query: options.query,
-      extraHeaders: options.headers,
-      discoveryDoc: discovery.doc ?? undefined,
-    })
-    const effectiveBody = resolvedBody ?? body
-    const isMpp = challengeResults.some(
-      (r) => r.severity === 'pass' && r.label === 'Challenge parseable',
-    )
-    const chainIds = (parsedChallenges ?? [])
-      .filter((ch) => ch.method !== 'stripe')
-      .map((ch) => ((ch.request as Record<string, unknown>).methodDetails as any)?.chainId)
-      .filter((id): id is number => typeof id === 'number')
-    const isTestnet = chainIds.some(chainIsTestnet)
-    const isMainnet = chainIds.some((id) => !chainIsTestnet(id))
-    const isNonMppPayment =
-      !isMpp && challengeResults.some((r) => r.label === 'Not an MPP endpoint')
-    const hasPaymentScheme = challengeResults.some(
-      (r) => r.severity === 'pass' && r.label === 'WWW-Authenticate header present',
-    )
-    const challengeFailed = challengeResults.some(
-      (r) => r.severity === 'fail' && r.label === 'Challenge parseable',
-    )
-    const isMalformedChallenge = !isMpp && hasPaymentScheme && challengeFailed
-
-    const methods = parsedChallenges?.map((c) => c.method) ?? []
-
-    yield {
-      phase: 'challenge',
-      endpoint,
-      results: challengeResults,
-      isMpp,
-      isTestnet,
-      isMainnet,
-      isNonMppPayment,
-      isMalformedChallenge,
-      methods,
-    }
-
-    if (isMpp) {
-      const errorResults = await validateErrorHandling(baseUrl, endpoint, {
-        body: effectiveBody,
-        query: options.query,
-      })
-      yield { phase: 'errorHandling', endpoint, results: errorResults }
-
-      if (!options.skipPayment) {
-        const onResults = options.onPaymentResults
-        const paymentResults = await validatePaymentFlow(baseUrl, endpoint, verbose, {
-          body: effectiveBody,
-          query: options.query,
-          extraHeaders: options.headers,
-          yes: options.yes,
-          silent: !onResults,
-          interactive: options.interactive,
-          ...(onResults && { onResults }),
-        })
-        const succeeded = paymentResults.some(
-          (r) => r.severity === 'pass' && r.label === 'Payment: successful',
-        )
-        yield { phase: 'payment', endpoint, results: paymentResults, succeeded }
-      }
-    }
-  }
-}
-
-/** Runs the full validation suite and returns all results as a batch. */
-export async function validate(options: ValidateOptions): Promise<ValidateResult> {
-  const baseUrl = options.url.replace(/\/$/, '').replace(/\/openapi\.json$/i, '')
-  let discovery: DiscoveryResult | undefined
-  const endpointResults: EndpointValidationResult[] = []
-  let current: EndpointValidationResult | undefined
-
-  let sawTestnet = false
-  let sawMainnet = false
-
-  for await (const event of validateStream(options)) {
-    switch (event.phase) {
-      case 'discovery':
-        discovery = event.discovery
-        break
-      case 'endpoint':
-        current = {
-          method: event.endpoint.method,
-          path: event.endpoint.path,
-          challenge: [],
-          errorHandling: [],
-          payment: [],
-        }
-        endpointResults.push(current)
-        break
-      case 'challenge':
-        if (current) current.challenge = event.results
-        if (event.isMpp) {
-          if (event.isTestnet) sawTestnet = true
-          if (event.isMainnet) sawMainnet = true
-        }
-        break
-      case 'errorHandling':
-        if (current) current.errorHandling = event.results
-        break
-      case 'payment':
-        if (current) current.payment = event.results
-        break
-    }
-  }
-
-  const summary = { passed: 0, failed: 0, warnings: 0, skipped: 0 }
-  if (discovery) {
-    for (const r of discovery.checks) {
-      if (r.severity === 'pass') summary.passed++
-      else if (r.severity === 'fail') summary.failed++
-      else if (r.severity === 'warn') summary.warnings++
-      else if (r.severity === 'skip') summary.skipped++
-    }
-  }
-  for (const ep of endpointResults) {
-    for (const r of [...ep.challenge, ...ep.errorHandling, ...ep.payment]) {
-      if (r.severity === 'pass') summary.passed++
-      else if (r.severity === 'fail') summary.failed++
-      else if (r.severity === 'warn') summary.warnings++
-      else if (r.severity === 'skip') summary.skipped++
-    }
-  }
-
-  if (!discovery) throw new Error('Discovery phase did not complete')
-
-  const suggestions = computeSuggestions(endpointResults, discovery, { sawTestnet, sawMainnet })
-
-  return {
-    url: baseUrl,
-    discovery,
-    endpoints: endpointResults,
-    summary,
-    suggestions,
-  }
-}
-
-function computeSuggestions(
-  endpoints: EndpointValidationResult[],
-  discovery: DiscoveryResult,
-  flags: { sawTestnet: boolean; sawMainnet: boolean },
-): string[] {
-  const steps: string[] = []
-  const allResults = endpoints.flatMap((ep) => [...ep.challenge, ...ep.payment])
-
-  if (!discovery.found) {
-    steps.push(missingDiscoverySuggestion)
-  }
-
-  const sawCryptoMainnet = flags.sawMainnet
-  const sawCryptoTestnet = flags.sawTestnet
-  const sawStripeLive = allResults.some(
-    (r) => r.label.includes('[stripe]') && r.label.includes('livemode'),
-  )
-
-  if (sawCryptoMainnet && !sawCryptoTestnet) {
-    steps.push(
-      'Validate your testnet server to test without real funds (Tempo wallets are automatically provisioned).',
-    )
-  } else if (sawCryptoTestnet && !sawCryptoMainnet) {
-    steps.push('Validate your mainnet server to confirm real payments work end-to-end.')
-  }
-  if (sawStripeLive) {
-    steps.push(
-      'Validate your testmode Stripe server to test card payments end-to-end (auto-pays with test card).',
-    )
-  }
-
-  return steps
-}
-
-const allChains = Object.values(viemChains) as Chain[]
-
-function chainIsTestnet(chainId: number): boolean {
-  return allChains.find((c) => c.id === chainId)?.testnet === true
-}
-
-async function runDiscovery(baseUrl: string, options: ValidateOptions): Promise<DiscoveryResult> {
-  const checks: CheckResult[] = []
-  let endpoints: EndpointSpec[] = []
-  let discoveryDoc: Record<string, unknown> | null = null
-  let found = false
-  let valid = false
-
-  // Try the user's path first, then root, then /api.
-  const origin = new URL(baseUrl).origin
-  let candidates: string[]
-  if (options.discoveryPath) {
-    candidates = [
-      new URL(options.discoveryPath, baseUrl + '/').href.replace(/\/openapi\.json$/i, ''),
-    ]
-  } else {
-    candidates = [baseUrl, origin, `${origin}/api`]
-    candidates = [...new Set(candidates)]
-  }
-  let discoveryResult: Awaited<ReturnType<typeof fetchDiscoveryDoc>> | undefined
-  const attemptedErrors: string[] = []
-  for (const candidate of candidates) {
-    discoveryResult = await fetchDiscoveryDoc(candidate)
-    if ('error' in discoveryResult) {
-      attemptedErrors.push(`${candidate}/openapi.json: ${discoveryResult.error}`)
-    } else {
-      break
-    }
-  }
-
-  if (!discoveryResult || 'error' in discoveryResult) {
-    checks.push({
-      label: 'Document found',
-      detail: attemptedErrors.join('; '),
-      hint: 'MPP servers must serve an OpenAPI document at /openapi.json with x-payment-info extensions.',
-      severity: 'fail',
-    })
-  } else {
-    found = true
-    checks.push({ label: 'Document found and parseable', severity: 'pass' })
-
-    const issues = validateDiscoveryDoc(discoveryResult.doc)
-    const errors = issues.filter((i) => i.severity === 'error')
-    const warnings = issues.filter((i) => i.severity === 'warning')
-
-    if (errors.length > 0) {
-      checks.push({
-        label: 'Valid OpenAPI structure',
-        detail: `${errors.length} error(s)`,
-        severity: 'fail',
-      })
-      for (const e of errors) {
-        checks.push({ label: e.message, detail: e.path, severity: 'fail' })
-      }
-    } else {
-      valid = true
-      checks.push({ label: 'Valid OpenAPI structure', severity: 'pass' })
-    }
-
-    for (const w of warnings) {
-      checks.push({ label: w.message, detail: w.path, severity: 'warn' })
-    }
-
-    discoveryDoc = discoveryResult.doc as Record<string, unknown>
-  }
-
-  if (options.endpoint) {
-    const parsed = parseEndpointArg(options.endpoint)
-    if (parsed) endpoints.push(parsed)
-  } else if (discoveryDoc) {
-    endpoints = extractEndpointsFromDiscovery(discoveryDoc)
-
-    const NO_AMOUNT = BigInt('999999999999999999')
-    endpoints.sort((a, b) => {
-      const aAmt = isValidIntegerAmount(a.amount) ? BigInt(a.amount!) : NO_AMOUNT
-      const bAmt = isValidIntegerAmount(b.amount) ? BigInt(b.amount!) : NO_AMOUNT
-      return aAmt < bAmt ? -1 : aAmt > bAmt ? 1 : 0
-    })
-
-    if (endpoints.length > 0) {
-      checks.push({
-        label: 'Paid endpoints found',
-        detail: `${endpoints.length} endpoint(s)`,
-        severity: 'pass',
-      })
-    } else {
-      checks.push({
-        label: 'Paid endpoints found',
-        detail: 'No endpoints with x-payment-info',
-        severity: 'warn',
-      })
-    }
-  }
-
-  return { found, valid, endpoints, checks, doc: discoveryDoc }
-}

package/src/validation/index.ts

@@ -1,11 +0,0 @@
-export { buildUrl, validate, validateStream } from './core.js'
-export type {
-  CheckResult,
-  DiscoveryResult,
-  EndpointSpec,
-  EndpointValidationResult,
-  PathParameter,
-  ValidateEvent,
-  ValidateOptions,
-  ValidateResult,
-} from './core.js'

package/src/viem/Account.test.ts

@@ -1,72 +0,0 @@
-import { createClient, http } from 'viem'
-import { privateKeyToAccount } from 'viem/accounts'
-import { tempo as mainnet } from 'viem/tempo/chains'
-import { describe, expect, test } from 'vp/test'
-
-import * as Account from './Account.js'
-
-const account = privateKeyToAccount(
-  '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
-)
-
-const otherAccount = privateKeyToAccount(
-  '0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d',
-)
-
-const clientWithAccount = createClient({
-  account,
-  chain: mainnet,
-  transport: http(),
-})
-
-const clientWithoutAccount = createClient({
-  chain: mainnet,
-  transport: http(),
-})
-
-describe('getResolver', () => {
-  test('behavior: returns Account when passed as default', () => {
-    const getAccount = Account.getResolver({ account })
-    const result = getAccount(clientWithoutAccount)
-    expect(result).toBe(account)
-  })
-
-  test('behavior: returns Account when passed as override', () => {
-    const getAccount = Account.getResolver()
-    const result = getAccount(clientWithoutAccount, { account: otherAccount })
-    expect(result).toBe(otherAccount)
-  })
-
-  test('behavior: override takes precedence over default', () => {
-    const getAccount = Account.getResolver({ account })
-    const result = getAccount(clientWithoutAccount, { account: otherAccount })
-    expect(result).toBe(otherAccount)
-  })
-
-  test('behavior: falls back to client.account when no account provided', () => {
-    const getAccount = Account.getResolver()
-    const result = getAccount(clientWithAccount)
-    expect(result).toBe(account)
-  })
-
-  test('behavior: Address returns parsed account', () => {
-    const getAccount = Account.getResolver()
-    const result = getAccount(clientWithoutAccount, { account: account.address })
-    expect(result.address).toBe(account.address)
-    expect(result.type).toBe('json-rpc')
-  })
-
-  test('behavior: Address as default returns parsed account', () => {
-    const getAccount = Account.getResolver({ account: account.address })
-    const result = getAccount(clientWithoutAccount)
-    expect(result.address).toBe(account.address)
-    expect(result.type).toBe('json-rpc')
-  })
-
-  test('error: throws when no account and client has no account', () => {
-    const getAccount = Account.getResolver()
-    expect(() => getAccount(clientWithoutAccount)).toThrowErrorMatchingInlineSnapshot(
-      `[Error: No \`account\` provided. Pass \`account\` to parameters or context.]`,
-    )
-  })
-})

package/src/viem/Account.ts

@@ -1,30 +0,0 @@
-import type { Address, Client, Account as viem_Account } from 'viem'
-import { parseAccount } from 'viem/accounts'
-
-export type Account = viem_Account
-
-export function getResolver(parameters: getResolver.Parameters = {}) {
-  const { account: defaultAccount } = parameters
-
-  return (
-    client: Client,
-    { account: override }: { account?: Account | Address | undefined } = {},
-  ): Account => {
-    const account = override ?? defaultAccount
-
-    if (!account) {
-      if (!client.account)
-        throw new Error('No `account` provided. Pass `account` to parameters or context.')
-      return client.account
-    }
-
-    return parseAccount(account)
-  }
-}
-
-export declare namespace getResolver {
-  type Parameters = {
-    /** Account to use for signing. If an Address is provided, it must match the client's account. */
-    account?: Account | Address | undefined
-  }
-}