moltspay 0.5.4 → 0.7.1

package/dist/server/index.d.mts

@@ -0,0 +1,120 @@
+/**
+ * MoltsPay Server Types
+ */
+interface ServiceConfig {
+    id: string;
+    name: string;
+    description?: string;
+    price: number;
+    currency: string;
+    input: Record<string, InputField>;
+    output: Record<string, OutputField>;
+    /** Shell command to execute for this service. Params passed as JSON to stdin. */
+    command?: string;
+}
+interface InputField {
+    type: 'string' | 'number' | 'boolean' | 'object';
+    required?: boolean;
+    description?: string;
+}
+interface OutputField {
+    type: 'string' | 'number' | 'boolean' | 'object';
+    description?: string;
+}
+interface ProviderConfig {
+    name: string;
+    description?: string;
+    wallet: string;
+    chain: string;
+}
+interface ServicesManifest {
+    provider: ProviderConfig;
+    services: ServiceConfig[];
+}
+type SkillFunction = (params: Record<string, any>) => Promise<Record<string, any>>;
+interface RegisteredSkill {
+    id: string;
+    config: ServiceConfig;
+    handler: SkillFunction;
+}
+interface PaymentRequest {
+    chargeId: string;
+    service: string;
+    amount: number;
+    currency: string;
+    wallet: string;
+    chain: string;
+    expiresAt: number;
+}
+interface VerifyRequest {
+    chargeId: string;
+    txHash: string;
+}
+type ChargeStatus = 'pending' | 'paid' | 'completed' | 'expired' | 'failed';
+interface Charge {
+    id: string;
+    service: string;
+    params: Record<string, any>;
+    amount: number;
+    currency: string;
+    status: ChargeStatus;
+    txHash?: string;
+    result?: Record<string, any>;
+    createdAt: number;
+    expiresAt: number;
+    paidAt?: number;
+    completedAt?: number;
+}
+interface MoltsPayServerOptions {
+    port?: number;
+    host?: string;
+    chargeExpirySecs?: number;
+}
+
+/**
+ * MoltsPay Server - Payment infrastructure for AI Agents
+ *
+ * Usage:
+ *   const server = new MoltsPayServer('./moltspay.services.json');
+ *   server.skill('text-to-video', async (params) => { ... });
+ *   server.listen(3000);
+ */
+
+declare class MoltsPayServer {
+    private manifest;
+    private skills;
+    private charges;
+    private options;
+    constructor(servicesPath: string, options?: MoltsPayServerOptions);
+    /**
+     * Register a skill handler for a service
+     */
+    skill(serviceId: string, handler: SkillFunction): this;
+    /**
+     * Start the server
+     */
+    listen(port?: number): void;
+    private handleRequest;
+    /**
+     * GET /services - List available services
+     */
+    private handleGetServices;
+    /**
+     * POST /pay - Create payment request
+     * Body: { service: string, params: object }
+     */
+    private handlePay;
+    /**
+     * POST /verify - Verify payment and execute skill
+     * Body: { chargeId: string, txHash: string }
+     */
+    private handleVerify;
+    /**
+     * GET /status/:chargeId - Check charge status
+     */
+    private handleStatus;
+    private readBody;
+    private sendJson;
+}
+
+export { type Charge, type ChargeStatus, type InputField, MoltsPayServer, type MoltsPayServerOptions, type OutputField, type PaymentRequest, type ProviderConfig, type RegisteredSkill, type ServiceConfig, type ServicesManifest, type SkillFunction, type VerifyRequest };

package/dist/server/index.d.ts

