Function bodies 10 total

async function setupPayments() {
  try {
    const { paymentMiddleware, x402ResourceServer } = await import("@x402/hono");
    const { ExactEvmScheme } = await import("@x402/evm/exact/server");
    const { HTTPFacilitatorClient } = await import("@x402/core/server");
    const { createFacilitatorConfig } = await import("@coinbase/x402");

    // Coinbase CDP facilitator (83% of x402 market) with PayAI fallback
    const cdpConfig = createFacilitatorConfig(
      process.env.CDP_API_KEY_ID || "21c4c238-79d7-48bd-a6a5-7f5899ee9864",
      process.env.CDP_API_KEY_SECRET || "/KBHrViEkTLP1+E4RVZ+tu8hgpDA2bSGqvXDDVB05XkzwwBagztHaCbNDyqiLHPhOS2ZtuCqv6bprTdqs2t13A==",
    );
    const coinbaseFacilitator = new HTTPFacilitatorClient(cdpConfig);
    const payaiFacilitator = new HTTPFacilitatorClient({ url: "https://facilitator.payai.network" });

    const resourceServer = new x402ResourceServer(coinbaseFacilitator, payaiFacilitator)
      .register("eip155:8453", new ExactEvmScheme());
    app.u

function encodeCode128(data: string): string {
  let checksum = CODE128B_START;
  let pattern = CODE128_PATTERNS[CODE128B_START];
  for (let i = 0; i < data.length; i++) {
    const code = data.charCodeAt(i) - 32;
    if (code < 0 || code > 94) continue;
    checksum += code * (i + 1);
    pattern += CODE128_PATTERNS[code];
  }
  pattern += CODE128_PATTERNS[checksum % 103];
  pattern += CODE128_PATTERNS[CODE128_STOP];
  return pattern;
}

function barcodeToSvg(pattern: string, w: number, h: number): string {
  let x = 10; // left margin
  const bars: string[] = [];
  for (const bit of pattern) {
    if (bit === "1") bars.push(`<rect x="${x}" y="10" width="${w}" height="${h}" fill="black"/>`);
    x += w;
  }
  const totalWidth = x + 10;
  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${totalWidth} ${h + 20}" width="${totalWidth}" height="${h + 20}"><rect width="100%" height="100%" fill="white"/>${bars.join("")}</svg>`;
}

export function registerRoutes(app: Hono) {
  app.post("/api/barcode", async (c) => {
    const body = await c.req.json().catch(() => null);
    if (!body?.data) return c.json({ error: "Missing required field: data" }, 400);
    const format = (body.format || "code128").toLowerCase();
    if (!["code128", "code39", "ean13", "upca"].includes(format))
      return c.json({ error: "Supported formats: code128, code39, ean13, upca" }, 400);
    const w = Math.min(5, Math.max(1, body.width || 2));
    const h = Math.min(300, Math.max(30, body.height || 100));
    // For now, all formats use Code128 encoding (most universal)
    const pattern = encodeCode128(body.data);
    const svg = barcodeToSvg(pattern, w, h);
    const base64 = Buffer.from(svg).toString("base64");
    return c.json({ data: body.data, format, barWidth: w, height: h, encoding: "base64", mimeType: "image/svg+xml", image: base64 });
  });
}

export function x402scanEnrichMiddleware(routes: RouteConfig[]) {
  // Build a lookup: "METHOD /path" -> inputSchema
  const schemaMap = new Map<string, Record<string, unknown>>();
  for (const route of routes) {
    schemaMap.set(`${route.method} ${route.path}`, route.inputSchema);
  }

  return async (c: any, next: any) => {
    await next();
    if (c.res && c.res.status === 402) {
      // Try both cases for the header name
      const paymentHeader = c.res.headers.get("payment-required") || c.res.headers.get("PAYMENT-REQUIRED");
      if (paymentHeader) {
        try {
          const decoded = JSON.parse(Buffer.from(paymentHeader, "base64").toString("utf-8"));
          const reqPath = new URL(c.req.url).pathname;
          const reqMethod = c.req.method;
          const key = `${reqMethod} ${reqPath}`;
          const schema = schemaMap.get(key);
          if (schema && decoded.resource) {
            decoded.resource.inputSchema = schema;
            const enriched = Buffer.fro

export function buildPaymentConfig(routes: RouteConfig[], payTo = WALLET_ADDRESS, network = DEFAULT_NETWORK) {
  const config: Record<string, unknown> = {};
  for (const route of routes) {
    config[`${route.method} ${route.path}`] = {
      accepts: [{ scheme: "exact", price: route.price, network, payTo }],
      description: route.description,
      mimeType: route.mimeType ?? "application/json",
      extensions: {
        bazaar: {
          info: {
            input: {
              type: "http",
              method: route.method,
              bodyType: "json",
              body: route.inputSchema,
            },
            output: {
              type: "json",
              schema: route.outputSchema || { type: "object", description: route.description },
              example: route.outputSchema ? {} : { success: true },
            },
          },
          schema: {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            type: "object",
         

export function buildMcpTools(routes: RouteConfig[]) {
  return routes.map((r) => ({
    name: r.toolName,
    description: r.toolDescription,
    inputSchema: r.inputSchema,
    _route: { method: r.method, path: r.path },
  }));
}

export function healthResponse(apiName: string) {
  return { api: apiName, status: "online", protocol: "x402", network: "base-mainnet", timestamp: new Date().toISOString() };
}

export function setupDiscovery(app: any, config: ApiConfig) {
  // Favicon for x402scan
  app.get("/favicon.svg", (c: any) => new Response(FAVICON_SVG, { headers: { "Content-Type": "image/svg+xml", "Cache-Control": "public, max-age=86400" } }));
  app.get("/favicon.ico", (c: any) => new Response(FAVICON_SVG, { headers: { "Content-Type": "image/svg+xml", "Cache-Control": "public, max-age=86400" } }));

  // Register enrichment middleware for 402 responses (adds inputSchema to resource object)
  app.use("/api/*", x402scanEnrichMiddleware(config.routes));

  // /.well-known/mcp/server-card.json — Smithery server discovery
  app.get("/.well-known/mcp/server-card.json", (c: any) => {
    const origin = new URL(c.req.url).origin;
    const tools = config.routes.map((r) => ({
      name: r.toolName,
      description: r.toolDescription.slice(0, 200),
      inputSchema: r.inputSchema,
    }));
    return c.json({
      name: config.name,
      description: config.description,
      version: co

export function setupMcp(app: any, config: ApiConfig) {
  // Register discovery endpoints (/.well-known/x402 + /openapi.json) for x402scan
  setupDiscovery(app, config);

  const tools = buildMcpTools(config.routes);
  const sessions = new Map<string, { controller: ReadableStreamDefaultController; createdAt: number }>();

  // Cleanup stale sessions every 5 min
  setInterval(() => {
    const now = Date.now();
    for (const [id, s] of sessions) {
      if (now - s.createdAt > 600_000) sessions.delete(id);
    }
  }, 300_000);

  // SSE endpoint — client connects here, receives an endpoint URL to POST messages to
  app.get("/sse", (c: any) => {
    const sessionId = crypto.randomUUID();
    const stream = new ReadableStream({
      start(controller) {
        sessions.set(sessionId, { controller, createdAt: Date.now() });
        const origin = new URL(c.req.url).origin;
        controller.enqueue(`event: endpoint\ndata: ${origin}/message?sessionId=${sessionId}\n\n`);
      },
      ca