moltspay 0.8.14 → 0.9.0

package/dist/cli/index.js

@@ -27,7 +27,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var import_commander = require("commander");
 var import_os2 = require("os");
 var import_path2 = require("path");
-var import_fs3 = require("fs");
+var import_fs4 = require("fs");
 var import_child_process = require("child_process");
 
 // src/client/index.ts
@@ -433,15 +433,459 @@ var MoltsPayClient = class {
 };
 
 // src/server/index.ts
-var import_fs2 = require("fs");
+var import_fs3 = 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_fs2 = require("fs");
 var path = __toESM(require("path"));
 var X402_VERSION2 = 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_fs2.existsSync)(envPath)) {
+      try {
+        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;
+          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_VERSION2,
+        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_VERSION2,
+        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_VERSION3 = 2;
 var PAYMENT_REQUIRED_HEADER2 = "x-payment-required";
 var PAYMENT_HEADER2 = "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
@@ -452,15 +896,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_fs2.existsSync)(envPath)) {
+    if ((0, import_fs3.existsSync)(envPath)) {
       try {
-        const content = (0, import_fs2.readFileSync)(envPath, "utf-8");
+        const content = (0, import_fs3.readFileSync)(envPath, "utf-8");
         for (const line of content.split("\n")) {
           const trimmed = line.trim();
           if (!trimmed || trimmed.startsWith("#")) continue;
@@ -477,77 +921,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_fs2.readFileSync)(servicesPath, "utf-8");
+    loadEnvFile2();
+    const content = (0, import_fs3.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)`);
   }
   /**
@@ -573,6 +984,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)`);
     });
   }
   /**
@@ -593,6 +1005,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_HEADER2];
@@ -618,18 +1033,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_VERSION2,
+        version: X402_VERSION3,
         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
    */
