x402z-facilitator 0.0.7 → 0.0.9

package/dist/service/bootstrap.js

@@ -0,0 +1,581 @@
+"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/service/bootstrap.ts
+var bootstrap_exports = {};
+__export(bootstrap_exports, {
+  createFacilitatorFromEnv: () => createFacilitatorFromEnv,
+  startFacilitator: () => startFacilitator
+});
+module.exports = __toCommonJS(bootstrap_exports);
+var import_facilitator = require("@x402/core/facilitator");
+var import_evm = require("@x402/evm");
+var import_viem2 = require("viem");
+var import_accounts = require("viem/accounts");
+
+// src/service/service.ts
+var import_node_http = require("http");
+async function readJson(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  const body = Buffer.concat(chunks).toString("utf8");
+  return JSON.parse(body);
+}
+function sendJson(res, status, payload) {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(payload));
+}
+function createFacilitatorService(config) {
+  const server = (0, import_node_http.createServer)(async (req, res) => {
+    try {
+      const method = req.method ?? "GET";
+      const url = req.url ?? "/";
+      if (process.env.X402Z_DEBUG === "1") {
+        console.debug(`[x402z-facilitator] ${method} ${url}`);
+      }
+      if (!req.url) {
+        sendJson(res, 404, { error: "not_found" });
+        return;
+      }
+      if (req.method === "GET" && req.url === "/supported") {
+        sendJson(res, 200, config.facilitator.getSupported());
+        return;
+      }
+      if (req.method === "POST" && req.url === "/verify") {
+        const body = await readJson(req);
+        const result = await config.facilitator.verify(body.paymentPayload, body.paymentRequirements);
+        sendJson(res, 200, result);
+        return;
+      }
+      if (req.method === "POST" && req.url === "/settle") {
+        const body = await readJson(req);
+        const result = await config.facilitator.settle(body.paymentPayload, body.paymentRequirements);
+        sendJson(res, 200, result);
+        return;
+      }
+      sendJson(res, 404, { error: "not_found" });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "internal_error";
+      sendJson(res, 500, { error: message });
+    }
+  });
+  return server;
+}
+
+// src/scheme/scheme.ts
+var import_viem = require("viem");
+var import_x402z_shared = require("x402z-shared");
+var batcherAbi = [
+  {
+    inputs: [
+      { internalType: "address", name: "token", type: "address" },
+      {
+        components: [
+          {
+            components: [
+              { internalType: "address", name: "holder", type: "address" },
+              { internalType: "address", name: "payee", type: "address" },
+              { internalType: "uint256", name: "maxClearAmount", type: "uint256" },
+              { internalType: "bytes32", name: "resourceHash", type: "bytes32" },
+              { internalType: "uint48", name: "validAfter", type: "uint48" },
+              { internalType: "uint48", name: "validBefore", type: "uint48" },
+              { internalType: "bytes32", name: "nonce", type: "bytes32" },
+              { internalType: "bytes32", name: "encryptedAmountHash", type: "bytes32" }
+            ],
+            internalType: "struct IFHEToken.ConfidentialPayment",
+            name: "p",
+            type: "tuple"
+          },
+          { internalType: "externalEuint64", name: "encryptedAmountInput", type: "bytes32" },
+          { internalType: "bytes", name: "inputProof", type: "bytes" },
+          { internalType: "bytes", name: "sig", type: "bytes" }
+        ],
+        internalType: "struct FHETokenBatcher.Request[]",
+        name: "requests",
+        type: "tuple[]"
+      }
+    ],
+    name: "batchConfidentialTransferWithAuthorization",
+    outputs: [
+      { internalType: "bool[]", name: "successes", type: "bool[]" },
+      { internalType: "bytes32[]", name: "transferredHandles", type: "bytes32[]" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "uint256", name: "index", type: "uint256" },
+      { indexed: false, internalType: "bytes32", name: "transferredHandle", type: "bytes32" }
+    ],
+    name: "BatchItemSuccess",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "uint256", name: "index", type: "uint256" },
+      { indexed: false, internalType: "bytes", name: "reason", type: "bytes" }
+    ],
+    name: "BatchItemFailure",
+    type: "event"
+  }
+];
+var X402zEvmFacilitator = class {
+  constructor(config) {
+    this.config = config;
+    this.scheme = "erc7984-mind-v1";
+    this.caipFamily = "eip155:*";
+    this.queue = [];
+    this.hashFn = config.hashEncryptedAmountInput ?? import_x402z_shared.hashEncryptedAmountInput;
+    this.clock = config.clock ?? (() => Math.floor(Date.now() / 1e3));
+    this.checkUsedNonces = config.checkUsedNonces ?? true;
+    this.waitForReceipt = config.waitForReceipt ?? true;
+    this.batchIntervalMs = Math.max(0, config.batchIntervalMs ?? 15e3);
+    this.receiptOptions = config.receipt;
+    this.batcherAddress = (0, import_viem.getAddress)(config.batcherAddress);
+  }
+  getExtra(_) {
+    return void 0;
+  }
+  getSigners(_) {
+    return [...this.config.signer.getAddresses()];
+  }
+  async verify(payload, requirements) {
+    const confidentialPayload = payload.payload;
+    if (payload.accepted.scheme !== this.scheme || requirements.scheme !== this.scheme) {
+      return {
+        isValid: false,
+        invalidReason: "unsupported_scheme",
+        payer: confidentialPayload?.authorization?.holder
+      };
+    }
+    if (payload.accepted.network !== requirements.network) {
+      return {
+        isValid: false,
+        invalidReason: "network_mismatch",
+        payer: confidentialPayload.authorization.holder
+      };
+    }
+    const extra = requirements.extra;
+    const eip712 = extra?.eip712;
+    if (!eip712?.name || !eip712?.version) {
+      return {
+        isValid: false,
+        invalidReason: "missing_eip712_domain",
+        payer: confidentialPayload.authorization.holder
+      };
+    }
+    const now = this.clock();
+    const validAfter = Number(confidentialPayload.authorization.validAfter);
+    const validBefore = Number(confidentialPayload.authorization.validBefore);
+    if (Number.isNaN(validAfter) || Number.isNaN(validBefore)) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_validity_window",
+        payer: confidentialPayload.authorization.holder
+      };
+    }
+    if (now < validAfter || now > validBefore) {
+      return {
+        isValid: false,
+        invalidReason: "authorization_expired",
+        payer: confidentialPayload.authorization.holder
+      };
+    }
+    if (!(0, import_viem.isAddressEqual)((0, import_viem.getAddress)(confidentialPayload.authorization.payee), (0, import_viem.getAddress)(requirements.payTo))) {
+      return {
+        isValid: false,
+        invalidReason: "recipient_mismatch",
+        payer: confidentialPayload.authorization.holder
+      };
+    }
+    const computedHash = this.hashFn(confidentialPayload.encryptedAmountInput);
+    if (computedHash !== confidentialPayload.authorization.encryptedAmountHash) {
+      return {
+        isValid: false,
+        invalidReason: "encrypted_amount_mismatch",
+        payer: confidentialPayload.authorization.holder
+      };
+    }
+    const chainId = parseInt(requirements.network.split(":")[1]);
+    const isValidSignature = await this.config.signer.verifyTypedData({
+      address: confidentialPayload.authorization.holder,
+      domain: {
+        name: eip712.name,
+        version: eip712.version,
+        chainId,
+        verifyingContract: (0, import_viem.getAddress)(requirements.asset)
+      },
+      types: import_x402z_shared.confidentialPaymentTypes,
+      primaryType: "ConfidentialPayment",
+      message: {
+        holder: (0, import_viem.getAddress)(confidentialPayload.authorization.holder),
+        payee: (0, import_viem.getAddress)(confidentialPayload.authorization.payee),
+        maxClearAmount: BigInt(confidentialPayload.authorization.maxClearAmount),
+        resourceHash: confidentialPayload.authorization.resourceHash,
+        validAfter: BigInt(confidentialPayload.authorization.validAfter),
+        validBefore: BigInt(confidentialPayload.authorization.validBefore),
+        nonce: confidentialPayload.authorization.nonce,
+        encryptedAmountHash: confidentialPayload.authorization.encryptedAmountHash
+      },
+      signature: confidentialPayload.signature
+    });
+    if (!isValidSignature) {
+      return {
+        isValid: false,
+        invalidReason: "invalid_signature",
+        payer: confidentialPayload.authorization.holder
+      };
+    }
+    if (this.checkUsedNonces) {
+      const used = await this.config.signer.readContract({
+        address: (0, import_viem.getAddress)(requirements.asset),
+        abi: import_x402z_shared.confidentialTokenAbi,
+        functionName: "usedNonces",
+        args: [confidentialPayload.authorization.holder, confidentialPayload.authorization.nonce]
+      });
+      if (used) {
+        return {
+          isValid: false,
+          invalidReason: "nonce_already_used",
+          payer: confidentialPayload.authorization.holder
+        };
+      }
+    }
+    return {
+      isValid: true,
+      payer: confidentialPayload.authorization.holder
+    };
+  }
+  async settle(payload, requirements) {
+    const valid = await this.verify(payload, requirements);
+    const confidentialPayload = payload.payload;
+    if (!valid.isValid) {
+      return {
+        success: false,
+        errorReason: valid.invalidReason ?? "invalid_payment",
+        payer: confidentialPayload.authorization.holder,
+        transaction: "",
+        network: requirements.network
+      };
+    }
+    return new Promise((resolve) => {
+      this.queue.push({ payload, requirements, resolve });
+      this.scheduleFlush();
+    });
+  }
+  scheduleFlush() {
+    if (this.flushTimer) {
+      return;
+    }
+    const delay = this.batchIntervalMs;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = void 0;
+      void this.flushQueue();
+    }, delay);
+  }
+  async flushQueue() {
+    if (this.queue.length === 0) {
+      return;
+    }
+    const queued = this.queue;
+    this.queue = [];
+    const byToken = /* @__PURE__ */ new Map();
+    for (const entry of queued) {
+      const tokenKey = (0, import_viem.getAddress)(entry.requirements.asset);
+      const group = byToken.get(tokenKey) ?? [];
+      group.push(entry);
+      byToken.set(tokenKey, group);
+    }
+    for (const [tokenAddress, entries] of byToken.entries()) {
+      await this.flushBatch(tokenAddress, entries);
+    }
+    if (this.queue.length > 0) {
+      this.scheduleFlush();
+    }
+  }
+  async flushBatch(tokenAddress, entries) {
+    const requests = entries.map((entry) => {
+      const confidentialPayload = entry.payload.payload;
+      return {
+        p: confidentialPayload.authorization,
+        encryptedAmountInput: confidentialPayload.encryptedAmountInput,
+        inputProof: confidentialPayload.inputProof,
+        sig: confidentialPayload.signature
+      };
+    });
+    const txRequest = {
+      address: this.batcherAddress,
+      abi: batcherAbi,
+      functionName: "batchConfidentialTransferWithAuthorization",
+      args: [tokenAddress, requests]
+    };
+    if (process.env.X402Z_DEBUG === "1") {
+      console.debug("[x402z-facilitator] settle tx", {
+        batcherAddress: this.batcherAddress,
+        tokenAddress,
+        functionName: txRequest.functionName,
+        to: txRequest.address,
+        size: requests.length
+      });
+    }
+    let txHash;
+    try {
+      txHash = await this.config.signer.writeContract(txRequest);
+    } catch (error) {
+      for (const entry of entries) {
+        const confidentialPayload = entry.payload.payload;
+        entry.resolve({
+          success: false,
+          errorReason: "settlement_failed",
+          payer: confidentialPayload.authorization.holder,
+          transaction: "",
+          network: entry.requirements.network
+        });
+      }
+      return;
+    }
+    if (process.env.X402Z_DEBUG === "1") {
+      console.debug("[x402z-facilitator] tx submitted", txHash);
+    }
+    let receipt;
+    if (this.waitForReceipt) {
+      receipt = await this.config.signer.waitForTransactionReceipt({ hash: txHash });
+      if (process.env.X402Z_DEBUG === "1") {
+        console.debug("[x402z-facilitator] tx receipt", receipt);
+      }
+      if (receipt.status !== "success") {
+        for (const entry of entries) {
+          const confidentialPayload = entry.payload.payload;
+          entry.resolve({
+            success: false,
+            errorReason: "settlement_failed",
+            payer: confidentialPayload.authorization.holder,
+            transaction: txHash,
+            network: entry.requirements.network
+          });
+        }
+        return;
+      }
+    }
+    if (!this.waitForReceipt) {
+      entries.forEach((entry) => {
+        const confidentialPayload = entry.payload.payload;
+        entry.resolve({
+          success: true,
+          payer: confidentialPayload.authorization.holder,
+          transaction: txHash,
+          network: entry.requirements.network
+        });
+      });
+      return;
+    }
+    const batchResults = /* @__PURE__ */ new Map();
+    if (receipt?.logs) {
+      for (const log of receipt.logs) {
+        if (!log?.address) {
+          continue;
+        }
+        if (!(0, import_viem.isAddressEqual)((0, import_viem.getAddress)(log.address), this.batcherAddress)) {
+          continue;
+        }
+        const decoded = (0, import_viem.decodeEventLog)({
+          abi: batcherAbi,
+          data: log.data,
+          topics: log.topics
+        });
+        if (process.env.X402Z_DEBUG === "1") {
+          console.debug("[x402z-facilitator] batch log", decoded);
+        }
+        if (decoded.eventName === "BatchItemSuccess") {
+          const args = decoded.args;
+          batchResults.set(Number(args.index), {
+            success: true,
+            transferredHandle: args.transferredHandle
+          });
+        } else if (decoded.eventName === "BatchItemFailure") {
+          const args = decoded.args;
+          batchResults.set(Number(args.index), {
+            success: false,
+            failureReason: args.reason
+          });
+        }
+      }
+    }
+    entries.forEach((entry, index) => {
+      const confidentialPayload = entry.payload.payload;
+      const batchResult = batchResults.get(index);
+      if (!batchResult || !batchResult.success) {
+        entry.resolve(
+          {
+            success: false,
+            errorReason: "settlement_failed",
+            payer: confidentialPayload.authorization.holder,
+            transaction: txHash,
+            network: entry.requirements.network,
+            ...batchResult ? { batch: { index, ...batchResult } } : {}
+          }
+        );
+        return;
+      }
+      entry.resolve(
+        {
+          success: true,
+          payer: confidentialPayload.authorization.holder,
+          transaction: txHash,
+          network: entry.requirements.network,
+          batch: { index, ...batchResult }
+        }
+      );
+    });
+  }
+};
+
+// src/service/bootstrap.ts
+function requireEnv(key) {
+  const value = process.env[key];
+  if (!value) {
+    throw new Error(`Missing required env var: ${key}`);
+  }
+  return value;
+}
+function createFacilitatorFromEnv() {
+  const privateKey = requireEnv("FACILITATOR_EVM_PRIVATE_KEY");
+  const chainId = Number(process.env.FACILITATOR_EVM_CHAIN_ID ?? "11155111");
+  const rpcUrl = requireEnv("FACILITATOR_EVM_RPC_URL");
+  const networks = (process.env.FACILITATOR_NETWORKS ?? "eip155:11155111").split(",").map((network) => network.trim()).filter(Boolean);
+  const waitForReceipt = (process.env.FACILITATOR_WAIT_FOR_RECEIPT ?? "true") === "true";
+  const batcherAddress = process.env.FACILITATOR_BATCHER_ADDRESS;
+  if (!batcherAddress) {
+    throw new Error("FACILITATOR_BATCHER_ADDRESS is required");
+  }
+  const batchIntervalMs = process.env.FACILITATOR_BATCH_INTERVAL_MS ? Number(process.env.FACILITATOR_BATCH_INTERVAL_MS) : void 0;
+  const receiptTimeoutMs = process.env.FACILITATOR_RECEIPT_TIMEOUT_MS ? Number(process.env.FACILITATOR_RECEIPT_TIMEOUT_MS) : void 0;
+  const receiptConfirmations = process.env.FACILITATOR_RECEIPT_CONFIRMATIONS ? Number(process.env.FACILITATOR_RECEIPT_CONFIRMATIONS) : void 0;
+  const receiptPollingIntervalMs = process.env.FACILITATOR_RECEIPT_POLLING_INTERVAL_MS ? Number(process.env.FACILITATOR_RECEIPT_POLLING_INTERVAL_MS) : void 0;
+  const gasMultiplier = process.env.FACILITATOR_GAS_MULTIPLIER ? Number(process.env.FACILITATOR_GAS_MULTIPLIER) : void 0;
+  const debugEnabled = process.env.X402Z_DEBUG === "1";
+  const account = (0, import_accounts.privateKeyToAccount)(privateKey);
+  if (debugEnabled) {
+    console.debug("[x402z-facilitator] config", {
+      chainId,
+      networks,
+      rpcUrl,
+      waitForReceipt,
+      batcherAddress,
+      gasMultiplier,
+      batchIntervalMs,
+      receipt: {
+        confirmations: receiptConfirmations,
+        timeoutMs: receiptTimeoutMs,
+        pollingIntervalMs: receiptPollingIntervalMs
+      },
+      address: account.address
+    });
+  }
+  const client = (0, import_viem2.createWalletClient)({
+    account,
+    chain: {
+      id: chainId,
+      name: "custom",
+      nativeCurrency: { name: "native", symbol: "NATIVE", decimals: 18 },
+      rpcUrls: { default: { http: [rpcUrl] } }
+    },
+    transport: (0, import_viem2.http)(rpcUrl)
+  }).extend(import_viem2.publicActions);
+  const signer = (0, import_evm.toFacilitatorEvmSigner)({
+    address: account.address,
+    readContract: (args) => client.readContract({
+      ...args,
+      args: args.args || []
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }),
+    verifyTypedData: (args) => client.verifyTypedData(args),
+    writeContract: async (args) => {
+      let gas;
+      if (gasMultiplier && gasMultiplier > 0) {
+        try {
+          const estimated = await client.estimateContractGas({
+            ...args,
+            args: args.args || [],
+            account
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          });
+          const scale = BigInt(Math.round(gasMultiplier * 1e3));
+          const scaled = estimated * scale / 1000n;
+          gas = scaled > estimated ? scaled : estimated;
+        } catch (error) {
+          if (debugEnabled) {
+            console.debug("[x402z-facilitator] gas estimate failed", error);
+          }
+        }
+      }
+      return client.writeContract({
+        ...args,
+        args: args.args || [],
+        ...gas ? { gas } : {}
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      });
+    },
+    sendTransaction: (args) => (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      client.sendTransaction({ to: args.to, data: args.data })
+    ),
+    waitForTransactionReceipt: (args) => client.waitForTransactionReceipt(args),
+    getCode: (args) => client.getCode(args)
+  });
+  const facilitator = new import_facilitator.x402Facilitator();
+  for (const network of networks) {
+    facilitator.register(
+      network,
+      new X402zEvmFacilitator({
+        signer,
+        waitForReceipt,
+        batcherAddress,
+        batchIntervalMs,
+        receipt: {
+          confirmations: receiptConfirmations,
+          timeoutMs: receiptTimeoutMs,
+          pollingIntervalMs: receiptPollingIntervalMs
+        }
+      })
+    );
+  }
+  return facilitator;
+}
+function startFacilitator() {
+  const facilitator = createFacilitatorFromEnv();
+  const port = Number(process.env.FACILITATOR_PORT ?? "8040");
+  const server = createFacilitatorService({ facilitator, port });
+  server.listen(port);
+  return { port };
+}
+if (require.main === module) {
+  const { port } = startFacilitator();
+  console.log(`Confidential facilitator listening on :${port}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFacilitatorFromEnv,
+  startFacilitator
+});

package/dist/service/bootstrap.mjs

@@ -0,0 +1,8 @@
+import {
+  createFacilitatorFromEnv,
+  startFacilitator
+} from "../chunk-3XCMVK47.mjs";
+export {
+  createFacilitatorFromEnv,
+  startFacilitator
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "x402z-facilitator",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -11,7 +11,7 @@
     "@x402/core": "^2.0.0",
     "@x402/evm": "^2.0.0",
     "viem": "^2.39.3",
-    "x402z-shared": "0.0.7"
+    "x402z-shared": "0.0.9"
   },
   "devDependencies": {
     "jest": "^29.7.0",
@@ -20,7 +20,7 @@
     "@types/node": "^22.13.4"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/bootstrap.ts --format cjs,esm --dts",
+    "build": "tsup src/index.ts src/service/bootstrap.ts --format cjs,esm --dts",
     "test": "jest",
     "start": "node dist/bootstrap.js"
   }