moltspay 0.8.14 → 0.9.0

package/dist/index.mjs

@@ -2891,7 +2891,7 @@ function alphabet(letters) {
   };
 }
 // @__NO_SIDE_EFFECTS__
-function join4(separator = "") {
+function join5(separator = "") {
   astr("join", separator);
   return {
     encode: (from) => {
@@ -3098,10 +3098,10 @@ var init_esm = __esm({
       convertRadix2,
       radix,
       radix2,
-      join: join4,
+      join: join5,
       padding
     };
-    genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => /* @__PURE__ */ chain(/* @__PURE__ */ radix(58), /* @__PURE__ */ alphabet(abc), /* @__PURE__ */ join4(""));
+    genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => /* @__PURE__ */ chain(/* @__PURE__ */ radix(58), /* @__PURE__ */ alphabet(abc), /* @__PURE__ */ join5(""));
     base58 = /* @__PURE__ */ genBase58("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
     createBase58check = (sha2566) => /* @__PURE__ */ chain(checksum(4, (data) => sha2566(sha2566(data))), base58);
   }
@@ -3249,14 +3249,14 @@ var init_esm2 = __esm({
         }
         this.pubHash = hash160(this.pubKey);
       }
-      derive(path4) {
-        if (!/^[mM]'?/.test(path4)) {
+      derive(path5) {
+        if (!/^[mM]'?/.test(path5)) {
           throw new Error('Path must start with "m" or "M"');
         }
-        if (/^[mM]'?$/.test(path4)) {
+        if (/^[mM]'?$/.test(path5)) {
           return this;
         }
-        const parts = path4.replace(/^[mM]'?\//, "").split("/");
+        const parts = path5.replace(/^[mM]'?\//, "").split("/");
         let child = this;
         for (const c of parts) {
           const m = /^(\d+)('?)$/.exec(c);
@@ -9617,8 +9617,8 @@ var init_privateKeyToAccount = __esm({
 });
 
 // node_modules/viem/_esm/accounts/hdKeyToAccount.js
-function hdKeyToAccount(hdKey_, { accountIndex = 0, addressIndex = 0, changeIndex = 0, path: path4, ...options } = {}) {
-  const hdKey = hdKey_.derive(path4 || `m/44'/60'/${accountIndex}'/${changeIndex}/${addressIndex}`);
+function hdKeyToAccount(hdKey_, { accountIndex = 0, addressIndex = 0, changeIndex = 0, path: path5, ...options } = {}) {
+  const hdKey = hdKey_.derive(path5 || `m/44'/60'/${accountIndex}'/${changeIndex}/${addressIndex}`);
   const account = privateKeyToAccount(toHex(hdKey.privateKey), options);
   return {
     ...account,
@@ -30330,20 +30330,478 @@ init_esm_shims();
 
 // src/server/index.ts
 init_esm_shims();
-import { readFileSync, existsSync } from "fs";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
 import { createServer } from "http";
+import * as path3 from "path";
+
+// src/facilitators/index.ts
+init_esm_shims();
+
+// src/facilitators/interface.ts
+init_esm_shims();
+var BaseFacilitator = class {
+  supportsNetwork(network) {
+    return this.supportedNetworks.includes(network);
+  }
+};
+
+// src/facilitators/cdp.ts
+init_esm_shims();
+import { readFileSync, existsSync } from "fs";
 import * as path2 from "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 = [
+    path2.join(process.cwd(), ".env"),
+    path2.join(process.env.HOME || "", ".moltspay", ".env")
+  ];
+  for (const envPath of envPaths) {
+    if (existsSync(envPath)) {
+      try {
+        const content = 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
+init_esm_shims();
+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 };
+  }
+};
+var defaultRegistry = null;
+function getDefaultRegistry() {
+  if (!defaultRegistry) {
+    defaultRegistry = new FacilitatorRegistry();
+  }
+  return defaultRegistry;
+}
+function createRegistry(selection) {
+  return new FacilitatorRegistry(selection);
+}
 
 // src/server/types.ts
 init_esm_shims();
 
 // src/server/index.ts
-var X402_VERSION = 2;
+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
@@ -30354,15 +30812,15 @@ var USDC_DOMAIN = {
   name: "USD Coin",
   version: "2"
 };
-function loadEnvFiles() {
+function loadEnvFile2() {
   const envPaths = [
-    path2.join(process.cwd(), ".env"),
-    path2.join(process.env.HOME || "", ".moltspay", ".env")
+    path3.join(process.cwd(), ".env"),
+    path3.join(process.env.HOME || "", ".moltspay", ".env")
   ];
   for (const envPath of envPaths) {
-    if (existsSync(envPath)) {
+    if (existsSync2(envPath)) {
       try {
-        const content = readFileSync(envPath, "utf-8");
+        const content = readFileSync2(envPath, "utf-8");
         for (const line of content.split("\n")) {
           const trimmed = line.trim();
           if (!trimmed || trimmed.startsWith("#")) continue;
@@ -30379,77 +30837,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 = readFileSync(servicesPath, "utf-8");
+    loadEnvFile2();
+    const content = readFileSync2(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)`);
   }
   /**
@@ -30475,6 +30900,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)`);
     });
   }
   /**
@@ -30495,6 +30921,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];
@@ -30520,18 +30949,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
    */
@@ -30563,11 +31011,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 {
@@ -30582,17 +31035,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)
@@ -30601,7 +31055,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);
   }
   /**
@@ -30610,7 +31064,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}`,
@@ -30633,7 +31087,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;
@@ -30647,7 +31101,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();
@@ -30662,77 +31116,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 = "";
@@ -30759,9 +31142,9 @@ var MoltsPayServer = class {
 
 // src/client/index.ts
 init_esm_shims();
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync, statSync, chmodSync } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync, mkdirSync, statSync, chmodSync } from "fs";
 import { homedir } from "os";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { Wallet, ethers } from "ethers";
 
 // src/chains/index.ts
@@ -30846,7 +31229,7 @@ var ERC20_ABI = [
 init_esm_shims();
 
 // src/client/index.ts
-var X402_VERSION2 = 2;
+var X402_VERSION3 = 2;
 var PAYMENT_REQUIRED_HEADER2 = "x-payment-required";
 var PAYMENT_HEADER2 = "x-payment";
 var DEFAULT_CONFIG = {
@@ -30864,7 +31247,7 @@ var MoltsPayClient = class {
   todaySpending = 0;
   lastSpendingReset = 0;
   constructor(options = {}) {
-    this.configDir = options.configDir || join2(homedir(), ".moltspay");
+    this.configDir = options.configDir || join3(homedir(), ".moltspay");
     this.config = this.loadConfig();
     this.walletData = this.loadWallet();
     this.loadSpending();
@@ -30972,7 +31355,7 @@ var MoltsPayClient = class {
     }
     const authorization = await this.signEIP3009(payTo, amount, chain2);
     const payload = {
-      x402Version: X402_VERSION2,
+      x402Version: X402_VERSION3,
       payload: authorization,
       // v2 requires 'accepted' field with the requirements being fulfilled
       accepted: {
@@ -31069,26 +31452,26 @@ var MoltsPayClient = class {
   }
   // --- Config & Wallet Management ---
   loadConfig() {
-    const configPath = join2(this.configDir, "config.json");
-    if (existsSync2(configPath)) {
-      const content = readFileSync2(configPath, "utf-8");
+    const configPath = join3(this.configDir, "config.json");
+    if (existsSync3(configPath)) {
+      const content = readFileSync3(configPath, "utf-8");
       return { ...DEFAULT_CONFIG, ...JSON.parse(content) };
     }
     return { ...DEFAULT_CONFIG };
   }
   saveConfig() {
     mkdirSync(this.configDir, { recursive: true });
-    const configPath = join2(this.configDir, "config.json");
+    const configPath = join3(this.configDir, "config.json");
     writeFileSync(configPath, JSON.stringify(this.config, null, 2));
   }
   /**
    * Load spending data from disk
    */
   loadSpending() {
-    const spendingPath = join2(this.configDir, "spending.json");
-    if (existsSync2(spendingPath)) {
+    const spendingPath = join3(this.configDir, "spending.json");
+    if (existsSync3(spendingPath)) {
       try {
-        const data = JSON.parse(readFileSync2(spendingPath, "utf-8"));
+        const data = JSON.parse(readFileSync3(spendingPath, "utf-8"));
         const today = (/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0);
         if (data.date && data.date === today) {
           this.todaySpending = data.amount || 0;
@@ -31108,7 +31491,7 @@ var MoltsPayClient = class {
    */
   saveSpending() {
     mkdirSync(this.configDir, { recursive: true });
-    const spendingPath = join2(this.configDir, "spending.json");
+    const spendingPath = join3(this.configDir, "spending.json");
     const data = {
       date: this.lastSpendingReset || (/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0),
       amount: this.todaySpending,
@@ -31117,8 +31500,8 @@ var MoltsPayClient = class {
     writeFileSync(spendingPath, JSON.stringify(data, null, 2));
   }
   loadWallet() {
-    const walletPath = join2(this.configDir, "wallet.json");
-    if (existsSync2(walletPath)) {
+    const walletPath = join3(this.configDir, "wallet.json");
+    if (existsSync3(walletPath)) {
       try {
         const stats = statSync(walletPath);
         const mode = stats.mode & 511;
@@ -31129,7 +31512,7 @@ var MoltsPayClient = class {
         }
       } catch (err) {
       }
-      const content = readFileSync2(walletPath, "utf-8");
+      const content = readFileSync3(walletPath, "utf-8");
       return JSON.parse(content);
     }
     return null;
@@ -31145,7 +31528,7 @@ var MoltsPayClient = class {
       privateKey: wallet.privateKey,
       createdAt: Date.now()
     };
-    const walletPath = join2(configDir, "wallet.json");
+    const walletPath = join3(configDir, "wallet.json");
     writeFileSync(walletPath, JSON.stringify(walletData, null, 2), { mode: 384 });
     const config = {
       chain: options.chain,
@@ -31154,7 +31537,7 @@ var MoltsPayClient = class {
         maxPerDay: options.maxPerDay
       }
     };
-    const configPath = join2(configDir, "config.json");
+    const configPath = join3(configDir, "config.json");
     writeFileSync(configPath, JSON.stringify(config, null, 2));
     return { address: wallet.address, configDir };
   }
@@ -31193,10 +31576,10 @@ import { ethers as ethers2 } from "ethers";
 // src/wallet/createWallet.ts
 init_esm_shims();
 import { ethers as ethers3 } from "ethers";
-import { writeFileSync as writeFileSync2, readFileSync as readFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
-import { join as join3, dirname } from "path";
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync4, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
+import { join as join4, dirname } from "path";
 import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "crypto";
-var DEFAULT_STORAGE_DIR = join3(process.env.HOME || "~", ".moltspay");
+var DEFAULT_STORAGE_DIR = join4(process.env.HOME || "~", ".moltspay");
 var DEFAULT_STORAGE_FILE = "wallet.json";
 function encryptPrivateKey(privateKey, password) {
   const salt = randomBytes(16);
@@ -31219,10 +31602,10 @@ function decryptPrivateKey(encrypted, password, iv, salt) {
   return decrypted;
 }
 function createWallet(options = {}) {
-  const storagePath = options.storagePath || join3(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
-  if (existsSync3(storagePath) && !options.overwrite) {
+  const storagePath = options.storagePath || join4(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
+  if (existsSync4(storagePath) && !options.overwrite) {
     try {
-      const existing = JSON.parse(readFileSync3(storagePath, "utf8"));
+      const existing = JSON.parse(readFileSync4(storagePath, "utf8"));
       return {
         success: true,
         address: existing.address,
@@ -31254,7 +31637,7 @@ function createWallet(options = {}) {
       walletData.privateKey = wallet.privateKey;
     }
     const dir = dirname(storagePath);
-    if (!existsSync3(dir)) {
+    if (!existsSync4(dir)) {
       mkdirSync2(dir, { recursive: true });
     }
     writeFileSync2(storagePath, JSON.stringify(walletData, null, 2), { mode: 384 });
@@ -31272,12 +31655,12 @@ function createWallet(options = {}) {
   }
 }
 function loadWallet(options = {}) {
-  const storagePath = options.storagePath || join3(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
-  if (!existsSync3(storagePath)) {
+  const storagePath = options.storagePath || join4(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
+  if (!existsSync4(storagePath)) {
     return { success: false, error: "Wallet not found. Run createWallet() first." };
   }
   try {
-    const data = JSON.parse(readFileSync3(storagePath, "utf8"));
+    const data = JSON.parse(readFileSync4(storagePath, "utf8"));
     if (data.encrypted) {
       if (!options.password) {
         return { success: false, error: "Wallet is encrypted. Password required." };
@@ -31292,20 +31675,20 @@ function loadWallet(options = {}) {
   }
 }
 function getWalletAddress(storagePath) {
-  const path4 = storagePath || join3(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
-  if (!existsSync3(path4)) {
+  const path5 = storagePath || join4(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
+  if (!existsSync4(path5)) {
     return null;
   }
   try {
-    const data = JSON.parse(readFileSync3(path4, "utf8"));
+    const data = JSON.parse(readFileSync4(path5, "utf8"));
     return data.address;
   } catch {
     return null;
   }
 }
 function walletExists(storagePath) {
-  const path4 = storagePath || join3(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
-  return existsSync3(path4);
+  const path5 = storagePath || join4(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
+  return existsSync4(path5);
 }
 
 // src/verify/index.ts
@@ -31448,8 +31831,8 @@ async function waitForTransaction(txHash, chain2 = "base", confirmations = 1, ti
 // src/cdp/index.ts
 init_esm_shims();
 import * as fs from "fs";
-import * as path3 from "path";
-var DEFAULT_STORAGE_DIR2 = path3.join(process.env.HOME || ".", ".moltspay");
+import * as path4 from "path";
+var DEFAULT_STORAGE_DIR2 = path4.join(process.env.HOME || ".", ".moltspay");
 var CDP_CONFIG_FILE = "cdp-wallet.json";
 function isCDPAvailable() {
   try {
@@ -31471,7 +31854,7 @@ function getCDPCredentials(config) {
 async function initCDPWallet(config = {}) {
   const storageDir = config.storageDir || DEFAULT_STORAGE_DIR2;
   const chain2 = config.chain || "base";
-  const storagePath = path3.join(storageDir, CDP_CONFIG_FILE);
+  const storagePath = path4.join(storageDir, CDP_CONFIG_FILE);
   if (fs.existsSync(storagePath)) {
     try {
       const data = JSON.parse(fs.readFileSync(storagePath, "utf-8"));
@@ -31533,7 +31916,7 @@ async function initCDPWallet(config = {}) {
 }
 function loadCDPWallet(config = {}) {
   const storageDir = config.storageDir || DEFAULT_STORAGE_DIR2;
-  const storagePath = path3.join(storageDir, CDP_CONFIG_FILE);
+  const storagePath = path4.join(storageDir, CDP_CONFIG_FILE);
   if (!fs.existsSync(storagePath)) {
     return null;
   }
@@ -31651,15 +32034,20 @@ var CDPWallet = class {
   }
 };
 export {
+  BaseFacilitator,
+  CDPFacilitator,
   CDPWallet,
   CHAINS,
   ERC20_ABI,
+  FacilitatorRegistry,
   MoltsPayClient,
   MoltsPayServer,
+  createRegistry,
   createWallet,
   getCDPWalletAddress,
   getChain,
   getChainById,
+  getDefaultRegistry,
   getTransactionStatus,
   getWalletAddress,
   initCDPWallet,