@routedock/routedock 0.1.2 → 0.3.0

package/src/client/x402Client.ts

@@ -1,84 +0,0 @@
-import { createEd25519Signer } from '@x402/stellar'
-import { ExactStellarScheme } from '@x402/stellar/exact/client'
-import { x402Client, x402HTTPClient } from '@x402/core/client'
-import {
-  decodePaymentRequiredHeader,
-  decodePaymentResponseHeader,
-  encodePaymentSignatureHeader,
-} from '@x402/core/http'
-import type { Network as X402Network } from '@x402/core/types'
-import type { RouteDockManifest, PaymentResult } from '../types.js'
-import { RouteDockManifestError } from '../types.js'
-
-type Network = 'testnet' | 'mainnet'
-
-const CAIP2: Record<Network, X402Network> = {
-  testnet: 'stellar:testnet',
-  mainnet: 'stellar:pubnet',
-}
-
-export class X402Client {
-  private readonly httpClient: x402HTTPClient
-
-  constructor(
-    private readonly secretKey: string,
-    private readonly network: Network,
-  ) {
-    const caip2 = CAIP2[network]
-    const signer = createEd25519Signer(secretKey, caip2)
-    const scheme = new ExactStellarScheme(signer)
-    const core = new x402Client()
-    core.register(caip2, scheme)
-    this.httpClient = new x402HTTPClient(core)
-  }
-
-  async pay(url: string, manifest: RouteDockManifest): Promise<PaymentResult> {
-    const pricing = manifest.pricing.x402
-    if (!pricing) {
-      throw new RouteDockManifestError('manifest.pricing.x402 missing')
-    }
-    if (!pricing.facilitator) {
-      throw new RouteDockManifestError('manifest.pricing.x402.facilitator missing')
-    }
-
-    // Initial request — expect 402. Include mode hint so middleware routes correctly.
-    const init = await fetch(url, { headers: { 'X-Preferred-Mode': 'x402' } })
-    if (init.status !== 402) {
-      const data = await init.json()
-      return { data, txHash: null, mode: 'x402', amount: pricing.amount, timestamp: Date.now() }
-    }
-
-    // Parse payment requirements from header
-    const reqHeader = init.headers.get('X-Payment-Requirements')
-    if (!reqHeader) {
-      throw new RouteDockManifestError('402 response missing X-Payment-Requirements header')
-    }
-
-    const paymentRequired = decodePaymentRequiredHeader(reqHeader)
-
-    // Build signed payment payload
-    const paymentPayload = await this.httpClient.createPaymentPayload(paymentRequired)
-    const paymentHeaders = this.httpClient.encodePaymentSignatureHeader(paymentPayload)
-
-    // Re-request with payment
-    const settled = await fetch(url, { headers: paymentHeaders })
-    if (!settled.ok) {
-      throw new RouteDockManifestError(`x402 payment failed: HTTP ${settled.status}`)
-    }
-
-    // Extract settlement tx hash from response header
-    let txHash: string | null = null
-    const responseHeader = settled.headers.get('X-Payment-Response')
-    if (responseHeader) {
-      try {
-        const settleResponse = decodePaymentResponseHeader(responseHeader)
-        txHash = (settleResponse as { transaction?: string }).transaction ?? null
-      } catch {
-        // non-fatal — some facilitators may omit the response header
-      }
-    }
-
-    const data = await settled.json()
-    return { data, txHash, mode: 'x402', amount: pricing.amount, timestamp: Date.now() }
-  }
-}

package/src/index.ts

@@ -1,9 +0,0 @@
-// Full SDK — types, client, provider, store
-export * from './types.js'
-export * from './client/RouteDockClient.js'
-export * from './client/ModeRouter.js'
-export * from './client/x402Client.js'
-export * from './client/MppChargeClient.js'
-export * from './client/MppSessionClient.js'
-export * from './store/SessionStore.js'
-export * from './provider/routedockMiddleware.js'

package/src/provider/MppChargeHandler.ts

