aipp-node 1.2.0 → 1.2.1

package/dist/client.d.ts

@@ -0,0 +1,29 @@
+import { AippConfig, ChargeParams, ChargeResponse, ChargeStatus, ReceiptResponse, MarketplaceManifest } from './types';
+export declare class Aipp {
+    private apiKey;
+    private baseUrl;
+    constructor(config: AippConfig);
+    private request;
+    /**
+     * Creates a new Invoice (either L402 or x402)
+     */
+    createCharge(params: ChargeParams): Promise<ChargeResponse>;
+    /**
+     * Checks the status of an existing charge
+     */
+    getCharge(paymentHash: string, txHash?: string): Promise<ChargeStatus>;
+    /**
+     * Triggers a manual withdrawal of your merchant balance
+     */
+    payout(): Promise<import('./types').PayoutResponse>;
+    /**
+     * Retrieves an EU AI Act Article 26 compliant receipt for a settled invoice.
+     * Only available for invoices with status = 'settled'.
+     */
+    getReceipt(paymentHash: string): Promise<ReceiptResponse>;
+    /**
+     * Returns the PaidMCP.dev compatible marketplace manifest for this merchant.
+     * Use this JSON to list your AIPP-protected endpoints on AI agent directories.
+     */
+    getMarketplaceManifest(): Promise<MarketplaceManifest>;
+}

package/dist/client.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Aipp = void 0;
+class Aipp {
+    constructor(config) {
+        if (!config.apiKey) {
+            throw new Error('AIPP: apiKey is required');
+        }
+        this.apiKey = config.apiKey;
+        this.baseUrl = config.baseUrl || 'https://aipp.dev';
+    }
+    async request(endpoint, options = {}) {
+        const url = `${this.baseUrl}${endpoint}`;
+        const headers = {
+            'Content-Type': 'application/json',
+            'X-Api-Key': this.apiKey,
+            ...options.headers,
+        };
+        const response = await fetch(url, { ...options, headers });
+        if (!response.ok) {
+            let errorData;
+            try {
+                errorData = await response.json();
+            }
+            catch (err) {
+                throw new Error(`AIPP API Error: ${response.status} ${response.statusText}`);
+            }
+            throw new Error(`AIPP API Error: ${errorData.error || response.statusText}`);
+        }
+        return response.json();
+    }
+    /**
+     * Creates a new Invoice (either L402 or x402)
+     */
+    async createCharge(params) {
+        if (!params.amountSats && !params.amountUsd) {
+            throw new Error('AIPP: Either amountSats or amountUsd is required');
+        }
+        const body = { memo: params.memo };
+        if (params.amountSats)
+            body.amount_sats = params.amountSats;
+        if (params.amountUsd)
+            body.amount_usd = params.amountUsd;
+        if (params.protocol)
+            body.protocol = params.protocol;
+        return this.request('/invoice/create', {
+            method: 'POST',
+            body: JSON.stringify(body),
+        });
+    }
+    /**
+     * Checks the status of an existing charge
+     */
+    async getCharge(paymentHash, txHash) {
+        if (!paymentHash) {
+            throw new Error('AIPP: paymentHash is required');
+        }
+        const query = txHash ? `?tx_hash=${txHash}` : '';
+        return this.request(`/invoice/status/${paymentHash}${query}`, {
+            method: 'GET',
+        });
+    }
+    /**
+     * Triggers a manual withdrawal of your merchant balance
+     */
+    async payout() {
+        return this.request('/merchant/payout', {
+            method: 'POST',
+        });
+    }
+    /**
+     * Retrieves an EU AI Act Article 26 compliant receipt for a settled invoice.
+     * Only available for invoices with status = 'settled'.
+     */
+    async getReceipt(paymentHash) {
+        if (!paymentHash) {
+            throw new Error('AIPP: paymentHash is required');
+        }
+        return this.request(`/invoice/receipt/${paymentHash}`, {
+            method: 'GET',
+        });
+    }
+    /**
+     * Returns the PaidMCP.dev compatible marketplace manifest for this merchant.
+     * Use this JSON to list your AIPP-protected endpoints on AI agent directories.
+     */
+    async getMarketplaceManifest() {
+        return this.request('/paidmcp.json', {
+            method: 'GET',
+        });
+    }
+}
+exports.Aipp = Aipp;

package/dist/index.d.ts

