x402z-facilitator 0.0.10 → 0.0.12

package/dist/chunk-B6WVQBNK.mjs

@@ -0,0 +1,636 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/service/bootstrap.ts
+import { x402Facilitator } from "@x402/core/facilitator";
+import { toFacilitatorEvmSigner } from "@x402/evm";
+import { createWalletClient, http, publicActions } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+
+// src/service/service.ts
+import { createServer } from "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 = 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;
+}
+function startFacilitatorService(config) {
+  const port = config.port ?? 8040;
+  const server = createFacilitatorService(config);
+  server.listen(port);
+  return { port };
+}
+
+// src/scheme/scheme.ts
+import { decodeEventLog, getAddress, isAddressEqual } from "viem";
+import {
+  confidentialPaymentTypes,
+  confidentialTokenAbi,
+  hashEncryptedAmountInput
+} from "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 ?? 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 = 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 (!isAddressEqual(getAddress(confidentialPayload.authorization.payee), 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: getAddress(requirements.asset)
+      },
+      types: confidentialPaymentTypes,
+      primaryType: "ConfidentialPayment",
+      message: {
+        holder: getAddress(confidentialPayload.authorization.holder),
+        payee: 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: getAddress(requirements.asset),
+        abi: 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 = 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 buildRequests = (batchEntries2) => batchEntries2.map(({ entry }) => {
+      const confidentialPayload = entry.payload.payload;
+      return {
+        p: confidentialPayload.authorization,
+        encryptedAmountInput: confidentialPayload.encryptedAmountInput,
+        inputProof: confidentialPayload.inputProof,
+        sig: confidentialPayload.signature
+      };
+    });
+    const originalEntries = entries.map((entry, index) => ({ entry, index }));
+    let batchEntries = originalEntries;
+    let requests = buildRequests(batchEntries);
+    let 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
+      });
+    }
+    try {
+      const [successes, transferredHandles] = await this.config.signer.simulateContract(txRequest);
+      if (successes.length === batchEntries.length && transferredHandles.length === batchEntries.length) {
+        const filtered = [];
+        batchEntries.forEach((item, index) => {
+          if (successes[index]) {
+            filtered.push(item);
+            return;
+          }
+          const confidentialPayload = item.entry.payload.payload;
+          item.entry.resolve(
+            {
+              success: false,
+              errorReason: "preflight_failed",
+              payer: confidentialPayload.authorization.holder,
+              transaction: "",
+              network: item.entry.requirements.network,
+              batch: { index: item.index, success: false, transferredHandle: transferredHandles[index] }
+            }
+          );
+        });
+        if (filtered.length === 0) {
+          return;
+        }
+        batchEntries = filtered;
+        requests = buildRequests(batchEntries);
+        txRequest = {
+          ...txRequest,
+          args: [tokenAddress, requests]
+        };
+      }
+    } catch (error) {
+      for (const entry of entries) {
+        const confidentialPayload = entry.payload.payload;
+        entry.resolve({
+          success: false,
+          errorReason: "preflight_failed",
+          payer: confidentialPayload.authorization.holder,
+          transaction: "",
+          network: entry.requirements.network
+        });
+      }
+      return;
+    }
+    const settleEntries = batchEntries.map((item) => item.entry);
+    let txHash;
+    try {
+      txHash = await this.config.signer.writeContract(txRequest);
+    } catch (error) {
+      for (const entry of settleEntries) {
+        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 settleEntries) {
+          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) {
+      settleEntries.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 (!isAddressEqual(getAddress(log.address), this.batcherAddress)) {
+          continue;
+        }
+        const decoded = 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
+          });
+        }
+      }
+    }
+    settleEntries.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 = 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 = createWalletClient({
+    account,
+    chain: {
+      id: chainId,
+      name: "custom",
+      nativeCurrency: { name: "native", symbol: "NATIVE", decimals: 18 },
+      rpcUrls: { default: { http: [rpcUrl] } }
+    },
+    transport: http(rpcUrl)
+  }).extend(publicActions);
+  const baseSigner = 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 signer = {
+    ...baseSigner,
+    simulateContract: async (args) => {
+      const result = await client.simulateContract({
+        ...args,
+        args: args.args || [],
+        account
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      });
+      return result.result;
+    }
+  };
+  const facilitator = new 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}`);
+}
+
+export {
+  X402zEvmFacilitator,
+  createFacilitatorService,
+  startFacilitatorService,
+  createFacilitatorFromEnv,
+  startFacilitator
+};