moltspay 0.8.0 → 0.8.2

package/.env.example

@@ -0,0 +1,10 @@
+# MoltsPay Server Configuration
+# Copy to ~/.moltspay/.env or ./.env and fill in values
+
+# Network: true = Base mainnet, false = Base Sepolia testnet
+USE_MAINNET=true
+
+# CDP API Credentials (required for mainnet)
+# Get from: https://portal.cdp.coinbase.com/
+CDP_API_KEY_ID=
+CDP_API_KEY_SECRET=

package/dist/cli/index.js

@@ -367,38 +367,96 @@ var MoltsPayClient = class {
 // src/server/index.ts
 var import_fs2 = require("fs");
 var import_http = require("http");
-var import_ethers2 = require("ethers");
+var path = __toESM(require("path"));
 var X402_VERSION2 = 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";
+function loadEnvFiles() {
+  try {
+    const dotenv = require("dotenv");
+    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)) {
+        dotenv.config({ path: envPath });
+        console.log(`[MoltsPay] Loaded config from ${envPath}`);
+        break;
+      }
+    }
+  } 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;
-  provider = null;
-  wallet = null;
+  cdpConfig;
+  facilitatorUrl;
+  networkId;
   constructor(servicesPath, options = {}) {
+    this.cdpConfig = getCDPConfig();
     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",
-      privateKey: options.privateKey || process.env.MOLTSPAY_PRIVATE_KEY
+      host: options.host || "0.0.0.0"
     };
