moltspay 0.8.14 → 0.9.0

package/dist/server/index.js

@@ -33,15 +33,459 @@ __export(server_exports, {
   MoltsPayServer: () => MoltsPayServer
 });
 module.exports = __toCommonJS(server_exports);
-var import_fs = require("fs");
+var import_fs2 = require("fs");
 var import_http = require("http");
+var path2 = __toESM(require("path"));
+
+// src/facilitators/interface.ts
+var BaseFacilitator = class {
+  supportsNetwork(network) {
+    return this.supportedNetworks.includes(network);
+  }
+};
+
+// src/facilitators/cdp.ts
+var import_fs = require("fs");
 var path = __toESM(require("path"));
 var X402_VERSION = 2;
+var CDP_MAINNET_URL = "https://api.cdp.coinbase.com/platform/v2/x402";
+var CDP_TESTNET_URL = "https://www.x402.org/facilitator";
+function loadEnvFile() {
+  const envPaths = [
+    path.join(process.cwd(), ".env"),
+    path.join(process.env.HOME || "", ".moltspay", ".env")
+  ];
+  for (const envPath of envPaths) {
+    if ((0, import_fs.existsSync)(envPath)) {
+      try {
+        const content = (0, import_fs.readFileSync)(envPath, "utf-8");
+        for (const line of content.split("\n")) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith("#")) continue;
+          const eqIndex = trimmed.indexOf("=");
+          if (eqIndex === -1) continue;
+          const key = trimmed.slice(0, eqIndex).trim();
+          let value = trimmed.slice(eqIndex + 1).trim();
+          if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+            value = value.slice(1, -1);
+          }
+          if (!process.env[key]) {
+            process.env[key] = value;
+          }
+        }
+        break;
+      } catch {
+      }
+    }
+  }
+}
+var CDPFacilitator = class extends BaseFacilitator {
+  name = "cdp";
+  displayName = "Coinbase CDP";
+  supportedNetworks;
+  endpoint;
+  useMainnet;
+  apiKeyId;
+  apiKeySecret;
+  constructor(config = {}) {
+    super();
+    loadEnvFile();
+    this.useMainnet = config.useMainnet ?? process.env.USE_MAINNET?.toLowerCase() === "true";
+    this.apiKeyId = config.apiKeyId || process.env.CDP_API_KEY_ID;
+    this.apiKeySecret = config.apiKeySecret || process.env.CDP_API_KEY_SECRET;
+    this.endpoint = this.useMainnet ? CDP_MAINNET_URL : CDP_TESTNET_URL;
+    this.supportedNetworks = this.useMainnet ? ["eip155:8453"] : ["eip155:8453", "eip155:84532"];
+    if (this.useMainnet && (!this.apiKeyId || !this.apiKeySecret)) {
+      console.warn("[CDPFacilitator] WARNING: Mainnet mode but missing CDP credentials!");
+      console.warn("[CDPFacilitator] Set CDP_API_KEY_ID and CDP_API_KEY_SECRET");
+    }
+  }
+  /**
+   * Get auth headers for CDP API requests
+   */
+  async getAuthHeaders(method, urlPath, body) {
+    if (!this.useMainnet) {
+      return {};
+    }
+    if (!this.apiKeyId || !this.apiKeySecret) {
+      throw new Error("CDP credentials required for mainnet");
+    }
+    try {
+      const { getAuthHeaders } = await import("@coinbase/cdp-sdk/auth");
+      return await getAuthHeaders({
+        apiKeyId: this.apiKeyId,
+        apiKeySecret: this.apiKeySecret,
+        requestMethod: method,
+        requestHost: "api.cdp.coinbase.com",
+        requestPath: urlPath,
+        requestBody: body
+      });
+    } catch (err) {
+      throw new Error(`Failed to generate CDP auth: ${err.message}`);
+    }
+  }
+  /**
+   * Health check - verify facilitator is reachable
+   */
+  async healthCheck() {
+    const start = Date.now();
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 5e3);
+      const response = await fetch(this.endpoint.replace("/x402", ""), {
+        method: "HEAD",
+        signal: controller.signal
+      }).catch(() => null);
+      clearTimeout(timeout);
+      const latencyMs = Date.now() - start;
+      return {
+        healthy: response !== null,
+        latencyMs
+      };
+    } catch (err) {
+      return {
+        healthy: false,
+        error: err.message,
+        latencyMs: Date.now() - start
+      };
+    }
+  }
+  /**
+   * Verify payment signature with facilitator
+   */
+  async verify(paymentPayload, requirements) {
+    try {
+      const requestBody = {
+        x402Version: X402_VERSION,
+        paymentPayload,
+        paymentRequirements: requirements
+      };
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (this.useMainnet) {
+        const authHeaders = await this.getAuthHeaders(
+          "POST",
+          "/platform/v2/x402/verify",
+          requestBody
+        );
+        Object.assign(headers, authHeaders);
+      }
+      const response = await fetch(`${this.endpoint}/verify`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(requestBody)
+      });
+      const result = await response.json();
+      if (!response.ok || !result.isValid) {
+        return {
+          valid: false,
+          error: result.invalidReason || result.error || "Verification failed",
+          details: result
+        };
+      }
+      return { valid: true, details: result };
+    } catch (err) {
+      return {
+        valid: false,
+        error: `Facilitator error: ${err.message}`
+      };
+    }
+  }
+  /**
+   * Settle payment on-chain via facilitator
+   */
+  async settle(paymentPayload, requirements) {
+    try {
+      const requestBody = {
+        x402Version: X402_VERSION,
+        paymentPayload,
+        paymentRequirements: requirements
+      };
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (this.useMainnet) {
+        const authHeaders = await this.getAuthHeaders(
+          "POST",
+          "/platform/v2/x402/settle",
+          requestBody
+        );
+        Object.assign(headers, authHeaders);
+      }
+      const response = await fetch(`${this.endpoint}/settle`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(requestBody)
+      });
+      const result = await response.json();
+      if (!response.ok || !result.success) {
+        return {
+          success: false,
+          error: result.error || result.errorReason || "Settlement failed"
+        };
+      }
+      return {
+        success: true,
+        transaction: result.transaction,
+        status: result.status || "settled"
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: `Settlement error: ${err.message}`
+      };
+    }
+  }
+  /**
+   * Get CDP fee information
+   */
+  async getFee() {
+    return {
+      perTx: 1e-3,
+      currency: "USD",
+      freeQuota: 1e3
+    };
+  }
+  /**
+   * Get configuration summary (for logging)
+   */
+  getConfigSummary() {
+    const mode = this.useMainnet ? "mainnet" : "testnet";
+    const hasCredentials = !!(this.apiKeyId && this.apiKeySecret);
+    return `CDP Facilitator (${mode}, credentials: ${hasCredentials ? "yes" : "no"})`;
+  }
+};
+
+// src/facilitators/registry.ts
+var FacilitatorRegistry = class {
+  factories = /* @__PURE__ */ new Map();
+  instances = /* @__PURE__ */ new Map();
+  selection;
+  roundRobinIndex = 0;
+  constructor(selection) {
+    this.registerFactory("cdp", (config) => new CDPFacilitator(config));
+    this.selection = selection || { primary: "cdp", strategy: "failover" };
+  }
+  /**
+   * Register a new facilitator factory
+   */
+  registerFactory(name, factory) {
+    this.factories.set(name, factory);
+  }
+  /**
+   * Get or create a facilitator instance
+   */
+  get(name, config) {
+    if (this.instances.has(name)) {
+      return this.instances.get(name);
+    }
+    const factory = this.factories.get(name);
+    if (!factory) {
+      throw new Error(`Unknown facilitator: ${name}. Available: ${Array.from(this.factories.keys()).join(", ")}`);
+    }
+    const mergedConfig = {
+      ...this.selection.config?.[name],
+      ...config
+    };
+    const instance = factory(mergedConfig);
+    this.instances.set(name, instance);
+    return instance;
+  }
+  /**
+   * Get all configured facilitator names
+   */
+  getConfiguredNames() {
+    const names = [this.selection.primary];
+    if (this.selection.fallback) {
+      names.push(...this.selection.fallback);
+    }
+    return names;
+  }
+  /**
+   * Get list of facilitators based on selection strategy
+   */
+  async getOrderedFacilitators(network) {
+    const names = this.getConfiguredNames();
+    const facilitators = [];
+    for (const name of names) {
+      try {
+        const f = this.get(name);
+        if (f.supportsNetwork(network)) {
+          facilitators.push(f);
+        }
+      } catch (err) {
+        console.warn(`[Registry] Failed to get facilitator ${name}:`, err);
+      }
+    }
+    if (facilitators.length === 0) {
+      throw new Error(`No facilitators available for network: ${network}`);
+    }
+    switch (this.selection.strategy) {
+      case "random":
+        return this.shuffle(facilitators);
+      case "roundrobin":
+        this.roundRobinIndex = (this.roundRobinIndex + 1) % facilitators.length;
+        return [
+          ...facilitators.slice(this.roundRobinIndex),
+          ...facilitators.slice(0, this.roundRobinIndex)
+        ];
+      case "cheapest":
+        return this.sortByCheapest(facilitators);
+      case "fastest":
+        return this.sortByFastest(facilitators);
+      case "failover":
+      default:
+        return facilitators;
+    }
+  }
+  shuffle(array) {
+    const result = [...array];
+    for (let i = result.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [result[i], result[j]] = [result[j], result[i]];
+    }
+    return result;
+  }
+  async sortByCheapest(facilitators) {
+    const withFees = await Promise.all(
+      facilitators.map(async (f) => {
+        try {
+          const fee = await f.getFee?.();
+          return { facilitator: f, perTx: fee?.perTx ?? Infinity };
+        } catch {
+          return { facilitator: f, perTx: Infinity };
+        }
+      })
+    );
+    withFees.sort((a, b) => a.perTx - b.perTx);
+    return withFees.map((w) => w.facilitator);
+  }
+  async sortByFastest(facilitators) {
+    const withLatency = await Promise.all(
+      facilitators.map(async (f) => {
+        try {
+          const health = await f.healthCheck();
+          return { facilitator: f, latency: health.latencyMs ?? Infinity };
+        } catch {
+          return { facilitator: f, latency: Infinity };
+        }
+      })
+    );
+    withLatency.sort((a, b) => a.latency - b.latency);
+    return withLatency.map((w) => w.facilitator);
+  }
+  /**
+   * Verify payment using configured facilitators
+   */
+  async verify(paymentPayload, requirements) {
+    const network = paymentPayload.accepted?.network || paymentPayload.network || requirements.network;
+    const facilitators = await this.getOrderedFacilitators(network);
+    let lastError;
+    for (const f of facilitators) {
+      try {
+        console.log(`[Registry] Trying ${f.name} for verify...`);
+        const result = await f.verify(paymentPayload, requirements);
+        if (result.valid) {
+          console.log(`[Registry] ${f.name} verify succeeded`);
+          return { ...result, facilitator: f.name };
+        }
+        lastError = result.error;
+        console.log(`[Registry] ${f.name} verify failed: ${result.error}`);
+        if (this.selection.strategy === "failover" && !this.isTransientError(result.error)) {
+          break;
+        }
+      } catch (err) {
+        lastError = err.message;
+        console.error(`[Registry] ${f.name} error:`, err.message);
+      }
+    }
+    return {
+      valid: false,
+      error: lastError || "All facilitators failed",
+      facilitator: "none"
+    };
+  }
+  /**
+   * Settle payment using configured facilitators
+   */
+  async settle(paymentPayload, requirements) {
+    const network = paymentPayload.accepted?.network || paymentPayload.network || requirements.network;
+    const facilitators = await this.getOrderedFacilitators(network);
+    let lastError;
+    for (const f of facilitators) {
+      try {
+        console.log(`[Registry] Trying ${f.name} for settle...`);
+        const result = await f.settle(paymentPayload, requirements);
+        if (result.success) {
+          console.log(`[Registry] ${f.name} settle succeeded: ${result.transaction}`);
+          return { ...result, facilitator: f.name };
+        }
+        lastError = result.error;
+        console.log(`[Registry] ${f.name} settle failed: ${result.error}`);
+      } catch (err) {
+        lastError = err.message;
+        console.error(`[Registry] ${f.name} error:`, err.message);
+      }
+    }
+    return {
+      success: false,
+      error: lastError || "All facilitators failed",
+      facilitator: "none"
+    };
+  }
+  /**
+   * Check health of all configured facilitators
+   */
+  async healthCheckAll() {
+    const results = {};
+    for (const name of this.getConfiguredNames()) {
+      try {
+        const f = this.get(name);
+        results[name] = await f.healthCheck();
+      } catch (err) {
+        results[name] = { healthy: false, error: err.message };
+      }
+    }
+    return results;
+  }
+  /**
+   * Check if an error is transient (network/server issue) vs permanent (bad request)
+   */
+  isTransientError(error) {
+    if (!error) return true;
+    const transientPatterns = [
+      /timeout/i,
+      /network/i,
+      /connection/i,
+      /ECONNREFUSED/i,
+      /ETIMEDOUT/i,
+      /503/,
+      /502/,
+      /500/
+    ];
+    return transientPatterns.some((p) => p.test(error));
+  }
+  /**
+   * Update selection configuration
+   */
+  setSelection(selection) {
+    this.selection = selection;
+    this.instances.clear();
+  }
+  /**
+   * Get current selection configuration
+   */
+  getSelection() {
+    return { ...this.selection };
+  }
+};
+
+// src/server/index.ts
+var X402_VERSION2 = 2;
 var PAYMENT_REQUIRED_HEADER = "x-payment-required";
 var PAYMENT_HEADER = "x-payment";
 var PAYMENT_RESPONSE_HEADER = "x-payment-response";