@@ -1,90 +0,0 @@
-import type { Request, Response, NextFunction, RequestHandler } from 'express'
-import { stellar } from '@stellar/mpp/charge/server'
-import { Mppx, Request as MppxRequest } from 'mppx/server'
-import type { RouteDockManifest } from '../types.js'
-import type { SessionStore } from '../store/SessionStore.js'
-
-type Network = 'testnet' | 'mainnet'
-
-const MPP_NETWORK: Record<Network, 'stellar:testnet' | 'stellar:pubnet'> = {
-  testnet: 'stellar:testnet',
-  mainnet: 'stellar:pubnet',
-}
-
-export interface MppChargeHandlerOptions {
-  payeeSecretKey: string
-  network: Network
-  amount: string
-  assetContract: string
-  manifest: RouteDockManifest
-  store?: SessionStore
-  onSettled?: (txHash: string, amount: string, mode: string) => Promise<void>
-}
-
-export function createMppChargeHandler(opts: MppChargeHandlerOptions): RequestHandler {
-  const networkId = MPP_NETWORK[opts.network]
-  const amountHumanReadable = opts.amount
-
-  const mppx = Mppx.create({
-    secretKey: opts.payeeSecretKey,
-    methods: [
-      stellar.charge({
-        recipient: opts.manifest.payee,
-        currency: opts.assetContract,
-        network: networkId,
-        feePayer: { envelopeSigner: opts.payeeSecretKey },
-      }),
-    ],
-  })
-
-  return async (req: Request, res: Response, next: NextFunction): Promise<void> => {
-    try {
-      const fetchReq = MppxRequest.fromNodeListener(req, res)
-      // `mppx['stellar/charge']` — method key is `name/intent`
-      const handler = (
-        mppx as unknown as {
-          'stellar/charge': (
-            opts: { amount: string; currency: string; recipient: string; description?: string },
-          ) => (input: globalThis.Request) => Promise<{ status: 402 | 200; challenge?: globalThis.Response; withReceipt?: (r: globalThis.Response) => globalThis.Response }>
-        }
-      )['stellar/charge']
-      const result = await handler({
-        amount: amountHumanReadable,
-        currency: opts.assetContract,
-        recipient: opts.manifest.payee,
-        description: opts.manifest.name,
-      })(fetchReq)
-
-      if (result.status === 402) {
-        const challenge = result.challenge!
-        res.status(402)
-        challenge.headers.forEach((v: string, k: string) => res.setHeader(k, v))
-        res.send(await challenge.text())
-        return
-      }
-
-      // status 200 — payment verified
-      const receipt = result.withReceipt!(new Response(''))
-      receipt.headers.forEach((v: string, k: string) => res.setHeader(k, v))
-
-      // Extract tx hash from receipt headers if available
-      const receiptHeader = receipt.headers.get('payment-receipt')
-      if (receiptHeader && opts.onSettled) {
-        try {
-          const parsed = JSON.parse(
-            Buffer.from(receiptHeader, 'base64').toString('utf8'),
-          ) as { reference?: string }
-          if (parsed.reference) {
-            await opts.onSettled(parsed.reference, opts.amount, 'mpp-charge')
-          }
-        } catch {
-          // non-fatal
-        }
-      }
-
-      next()
-    } catch (err) {
-      next(err)
-    }
-  }
-}

package/src/provider/MppSessionHandler.ts