@@ -1,71 +1,3 @@
-interface AippConfig {
-    apiKey: string;
-    baseUrl?: string;
-}
-interface ChargeParams {
-    amountSats?: number;
-    amountUsd?: number;
-    memo?: string;
-    protocol?: 'L402' | 'x402';
-}
-interface ChargeResponse {
-    payment_hash: string;
-    protocol: 'L402' | 'x402';
-    amount_usd?: number;
-    pay_to?: string;
-    network?: string;
-    token?: string;
-    payment_request?: string;
-    amount_sats?: number;
-}
-interface ChargeStatus {
-    paid: boolean;
-    status: 'pending' | 'settled';
-    preimage: string | null;
-}
-interface AippErrorResponse {
-    error: string;
-    code?: string;
-}
-interface PayoutResponse {
-    message: string;
-    amount_sats?: number;
-    amount_usd?: number;
-}
-
-declare class Aipp {
-    private apiKey;
-    private baseUrl;
-    constructor(config: AippConfig);
-    private request;
-    /**
-     * Creates a new Invoice (either L402 or x402)
-     */
-    createCharge(params: ChargeParams): Promise<ChargeResponse>;
-    /**
-     * Checks the status of an existing charge
-     */
-    getCharge(paymentHash: string, txHash?: string): Promise<ChargeStatus>;
-    /**
-     * Triggers a manual withdrawal of your merchant balance
-     */
-    payout(): Promise<PayoutResponse>;
-}
-
-interface L402Options {
-    client: Aipp;
-    jwtSecret: string;
-    resourceId: string;
-    amountSats?: number;
-    amountUsd?: number;
-    expiresInSeconds?: number;
-}
-declare function l402Paywall(options: L402Options): (req: any, res: any, next: any) => Promise<any>;
-interface X402Options {
-    client: Aipp;
-    resourceId: string;
-    amountUsd: number;
-}
-declare function x402Paywall(options: X402Options): (req: any, res: any, next: any) => Promise<any>;
-
-export { Aipp, type AippConfig, type AippErrorResponse, type ChargeParams, type ChargeResponse, type ChargeStatus, type L402Options, type PayoutResponse, type X402Options, l402Paywall, x402Paywall };
+export * from './client';
+export * from './types';
+export * from './middleware';

package/dist/index.js

