mppx 0.8.17 → 0.8.18

package/src/middlewares/hono.test.ts

@@ -1,473 +0,0 @@
-import { serve } from '@hono/node-server'
-import { Hono } from 'hono'
-import { Challenge, Credential, Method, Receipt, z } from 'mppx'
-import {
-  evm as evm_client,
-  Mppx as Mppx_client,
-  session as sessionIntent,
-  tempo as tempo_client,
-} from 'mppx/client'
-import { Mppx, discovery, payment } from 'mppx/hono'
-import { evm as evm_server, Mppx as ServerMppx, tempo as tempo_server } from 'mppx/server'
-import {
-  paymentRequiredHeader,
-  paymentResponseHeader,
-  paymentSignatureHeader,
-  type PaymentPayload,
-} from 'mppx/x402'
-import { Addresses } from 'viem/tempo'
-import { beforeAll, describe, expect, test } from 'vp/test'
-import * as Http from '~test/Http.js'
-import { accounts, asset, client, fundAccount } from '~test/tempo/viem.js'
-
-function createServer(app: Hono) {
-  return new Promise<Http.TestServer>((resolve) => {
-    const server = serve({ fetch: app.fetch, port: 0 }, (info) => {
-      resolve(
-        Http.wrapServer(server as unknown as import('node:http').Server, {
-          port: info.port,
-          url: `http://localhost:${info.port}`,
-        }),
-      )
-    })
-  })
-}
-
-const secretKey = 'test-secret-key-test-secret-key-32'
-
-describe('payment', () => {
-  test('short-circuits management responses', async () => {
-    let handlerRan = false
-    const intent = () => async () => ({
-      status: 200 as const,
-      withReceipt: () =>
-        new Response(null, {
-          headers: { 'Payment-Receipt': 'management-receipt' },
-          status: 204,
-        }),
-    })
-
-    const app = new Hono()
-    app.get('/', payment(intent as any, {} as any), (c) => {
-      handlerRan = true
-      return c.json({ data: 'content' })
-    })
-
-    const server = await createServer(app)
-    const response = await globalThis.fetch(server.url)
-    expect(response.status).toBe(204)
-    expect(response.headers.get('Payment-Receipt')).toBe('management-receipt')
-    expect(await response.text()).toBe('')
-    expect(handlerRan).toBe(false)
-
-    server.close()
-  })
-
-  test('copies transport-specific success headers', async () => {
-    const intent = () => async () => ({
-      status: 200 as const,
-      withReceipt: (response?: Response) =>
-        new Response(response?.body ?? null, {
-          headers: {
-            ...(response ? Object.fromEntries(response.headers) : {}),
-            'PAYMENT-RESPONSE': 'x402-response',
-          },
-          status: response?.status ?? 200,
-        }),
-    })
-
-    const app = new Hono()
-    app.get('/', payment(intent as any, {} as any), (c) => c.json({ data: 'content' }))
-
-    const server = await createServer(app)
-    const response = await globalThis.fetch(server.url)
-    expect(response.status).toBe(200)
-    expect(response.headers.get('PAYMENT-RESPONSE')).toBe('x402-response')
-
-    server.close()
-  })
-})
-
-const scopeMethod = Method.toServer(
-  Method.from({
-    name: 'mock',
-    intent: 'charge',
-    schema: {
-      credential: { payload: z.object({ token: z.string() }) },
-      request: z.object({
-        amount: z.string(),
-        currency: z.string(),
-        decimals: z.number(),
-        recipient: z.string(),
-      }),
-    },
-  }),
-  {
-    async verify() {
-      return {
-        method: 'mock',
-        reference: 'tx-mock',
-        status: 'success' as const,
-        timestamp: new Date().toISOString(),
-      }
-    },
-  },
-)
-
-function createScopeHarness() {
-  return Mppx.create({
-    methods: [scopeMethod],
-    realm: 'api.example.com',
-    secretKey,
-  })
-}
-
-function createChargeHarness(feePayer: boolean) {
-  const mppx = Mppx.create({
-    methods: [
-      tempo_server.charge({
-        getClient: () => client,
-        currency: asset,
-        account: accounts[0],
-        ...(feePayer ? { feePayer: true } : {}),
-      }),
-    ],
-    secretKey,
-  })
-
-  const { fetch } = Mppx_client.create({
-    polyfill: false,
-    methods: [
-      tempo_client.charge({
-        account: accounts[1],
-        getClient: () => client,
-      }),
-    ],
-  })
-
-  return { fetch, mppx }
-}
-
-describe('charge', () => {
-  test('returns 402 when no credential', async () => {
-    const { mppx } = createChargeHarness(false)
-
-    const app = new Hono()
-    app.get('/', mppx.charge({ amount: '1' }), (c) => c.json({ fortune: 'You will be rich' }))
-
-    const server = await createServer(app)
-    const response = await globalThis.fetch(server.url)
-    expect(response.status).toBe(402)
-    expect(response.headers.get('WWW-Authenticate')).toContain('Payment')
-
-    server.close()
-  })
-
-  test('returns 200 with receipt on valid payment', async () => {
-    const { fetch, mppx } = createChargeHarness(false)
-
-    const app = new Hono()
-    app.get('/', mppx.charge({ amount: '1' }), (c) => c.json({ fortune: 'You will be rich' }))
-
-    const server = await createServer(app)
-    const response = await fetch(server.url)
-    expect(response.status).toBe(200)
-
-    const body = await response.json()
-    expect(body).toEqual({ fortune: 'You will be rich' })
-
-    const receipt = Receipt.fromResponse(response)
-    expect(receipt.status).toBe('success')
-    expect(receipt.method).toBe('tempo')
-
-    server.close()
-  })
-
-  test('fee payer: returns 200 with receipt on valid payment', async () => {
-    const { fetch, mppx } = createChargeHarness(true)
-
-    const app = new Hono()
-    app.get('/', mppx.charge({ amount: '1' }), (c) => c.json({ fortune: 'You will be rich' }))
-
-    const server = await createServer(app)
-    const response = await fetch(server.url)
-    expect(response.status).toBe(200)
-    expect(Receipt.fromResponse(response).status).toBe('success')
-
-    server.close()
-  })
-
-  test('serves /openapi.json via auto discovery', async () => {
-    const { mppx } = createChargeHarness(false)
-
-    const app = new Hono()
-    app.get('/', mppx.charge({ amount: '1', description: 'Daily fortune' }), (c) =>
-      c.json({ fortune: 'You will be rich' }),
-    )
-    discovery(app, mppx, { auto: true, info: { title: 'Auto API', version: '2.0.0' } })
-
-    const server = await createServer(app)
-    const response = await globalThis.fetch(`${server.url}/openapi.json`)
-    expect(response.status).toBe(200)
-    expect(response.headers.get('cache-control')).toBe('public, max-age=300')
-
-    const body = (await response.json()) as Record<string, any>
-    expect(body.info).toEqual({ title: 'Auto API', version: '2.0.0' })
-    expect(body.paths['/'].get['x-payment-info'].offers[0]).toMatchObject({
-      amount: '1000000',
-      currency: asset,
-      description: 'Daily fortune',
-      intent: 'charge',
-      method: 'tempo',
-    })
-
-    server.close()
-  })
-
-  test('serves tempo and x402 from one Hono endpoint', async () => {
-    const transaction = `0x${'2'.repeat(64)}` as const
-    const payments = ServerMppx.create({
-      methods: [
-        tempo_server.charge({
-          account: accounts[0],
-          currency: asset,
-          getClient: () => client,
-          recipient: accounts[0].address,
-        }),
-        evm_server.charge({
-          currency: evm_server.assets.baseSepolia.USDC,
-          recipient: accounts[0].address,
-          x402: {
-            facilitator: {
-              async verify(paymentPayload: PaymentPayload) {
-                return {
-                  isValid: true,
-                  payer: payerOf(paymentPayload),
-                }
-              },
-              async settle(paymentPayload: PaymentPayload) {
-                return {
-                  network: paymentPayload.accepted.network,
-                  payer: payerOf(paymentPayload),
-                  success: true,
-                  transaction,
-                }
-              },
-            },
-          },
-        }),
-      ],
-      secretKey,
-    })
-
-    const route = payments.compose(
-      [payments.tempo.charge, { amount: '0', chainId: client.chain!.id }],
-      [payments.evm.charge, { amount: '0.01' }],
-    )
-
-    const app = new Hono()
-    app.get('/paid', async (c) => {
-      const result = await route(c.req.raw)
-      if (result.status === 402) return result.challenge
-      return result.withReceipt(c.json({ data: 'paid' }))
-    })
-
-    const server = await createServer(app)
-    const challenge = await globalThis.fetch(`${server.url}/paid`)
-    expect(challenge.status).toBe(402)
-    expect(challenge.headers.get('WWW-Authenticate')).toContain('Payment')
-    expect(challenge.headers.get(paymentRequiredHeader)).toBeTruthy()
-
-    const tempoPayment = Mppx_client.create({
-      methods: [
-        tempo_client.charge({
-          account: accounts[0],
-          getClient: () => client,
-        }),
-      ],
-      polyfill: false,
-    })
-    const tempoResponse = await tempoPayment.fetch(`${server.url}/paid`)
-    expect(tempoResponse.status).toBe(200)
-    expect(await tempoResponse.json()).toEqual({ data: 'paid' })
-    expect(tempoResponse.headers.get('Payment-Receipt')).toBeTruthy()
-
-    const x402Payment = Mppx_client.create({
-      methods: [
-        evm_client.charge({
-          account: accounts[0],
-        }),
-      ],
-      polyfill: false,
-    })
-    const paymentSignature = await x402Payment.createCredential(pureX402Challenge(challenge))
-    const x402Response = await x402Payment.rawFetch(`${server.url}/paid`, {
-      headers: { [paymentSignatureHeader]: paymentSignature },
-    })
-    expect(x402Response.status).toBe(200)
-    expect(await x402Response.json()).toEqual({ data: 'paid' })
-    expect(x402Response.headers.get(paymentResponseHeader)).toBeTruthy()
-
-    server.close()
-  })
-})
-
-function payerOf(paymentPayload: PaymentPayload): string {
-  if ('authorization' in paymentPayload.payload) return paymentPayload.payload.authorization.from
-  return paymentPayload.payload.permit2Authorization.from
-}
-
-function pureX402Challenge(response: Response): Response {
-  const paymentRequired = response.headers.get(paymentRequiredHeader)
-  if (!paymentRequired) throw new Error('Missing PAYMENT-REQUIRED header.')
-  return new Response(null, {
-    headers: { [paymentRequiredHeader]: paymentRequired },
-    status: 402,
-  })
-}
-
-describe('scope binding', () => {
-  const scopeOpts = {
-    amount: '1',
-    currency: '0x0000000000000000000000000000000000000001',
-    decimals: 6,
-    recipient: '0x0000000000000000000000000000000000000002',
-  }
-
-  test('auto-injects route scope and blocks same-economics replay across routes', async () => {
-    const mppx = createScopeHarness()
-
-    const app = new Hono()
-    app.get('/alpha/:id', mppx.charge(scopeOpts), (c) => c.json({ route: 'alpha' }))
-    app.get('/beta/:id', mppx.charge(scopeOpts), (c) => c.json({ route: 'beta' }))
-
-    const server = await createServer(app)
-    const challengeResponse = await fetch(`${server.url}/alpha/1`)
-    expect(challengeResponse.status).toBe(402)
-
-    const challenge = Challenge.fromResponse(challengeResponse)
-    expect(challenge.opaque).toBe('eyJfbXBweF9zY29wZSI6IkdFVCAvYWxwaGEvOmlkIn0')
-
-    const credential = Credential.from({ challenge, payload: { token: 'valid' } })
-    const replay = await fetch(`${server.url}/beta/1`, {
-      headers: { Authorization: Credential.serialize(credential) },
-    })
-
-    expect(replay.status).toBe(402)
-    server.close()
-  })
-
-  test('manual scope overrides adapter-derived route scope', async () => {
-    const mppx = createScopeHarness()
-
-    const app = new Hono()
-    app.get('/alpha/:id', mppx.charge({ ...scopeOpts, scope: 'shared-scope' }), (c) =>
-      c.json({ route: 'alpha' }),
-    )
-    app.get('/beta/:id', mppx.charge({ ...scopeOpts, scope: 'shared-scope' }), (c) =>
-      c.json({ route: 'beta' }),
-    )
-
-    const server = await createServer(app)
-    const challengeResponse = await fetch(`${server.url}/alpha/1`)
-    expect(challengeResponse.status).toBe(402)
-
-    const challenge = Challenge.fromResponse(challengeResponse)
-    expect(challenge.opaque).toBe('eyJfbXBweF9zY29wZSI6InNoYXJlZC1zY29wZSJ9')
-
-    const credential = Credential.from({ challenge, payload: { token: 'valid' } })
-    const replay = await fetch(`${server.url}/beta/2`, {
-      headers: { Authorization: Credential.serialize(credential) },
-    })
-
-    expect(replay.status).toBe(200)
-    expect(await replay.json()).toEqual({ route: 'beta' })
-    server.close()
-  })
-})
-
-describe('session', () => {
-  function createSessionHarness(feePayer: boolean) {
-    const mppx = Mppx.create({
-      methods: [
-        tempo_server.session({
-          getClient: () => client,
-          account: accounts[0],
-          currency: asset,
-          ...(feePayer ? { feePayer: accounts[1] } : {}),
-        } as any),
-      ],
-      secretKey,
-    })
-
-    const { fetch } = Mppx_client.create({
-      polyfill: false,
-      methods: [
-        sessionIntent({
-          account: accounts[2],
-          maxDeposit: '10',
-          getClient: () => client,
-        }),
-      ],
-    })
-
-    return { fetch, mppx }
-  }
-
-  beforeAll(async () => {
-    await fundAccount({ address: accounts[1].address, token: Addresses.pathUsd })
-    await fundAccount({ address: accounts[1].address, token: asset })
-    await fundAccount({ address: accounts[2].address, token: Addresses.pathUsd })
-    await fundAccount({ address: accounts[2].address, token: asset })
-  })
-
-  test('returns 402 when no credential', async () => {
-    const { mppx } = createSessionHarness(false)
-
-    const app = new Hono()
-    app.get('/', mppx.session({ amount: '1', currency: asset, unitType: 'token' }), (c) =>
-      c.json({ data: 'streamed' }),
-    )
-
-    const server = await createServer(app)
-    const response = await globalThis.fetch(server.url)
-    expect(response.status).toBe(402)
-    expect(response.headers.get('WWW-Authenticate')).toContain('Payment')
-
-    server.close()
-  })
-
-  test('returns 200 with receipt on valid payment', async () => {
-    const { fetch, mppx } = createSessionHarness(false)
-
-    const app = new Hono()
-    app.get('/', mppx.session({ amount: '1', currency: asset, unitType: 'token' }), (c) =>
-      c.json({ data: 'streamed' }),
-    )
-
-    const server = await createServer(app)
-    const response = await fetch(server.url)
-    expect(response.status).toBe(200)
-
-    const body = await response.json()
-    expect(body).toEqual({ data: 'streamed' })
-
-    server.close()
-  })
-
-  test('fee payer: returns 200 with receipt on valid payment', async () => {
-    const { fetch, mppx } = createSessionHarness(true)
-
-    const app = new Hono()
-    app.get('/', mppx.session({ amount: '1', currency: asset, unitType: 'token' }), (c) =>
-      c.json({ data: 'streamed' }),
-    )
-
-    const server = await createServer(app)
-    const response = await fetch(server.url)
-    expect(response.status).toBe(200)
-    expect(Receipt.fromResponse(response).status).toBe('success')
-
-    server.close()
-  })
-})