@@ -1,157 +0,0 @@
-import type { Request, Response, NextFunction, RequestHandler } from 'express'
-import { Keypair } from '@stellar/stellar-sdk'
-import { stellar, close as channelClose, Store } from '@stellar/mpp/channel/server'
-import { Mppx, Request as MppxRequest } from 'mppx/server'
-import type { RouteDockManifest } from '../types.js'
-
-type Network = 'testnet' | 'mainnet'
-
-const MPP_NETWORK: Record<Network, 'stellar:testnet' | 'stellar:pubnet'> = {
-  testnet: 'stellar:testnet',
-  mainnet: 'stellar:pubnet',
-}
-
-export interface MppSessionHandlerOptions {
-  payeeSecretKey: string
-  network: Network
-  channelContract: string
-  rate: string
-  assetContract: string
-  manifest: RouteDockManifest
-  commitmentPublicKey: string
-  onSettled?: (txHash: string, totalPaid: string, mode: string) => Promise<void>
-  onSessionOpen?: (channelId: string) => Promise<void>
-  onVoucher?: (voucherIndex: number, cumulativeAmount: string) => Promise<void>
-}
-
-export function createMppSessionHandler(opts: MppSessionHandlerOptions): RequestHandler {
-  const networkId = MPP_NETWORK[opts.network]
-  const rateHuman = opts.rate
-  const payeeKeypair = Keypair.fromSecret(opts.payeeSecretKey)
-  const cumulativeKey = `stellar:channel:cumulative:${opts.channelContract}`
-
-  const innerStore = Store.memory()
-
-  let lastCumulativeAmount = 0n
-  let voucherCount = 0
-  let sessionOpened = false
-
-  const wrappedStore: ReturnType<typeof Store.memory> = {
-    async get(key: string) { return innerStore.get(key) },
-    async put(key: string, value: unknown) {
-      await innerStore.put(key, value)
-      if (key === cumulativeKey && value && typeof value === 'object' && 'amount' in (value as Record<string, unknown>)) {
-        lastCumulativeAmount = BigInt((value as { amount: string }).amount)
-        voucherCount++
-
-        if (!sessionOpened) {
-          sessionOpened = true
-          if (opts.onSessionOpen) {
-            await opts.onSessionOpen(opts.channelContract)
-          }
-        }
-
-        if (opts.onVoucher) {
-          const humanAmount = (Number(lastCumulativeAmount) / 1e7).toFixed(7)
-          await opts.onVoucher(voucherCount, humanAmount)
-        }
-      }
-    },
-    async delete(key: string) { return innerStore.delete(key) },
-  }
-
-  const mppx = Mppx.create({
-    secretKey: opts.payeeSecretKey,
-    methods: [
-      stellar.channel({
-        channel: opts.channelContract,
-        commitmentKey: opts.commitmentPublicKey,
-        network: networkId,
-        store: wrappedStore,
-        sourceAccount: payeeKeypair.publicKey(),
-        feePayer: { envelopeSigner: payeeKeypair },
-      }),
-    ],
-  })
-
-  // Track the last signature from the authorization header
-  let lastSignatureHex = ''
-
-  return async (req: Request, res: Response, next: NextFunction): Promise<void> => {
-    try {
-      if (req.method === 'DELETE') {
-        const body = req.body as { amount?: string; signature?: string } | undefined
-        const closeAmount = body?.amount ? BigInt(body.amount) : lastCumulativeAmount
-        const closeSig = body?.signature ?? lastSignatureHex
-
-        if (closeAmount > 0n && closeSig) {
-          const closeTxHash = await channelClose({
-            channel: opts.channelContract,
-            amount: closeAmount,
-            signature: Buffer.from(closeSig, 'hex'),
-            feePayer: { envelopeSigner: payeeKeypair },
-            network: networkId,
-          })
-
-          if (opts.onSettled) {
-            const totalPaid = (Number(lastCumulativeAmount) / 1e7).toFixed(7)
-            await opts.onSettled(closeTxHash, totalPaid, 'mpp-session')
-          }
-
-          res.json({ closeTxHash })
-        } else {
-          res.json({ closeTxHash: null, message: 'no vouchers received' })
-        }
-
-        sessionOpened = false
-        voucherCount = 0
-        lastCumulativeAmount = 0n
-        return
-      }
-
-      // Extract the signature from the authorization header before passing to mppx
-      const authHeader = req.headers['authorization']
-      if (typeof authHeader === 'string' && authHeader.startsWith('Payment ')) {
-        try {
-          const credB64 = authHeader.replace(/^Payment\s+/, '').split(',').find(p => p.trim().startsWith('credential='))
-          if (credB64) {
-            const credJson = Buffer.from(credB64.split('=').slice(1).join('=').replace(/^"|"$/g, ''), 'base64').toString('utf8')
-            const cred = JSON.parse(credJson) as { payload?: { signature?: string } }
-            if (cred.payload?.signature) {
-              lastSignatureHex = cred.payload.signature
-            }
-          }
-        } catch {
-          // non-fatal — signature extraction is best-effort
-        }
-      }
-
-      const fetchReq = MppxRequest.fromNodeListener(req, res)
-
-      const result = await (mppx as unknown as {
-        channel: (o: { amount: string; description?: string }) =>
-          (r: globalThis.Request) => Promise<{
-            status: number
-            challenge?: globalThis.Response
-            withReceipt?: (r: globalThis.Response) => globalThis.Response
-          }>
-      }).channel({
-        amount: rateHuman,
-        description: opts.manifest.name,
-      })(fetchReq)
-
-      if (result.status === 402) {
-        const challenge = result.challenge!
-        res.status(402)
-        challenge.headers.forEach((v: string, k: string) => res.setHeader(k, v))
-        const body = await challenge.text()
-        res.send(body)
-        return
-      }
-
-      next()
-    } catch (err) {
-      next(err)
-    }
-  }
-}