@@ -0,0 +1,120 @@
+/**
+ * MoltsPay Server Types
+ */
+interface ServiceConfig {
+    id: string;
+    name: string;
+    description?: string;
+    price: number;
+    currency: string;
+    input: Record<string, InputField>;
+    output: Record<string, OutputField>;
+    /** Shell command to execute for this service. Params passed as JSON to stdin. */
+    command?: string;
+}
+interface InputField {
+    type: 'string' | 'number' | 'boolean' | 'object';
+    required?: boolean;
+    description?: string;
+}
+interface OutputField {
+    type: 'string' | 'number' | 'boolean' | 'object';
+    description?: string;
+}
+interface ProviderConfig {
+    name: string;
+    description?: string;
+    wallet: string;
+    chain: string;
+}
+interface ServicesManifest {
+    provider: ProviderConfig;
+    services: ServiceConfig[];
+}
+type SkillFunction = (params: Record<string, any>) => Promise<Record<string, any>>;
+interface RegisteredSkill {
+    id: string;
+    config: ServiceConfig;
+    handler: SkillFunction;
+}
+interface PaymentRequest {
+    chargeId: string;
+    service: string;
+    amount: number;
+    currency: string;
+    wallet: string;
+    chain: string;
+    expiresAt: number;
+}
+interface VerifyRequest {
+    chargeId: string;
+    txHash: string;
+}
+type ChargeStatus = 'pending' | 'paid' | 'completed' | 'expired' | 'failed';
+interface Charge {
+    id: string;
+    service: string;
+    params: Record<string, any>;
+    amount: number;
+    currency: string;
+    status: ChargeStatus;
+    txHash?: string;
+    result?: Record<string, any>;
+    createdAt: number;
+    expiresAt: number;
+    paidAt?: number;
+    completedAt?: number;
+}
+interface MoltsPayServerOptions {
+    port?: number;
+    host?: string;
+    chargeExpirySecs?: number;
+}
+
+/**
+ * MoltsPay Server - Payment infrastructure for AI Agents
+ *
+ * Usage:
+ *   const server = new MoltsPayServer('./moltspay.services.json');
+ *   server.skill('text-to-video', async (params) => { ... });
+ *   server.listen(3000);
+ */
+
+declare class MoltsPayServer {
+    private manifest;
+    private skills;
+    private charges;
+    private options;
+    constructor(servicesPath: string, options?: MoltsPayServerOptions);
+    /**
+     * Register a skill handler for a service
+     */
+    skill(serviceId: string, handler: SkillFunction): this;
+    /**
+     * Start the server
+     */
+    listen(port?: number): void;
+    private handleRequest;
+    /**
+     * GET /services - List available services
+     */
+    private handleGetServices;
+    /**
+     * POST /pay - Create payment request
+     * Body: { service: string, params: object }
+     */
+    private handlePay;
+    /**
+     * POST /verify - Verify payment and execute skill
+     * Body: { chargeId: string, txHash: string }
+     */
+    private handleVerify;
+    /**
+     * GET /status/:chargeId - Check charge status
+     */
+    private handleStatus;
+    private readBody;
+    private sendJson;
+}
+
+export { type Charge, type ChargeStatus, type InputField, MoltsPayServer, type MoltsPayServerOptions, type OutputField, type PaymentRequest, type ProviderConfig, type RegisteredSkill, type ServiceConfig, type ServicesManifest, type SkillFunction, type VerifyRequest };

package/dist/server/index.js