package/src/middlewares/hono.ts

@@ -1,153 +0,0 @@
-import type { Hono, MiddlewareHandler } from 'hono'
-
-import { generate, type GenerateConfig, type RouteConfig } from '../discovery/OpenApi.js'
-import * as Scope from '../server/internal/scope.js'
-import * as Mppx_core from '../server/Mppx.js'
-import * as Mppx_internal from './internal/mppx.js'
-
-export * from '../server/Methods.js'
-
-export namespace Mppx {
-  /**
-   * Creates a Hono-aware payment handler where each intent
-   * returns a Hono `MiddlewareHandler`.
-   *
-   * @example
-   * ```ts
-   * import { Hono } from 'hono'
-   * import { Mppx, tempo } from 'mppx/hono'
-   *
-   * const app = new Hono()
-   * const mppx = Mppx.create({ methods: [tempo()] })
-   *
-   * app.get('/premium', mppx.charge({ amount: '1' }), (c) =>
-   *   c.json({ data: 'paid content' }),
-   * )
-   * ```
-   */
-  export function create<const methods extends Mppx_core.Methods>(
-    config: Mppx_core.create.Config<methods>,
-  ): Mppx_internal.Wrap<Mppx_core.Mppx<methods>, MiddlewareHandler> {
-    return Mppx_internal.wrap(Mppx_core.create(config), payment)
-  }
-}
-
-/**
- * Hono middleware that gates a route behind a payment intent.
- *
- * Returns a 402 challenge if no valid credential is provided,
- * otherwise attaches a `Payment-Receipt` header to the response.
- *
- * @example
- * ```ts
- * import { Hono } from 'hono'
- * import { Mppx } from 'mppx/server'
- * import { payment } from 'mppx/hono'
- *
- * const mppx = Mppx.create({ methods: [tempo()] })
- *
- * const app = new Hono()
- * app.get('/premium', payment(mppx.charge, { amount: '1' }), (c) =>
- *   c.json({ data: 'paid content' }),
- * )
- * ```
- */
-export function payment<const intent extends Mppx_internal.AnyMethodFn>(
-  intent: intent,
-  options: intent extends (options: infer options) => any ? options : never,
-): MiddlewareHandler {
-  return async (c, next) => {
-    const request =
-      options.scope === undefined && Scope.read(options.meta) === undefined
-        ? Scope.attach(c.req.raw, `${c.req.method.toUpperCase()} ${c.req.routePath || c.req.path}`)
-        : c.req.raw
-    const result = await intent(options)(request)
-    if (result.status === 402) return result.challenge
-    const managementResponse = getManagementResponse(result)
-    if (managementResponse) return managementResponse
-    await next()
-    c.res = result.withReceipt(c.res)
-  }
-}
-
-function getManagementResponse(result: { withReceipt: (response?: Response) => Response }) {
-  try {
-    return result.withReceipt()
-  } catch (error) {
-    if (Mppx_core.isMissingReceiptResponseError(error)) {
-      return null
-    }
-    throw error
-  }
-}
-
-export type DiscoveryConfig = Omit<GenerateConfig, 'routes'> & {
-  auto?: boolean
-  path?: string
-  routes?: RouteConfig[]
-}
-
-const discoveryHeaders = { 'Cache-Control': 'public, max-age=300' }
-
-/**
- * Mounts a `GET /openapi.json` route that serves an OpenAPI discovery document.
- *
- * When `auto` is true, routes are introspected from Hono's internal `app.routes`
- * array. This is a **best-effort / experimental** convenience — `app.routes` is
- * not part of Hono's stable public API and may change across versions. Prefer
- * passing explicit `routes` for production use.
- */
-export function discovery(
-  app: Hono<any>,
-  mppx: { methods: readonly Mppx_internal.AnyServer[]; realm: string },
-  config: DiscoveryConfig = {},
-): void {
-  const mountPath = config.path ?? '/openapi.json'
-
-  let cached: string | undefined
-
-  app.get(mountPath, (c) => {
-    if (!cached) {
-      const routes = config.routes ?? (config.auto ? introspectRoutes(app) : [])
-      const doc = generate(mppx, {
-        ...(config.info ? { info: config.info } : {}),
-        routes,
-        ...(config.serviceInfo ? { serviceInfo: config.serviceInfo } : {}),
-      })
-      cached = JSON.stringify(doc)
-    }
-
-    c.header('Cache-Control', discoveryHeaders['Cache-Control'])
-    c.header('Content-Type', 'application/json')
-    return c.body(cached)
-  })
-}
-
-function introspectRoutes(app: Hono<any>): RouteConfig[] {
-  const routes: RouteConfig[] = []
-  const appRoutes = (app as any).routes as
-    | { handler: any; method: string; path: string }[]
-    | undefined
-
-  if (!appRoutes) return routes
-
-  const seen = new Set<string>()
-
-  for (const route of appRoutes) {
-    const internal = (route.handler as { _internal?: Record<string, unknown> } | undefined)
-      ?._internal
-    if (!internal) continue
-
-    const key = `${route.method}:${route.path}:${internal.name}/${internal.intent}`
-    if (seen.has(key)) continue
-    seen.add(key)
-
-    routes.push({
-      handler: route.handler,
-      method: route.method,
-      path: route.path,
-    })
-  }
-
-  return routes
-}