package/src/provider/index.ts

@@ -1,7 +0,0 @@
-// Provider-only exports (Express middleware + handlers)
-export * from '../types.js'
-export * from './routedockMiddleware.js'
-export * from './x402Handler.js'
-export * from './MppChargeHandler.js'
-export * from './MppSessionHandler.js'
-export * from '../store/SessionStore.js'

package/src/provider/routedockMiddleware.ts

@@ -1,154 +0,0 @@
-import type { Request, Response, NextFunction, RequestHandler } from 'express'
-import { createX402Handler } from './x402Handler.js'
-import { createMppChargeHandler } from './MppChargeHandler.js'
-import { createMppSessionHandler } from './MppSessionHandler.js'
-import type { RouteDockManifest, PaymentMode } from '../types.js'
-
-export interface RouteDockMiddlewareOptions {
-  modes: PaymentMode[]
-  pricing: {
-    x402?: string
-    'mpp-charge'?: string
-    'mpp-session'?: { rate: string; channelContract: string }
-  }
-  asset: string
-  /** Stellar Asset Contract address for the payment asset */
-  assetContract: string
-  payee: string
-  network: 'testnet' | 'mainnet'
-  /** Private key (S...) of the server/payee account */
-  payeeSecretKey: string
-  /** Required for x402 mode */
-  facilitatorApiKey?: string
-  /** Required for mpp-session mode — ed25519 public key (G...) for verifying commitments */
-  commitmentPublicKey?: string
-  /** Full RouteDock manifest — served at /.well-known/routedock.json */
-  manifest: RouteDockManifest
-  /** Called after each successful on-chain settlement */
-  onSettled?: (txHash: string, amount: string, mode: string) => Promise<void>
-  /** Called when a new mpp-session is opened (first voucher received) */
-  onSessionOpen?: (channelId: string) => Promise<void>
-  /** Called after each verified voucher in an mpp-session */
-  onVoucher?: (voucherIndex: number, cumulativeAmount: string) => Promise<void>
-}
-
-/**
- * Express middleware factory for RouteDock provider endpoints.
- *
- * Automatically serves /.well-known/routedock.json and enforces payment
- * verification for all three modes (x402, mpp-charge, mpp-session).
- *
- * @example
- * ```ts
- * import { routedock } from '@routedock/sdk/provider'
- *
- * app.use('/price', routedock({
- *   modes: ['x402', 'mpp-charge'],
- *   pricing: { x402: '0.001', 'mpp-charge': '0.0008' },
- *   ...
- * }))
- * ```
- */
-export function routedock(opts: RouteDockMiddlewareOptions): RequestHandler {
-  const handlers: RequestHandler[] = []
-
-  if (opts.modes.includes('x402')) {
-    const x402Price = opts.pricing.x402
-    if (x402Price) {
-      handlers.push(
-        createX402Handler({
-          payeeSecretKey: opts.payeeSecretKey,
-          network: opts.network,
-          amount: x402Price,
-          assetContract: opts.assetContract,
-          ...(opts.facilitatorApiKey ? { facilitatorApiKey: opts.facilitatorApiKey } : {}),
-          manifest: opts.manifest,
-          ...(opts.onSettled ? { onSettled: opts.onSettled } : {}),
-        }),
-      )
-    }
-  }
-
-  if (opts.modes.includes('mpp-charge')) {
-    const chargePrice = opts.pricing['mpp-charge']
-    if (chargePrice) {
-      handlers.push(
-        createMppChargeHandler({
-          payeeSecretKey: opts.payeeSecretKey,
-          network: opts.network,
-          amount: chargePrice,
-          assetContract: opts.assetContract,
-          manifest: opts.manifest,
-          ...(opts.onSettled ? { onSettled: opts.onSettled } : {}),
-        }),
-      )
-    }
-  }
-
-  if (opts.modes.includes('mpp-session')) {
-    const sessionPricing = opts.pricing['mpp-session']
-    if (sessionPricing) {
-      if (!opts.commitmentPublicKey) {
-        throw new Error('routedock: mpp-session mode requires commitmentPublicKey')
-      }
-      handlers.push(
-        createMppSessionHandler({
-          payeeSecretKey: opts.payeeSecretKey,
-          network: opts.network,
-          channelContract: sessionPricing.channelContract,
-          rate: sessionPricing.rate,
-          assetContract: opts.assetContract,
-          manifest: opts.manifest,
-          commitmentPublicKey: opts.commitmentPublicKey,
-          ...(opts.onSettled ? { onSettled: opts.onSettled } : {}),
-          ...(opts.onSessionOpen ? { onSessionOpen: opts.onSessionOpen } : {}),
-          ...(opts.onVoucher ? { onVoucher: opts.onVoucher } : {}),
-        }),
-      )
-    }
-  }
-
-  return (req: Request, res: Response, next: NextFunction): void => {
-    // Serve manifest at /.well-known/routedock.json
-    if (req.path === '/.well-known/routedock.json') {
-      res.json(opts.manifest)
-      return
-    }
-
-    // No handlers — pass through
-    if (handlers.length === 0) {
-      next()
-      return
-    }
-
-    // Route to the correct handler based on request headers.
-    // x402 clients send `payment-signature` or `x-payment` headers.
-    // mppx clients send `authorization` with the mppx bearer scheme.
-    // On initial request (no payment), use the last handler (mppx returns
-    // WWW-Authenticate which x402 clients ignore; x402 only runs when its
-    // header is explicitly present).
-    const hasX402Header = !!(req.headers['payment-signature'] || req.headers['x-payment'])
-    const prefersX402 = req.headers['x-preferred-mode'] === 'x402'
-
-    let handler: RequestHandler | undefined
-    if (hasX402Header || prefersX402) {
-      handler = handlers[0]
-    } else {
-      handler = handlers[handlers.length - 1]
-    }
-
-    if (!handler) {
-      next()
-      return
-    }
-    void Promise.resolve()
-      .then(() => new Promise<void>((resolve, reject) => {
-        handler!(req, res, (handlerErr?: unknown) => {
-          if (handlerErr != null) reject(handlerErr)
-          else resolve()
-        })
-      }))
-      .then(() => next())
-      .catch((err) => next(err))
-  }
-}