-var FACILITATOR_TESTNET = "https://www.x402.org/facilitator";
-var FACILITATOR_MAINNET = "https://api.cdp.coinbase.com/platform/v2/x402";
 var USDC_ADDRESSES = {
   "eip155:8453": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
   // Base mainnet
@@ -52,15 +496,15 @@ var USDC_DOMAIN = {
   name: "USD Coin",
   version: "2"
 };
-function loadEnvFiles() {
+function loadEnvFile2() {
   const envPaths = [
-    path.join(process.cwd(), ".env"),
-    path.join(process.env.HOME || "", ".moltspay", ".env")
+    path2.join(process.cwd(), ".env"),
+    path2.join(process.env.HOME || "", ".moltspay", ".env")
   ];
   for (const envPath of envPaths) {
-    if ((0, import_fs.existsSync)(envPath)) {
+    if ((0, import_fs2.existsSync)(envPath)) {
       try {
-        const content = (0, import_fs.readFileSync)(envPath, "utf-8");
+        const content = (0, import_fs2.readFileSync)(envPath, "utf-8");
         for (const line of content.split("\n")) {
           const trimmed = line.trim();
           if (!trimmed || trimmed.startsWith("#")) continue;
@@ -77,77 +521,44 @@ function loadEnvFiles() {
         }
         console.log(`[MoltsPay] Loaded config from ${envPath}`);
         break;
-      } catch (err) {
-        console.warn(`[MoltsPay] Failed to load ${envPath}:`, err);
+      } catch {
       }
     }
   }
 }
-function getCDPConfig() {
-  loadEnvFiles();
-  return {
-    useMainnet: process.env.USE_MAINNET?.toLowerCase() === "true",
-    apiKeyId: process.env.CDP_API_KEY_ID,
-    apiKeySecret: process.env.CDP_API_KEY_SECRET
-  };
-}
-async function getCDPAuthHeaders(method, urlPath, body) {
-  const config = getCDPConfig();
-  if (!config.apiKeyId || !config.apiKeySecret) {
-    throw new Error("CDP_API_KEY_ID and CDP_API_KEY_SECRET required for mainnet");
-  }
-  try {
-    const { getAuthHeaders } = await import("@coinbase/cdp-sdk/auth");
-    const headers = await getAuthHeaders({
-      apiKeyId: config.apiKeyId,
-      apiKeySecret: config.apiKeySecret,
-      requestMethod: method,
-      requestHost: "api.cdp.coinbase.com",
-      requestPath: urlPath,
-      requestBody: body
-    });
-    return headers;
-  } catch (err) {
-    console.error("[MoltsPay] Failed to generate CDP auth headers:", err.message);
-    throw err;
-  }
-}
 var MoltsPayServer = class {
   manifest;
   skills = /* @__PURE__ */ new Map();
   options;
-  cdpConfig;
-  facilitatorUrl;
+  registry;
   networkId;
+  useMainnet;
   constructor(servicesPath, options = {}) {
-    this.cdpConfig = getCDPConfig();
-    const content = (0, import_fs.readFileSync)(servicesPath, "utf-8");
+    loadEnvFile2();
+    const content = (0, import_fs2.readFileSync)(servicesPath, "utf-8");
     this.manifest = JSON.parse(content);
     this.options = {
       port: options.port || 3e3,
-      host: options.host || "0.0.0.0"
+      host: options.host || "0.0.0.0",
+      ...options
     };
-    if (this.cdpConfig.useMainnet) {
-      if (!this.cdpConfig.apiKeyId || !this.cdpConfig.apiKeySecret) {
-        console.warn("[MoltsPay] WARNING: USE_MAINNET=true but CDP keys not set!");
-        console.warn("[MoltsPay] Set CDP_API_KEY_ID and CDP_API_KEY_SECRET in ~/.moltspay/.env");
+    this.useMainnet = process.env.USE_MAINNET?.toLowerCase() === "true";
+    this.networkId = this.useMainnet ? "eip155:8453" : "eip155:84532";
+    const facilitatorConfig = options.facilitators || {
+      primary: "cdp",
+      strategy: "failover",
+      config: {
+        cdp: { useMainnet: this.useMainnet }
       }
-      this.facilitatorUrl = FACILITATOR_MAINNET;
-      this.networkId = "eip155:8453";
-    } else {
-      this.facilitatorUrl = options.facilitatorUrl || FACILITATOR_TESTNET;
-      this.networkId = "eip155:84532";
-    }
-    const networkName = this.cdpConfig.useMainnet ? "Base mainnet" : "Base Sepolia (testnet)";
-    const facilitatorName = this.cdpConfig.useMainnet ? "CDP" : "x402.org";
+    };
+    this.registry = new FacilitatorRegistry(facilitatorConfig);
+    const primaryFacilitator = this.registry.get(facilitatorConfig.primary);
+    const networkName = this.useMainnet ? "Base mainnet" : "Base Sepolia (testnet)";
     console.log(`[MoltsPay] Loaded ${this.manifest.services.length} services from ${servicesPath}`);
     console.log(`[MoltsPay] Provider: ${this.manifest.provider.name}`);
     console.log(`[MoltsPay] Receive wallet: ${this.manifest.provider.wallet}`);
     console.log(`[MoltsPay] Network: ${this.networkId} (${networkName})`);
-    console.log(`[MoltsPay] Facilitator: ${facilitatorName} (${this.facilitatorUrl})`);
-    if (this.cdpConfig.useMainnet && this.cdpConfig.apiKeyId) {
-      console.log(`[MoltsPay] CDP API Key: ${this.cdpConfig.apiKeyId.slice(0, 8)}...`);
-    }
+    console.log(`[MoltsPay] Facilitator: ${primaryFacilitator.displayName} (${facilitatorConfig.strategy || "failover"})`);
     console.log(`[MoltsPay] Protocol: x402 (gasless for both client AND server)`);
   }
   /**
@@ -173,6 +584,7 @@ var MoltsPayServer = class {
       console.log(`[MoltsPay] Endpoints:`);
       console.log(`  GET  /services     - List available services`);
       console.log(`  POST /execute      - Execute service (x402 payment)`);
+      console.log(`  GET  /health       - Health check (incl. facilitators)`);
     });
   }
   /**
@@ -193,6 +605,9 @@ var MoltsPayServer = class {
       if (url.pathname === "/services" && req.method === "GET") {
         return this.handleGetServices(res);
       }
+      if (url.pathname === "/health" && req.method === "GET") {
+        return await this.handleHealthCheck(res);
+      }
       if (url.pathname === "/execute" && req.method === "POST") {
         const body = await this.readBody(req);
         const paymentHeader = req.headers[PAYMENT_HEADER];
@@ -218,18 +633,37 @@ var MoltsPayServer = class {
       output: s.output,
       available: this.skills.has(s.id)
     }));
+    const selection = this.registry.getSelection();
     this.sendJson(res, 200, {
       provider: this.manifest.provider,
       services,
       x402: {
-        version: X402_VERSION,
+        version: X402_VERSION2,
         network: this.networkId,
         schemes: ["exact"],
-        facilitator: this.cdpConfig.useMainnet ? "cdp" : "x402.org",
-        mainnet: this.cdpConfig.useMainnet
+        facilitators: {
+          primary: selection.primary,
+          fallback: selection.fallback,
+          strategy: selection.strategy
+        },
+        mainnet: this.useMainnet
       }
     });
   }
+  /**
+   * GET /health - Health check endpoint
+   */
+  async handleHealthCheck(res) {
+    const facilitatorHealth = await this.registry.healthCheckAll();
+    const allHealthy = Object.values(facilitatorHealth).every((h) => h.healthy);
+    this.sendJson(res, allHealthy ? 200 : 503, {
+      status: allHealthy ? "healthy" : "degraded",
+      network: this.networkId,
+      facilitators: facilitatorHealth,
+      services: this.manifest.services.length,
+      registered: this.skills.size
+    });
+  }
   /**
    * POST /execute - Execute service with x402 payment
    */
@@ -261,11 +695,16 @@ var MoltsPayServer = class {
     if (!validation.valid) {
       return this.sendJson(res, 402, { error: validation.error });
     }
-    console.log(`[MoltsPay] Verifying payment with facilitator...`);
-    const verifyResult = await this.verifyWithFacilitator(payment, skill.config);
+    const requirements = this.buildPaymentRequirements(skill.config);
+    console.log(`[MoltsPay] Verifying payment...`);
+    const verifyResult = await this.registry.verify(payment, requirements);
     if (!verifyResult.valid) {
-      return this.sendJson(res, 402, { error: `Payment verification failed: ${verifyResult.error}` });
+      return this.sendJson(res, 402, {
+        error: `Payment verification failed: ${verifyResult.error}`,
+        facilitator: verifyResult.facilitator
+      });
     }
+    console.log(`[MoltsPay] Verified by ${verifyResult.facilitator}`);
     console.log(`[MoltsPay] Executing skill: ${service}`);
     let result;
     try {
@@ -280,17 +719,18 @@ var MoltsPayServer = class {
     console.log(`[MoltsPay] Skill succeeded, settling payment...`);
     let settlement = null;
     try {
-      settlement = await this.settleWithFacilitator(payment, skill.config);
-      console.log(`[MoltsPay] Payment settled: ${settlement.transaction || "pending"}`);
+      settlement = await this.registry.settle(payment, requirements);
+      console.log(`[MoltsPay] Payment settled by ${settlement.facilitator}: ${settlement.transaction || "pending"}`);
     } catch (err) {
       console.error("[MoltsPay] Settlement failed:", err.message);
     }
     const responseHeaders = {};
-    if (settlement) {
+    if (settlement?.success) {
       const responsePayload = {
         success: true,
         transaction: settlement.transaction,
-        network: payment.network
+        network: payment.network || payment.accepted?.network,
+        facilitator: settlement.facilitator
       };
       responseHeaders[PAYMENT_RESPONSE_HEADER] = Buffer.from(
         JSON.stringify(responsePayload)
@@ -299,7 +739,7 @@ var MoltsPayServer = class {
     this.sendJson(res, 200, {
       success: true,
       result,
-      payment: settlement ? { transaction: settlement.transaction, status: "settled" } : { status: "pending" }
+      payment: settlement?.success ? { transaction: settlement.transaction, status: "settled", facilitator: settlement.facilitator } : { status: "pending" }
     }, responseHeaders);
   }
   /**
@@ -308,7 +748,7 @@ var MoltsPayServer = class {
   sendPaymentRequired(config, res) {
     const requirements = this.buildPaymentRequirements(config);
     const paymentRequired = {
-      x402Version: X402_VERSION,
+      x402Version: X402_VERSION2,
       accepts: [requirements],
       resource: {
         url: `/execute?service=${config.id}`,
@@ -331,7 +771,7 @@ var MoltsPayServer = class {
    * Basic payment validation
    */
   validatePayment(payment, config) {
-    if (payment.x402Version !== X402_VERSION) {
+    if (payment.x402Version !== X402_VERSION2) {
       return { valid: false, error: `Unsupported x402 version: ${payment.x402Version}` };
     }
     const scheme = payment.accepted?.scheme || payment.scheme;
@@ -345,7 +785,7 @@ var MoltsPayServer = class {
     return { valid: true };
   }
   /**
-   * Build complete payment requirements for facilitator
+   * Build payment requirements for facilitator
    */
   buildPaymentRequirements(config) {
     const amountInUnits = Math.floor(config.price * 1e6).toString();
@@ -360,77 +800,6 @@ var MoltsPayServer = class {
       extra: USDC_DOMAIN
     };
   }
-  /**
-   * Verify payment with facilitator (testnet or CDP)
-   */
-  async verifyWithFacilitator(payment, config) {
-    try {
-      const requirements = this.buildPaymentRequirements(config);
-      const requestBody = {
-        x402Version: X402_VERSION,
-        // Required at top level for CDP
-        paymentPayload: payment,
-        paymentRequirements: requirements
-      };
-      console.log("[MoltsPay] Verify request:", JSON.stringify(requestBody, null, 2));
-      let headers = { "Content-Type": "application/json" };
-      if (this.cdpConfig.useMainnet) {
-        const authHeaders = await getCDPAuthHeaders(
-          "POST",
-          "/platform/v2/x402/verify",
-          requestBody
-        );
-        headers = { ...headers, ...authHeaders };
-      }
-      const response = await fetch(`${this.facilitatorUrl}/verify`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(requestBody)
-      });
-      const result = await response.json();
-      console.log("[MoltsPay] Verify response:", JSON.stringify(result, null, 2));
-      if (!response.ok || !result.isValid) {
-        return { valid: false, error: result.invalidReason || result.error || "Verification failed" };
-      }
-      return { valid: true };
-    } catch (err) {
-      return { valid: false, error: `Facilitator error: ${err.message}` };
-    }
-  }
-  /**
-   * Settle payment with facilitator (execute on-chain transfer)
-   */
-  async settleWithFacilitator(payment, config) {
-    const requirements = this.buildPaymentRequirements(config);
-    const requestBody = {
-      x402Version: X402_VERSION,
-      // Required at top level for CDP
-      paymentPayload: payment,
-      paymentRequirements: requirements
-    };
-    let headers = { "Content-Type": "application/json" };
-    if (this.cdpConfig.useMainnet) {
-      const authHeaders = await getCDPAuthHeaders(
-        "POST",
-        "/platform/v2/x402/settle",
-        requestBody
-      );
-      headers = { ...headers, ...authHeaders };
-    }
-    const response = await fetch(`${this.facilitatorUrl}/settle`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(requestBody)
-    });
-    const result = await response.json();
-    if (!response.ok || !result.success) {
-      throw new Error(result.error || result.errorReason || "Settlement failed");
-    }
-    return {
-      transaction: result.transaction,
-      status: result.status || "settled"
-    };
-  }
   async readBody(req) {
     return new Promise((resolve, reject) => {
       let body = "";