@@ -1,265 +1,19 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Aipp: () => Aipp,
-  l402Paywall: () => l402Paywall,
-  x402Paywall: () => x402Paywall
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/client.ts
-var Aipp = class {
-  apiKey;
-  baseUrl;
-  constructor(config) {
-    if (!config.apiKey) {
-      throw new Error("AIPP: apiKey is required");
-    }
-    this.apiKey = config.apiKey;
-    this.baseUrl = config.baseUrl || "https://aipp.dev";
-  }
-  async request(endpoint, options = {}) {
-    const url = `${this.baseUrl}${endpoint}`;
-    const headers = {
-      "Content-Type": "application/json",
-      "X-Api-Key": this.apiKey,
-      ...options.headers
-    };
-    const response = await fetch(url, { ...options, headers });
-    if (!response.ok) {
-      let errorData;
-      try {
-        errorData = await response.json();
-      } catch (err) {
-        throw new Error(`AIPP API Error: ${response.status} ${response.statusText}`);
-      }
-      throw new Error(`AIPP API Error: ${errorData.error || response.statusText}`);
-    }
-    return response.json();
-  }
-  /**
-   * Creates a new Invoice (either L402 or x402)
-   */
-  async createCharge(params) {
-    if (!params.amountSats && !params.amountUsd) {
-      throw new Error("AIPP: Either amountSats or amountUsd is required");
-    }
-    const body = { memo: params.memo };
-    if (params.amountSats) body.amount_sats = params.amountSats;
-    if (params.amountUsd) body.amount_usd = params.amountUsd;
-    if (params.protocol) body.protocol = params.protocol;
-    return this.request("/invoice/create", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
-  }
-  /**
-   * Checks the status of an existing charge
-   */
-  async getCharge(paymentHash, txHash) {
-    if (!paymentHash) {
-      throw new Error("AIPP: paymentHash is required");
-    }
-    const query = txHash ? `?tx_hash=${txHash}` : "";
-    return this.request(`/invoice/status/${paymentHash}${query}`, {
-      method: "GET"
-    });
-  }
-  /**
-   * Triggers a manual withdrawal of your merchant balance
-   */
-  async payout() {
-    return this.request("/merchant/payout", {
-      method: "POST"
-    });
-  }
-};
-
-// src/middleware.ts
-var import_crypto2 = __toESM(require("crypto"));
-
-// src/jwt.ts
-var import_crypto = __toESM(require("crypto"));
-function base64urlEncode(str) {
-  const buf = Buffer.isBuffer(str) ? str : Buffer.from(str);
-  return buf.toString("base64url");
-}
-function base64urlDecode(str) {
-  return Buffer.from(str, "base64url").toString("utf8");
-}
-function signJwt(payload, secret) {
-  const header = { alg: "HS256", typ: "JWT" };
-  const encodedHeader = base64urlEncode(JSON.stringify(header));
-  const encodedPayload = base64urlEncode(JSON.stringify(payload));
-  const data = `${encodedHeader}.${encodedPayload}`;
-  const signature = import_crypto.default.createHmac("sha256", secret).update(data).digest("base64url");
-  return `${data}.${signature}`;
-}
-function verifyJwt(token, secret) {
-  const parts = token.split(".");
-  if (parts.length !== 3) {
-    throw new Error("Invalid JWT format");
-  }
-  const [encodedHeader, encodedPayload, signature] = parts;
-  const data = `${encodedHeader}.${encodedPayload}`;
-  const expectedSignature = import_crypto.default.createHmac("sha256", secret).update(data).digest("base64url");
-  const signatureBuffer = Buffer.from(signature);
-  const expectedBuffer = Buffer.from(expectedSignature);
-  if (signatureBuffer.length !== expectedBuffer.length || !import_crypto.default.timingSafeEqual(signatureBuffer, expectedBuffer)) {
-    throw new Error("Invalid JWT signature");
-  }
-  const payload = JSON.parse(base64urlDecode(encodedPayload));
-  if (payload.exp && Date.now() >= payload.exp * 1e3) {
-    throw new Error("JWT expired");
-  }
-  return payload;
-}
-
-// src/middleware.ts
-function l402Paywall(options) {
-  if (!options.amountSats && !options.amountUsd) {
-    throw new Error("Either amountSats or amountUsd must be provided for l402Paywall");
-  }
-  return async (req, res, next) => {
-    const authHeader = req.headers.authorization || req.headers.Authorization;
-    let valid = false;
-    if (authHeader && typeof authHeader === "string" && authHeader.startsWith("L402 ")) {
-      const parts = authHeader.substring(5).split(":");
-      if (parts.length === 2) {
-        const [macaroonStr, preimage] = parts;
-        try {
-          const payload = verifyJwt(macaroonStr, options.jwtSecret);
-          if (payload.resource_id !== options.resourceId) {
-            throw new Error("Invalid resource");
-          }
-          const preimageHash = import_crypto2.default.createHash("sha256").update(Buffer.from(preimage, "hex")).digest("hex");
-          const expectedHash = payload.payment_hash;
-          if (typeof expectedHash === "string" && expectedHash.length === preimageHash.length && import_crypto2.default.timingSafeEqual(Buffer.from(preimageHash, "hex"), Buffer.from(expectedHash, "hex"))) {
-            valid = true;
-          }
-        } catch (e) {
-        }
-      }
-    }
-    if (valid) {
-      return next();
-    }
-    try {
-      const charge = await options.client.createCharge({
-        amountSats: options.amountSats,
-        amountUsd: options.amountUsd,
-        memo: `L402 Payment for ${options.resourceId}`
-      });
-      const expiresIn = options.expiresInSeconds || 3600;
-      const payload = {
-        payment_hash: charge.payment_hash,
-        resource_id: options.resourceId,
-        exp: Math.floor(Date.now() / 1e3) + expiresIn
-      };
-      const jwtToken = signJwt(payload, options.jwtSecret);
-      res.status(402);
-      res.setHeader("Www-Authenticate", `L402 macaroon="${jwtToken}" invoice="${charge.payment_request}"`);
-      res.json({
-        error: "Payment Required",
-        code: "L402",
-        payment_request: charge.payment_request,
-        macaroon: jwtToken
-      });
-    } catch (err) {
-      res.status(500).json({ error: "Failed to generate L402 challenge", details: err.message || err });
-    }
-  };
-}
-function x402Paywall(options) {
-  return async (req, res, next) => {
-    const authHeader = req.headers.authorization || req.headers.Authorization;
-    let txHash = req.query.tx_hash || req.headers["payment-signature"] || req.headers["x-payment-signature"];
-    let paymentHash = req.query.payment_hash || req.headers["x-payment-hash"];
-    if (!txHash && authHeader && typeof authHeader === "string") {
-      if (authHeader.startsWith("Bearer ")) {
-        txHash = authHeader.substring(7).trim();
-      } else if (authHeader.startsWith("x402 ")) {
-        txHash = authHeader.substring(5).trim();
-      } else if (authHeader.startsWith("L402 ")) {
-        const parts = authHeader.substring(5).split(":");
-        if (parts.length === 2) {
-          paymentHash = parts[0];
-          txHash = parts[1];
-        }
-      }
-    }
-    if (paymentHash && txHash) {
-      try {
-        const chargeStatus = await options.client.getCharge(paymentHash, txHash);
-        if (chargeStatus.status === "settled") {
-          return next();
-        }
-      } catch (e) {
-      }
-    }
-    try {
-      const charge = await options.client.createCharge({
-        amountUsd: options.amountUsd,
-        protocol: "x402",
-        memo: `x402 Payment for ${options.resourceId}`
-      });
-      const challengeObj = {
-        scheme: "exact",
-        network: "base",
-        payTo: charge.pay_to || "",
-        price: options.amountUsd.toFixed(2),
-        token: charge.token || "",
-        payment_hash: charge.payment_hash
-      };
-      const challengeBase64 = Buffer.from(JSON.stringify(challengeObj), "utf8").toString("base64");
-      res.setHeader("PAYMENT-REQUIRED", challengeBase64);
-      res.status(402);
-      res.json({
-        error: "Payment Required",
-        code: "x402",
-        payment_hash: charge.payment_hash,
-        pay_to: challengeObj.payTo,
-        price: challengeObj.price,
-        token: challengeObj.token,
-        network: challengeObj.network
-      });
-    } catch (err) {
-      res.status(500).json({ error: "Failed to generate x402 challenge", details: err.message || err });
-    }
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Aipp,
-  l402Paywall,
-  x402Paywall
-});
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./middleware"), exports);

package/dist/jwt.d.ts

@@ -0,0 +1,2 @@
+export declare function signJwt(payload: any, secret: string): string;
+export declare function verifyJwt(token: string, secret: string): any;

package/dist/jwt.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signJwt = signJwt;
+exports.verifyJwt = verifyJwt;
+const crypto_1 = __importDefault(require("crypto"));
+function base64urlEncode(str) {
+    const buf = Buffer.isBuffer(str) ? str : Buffer.from(str);
+    return buf.toString('base64url');
+}
+function base64urlDecode(str) {
+    return Buffer.from(str, 'base64url').toString('utf8');
+}
+function signJwt(payload, secret) {
+    const header = { alg: 'HS256', typ: 'JWT' };
+    const encodedHeader = base64urlEncode(JSON.stringify(header));
+    const encodedPayload = base64urlEncode(JSON.stringify(payload));
+    const data = `${encodedHeader}.${encodedPayload}`;
+    const signature = crypto_1.default.createHmac('sha256', secret).update(data).digest('base64url');
+    return `${data}.${signature}`;
+}
+function verifyJwt(token, secret) {
+    const parts = token.split('.');
+    if (parts.length !== 3) {
+        throw new Error('Invalid JWT format');
+    }
+    const [encodedHeader, encodedPayload, signature] = parts;
+    const data = `${encodedHeader}.${encodedPayload}`;
+    const expectedSignature = crypto_1.default.createHmac('sha256', secret).update(data).digest('base64url');
+    // Constant time comparison to prevent timing attacks
+    const signatureBuffer = Buffer.from(signature);
+    const expectedBuffer = Buffer.from(expectedSignature);
+    if (signatureBuffer.length !== expectedBuffer.length || !crypto_1.default.timingSafeEqual(signatureBuffer, expectedBuffer)) {
+        throw new Error('Invalid JWT signature');
+    }
+    const payload = JSON.parse(base64urlDecode(encodedPayload));
+    if (payload.exp && Date.now() >= payload.exp * 1000) {
+        throw new Error('JWT expired');
+    }
+    return payload;
+}

package/dist/middleware.d.ts

@@ -0,0 +1,16 @@
+import { Aipp } from './client';
+export interface L402Options {
+    client: Aipp;
+    jwtSecret: string;
+    resourceId: string;
+    amountSats?: number;
+    amountUsd?: number;
+    expiresInSeconds?: number;
+}
+export declare function l402Paywall(options: L402Options): (req: any, res: any, next: any) => Promise<any>;
+export interface X402Options {
+    client: Aipp;
+    resourceId: string;
+    amountUsd: number;
+}
+export declare function x402Paywall(options: X402Options): (req: any, res: any, next: any) => Promise<any>;

package/dist/middleware.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.l402Paywall = l402Paywall;
+exports.x402Paywall = x402Paywall;
+const crypto_1 = __importDefault(require("crypto"));
+const jwt_1 = require("./jwt");
+function l402Paywall(options) {
+    if (!options.amountSats && !options.amountUsd) {
+        throw new Error('Either amountSats or amountUsd must be provided for l402Paywall');
+    }
+    return async (req, res, next) => {
+        const authHeader = req.headers.authorization || req.headers.Authorization;
+        let valid = false;
+        if (authHeader && typeof authHeader === 'string' && authHeader.startsWith('L402 ')) {
+            const parts = authHeader.substring(5).split(':');
+            if (parts.length === 2) {
+                const [macaroonStr, preimage] = parts;
+                try {
+                    // Verify JWT signature and expiration
+                    const payload = (0, jwt_1.verifyJwt)(macaroonStr, options.jwtSecret);
+                    if (payload.resource_id !== options.resourceId) {
+                        throw new Error('Invalid resource');
+                    }
+                    // Verify preimage hash matches payment_hash securely
+                    const preimageHash = crypto_1.default.createHash('sha256').update(Buffer.from(preimage, 'hex')).digest('hex');
+                    const expectedHash = payload.payment_hash;
+                    if (typeof expectedHash === 'string' &&
+                        expectedHash.length === preimageHash.length &&
+                        crypto_1.default.timingSafeEqual(Buffer.from(preimageHash, 'hex'), Buffer.from(expectedHash, 'hex'))) {
+                        valid = true;
+                    }
+                }
+                catch (e) {
+                    // Invalid or expired JWT -> Fall through to 402 and issue new invoice
+                }
+            }
+        }
+        if (valid) {
+            return next();
+        }
+        try {
+            // Create invoice via AIPP
+            const charge = await options.client.createCharge({
+                amountSats: options.amountSats,
+                amountUsd: options.amountUsd,
+                memo: `L402 Payment for ${options.resourceId}`
+            });
+            // Issue JWT
+            const expiresIn = options.expiresInSeconds || 3600; // default 1 hour
+            const payload = {
+                payment_hash: charge.payment_hash,
+                resource_id: options.resourceId,
+                exp: Math.floor(Date.now() / 1000) + expiresIn
+            };
+            const jwtToken = (0, jwt_1.signJwt)(payload, options.jwtSecret);
+            res.status(402);
+            res.setHeader('Www-Authenticate', `L402 macaroon="${jwtToken}" invoice="${charge.payment_request}"`);
+            res.json({
+                error: "Payment Required",
+                code: "L402",
+                payment_request: charge.payment_request,
+                macaroon: jwtToken
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: "Failed to generate L402 challenge", details: err.message || err });
+        }
+    };
+}
+function x402Paywall(options) {
+    return async (req, res, next) => {
+        const authHeader = req.headers.authorization || req.headers.Authorization;
+        let txHash = (req.query.tx_hash || req.headers['payment-signature'] || req.headers['x-payment-signature']);
+        let paymentHash = (req.query.payment_hash || req.headers['x-payment-hash']);
+        if (!txHash && authHeader && typeof authHeader === 'string') {
+            if (authHeader.startsWith('Bearer ')) {
+                txHash = authHeader.substring(7).trim();
+            }
+            else if (authHeader.startsWith('x402 ')) {
+                txHash = authHeader.substring(5).trim();
+            }
+            else if (authHeader.startsWith('L402 ')) {
+                // Fallback or double format check
+                const parts = authHeader.substring(5).split(':');
+                if (parts.length === 2) {
+                    paymentHash = parts[0];
+                    txHash = parts[1];
+                }
+            }
+        }
+        if (paymentHash && txHash) {
+            try {
+                const chargeStatus = await options.client.getCharge(paymentHash, txHash);
+                if (chargeStatus.status === 'settled') {
+                    return next();
+                }
+            }
+            catch (e) {
+                // Validation failed, proceed to challenge
+            }
+        }
+        try {
+            const charge = await options.client.createCharge({
+                amountUsd: options.amountUsd,
+                protocol: 'x402',
+                memo: `x402 Payment for ${options.resourceId}`
+            });
+            const challengeObj = {
+                scheme: 'exact',
+                network: 'base',
+                payTo: charge.pay_to || '',
+                price: options.amountUsd.toFixed(2),
+                token: charge.token || '',
+                payment_hash: charge.payment_hash
+            };
+            const challengeBase64 = Buffer.from(JSON.stringify(challengeObj), 'utf8').toString('base64');
+            res.setHeader('PAYMENT-REQUIRED', challengeBase64);
+            res.status(402);
+            res.json({
+                error: "Payment Required",
+                code: "x402",
+                payment_hash: charge.payment_hash,
+                pay_to: challengeObj.payTo,
+                price: challengeObj.price,
+                token: challengeObj.token,
+                network: challengeObj.network
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: "Failed to generate x402 challenge", details: err.message || err });
+        }
+    };
+}