package/src/provider/x402Handler.ts

@@ -1,164 +0,0 @@
-import type { Request, Response, NextFunction, RequestHandler } from 'express'
-import { Keypair } from '@stellar/stellar-sdk'
-import { ExactStellarScheme as ExactStellarFacilitatorScheme } from '@x402/stellar/exact/facilitator'
-import { ExactStellarScheme as ExactStellarServerScheme } from '@x402/stellar/exact/server'
-import { HTTPFacilitatorClient, x402ResourceServer } from '@x402/core/server'
-import { createEd25519Signer } from '@x402/stellar'
-import {
-  decodePaymentSignatureHeader,
-  encodePaymentRequiredHeader,
-  encodePaymentResponseHeader,
-} from '@x402/core/http'
-import type { Network as X402Network } from '@x402/core/types'
-import type { RouteDockManifest } from '../types.js'
-
-type Network = 'testnet' | 'mainnet'
-
-const CAIP2: Record<Network, X402Network> = {
-  testnet: 'stellar:testnet',
-  mainnet: 'stellar:pubnet',
-}
-
-const OZ_FACILITATOR_URL = 'https://channels.openzeppelin.com/x402'
-
-export interface X402HandlerOptions {
-  payeeSecretKey: string
-  network: Network
-  amount: string
-  assetContract: string
-  facilitatorApiKey?: string
-  manifest: RouteDockManifest
-  onSettled?: (txHash: string, amount: string, mode: string) => Promise<void>
-}
-
-export function createX402Handler(opts: X402HandlerOptions): RequestHandler {
-  const caip2 = CAIP2[opts.network]
-  const payeeKeypair = Keypair.fromSecret(opts.payeeSecretKey)
-  const signer = createEd25519Signer(opts.payeeSecretKey, caip2)
-
-  const useOzFacilitator = opts.network === 'mainnet' && opts.facilitatorApiKey
-
-  // Mainnet: OZ hosted facilitator via x402ResourceServer
-  // Testnet: local ExactStellarFacilitatorScheme (OZ facilitator does not serve testnet)
-  const localFacilitator = new ExactStellarFacilitatorScheme([signer], {
-    areFeesSponsored: true,
-  })
-
-  let ozServer: x402ResourceServer | null = null
-  if (useOzFacilitator) {
-    const apiKey = opts.facilitatorApiKey!
-    const facilitator = new HTTPFacilitatorClient({
-      url: OZ_FACILITATOR_URL,
-      createAuthHeaders: async () => ({
-        verify: { Authorization: `Bearer ${apiKey}` },
-        settle: { Authorization: `Bearer ${apiKey}` },
-        supported: { Authorization: `Bearer ${apiKey}` },
-      }),
-    })
-    ozServer = new x402ResourceServer(facilitator)
-    ozServer.register(caip2, new ExactStellarServerScheme())
-  }
-
-  const amountInBaseUnits = String(Math.round(parseFloat(opts.amount) * 1e7))
-  const requirements = {
-    scheme: 'exact' as const,
-    network: caip2,
-    asset: opts.assetContract,
-    amount: amountInBaseUnits,
-    payTo: opts.manifest.payee,
-    maxTimeoutSeconds: 60,
-    extra: {
-      areFeesSponsored: true,
-      ...(useOzFacilitator ? {} : { facilitatorAddresses: [payeeKeypair.publicKey()] }),
-    },
-  }
-
-  return async (req: Request, res: Response, next: NextFunction): Promise<void> => {
-    try {
-      const paymentHeader = (req.headers['payment-signature'] ?? req.headers['x-payment']) as string | undefined
-
-      if (!paymentHeader) {
-        if (ozServer) {
-          const resourceInfo = {
-            url: `${req.protocol}://${req.get('host') ?? ''}${req.originalUrl}`,
-            description: opts.manifest.name,
-          }
-          const paymentRequired = await ozServer.createPaymentRequiredResponse(
-            [requirements],
-            resourceInfo,
-          )
-          res
-            .status(402)
-            .setHeader('Content-Type', 'application/json')
-            .setHeader('X-Payment-Requirements', encodePaymentRequiredHeader(paymentRequired))
-            .json({ error: 'Payment Required' })
-        } else {
-          const x402Response = {
-            x402Version: 2,
-            resource: {
-              url: `${req.protocol}://${req.get('host') ?? ''}${req.originalUrl}`,
-              description: opts.manifest.name,
-            },
-            accepts: [requirements],
-          }
-          res
-            .status(402)
-            .setHeader('Content-Type', 'application/json')
-            .setHeader('X-Payment-Requirements', encodePaymentRequiredHeader(x402Response))
-            .json({ error: 'Payment Required' })
-        }
-        return
-      }
-
-      const payload = decodePaymentSignatureHeader(paymentHeader)
-      let txHash: string | null = null
-
-      if (ozServer) {
-        const settleResult = await ozServer.settlePayment(payload, requirements)
-        txHash = (settleResult as { transaction?: string }).transaction ?? null
-        if (settleResult) {
-          res.setHeader(
-            'X-Payment-Response',
-            encodePaymentResponseHeader(
-              settleResult as Parameters<typeof encodePaymentResponseHeader>[0],
-            ),
-          )
-        }
-      } else {
-        const verifyResult = await localFacilitator.verify(
-          payload as Parameters<typeof localFacilitator.verify>[0],
-          requirements,
-        )
-        if (!verifyResult.isValid) {
-          res.status(401).json({
-            error: 'Payment verification failed',
-            reason: (verifyResult as { invalidReason?: string }).invalidReason,
-          })
-          return
-        }
-        const settleResult = await localFacilitator.settle(
-          payload as Parameters<typeof localFacilitator.settle>[0],
-          requirements,
-        )
-        txHash = (settleResult as { transaction?: string }).transaction ?? null
-        if (settleResult) {
-          res.setHeader(
-            'X-Payment-Response',
-            encodePaymentResponseHeader(
-              settleResult as Parameters<typeof encodePaymentResponseHeader>[0],
-            ),
-          )
-        }
-      }
-
-      if (txHash && opts.onSettled) {
-        await opts.onSettled(txHash, opts.amount, 'x402')
-      }
-
-      next()
-    } catch (err) {
-      console.error('[x402] Settlement error:', err)
-      res.status(500).json({ error: 'Payment settlement failed' })
-    }
-  }
-}