@@ -661,11 +1095,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 {
@@ -680,17 +1119,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)
@@ -699,7 +1139,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);
   }
   /**
@@ -708,7 +1148,7 @@ var MoltsPayServer = class {
   sendPaymentRequired(config, res) {
     const requirements = this.buildPaymentRequirements(config);
     const paymentRequired = {
-      x402Version: X402_VERSION2,
+      x402Version: X402_VERSION3,
       accepts: [requirements],
       resource: {
         url: `/execute?service=${config.id}`,
@@ -731,7 +1171,7 @@ var MoltsPayServer = class {
    * Basic payment validation
    */
   validatePayment(payment, config) {
-    if (payment.x402Version !== X402_VERSION2) {
+    if (payment.x402Version !== X402_VERSION3) {
       return { valid: false, error: `Unsupported x402 version: ${payment.x402Version}` };
     }
     const scheme = payment.accepted?.scheme || payment.scheme;
@@ -745,7 +1185,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();
@@ -760,77 +1200,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_VERSION2,
-        // 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_VERSION2,
-      // 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((resolve2, reject) => {
       let body = "";
@@ -860,8 +1229,8 @@ var readline = __toESM(require("readline"));
 var program = new import_commander.Command();
 var DEFAULT_CONFIG_DIR = (0, import_path2.join)((0, import_os2.homedir)(), ".moltspay");
 var PID_FILE = (0, import_path2.join)(DEFAULT_CONFIG_DIR, "server.pid");
-if (!(0, import_fs3.existsSync)(DEFAULT_CONFIG_DIR)) {
-  (0, import_fs3.mkdirSync)(DEFAULT_CONFIG_DIR, { recursive: true });
+if (!(0, import_fs4.existsSync)(DEFAULT_CONFIG_DIR)) {
+  (0, import_fs4.mkdirSync)(DEFAULT_CONFIG_DIR, { recursive: true });
 }
 function prompt(question) {
   const rl = readline.createInterface({
@@ -878,7 +1247,7 @@ function prompt(question) {
 program.name("moltspay").description("MoltsPay - Payment infrastructure for AI Agents").version("1.0.0");
 program.command("init").description("Initialize MoltsPay client (create wallet, set limits)").option("--chain <chain>", "Blockchain to use", "base").option("--max-per-tx <amount>", "Max amount per transaction").option("--max-per-day <amount>", "Max amount per day").option("--config-dir <dir>", "Config directory", DEFAULT_CONFIG_DIR).action(async (options) => {
   console.log("\n\u{1F510} MoltsPay Client Setup\n");
-  if ((0, import_fs3.existsSync)((0, import_path2.join)(options.configDir, "wallet.json"))) {
+  if ((0, import_fs4.existsSync)((0, import_path2.join)(options.configDir, "wallet.json"))) {
     console.log('\u26A0\uFE0F  Already initialized. Use "moltspay config" to update settings.');
     console.log(`   Config dir: ${options.configDir}`);
     return;
@@ -1027,14 +1396,14 @@ program.command("start <paths...>").description("Start MoltsPay server from skil
     let manifestPath;
     let skillDir;
     let isSkillDir = false;
-    if ((0, import_fs3.existsSync)((0, import_path2.join)(resolvedPath, "moltspay.services.json"))) {
+    if ((0, import_fs4.existsSync)((0, import_path2.join)(resolvedPath, "moltspay.services.json"))) {
       manifestPath = (0, import_path2.join)(resolvedPath, "moltspay.services.json");
       skillDir = resolvedPath;
       isSkillDir = true;
-    } else if ((0, import_fs3.existsSync)(resolvedPath) && resolvedPath.endsWith(".json")) {
+    } else if ((0, import_fs4.existsSync)(resolvedPath) && resolvedPath.endsWith(".json")) {
       manifestPath = resolvedPath;
       skillDir = (0, import_path2.dirname)(resolvedPath);
-    } else if ((0, import_fs3.existsSync)(resolvedPath)) {
+    } else if ((0, import_fs4.existsSync)(resolvedPath)) {
       console.error(`\u274C No moltspay.services.json found in: ${resolvedPath}`);
       continue;
     } else {
@@ -1043,20 +1412,33 @@ program.command("start <paths...>").description("Start MoltsPay server from skil
     }
     console.log(`\u{1F4E6} Loading: ${manifestPath}`);
     try {
-      const manifestContent = JSON.parse((0, import_fs3.readFileSync)(manifestPath, "utf-8"));
+      const manifestContent = JSON.parse((0, import_fs4.readFileSync)(manifestPath, "utf-8"));
       if (!provider) {
         provider = manifestContent.provider;
       }
       let skillModule = null;
       if (isSkillDir) {
-        const indexPath = (0, import_path2.join)(skillDir, "index.js");
-        if ((0, import_fs3.existsSync)(indexPath)) {
+        let entryPoint = "index.js";
+        const pkgJsonPath = (0, import_path2.join)(skillDir, "package.json");
+        if ((0, import_fs4.existsSync)(pkgJsonPath)) {
           try {
-            skillModule = await import(indexPath);
-            console.log(`   \u2705 Loaded module: ${indexPath}`);
+            const pkgJson = JSON.parse((0, import_fs4.readFileSync)(pkgJsonPath, "utf-8"));
+            if (pkgJson.main) {
+              entryPoint = pkgJson.main;
+            }
+          } catch {
+          }
+        }
+        const modulePath = (0, import_path2.join)(skillDir, entryPoint);
+        if ((0, import_fs4.existsSync)(modulePath)) {
+          try {
+            skillModule = await import(modulePath);
+            console.log(`   \u2705 Loaded module: ${modulePath}`);
           } catch (err) {
             console.error(`   \u26A0\uFE0F  Failed to load module: ${err.message}`);
           }
+        } else {
+          console.error(`   \u26A0\uFE0F  Entry point not found: ${modulePath}`);
         }
       }
       for (const service of manifestContent.services) {
@@ -1127,7 +1509,7 @@ program.command("start <paths...>").description("Start MoltsPay server from skil
     services: allServices
   };
   const tempManifestPath = (0, import_path2.join)(DEFAULT_CONFIG_DIR, "combined-manifest.json");
-  (0, import_fs3.writeFileSync)(tempManifestPath, JSON.stringify(combinedManifest, null, 2));
+  (0, import_fs4.writeFileSync)(tempManifestPath, JSON.stringify(combinedManifest, null, 2));
   console.log(`
 \u{1F4CB} Combined manifest: ${allServices.length} services`);
   console.log(`   Provider: ${provider.name}`);
@@ -1140,12 +1522,12 @@ program.command("start <paths...>").description("Start MoltsPay server from skil
       server.skill(serviceId, handler);
     }
     const pidData = { pid: process.pid, port, paths: allPaths };
-    (0, import_fs3.writeFileSync)(PID_FILE, JSON.stringify(pidData, null, 2));
+    (0, import_fs4.writeFileSync)(PID_FILE, JSON.stringify(pidData, null, 2));
     server.listen(port);
     const cleanup = () => {
       try {
-        if ((0, import_fs3.existsSync)(PID_FILE)) (0, import_fs3.unlinkSync)(PID_FILE);
-        if ((0, import_fs3.existsSync)(tempManifestPath)) (0, import_fs3.unlinkSync)(tempManifestPath);
+        if ((0, import_fs4.existsSync)(PID_FILE)) (0, import_fs4.unlinkSync)(PID_FILE);
+        if ((0, import_fs4.existsSync)(tempManifestPath)) (0, import_fs4.unlinkSync)(tempManifestPath);
       } catch {
       }
     };
@@ -1166,12 +1548,12 @@ program.command("start <paths...>").description("Start MoltsPay server from skil
   }
 });
 program.command("stop").description("Stop the running MoltsPay server").action(async () => {
-  if (!(0, import_fs3.existsSync)(PID_FILE)) {
+  if (!(0, import_fs4.existsSync)(PID_FILE)) {
     console.log("\u274C No running server found (no PID file)");
     process.exit(1);
   }
   try {
-    const pidData = JSON.parse((0, import_fs3.readFileSync)(PID_FILE, "utf-8"));
+    const pidData = JSON.parse((0, import_fs4.readFileSync)(PID_FILE, "utf-8"));
     const { pid, port, manifest } = pidData;
     console.log(`
 \u{1F6D1} Stopping MoltsPay Server
@@ -1184,7 +1566,7 @@ program.command("stop").description("Stop the running MoltsPay server").action(a
       process.kill(pid, 0);
     } catch {
       console.log("\u26A0\uFE0F  Process not running, cleaning up PID file...");
-      (0, import_fs3.unlinkSync)(PID_FILE);
+      (0, import_fs4.unlinkSync)(PID_FILE);
       process.exit(0);
     }
     process.kill(pid, "SIGTERM");
@@ -1196,8 +1578,8 @@ program.command("stop").description("Stop the running MoltsPay server").action(a
       process.kill(pid, "SIGKILL");
     } catch {
     }
-    if ((0, import_fs3.existsSync)(PID_FILE)) {
-      (0, import_fs3.unlinkSync)(PID_FILE);
+    if ((0, import_fs4.existsSync)(PID_FILE)) {
+      (0, import_fs4.unlinkSync)(PID_FILE);
     }
     console.log("\u2705 Server stopped\n");
   } catch (err) {
@@ -1227,11 +1609,11 @@ program.command("pay <server> <service> [params]").description("Pay for a servic
       params.image_url = imagePath;
     } else {
       const filePath = (0, import_path2.resolve)(imagePath);
-      if (!(0, import_fs3.existsSync)(filePath)) {
+      if (!(0, import_fs4.existsSync)(filePath)) {
         console.error(`\u274C Image file not found: ${filePath}`);
         process.exit(1);
       }
-      const imageData = (0, import_fs3.readFileSync)(filePath);
+      const imageData = (0, import_fs4.readFileSync)(filePath);
       params.image_base64 = imageData.toString("base64");
     }
   }
@@ -1272,9 +1654,9 @@ program.command("pay <server> <service> [params]").description("Pay for a servic
 program.command("validate <path>").description("Validate a moltspay.services.json file against the schema").action(async (inputPath) => {
   const resolvedPath = (0, import_path2.resolve)(inputPath);
   let manifestPath;
-  if ((0, import_fs3.existsSync)((0, import_path2.join)(resolvedPath, "moltspay.services.json"))) {
+  if ((0, import_fs4.existsSync)((0, import_path2.join)(resolvedPath, "moltspay.services.json"))) {
     manifestPath = (0, import_path2.join)(resolvedPath, "moltspay.services.json");
-  } else if (resolvedPath.endsWith(".json") && (0, import_fs3.existsSync)(resolvedPath)) {
+  } else if (resolvedPath.endsWith(".json") && (0, import_fs4.existsSync)(resolvedPath)) {
     manifestPath = resolvedPath;
   } else {
     console.error(`\u274C Not found: ${resolvedPath}`);
@@ -1284,7 +1666,7 @@ program.command("validate <path>").description("Validate a moltspay.services.jso
 \u{1F4CB} Validating: ${manifestPath}
 `);
   try {
-    const content = JSON.parse((0, import_fs3.readFileSync)(manifestPath, "utf-8"));
+    const content = JSON.parse((0, import_fs4.readFileSync)(manifestPath, "utf-8"));
     const errors = [];
     if (!content.provider) {
       errors.push("Missing required field: provider");