@@ -0,0 +1,418 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server/index.ts
+var server_exports = {};
+__export(server_exports, {
+  MoltsPayServer: () => MoltsPayServer
+});
+module.exports = __toCommonJS(server_exports);
+var import_fs = require("fs");
+var import_http = require("http");
+
+// src/verify/index.ts
+var import_ethers = require("ethers");
+
+// src/chains/index.ts
+var CHAINS = {
+  // ============ Mainnet ============
+  base: {
+    name: "Base",
+    chainId: 8453,
+    rpc: "https://mainnet.base.org",
+    usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    explorer: "https://basescan.org/address/",
+    explorerTx: "https://basescan.org/tx/",
+    avgBlockTime: 2
+  },
+  polygon: {
+    name: "Polygon",
+    chainId: 137,
+    rpc: "https://polygon-rpc.com",
+    usdc: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+    explorer: "https://polygonscan.com/address/",
+    explorerTx: "https://polygonscan.com/tx/",
+    avgBlockTime: 2
+  },
+  ethereum: {
+    name: "Ethereum",
+    chainId: 1,
+    rpc: "https://eth.llamarpc.com",
+    usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    explorer: "https://etherscan.io/address/",
+    explorerTx: "https://etherscan.io/tx/",
+    avgBlockTime: 12
+  },
+  // ============ Testnet ============
+  base_sepolia: {
+    name: "Base Sepolia",
+    chainId: 84532,
+    rpc: "https://sepolia.base.org",
+    usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    explorer: "https://sepolia.basescan.org/address/",
+    explorerTx: "https://sepolia.basescan.org/tx/",
+    avgBlockTime: 2
+  },
+  sepolia: {
+    name: "Sepolia",
+    chainId: 11155111,
+    rpc: "https://rpc.sepolia.org",
+    usdc: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+    explorer: "https://sepolia.etherscan.io/address/",
+    explorerTx: "https://sepolia.etherscan.io/tx/",
+    avgBlockTime: 12
+  }
+};
+function getChain(name) {
+  const config = CHAINS[name];
+  if (!config) {
+    throw new Error(`Unsupported chain: ${name}. Supported: ${Object.keys(CHAINS).join(", ")}`);
+  }
+  return config;
+}
+function getChainById(chainId) {
+  return Object.values(CHAINS).find((c) => c.chainId === chainId);
+}
+
+// src/verify/index.ts
+var TRANSFER_EVENT_TOPIC = import_ethers.ethers.id("Transfer(address,address,uint256)");
+async function verifyPayment(params) {
+  const { txHash, expectedAmount, expectedTo } = params;
+  let chain;
+  try {
+    if (typeof params.chain === "number") {
+      chain = getChainById(params.chain);
+    } else {
+      chain = getChain(params.chain || "base");
+    }
+    if (!chain) {
+      return { verified: false, error: `Unsupported chain: ${params.chain}` };
+    }
+  } catch (e) {
+    return { verified: false, error: `Unsupported chain: ${params.chain}` };
+  }
+  try {
+    const provider = new import_ethers.ethers.JsonRpcProvider(chain.rpc);
+    const receipt = await provider.getTransactionReceipt(txHash);
+    if (!receipt) {
+      return { verified: false, error: "Transaction not found or not confirmed" };
+    }
+    if (receipt.status !== 1) {
+      return { verified: false, error: "Transaction failed" };
+    }
+    const usdcAddress = chain.usdc?.toLowerCase();
+    if (!usdcAddress) {
+      return { verified: false, error: `Chain ${chain.name} USDC address not configured` };
+    }
+    for (const log of receipt.logs) {
+      if (log.address.toLowerCase() !== usdcAddress) {
+        continue;
+      }
+      if (log.topics.length < 3 || log.topics[0] !== TRANSFER_EVENT_TOPIC) {
+        continue;
+      }
+      const from = "0x" + log.topics[1].slice(-40);
+      const to = "0x" + log.topics[2].slice(-40);
+      const amountRaw = BigInt(log.data);
+      const amount = Number(amountRaw) / 1e6;
+      if (expectedTo && to.toLowerCase() !== expectedTo.toLowerCase()) {
+        continue;
+      }
+      if (amount < expectedAmount) {
+        return {
+          verified: false,
+          error: `Insufficient amount: received ${amount} USDC, expected ${expectedAmount} USDC`,
+          amount,
+          from,
+          to,
+          txHash,
+          blockNumber: receipt.blockNumber
+        };
+      }
+      return {
+        verified: true,
+        amount,
+        from,
+        to,
+        txHash,
+        blockNumber: receipt.blockNumber
+      };
+    }
+    return { verified: false, error: "No USDC transfer found" };
+  } catch (e) {
+    return { verified: false, error: e.message || String(e) };
+  }
+}
+
+// src/server/index.ts
+function generateChargeId() {
+  return "ch_" + Math.random().toString(36).substring(2, 15);
+}
+var MoltsPayServer = class {
+  manifest;
+  skills = /* @__PURE__ */ new Map();
+  charges = /* @__PURE__ */ new Map();
+  options;
+  constructor(servicesPath, options = {}) {
+    const content = (0, import_fs.readFileSync)(servicesPath, "utf-8");
+    this.manifest = JSON.parse(content);
+    this.options = {
+      port: options.port || 3e3,
+      host: options.host || "0.0.0.0",
+      chargeExpirySecs: options.chargeExpirySecs || 300
+      // 5 minutes
+    };
+    console.log(`[MoltsPay] Loaded ${this.manifest.services.length} services from ${servicesPath}`);
+    console.log(`[MoltsPay] Provider: ${this.manifest.provider.name}`);
+    console.log(`[MoltsPay] Wallet: ${this.manifest.provider.wallet}`);
+  }
+  /**
+   * Register a skill handler for a service
+   */
+  skill(serviceId, handler) {
+    const config = this.manifest.services.find((s) => s.id === serviceId);
+    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})`);
+    return this;
+  }
+  /**
+   * Start the server
+   */
+  listen(port) {
+    const p = port || this.options.port;
+    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}`);
+      console.log(`[MoltsPay] Endpoints:`);
+      console.log(`  GET  /services  - List available services`);
+      console.log(`  POST /pay       - Create payment & execute service`);
+      console.log(`  POST /verify    - Verify payment & get result`);
+      console.log(`  GET  /status/:id - Check charge status`);
+    });
+  }
+  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");
+    if (method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    try {
+      if (method === "GET" && path === "/services") {
+        return this.handleGetServices(res);
+      }
+      if (method === "POST" && path === "/pay") {
+        const body = await this.readBody(req);
+        return this.handlePay(body, res);
+      }
+      if (method === "POST" && path === "/verify") {
+        const body = await this.readBody(req);
+        return this.handleVerify(body, res);
+      }
+      if (method === "GET" && path.startsWith("/status/")) {
+        const chargeId = path.replace("/status/", "");
+        return this.handleStatus(chargeId, res);
+      }
+      this.sendJson(res, 404, { error: "Not found" });
+    } catch (err) {
+      console.error("[MoltsPay] Error:", err);
+      this.sendJson(res, 500, { error: err.message || "Internal error" });
+    }
+  }
+  /**
+   * GET /services - List available services
+   */
+  handleGetServices(res) {
+    const services = this.manifest.services.map((s) => ({
+      id: s.id,
+      name: s.name,
+      description: s.description,
+      price: s.price,
+      currency: s.currency,
+      input: s.input,
+      output: s.output,
+      available: this.skills.has(s.id)
+    }));
+    this.sendJson(res, 200, {
+      provider: this.manifest.provider,
+      services
+    });
+  }
+  /**
+   * POST /pay - Create payment request
+   * Body: { service: string, params: object }
+   */
+  handlePay(body, res) {
+    const { service, params } = body;
+    if (!service) {
+      return this.sendJson(res, 400, { error: "Missing service" });
+    }
+    const skill = this.skills.get(service);
+    if (!skill) {
+      return this.sendJson(res, 404, { error: `Service '${service}' not found or not registered` });
+    }
+    for (const [key, field] of Object.entries(skill.config.input)) {
+      if (field.required && (!params || params[key] === void 0)) {
+        return this.sendJson(res, 400, { error: `Missing required param: ${key}` });
+      }
+    }
+    const chargeId = generateChargeId();
+    const now = Date.now();
+    const charge = {
+      id: chargeId,
+      service,
+      params: params || {},
+      amount: skill.config.price,
+      currency: skill.config.currency,
+      status: "pending",
+      createdAt: now,
+      expiresAt: now + this.options.chargeExpirySecs * 1e3
+    };
+    this.charges.set(chargeId, charge);
+    const paymentRequest = {
+      chargeId,
+      service,
+      amount: charge.amount,
+      currency: charge.currency,
+      wallet: this.manifest.provider.wallet,
+      chain: this.manifest.provider.chain,
+      expiresAt: charge.expiresAt
+    };
+    this.sendJson(res, 402, {
+      message: "Payment required",
+      payment: paymentRequest
+    });
+  }
+  /**
+   * POST /verify - Verify payment and execute skill
+   * Body: { chargeId: string, txHash: string }
+   */
+  async handleVerify(body, res) {
+    const { chargeId, txHash } = body;
+    if (!chargeId || !txHash) {
+      return this.sendJson(res, 400, { error: "Missing chargeId or txHash" });
+    }
+    const charge = this.charges.get(chargeId);
+    if (!charge) {
+      return this.sendJson(res, 404, { error: "Charge not found" });
+    }
+    if (Date.now() > charge.expiresAt) {
+      charge.status = "expired";
+      return this.sendJson(res, 400, { error: "Charge expired" });
+    }
+    if (charge.status === "completed") {
+      return this.sendJson(res, 200, {
+        status: "completed",
+        result: charge.result
+      });
+    }
+    try {
+      const verification = await verifyPayment({
+        txHash,
+        expectedTo: this.manifest.provider.wallet,
+        expectedAmount: charge.amount,
+        chain: this.manifest.provider.chain
+      });
+      if (!verification.verified) {
+        charge.status = "failed";
+        return this.sendJson(res, 400, {
+          error: "Payment verification failed",
+          reason: verification.error
+        });
+      }
+      charge.status = "paid";
+      charge.txHash = txHash;
+      charge.paidAt = Date.now();
+      const skill = this.skills.get(charge.service);
+      console.log(`[MoltsPay] Executing skill: ${charge.service}`);
+      const result = await skill.handler(charge.params);
+      charge.status = "completed";
+      charge.result = result;
+      charge.completedAt = Date.now();
+      this.sendJson(res, 200, {
+        status: "completed",
+        chargeId,
+        txHash,
+        result
+      });
+    } catch (err) {
+      console.error("[MoltsPay] Skill execution error:", err);
+      charge.status = "failed";
+      this.sendJson(res, 500, {
+        error: "Skill execution failed",
+        message: err.message
+      });
+    }
+  }
+  /**
+   * GET /status/:chargeId - Check charge status
+   */
+  handleStatus(chargeId, res) {
+    const charge = this.charges.get(chargeId);
+    if (!charge) {
+      return this.sendJson(res, 404, { error: "Charge not found" });
+    }
+    this.sendJson(res, 200, {
+      chargeId: charge.id,
+      service: charge.service,
+      amount: charge.amount,
+      currency: charge.currency,
+      status: charge.status,
+      txHash: charge.txHash,
+      result: charge.status === "completed" ? charge.result : void 0,
+      createdAt: charge.createdAt,
+      expiresAt: charge.expiresAt
+    });
+  }
+  async readBody(req) {
+    return new Promise((resolve, reject) => {
+      let body = "";
+      req.on("data", (chunk) => body += chunk);
+      req.on("end", () => {
+        try {
+          resolve(body ? JSON.parse(body) : {});
+        } catch {
+          reject(new Error("Invalid JSON"));
+        }
+      });
+      req.on("error", reject);
+    });
+  }
+  sendJson(res, status, data) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data, null, 2));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MoltsPayServer
+});
+//# sourceMappingURL=index.js.map