-    if (this.options.privateKey) {
-      try {
-        const chain = getChain(this.manifest.provider.chain);
-        this.provider = new import_ethers2.ethers.JsonRpcProvider(chain.rpc);
-        this.wallet = new import_ethers2.ethers.Wallet(this.options.privateKey, this.provider);
-        console.log(`[MoltsPay] Payment wallet: ${this.wallet.address}`);
-      } catch (err) {
-        console.warn("[MoltsPay] Warning: Could not initialize wallet for payment claims");
+    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.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";
     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] Protocol: x402 (gasless, pay-for-success)`);
+    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] Protocol: x402 (gasless for both client AND server)`);
   }
   /**
    * Register a skill handler for a service
@@ -408,48 +466,45 @@ var MoltsPayServer = class {
     if (!config) {
       throw new Error(`Service '${serviceId}' not found in manifest`);
     }
-    this.skills.set(serviceId, {
-      id: serviceId,
-      config,
-      handler
-    });
-    console.log(`[MoltsPay] Registered skill: ${serviceId} ($${config.price} ${config.currency})`);
+    this.skills.set(serviceId, { id: serviceId, config, handler });
     return this;
   }
   /**
-   * Start the server
+   * Start HTTP server
    */
   listen(port) {
-    const p = port || this.options.port;
+    const p = port || this.options.port || 3e3;
+    const host = this.options.host || "0.0.0.0";
     const server = (0, import_http.createServer)((req, res) => this.handleRequest(req, res));
-    server.listen(p, this.options.host, () => {
-      console.log(`[MoltsPay] Server listening on http://${this.options.host}:${p}`);
+    server.listen(p, host, () => {
+      console.log(`[MoltsPay] Server listening on http://${host}:${p}`);
       console.log(`[MoltsPay] Endpoints:`);
       console.log(`  GET  /services     - List available services`);
       console.log(`  POST /execute      - Execute service (x402 payment)`);
     });
   }
+  /**
+   * Handle incoming request
+   */
   async handleRequest(req, res) {
-    const url = new URL(req.url || "/", `http://${req.headers.host}`);
-    const path = url.pathname;
-    const method = req.method || "GET";
     res.setHeader("Access-Control-Allow-Origin", "*");
     res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
     res.setHeader("Access-Control-Allow-Headers", "Content-Type, X-Payment");
     res.setHeader("Access-Control-Expose-Headers", "X-Payment-Required, X-Payment-Response");
-    if (method === "OPTIONS") {
+    if (req.method === "OPTIONS") {
       res.writeHead(204);
       res.end();
       return;
     }
     try {
-      if (method === "GET" && path === "/services") {
+      const url = new URL(req.url || "/", `http://${req.headers.host}`);
+      if (url.pathname === "/services" && req.method === "GET") {
         return this.handleGetServices(res);
       }
-      if (method === "POST" && path === "/execute") {
+      if (url.pathname === "/execute" && req.method === "POST") {
         const body = await this.readBody(req);
         const paymentHeader = req.headers[PAYMENT_HEADER2];
-        return this.handleExecute(body, paymentHeader, res);
+        return await this.handleExecute(body, paymentHeader, res);
       }
       this.sendJson(res, 404, { error: "Not found" });
     } catch (err) {
@@ -461,7 +516,6 @@ var MoltsPayServer = class {
    * GET /services - List available services
    */
   handleGetServices(res) {
-    const chain = getChain(this.manifest.provider.chain);
     const services = this.manifest.services.map((s) => ({
       id: s.id,
       name: s.name,
@@ -477,15 +531,15 @@ var MoltsPayServer = class {
       services,
       x402: {
         version: X402_VERSION2,
-        network: `eip155:${chain.chainId}`,
-        schemes: ["exact"]
+        network: this.networkId,
+        schemes: ["exact"],
+        facilitator: this.cdpConfig.useMainnet ? "cdp" : "x402.org",
+        mainnet: this.cdpConfig.useMainnet
       }
     });
   }
   /**
    * POST /execute - Execute service with x402 payment
-   * Body: { service: string, params: object }
-   * Header: X-Payment (optional - if missing, returns 402)
    */
   async handleExecute(body, paymentHeader, res) {
     const { service, params } = body;
@@ -515,6 +569,11 @@ 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);
+    if (!verifyResult.valid) {
+      return this.sendJson(res, 402, { error: `Payment verification failed: ${verifyResult.error}` });
+    }
     console.log(`[MoltsPay] Executing skill: ${service}`);
     let result;
     try {
@@ -526,32 +585,46 @@ var MoltsPayServer = class {
         message: err.message
       });
     }
-    console.log(`[MoltsPay] Skill succeeded, claiming payment...`);
-    let txHash = null;
+    console.log(`[MoltsPay] Skill succeeded, settling payment...`);
+    let settlement = null;
     try {
-      txHash = await this.claimPayment(payment);
-      console.log(`[MoltsPay] Payment claimed: ${txHash}`);
+      settlement = await this.settleWithFacilitator(payment, skill.config);
+      console.log(`[MoltsPay] Payment settled: ${settlement.transaction || "pending"}`);
     } catch (err) {
-      console.error("[MoltsPay] Payment claim failed:", err.message);
+      console.error("[MoltsPay] Settlement failed:", err.message);
+    }
+    const responseHeaders = {};
+    if (settlement) {
+      const responsePayload = {
+        success: true,
+        transaction: settlement.transaction,
+        network: payment.network
+      };
+      responseHeaders[PAYMENT_RESPONSE_HEADER] = Buffer.from(
+        JSON.stringify(responsePayload)
+      ).toString("base64");
     }
     this.sendJson(res, 200, {
       success: true,
       result,
-      payment: txHash ? { txHash, status: "claimed" } : { status: "pending" }
-    });
+      payment: settlement ? { transaction: settlement.transaction, status: "settled" } : { status: "pending" }
+    }, responseHeaders);
   }
   /**
    * Return 402 with x402 payment requirements
    */
   sendPaymentRequired(config, res) {
-    const chain = getChain(this.manifest.provider.chain);
     const amountInUnits = Math.floor(config.price * 1e6).toString();
     const requirements = [{
       scheme: "exact",
-      network: `eip155:${chain.chainId}`,
+      network: this.networkId,
       maxAmountRequired: amountInUnits,
       resource: this.manifest.provider.wallet,
-      description: `${config.name} - $${config.price} ${config.currency}`
+      description: `${config.name} - $${config.price} ${config.currency}`,
+      extra: JSON.stringify({
+        facilitator: this.cdpConfig.useMainnet ? "cdp" : "x402.org",
+        mainnet: this.cdpConfig.useMainnet
+      })
     }];
     const encoded = Buffer.from(JSON.stringify(requirements)).toString("base64");
     res.writeHead(402, {
@@ -565,7 +638,7 @@ var MoltsPayServer = class {
     }, null, 2));
   }
   /**
-   * Validate x402 payment payload
+   * Basic payment validation
    */
   validatePayment(payment, config) {
     if (payment.x402Version !== X402_VERSION2) {
@@ -574,56 +647,89 @@ var MoltsPayServer = class {
     if (payment.scheme !== "exact") {
       return { valid: false, error: `Unsupported scheme: ${payment.scheme}` };
     }
-    const chain = getChain(this.manifest.provider.chain);
-    const expectedNetwork = `eip155:${chain.chainId}`;
-    if (payment.network !== expectedNetwork) {
-      return { valid: false, error: `Network mismatch: expected ${expectedNetwork}` };
-    }
-    const auth = payment.payload.authorization;
-    if (auth.to.toLowerCase() !== this.manifest.provider.wallet.toLowerCase()) {
-      return { valid: false, error: "Payment recipient mismatch" };
-    }
-    const amount = Number(auth.value) / 1e6;
-    if (amount < config.price) {
-      return { valid: false, error: `Insufficient amount: $${amount} < $${config.price}` };
-    }
-    const now = Math.floor(Date.now() / 1e3);
-    if (Number(auth.validBefore) < now) {
-      return { valid: false, error: "Payment authorization expired" };
-    }
-    if (Number(auth.validAfter) > now) {
-      return { valid: false, error: "Payment authorization not yet valid" };
+    if (payment.network !== this.networkId) {
+      return { valid: false, error: `Network mismatch: expected ${this.networkId}, got ${payment.network}` };
     }
     return { valid: true };
   }
   /**
-   * Claim payment using transferWithAuthorization
+   * Verify payment with facilitator (testnet or CDP)
    */
-  async claimPayment(payment) {
-    if (!this.wallet || !this.provider) {
-      throw new Error("Wallet not configured for payment claims");
-    }
-    const chain = getChain(this.manifest.provider.chain);
-    const auth = payment.payload.authorization;
-    const sig = payment.payload.signature;
-    const { r, s, v } = import_ethers2.ethers.Signature.from(sig);
-    const usdcAbi = [
-      "function transferWithAuthorization(address from, address to, uint256 value, uint256 validAfter, uint256 validBefore, bytes32 nonce, uint8 v, bytes32 r, bytes32 s)"
-    ];
-    const usdc = new import_ethers2.ethers.Contract(chain.usdc, usdcAbi, this.wallet);
-    const tx = await usdc.transferWithAuthorization(
-      auth.from,
-      auth.to,
-      auth.value,
-      auth.validAfter,
-      auth.validBefore,
-      auth.nonce,
-      v,
-      r,
-      s
-    );
-    const receipt = await tx.wait();
-    return receipt.hash;
+  async verifyWithFacilitator(payment, config) {
+    try {
+      const amountInUnits = Math.floor(config.price * 1e6).toString();
+      const requirements = {
+        scheme: "exact",
+        network: this.networkId,
+        maxAmountRequired: amountInUnits,
+        resource: this.manifest.provider.wallet,
+        payTo: this.manifest.provider.wallet
+      };
+      const requestBody = {
+        paymentPayload: payment,
+        paymentRequirements: requirements
+      };
+      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();
+      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 amountInUnits = Math.floor(config.price * 1e6).toString();
+    const requirements = {
+      scheme: "exact",
+      network: this.networkId,
+      maxAmountRequired: amountInUnits,
+      resource: this.manifest.provider.wallet,
+      payTo: this.manifest.provider.wallet
+    };
+    const requestBody = {
+      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) => {
@@ -639,8 +745,12 @@ var MoltsPayServer = class {
       req.on("error", reject);
     });
   }
-  sendJson(res, status, data) {
-    res.writeHead(status, { "Content-Type": "application/json" });
+  sendJson(res, status, data, extraHeaders) {
+    const headers = { "Content-Type": "application/json" };
+    if (extraHeaders) {
+      Object.assign(headers, extraHeaders);
+    }
+    res.writeHead(status, headers);
     res.end(JSON.stringify(data, null, 2));
   }
 };
@@ -801,7 +911,7 @@ program.command("services <url>").description("List services from a provider").o
     console.error("\u274C Error:", err.message);
   }
 });
-program.command("start <manifest>").description("Start MoltsPay server from services manifest").option("-p, --port <port>", "Port to listen on", "3000").option("--host <host>", "Host to bind", "0.0.0.0").option("--private-key <key>", "Private key for claiming payments (or use MOLTSPAY_PRIVATE_KEY env)").action(async (manifest, options) => {
+program.command("start <manifest>").description("Start MoltsPay server from services manifest").option("-p, --port <port>", "Port to listen on", "3000").option("--host <host>", "Host to bind", "0.0.0.0").option("--facilitator <url>", "x402 facilitator URL (default: https://x402.org/facilitator)").action(async (manifest, options) => {
   const manifestPath = (0, import_path2.resolve)(manifest);
   if (!(0, import_fs3.existsSync)(manifestPath)) {
     console.error(`\u274C Manifest not found: ${manifestPath}`);
@@ -809,16 +919,15 @@ program.command("start <manifest>").description("Start MoltsPay server from serv
   }
   const port = parseInt(options.port, 10);
   const host = options.host;
-  const privateKey = options.privateKey || process.env.MOLTSPAY_PRIVATE_KEY;
+  const facilitatorUrl = options.facilitator;
   console.log(`
 \u{1F680} Starting MoltsPay Server (x402 protocol)
 `);
   console.log(`   Manifest: ${manifestPath}`);
   console.log(`   Port: ${port}`);
-  console.log(`   Payment claims: ${privateKey ? "enabled" : "disabled (no private key)"}`);
   console.log("");
   try {
-    const server = new MoltsPayServer(manifestPath, { port, host, privateKey });
+    const server = new MoltsPayServer(manifestPath, { port, host, facilitatorUrl });
     const manifestContent = await import("fs").then(
       (fs) => JSON.parse(fs.readFileSync(manifestPath, "utf-8"))
     );