@x402x/facilitator-sdk 2.0.0

package/dist/index.mjs

@@ -0,0 +1,948 @@
+import { FacilitatorValidationError, toCanonicalNetworkKey, getNetworkName, getNetworkConfig, SETTLEMENT_ROUTER_ABI, isSettlementMode, parseSettlementExtra, SettlementRouterError, calculateCommitment } from '@x402x/extensions';
+export { FacilitatorValidationError, SETTLEMENT_ROUTER_ABI, SettlementRouterError, getNetworkConfig, isSettlementMode, parseSettlementExtra } from '@x402x/extensions';
+import { createPublicClient, http, createWalletClient, parseErc6492Signature, verifyTypedData } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+
+// src/facilitator.ts
+function isValidEthereumAddress(address) {
+  return /^0x[a-fA-F0-9]{40}$/.test(address);
+}
+function isValidHex(hex) {
+  return /^0x[a-fA-F0-9]*$/.test(hex) && hex.length % 2 === 0 && hex.length >= 2;
+}
+function isValid32ByteHex(hex) {
+  return /^0x[a-fA-F0-9]{64}$/.test(hex);
+}
+function isValid256BitHex(hex) {
+  return /^0x[a-fA-F0-9]{1,64}$/.test(hex);
+}
+function validateSettlementRouter(network, router, allowedRouters, networkConfig) {
+  if (!isValidEthereumAddress(router)) {
+    throw new FacilitatorValidationError(`Invalid SettlementRouter address: ${router}`);
+  }
+  if (allowedRouters && network in allowedRouters) {
+    const networkAllowedRouters = allowedRouters[network];
+    if (networkAllowedRouters.length > 0 && !networkAllowedRouters.includes(router)) {
+      throw new FacilitatorValidationError(
+        `SettlementRouter ${router} not allowed for network ${network}. Allowed routers: ${networkAllowedRouters.join(", ")}`
+      );
+    }
+  }
+  if (networkConfig?.settlementRouter && router !== networkConfig.settlementRouter) {
+    throw new FacilitatorValidationError(
+      `SettlementRouter ${router} does not match network config expected router ${networkConfig.settlementRouter}`
+    );
+  }
+  return router;
+}
+function validateSettlementExtra(extra) {
+  if (!extra || typeof extra !== "object") {
+    throw new FacilitatorValidationError("Missing or invalid extra field");
+  }
+  const e = extra;
+  if (!e.settlementRouter || typeof e.settlementRouter !== "string") {
+    throw new FacilitatorValidationError("Missing or invalid settlementRouter");
+  }
+  if (!isValidEthereumAddress(e.settlementRouter)) {
+    throw new FacilitatorValidationError("Invalid settlementRouter address format");
+  }
+  if (!e.salt || typeof e.salt !== "string") {
+    throw new FacilitatorValidationError("Missing or invalid salt");
+  }
+  if (!isValid32ByteHex(e.salt)) {
+    throw new FacilitatorValidationError("Salt must be a 32-byte hex string");
+  }
+  if (!e.payTo || typeof e.payTo !== "string") {
+    throw new FacilitatorValidationError("Missing or invalid payTo");
+  }
+  if (!isValidEthereumAddress(e.payTo)) {
+    throw new FacilitatorValidationError("Invalid payTo address format");
+  }
+  if (!e.facilitatorFee || typeof e.facilitatorFee !== "string") {
+    throw new FacilitatorValidationError("Missing or invalid facilitatorFee");
+  }
+  if (!isValid256BitHex(e.facilitatorFee)) {
+    throw new FacilitatorValidationError("Facilitator fee must be a valid hex number");
+  }
+  if (!e.hook || typeof e.hook !== "string") {
+    throw new FacilitatorValidationError("Missing or invalid hook");
+  }
+  if (!isValidEthereumAddress(e.hook)) {
+    throw new FacilitatorValidationError("Invalid hook address format");
+  }
+  if (!e.hookData || typeof e.hookData !== "string") {
+    throw new FacilitatorValidationError("Missing or invalid hookData");
+  }
+  if (!isValidHex(e.hookData)) {
+    throw new FacilitatorValidationError("Hook data must be valid hex");
+  }
+  return {
+    settlementRouter: e.settlementRouter,
+    salt: e.salt,
+    payTo: e.payTo,
+    facilitatorFee: e.facilitatorFee,
+    hook: e.hook,
+    hookData: e.hookData
+  };
+}
+function validateNetwork(network) {
+  if (!network || typeof network !== "string") {
+    throw new FacilitatorValidationError("Invalid network: must be a non-empty string");
+  }
+  if (!/^(eip155:\d+|[a-z][a-z0-9-]*[a-z0-9])$/.test(network)) {
+    throw new FacilitatorValidationError(`Invalid network format: ${network}`);
+  }
+  return network;
+}
+function validateFacilitatorConfig(config) {
+  if (!config.signer && !config.privateKey) {
+    throw new FacilitatorValidationError(
+      "Missing signer or privateKey in facilitator configuration"
+    );
+  }
+  if (config.signer) {
+    if (!isValidEthereumAddress(config.signer)) {
+      throw new FacilitatorValidationError(`Invalid signer address: ${config.signer}`);
+    }
+  }
+  if (config.privateKey) {
+    const privateKey = config.privateKey;
+    const hasPrefix = privateKey.startsWith("0x") || privateKey.startsWith("0X");
+    const hexBody = hasPrefix ? privateKey.slice(2) : privateKey;
+    if (!/^[a-fA-F0-9]{64}$/.test(hexBody)) {
+      throw new FacilitatorValidationError(
+        "Invalid private key format: must be 32-byte hex string (64 hex chars, with optional 0x prefix)"
+      );
+    }
+  }
+  if (config.allowedRouters) {
+    for (const [network, routers] of Object.entries(config.allowedRouters)) {
+      validateNetwork(network);
+      if (!Array.isArray(routers)) {
+        throw new FacilitatorValidationError(`Allowed routers for ${network} must be an array`);
+      }
+      for (const router of routers) {
+        if (!isValidEthereumAddress(router)) {
+          throw new FacilitatorValidationError(`Invalid router address for ${network}: ${router}`);
+        }
+      }
+    }
+  }
+  if (config.rpcUrls) {
+    for (const [network, rpcUrl] of Object.entries(config.rpcUrls)) {
+      validateNetwork(network);
+      if (typeof rpcUrl !== "string" || !rpcUrl.startsWith("http")) {
+        throw new FacilitatorValidationError(`Invalid RPC URL for ${network}: ${rpcUrl}`);
+      }
+    }
+  }
+}
+function validateGasLimit(gasLimit) {
+  if (gasLimit <= 0n) {
+    throw new FacilitatorValidationError("Gas limit must be positive");
+  }
+  if (gasLimit > 10000000n) {
+    throw new FacilitatorValidationError("Gas limit too large (> 10M)");
+  }
+}
+function validateGasMultiplier(multiplier) {
+  if (multiplier <= 0) {
+    throw new FacilitatorValidationError("Gas multiplier must be positive");
+  }
+  if (multiplier > 5) {
+    throw new FacilitatorValidationError("Gas multiplier too large (> 5x)");
+  }
+}
+function validateFeeAmount(fee, minFee, maxFee) {
+  let feeBigInt;
+  try {
+    feeBigInt = BigInt(fee);
+  } catch (error) {
+    throw new FacilitatorValidationError(`Invalid fee amount: ${fee}. Must be a valid number.`);
+  }
+  if (feeBigInt < 0n) {
+    throw new FacilitatorValidationError("Fee cannot be negative");
+  }
+  if (minFee && feeBigInt < BigInt(minFee)) {
+    throw new FacilitatorValidationError(`Fee below minimum: ${fee} < ${minFee}`);
+  }
+  if (maxFee && feeBigInt > BigInt(maxFee)) {
+    throw new FacilitatorValidationError(`Fee above maximum: ${fee} > ${maxFee}`);
+  }
+}
+function networkConfigToChain(networkConfig, rpcUrl) {
+  return {
+    id: networkConfig.chainId,
+    name: networkConfig.name,
+    nativeCurrency: {
+      name: networkConfig.metadata?.nativeToken || "ETH",
+      symbol: networkConfig.metadata?.nativeToken || "ETH",
+      decimals: 18
+    },
+    rpcUrls: {
+      default: {
+        http: [rpcUrl]
+      }
+    },
+    blockExplorers: {
+      default: {
+        name: "Explorer",
+        url: (() => {
+          const addressSuffix = "/address/";
+          const baseUrl = networkConfig.addressExplorerBaseUrl;
+          return baseUrl.endsWith(addressSuffix) ? baseUrl.slice(0, -addressSuffix.length) : baseUrl;
+        })()
+      }
+    },
+    testnet: networkConfig.type === "testnet"
+  };
+}
+function createPublicClientForNetwork(network, rpcUrls) {
+  const canonicalNetwork = toCanonicalNetworkKey(network);
+  const v1NetworkName = getNetworkName(canonicalNetwork);
+  const networkConfig = getNetworkConfig(v1NetworkName);
+  if (!networkConfig) {
+    throw new Error(`Network configuration not found for network: ${network}`);
+  }
+  const rpcUrl = rpcUrls?.[network] || rpcUrls?.[v1NetworkName] || rpcUrls?.[canonicalNetwork];
+  if (!rpcUrl) {
+    throw new Error(`No RPC URL available for network: ${network}. Please provide RPC URL in config.`);
+  }
+  const chain = networkConfigToChain(networkConfig, rpcUrl);
+  return createPublicClient({
+    chain,
+    transport: http(rpcUrl)
+  });
+}
+function createWalletClientForNetwork(network, signer, rpcUrls, transport, privateKey) {
+  const canonicalNetwork = toCanonicalNetworkKey(network);
+  const v1NetworkName = getNetworkName(canonicalNetwork);
+  const networkConfig = getNetworkConfig(v1NetworkName);
+  const rpcUrl = rpcUrls?.[network] || rpcUrls?.[v1NetworkName] || rpcUrls?.[canonicalNetwork];
+  if (!rpcUrl) {
+    throw new Error(`No RPC URL available for network: ${network}. Please provide RPC URL in config.`);
+  }
+  if (!signer && !privateKey) {
+    throw new Error("Either signer or privateKey must be provided to create wallet client");
+  }
+  let account;
+  if (privateKey) {
+    account = privateKeyToAccount(privateKey);
+  } else if (signer) {
+    account = signer;
+  } else {
+    throw new Error("Failed to create account: neither signer nor privateKey provided");
+  }
+  const chain = networkConfigToChain(networkConfig, rpcUrl);
+  return createWalletClient({
+    account,
+    chain,
+    transport: transport || http(rpcUrl)
+  });
+}
+function calculateGasLimit(baseFee, facilitatorFee, gasMultiplier = 1.2) {
+  validateGasMultiplier(gasMultiplier);
+  const baseGas = 200000n;
+  const hookGas = facilitatorFee !== "0x0" ? 100000n : 0n;
+  const totalGas = (baseGas + hookGas) * BigInt(Math.ceil(gasMultiplier * 100)) / 100n;
+  validateGasLimit(totalGas);
+  return totalGas;
+}
+async function checkIfSettled(publicClient, router, contextKey) {
+  try {
+    const isSettled = await publicClient.readContract({
+      address: router,
+      abi: SETTLEMENT_ROUTER_ABI,
+      functionName: "isSettled",
+      args: [contextKey]
+    });
+    return isSettled;
+  } catch (error) {
+    throw new Error(
+      `Failed to check settlement status: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+async function executeSettlementWithRouter(walletClient, params, config = {}) {
+  const gasLimit = config.gasLimit || calculateGasLimit("0x0", params.facilitatorFee, config.gasMultiplier);
+  console.log("[executeSettlementWithRouter] Settlement params:", {
+    token: params.token,
+    from: params.from,
+    value: params.value,
+    validAfter: params.validAfter,
+    validBefore: params.validBefore,
+    nonce: params.nonce,
+    signature: params.signature ? `${params.signature.slice(0, 10)}...` : void 0,
+    salt: params.salt,
+    payTo: params.payTo,
+    facilitatorFee: params.facilitatorFee,
+    hook: params.hook,
+    hookData: params.hookData,
+    settlementRouter: params.settlementRouter
+  });
+  try {
+    const txHash = await walletClient.writeContract({
+      address: params.settlementRouter,
+      abi: SETTLEMENT_ROUTER_ABI,
+      functionName: "settleAndExecute",
+      args: [
+        params.token,
+        params.from,
+        BigInt(params.value),
+        BigInt(params.validAfter),
+        BigInt(params.validBefore),
+        params.nonce,
+        params.signature,
+        params.salt,
+        params.payTo,
+        BigInt(params.facilitatorFee),
+        params.hook,
+        params.hookData
+      ],
+      gas: gasLimit,
+      chain: walletClient.chain,
+      account: walletClient.account ?? null
+    });
+    return txHash;
+  } catch (error) {
+    if (error instanceof Error) {
+      let errorMessage = `SettlementRouter execution failed: ${error.message}`;
+      if ("cause" in error && error.cause) {
+        errorMessage += ` (cause: ${error.cause})`;
+      }
+      throw new Error(errorMessage);
+    }
+    throw new Error("Unknown error during SettlementRouter execution");
+  }
+}
+async function waitForSettlementReceipt(publicClient, txHash, timeoutMs = 3e4) {
+  try {
+    const receipt = await publicClient.waitForTransactionReceipt({
+      hash: txHash,
+      timeout: timeoutMs
+    });
+    return {
+      success: receipt.status === "success",
+      blockNumber: receipt.blockNumber,
+      gasUsed: receipt.gasUsed,
+      effectiveGasPrice: receipt.effectiveGasPrice
+    };
+  } catch (error) {
+    throw new Error(
+      `Failed to get transaction receipt: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+function parseEvmExactPayload(payload) {
+  const evmPayload = payload.payload;
+  if (!evmPayload || !evmPayload.signature || !evmPayload.authorization) {
+    throw new Error("Invalid EVM exact payload structure");
+  }
+  return evmPayload;
+}
+function parseSettlementRouterParams(paymentRequirements, paymentPayload) {
+  if (!isSettlementMode(paymentRequirements)) {
+    throw new Error("Payment requirements are not in SettlementRouter mode");
+  }
+  const evmPayload = parseEvmExactPayload(paymentPayload);
+  const extra = parseSettlementExtra(paymentRequirements.extra);
+  return {
+    token: paymentRequirements.asset,
+    from: evmPayload.authorization.from,
+    value: paymentRequirements.amount,
+    // V2 uses 'amount', not 'maxAmountRequired'
+    validAfter: evmPayload.authorization.validAfter || "0x0",
+    validBefore: evmPayload.authorization.validBefore || "0xFFFFFFFFFFFFFFFF",
+    nonce: evmPayload.authorization.nonce,
+    signature: evmPayload.signature,
+    salt: extra.salt,
+    payTo: extra.payTo,
+    facilitatorFee: extra.facilitatorFee,
+    hook: extra.hook,
+    hookData: extra.hookData,
+    settlementRouter: extra.settlementRouter
+  };
+}
+async function executeSettlementWithWalletClient(walletClient, publicClient, paymentRequirements, paymentPayload, config = {}) {
+  try {
+    const canonicalNetwork = toCanonicalNetworkKey(paymentRequirements.network);
+    const v1NetworkName = getNetworkName(canonicalNetwork);
+    const networkConfig = getNetworkConfig(v1NetworkName);
+    const settlementRouter = paymentRequirements.extra?.settlementRouter;
+    if (!settlementRouter) {
+      throw new Error("Missing settlementRouter in payment requirements");
+    }
+    validateSettlementRouter(
+      paymentRequirements.network,
+      settlementRouter,
+      config.allowedRouters,
+      networkConfig
+    );
+    const params = parseSettlementRouterParams(paymentRequirements, paymentPayload);
+    const txHash = await executeSettlementWithRouter(walletClient, params, {
+      gasLimit: config.gasLimit,
+      gasMultiplier: config.gasMultiplier
+    });
+    const receipt = await waitForSettlementReceipt(publicClient, txHash, config.timeoutMs || 3e4);
+    return {
+      success: receipt.success,
+      transaction: txHash,
+      network: paymentRequirements.network,
+      payer: params.from,
+      // Use params.from for consistency
+      errorReason: receipt.success ? void 0 : "Transaction failed"
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    let payer;
+    try {
+      const params = parseSettlementRouterParams(paymentRequirements, paymentPayload);
+      payer = params.from;
+    } catch (parseError) {
+      console.error("[executeSettlementWithWalletClient] Failed to parse params:", parseError);
+      try {
+        const evmPayload = parseEvmExactPayload(paymentPayload);
+        payer = evmPayload.authorization.from;
+      } catch {
+        payer = void 0;
+      }
+    }
+    console.error("[executeSettlementWithWalletClient] Settlement failed:", {
+      error: errorMessage,
+      stack: error instanceof Error ? error.stack : void 0,
+      network: paymentRequirements.network,
+      asset: paymentRequirements.asset,
+      payer
+    });
+    return {
+      success: false,
+      transaction: "",
+      network: paymentRequirements.network,
+      payer,
+      errorReason: errorMessage
+    };
+  }
+}
+async function settleWithSettlementRouter(paymentRequirements, paymentPayload, config, options = {}) {
+  try {
+    const networkConfig = getNetworkConfig(paymentRequirements.network);
+    validateSettlementRouter(
+      paymentRequirements.network,
+      paymentRequirements.extra?.settlementRouter,
+      config.allowedRouters,
+      networkConfig
+    );
+    const params = parseSettlementRouterParams(paymentRequirements, paymentPayload);
+    const publicClient = createPublicClientForNetwork(paymentRequirements.network, config.rpcUrls);
+    const walletClient = createWalletClientForNetwork(
+      paymentRequirements.network,
+      config.signer,
+      config.rpcUrls,
+      void 0,
+      config.privateKey
+    );
+    const txHash = await executeSettlementWithRouter(walletClient, params, {
+      gasLimit: options.gasLimit,
+      gasMultiplier: options.gasMultiplier
+    });
+    const receipt = await waitForSettlementReceipt(
+      publicClient,
+      txHash,
+      options.timeoutMs || 3e4
+    );
+    return {
+      success: receipt.success,
+      transaction: txHash,
+      network: paymentRequirements.network,
+      payer: params.from,
+      errorReason: receipt.success ? void 0 : "Transaction failed"
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    let payer;
+    try {
+      const evmPayload = parseEvmExactPayload(paymentPayload);
+      payer = evmPayload.authorization.from;
+    } catch {
+      payer = void 0;
+    }
+    return {
+      success: false,
+      transaction: "",
+      network: paymentRequirements.network,
+      payer,
+      errorReason: errorMessage
+    };
+  }
+}
+var authorizationTypes = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+function parseEvmExactPayload2(payload) {
+  const evmPayload = payload.payload;
+  if (!evmPayload.signature) {
+    throw new FacilitatorValidationError("Missing signature in EVM exact payload");
+  }
+  if (!evmPayload.authorization) {
+    throw new FacilitatorValidationError("Missing authorization in EVM exact payload");
+  }
+  const auth = evmPayload.authorization;
+  if (!auth.from || !auth.to || !auth.value || !auth.nonce) {
+    throw new FacilitatorValidationError("Invalid authorization structure in EVM exact payload");
+  }
+  return evmPayload;
+}
+var eip3009ABI = [
+  {
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "validAfter", type: "uint256" },
+      { name: "validBefore", type: "uint256" },
+      { name: "nonce", type: "bytes32" },
+      { name: "signature", type: "bytes" }
+    ],
+    name: "transferWithAuthorization",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "account", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var RouterSettlementFacilitator = class {
+  constructor(config) {
+    this.scheme = "exact";
+    this.caipFamily = "eip155:*";
+    validateFacilitatorConfig(config);
+    this.config = {
+      // Default values
+      gasConfig: {
+        maxGasLimit: 5000000n,
+        gasMultiplier: 1.2
+      },
+      feeConfig: {
+        minFee: "0x0",
+        maxFee: "0xFFFFFFFFFFFFFFFF"
+      },
+      timeouts: {
+        verify: 5e3,
+        // 5 seconds
+        settle: 3e4
+        // 30 seconds
+      },
+      // Override with user config
+      ...config
+    };
+  }
+  /**
+   * Get scheme-specific extra data for responses
+   */
+  getExtra(network) {
+    try {
+      if (!network || typeof network !== "string" || network.trim() === "") {
+        return void 0;
+      }
+      const networkConfig = getNetworkConfig(network);
+      if (!networkConfig) {
+        return void 0;
+      }
+      return {
+        scheme: this.scheme,
+        caipFamily: this.caipFamily,
+        settlementRouter: networkConfig?.settlementRouter,
+        defaultAsset: networkConfig?.defaultAsset,
+        supportedNetworks: [network]
+        // Can be expanded for multi-network support
+      };
+    } catch (error) {
+      return void 0;
+    }
+  }
+  /**
+   * Get signer addresses for the network
+   * Derives from privateKey if signer address not explicitly provided
+   */
+  getSigners(network) {
+    validateNetwork(network);
+    if (this.config.signer) {
+      return [this.config.signer];
+    }
+    if (this.config.privateKey) {
+      const account = privateKeyToAccount(this.config.privateKey);
+      return [account.address];
+    }
+    throw new Error("Either signer or privateKey must be provided in FacilitatorConfig");
+  }
+  /**
+   * Verify payment payload without executing settlement
+   */
+  async verify(payload, requirements) {
+    try {
+      this.validateBasicPayload(payload, requirements);
+      const isRouterSettlement = isSettlementMode(requirements);
+      if (isRouterSettlement) {
+        return await this.verifySettlementRouter(payload, requirements);
+      } else {
+        return await this.verifyStandard(payload, requirements);
+      }
+    } catch (error) {
+      let payer;
+      try {
+        const evmPayload = parseEvmExactPayload2(payload);
+        payer = evmPayload.authorization.from;
+      } catch {
+        payer = void 0;
+      }
+      if (error instanceof FacilitatorValidationError || error instanceof SettlementRouterError) {
+        return {
+          isValid: false,
+          invalidReason: error.message,
+          payer: payer || ""
+        };
+      }
+      return {
+        isValid: false,
+        invalidReason: `Verification failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        payer: payer || ""
+      };
+    }
+  }
+  /**
+   * Settle payment by executing blockchain transaction
+   */
+  async settle(payload, requirements) {
+    try {
+      const verification = await this.verify(payload, requirements);
+      if (!verification.isValid) {
+        return {
+          success: false,
+          transaction: "",
+          network: requirements.network,
+          payer: verification.payer,
+          errorReason: verification.invalidReason || "Payment verification failed"
+        };
+      }
+      const isRouterSettlement = isSettlementMode(requirements);
+      if (isRouterSettlement) {
+        return await this.settleWithRouter(payload, requirements);
+      } else {
+        return await this.settleStandard(payload, requirements);
+      }
+    } catch (error) {
+      let payer;
+      try {
+        const evmPayload = parseEvmExactPayload2(payload);
+        payer = evmPayload.authorization.from;
+      } catch {
+        payer = void 0;
+      }
+      return {
+        success: false,
+        transaction: "",
+        network: requirements.network,
+        payer: payer || "",
+        errorReason: error instanceof Error ? error.message : "Unknown settlement error"
+      };
+    }
+  }
+  /**
+   * Validate basic payload and requirements
+   */
+  validateBasicPayload(payload, requirements) {
+    validateNetwork(requirements.network);
+    if (requirements.scheme !== this.scheme) {
+      throw new FacilitatorValidationError(
+        `Scheme mismatch: expected ${this.scheme}, got ${requirements.scheme}`
+      );
+    }
+    if (!requirements.network.startsWith("eip155:")) {
+      throw new FacilitatorValidationError(
+        `Unsupported network family: ${requirements.network}. Only EVM networks (eip155:*) are supported`
+      );
+    }
+    parseEvmExactPayload2(payload);
+    if (!requirements.asset) {
+      throw new FacilitatorValidationError("Missing asset in payment requirements");
+    }
+    if (!requirements.payTo) {
+      throw new FacilitatorValidationError("Missing payTo address in payment requirements");
+    }
+    if (!requirements.amount) {
+      throw new FacilitatorValidationError("Missing amount in payment requirements");
+    }
+  }
+  /**
+   * Verify payment for SettlementRouter mode
+   */
+  async verifySettlementRouter(payload, requirements) {
+    const evmPayload = parseEvmExactPayload2(payload);
+    const payer = evmPayload.authorization.from;
+    const settlementExtra = validateSettlementExtra(requirements.extra);
+    const networkConfig = getNetworkConfig(requirements.network);
+    validateSettlementRouter(
+      requirements.network,
+      settlementExtra.settlementRouter,
+      this.config.allowedRouters,
+      networkConfig
+    );
+    validateFeeAmount(
+      settlementExtra.facilitatorFee,
+      this.config.feeConfig?.minFee,
+      this.config.feeConfig?.maxFee
+    );
+    const publicClient = createPublicClientForNetwork(requirements.network, this.config.rpcUrls);
+    const extraWithDomain = requirements.extra;
+    const eip712Name = extraWithDomain?.name || "USD Coin";
+    const eip712Version = extraWithDomain?.version || "2";
+    try {
+      const parsedSignature = parseErc6492Signature(evmPayload.signature);
+      const typedData = {
+        types: authorizationTypes,
+        primaryType: "TransferWithAuthorization",
+        domain: {
+          name: eip712Name,
+          version: eip712Version,
+          chainId: parseInt(requirements.network.split(":")[1]),
+          verifyingContract: requirements.asset
+        },
+        message: {
+          from: payer,
+          to: evmPayload.authorization.to,
+          value: BigInt(evmPayload.authorization.value),
+          validAfter: BigInt(evmPayload.authorization.validAfter || "0x0"),
+          validBefore: BigInt(evmPayload.authorization.validBefore || "0xFFFFFFFFFFFFFFFF"),
+          nonce: evmPayload.authorization.nonce
+        }
+      };
+      const isValidSignature = await verifyTypedData({
+        address: payer,
+        ...typedData,
+        signature: parsedSignature.signature
+      });
+      if (!isValidSignature) {
+        return {
+          isValid: false,
+          invalidReason: "Invalid signature",
+          payer
+        };
+      }
+    } catch (error) {
+      return {
+        isValid: false,
+        invalidReason: `Signature verification failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        payer
+      };
+    }
+    try {
+      const chainId = parseInt(requirements.network.split(":")[1]);
+      const calculatedCommitment = calculateCommitment({
+        chainId,
+        hub: settlementExtra.settlementRouter,
+        asset: requirements.asset,
+        from: payer,
+        value: evmPayload.authorization.value,
+        validAfter: evmPayload.authorization.validAfter || "0x0",
+        validBefore: evmPayload.authorization.validBefore || "0xFFFFFFFFFFFFFFFF",
+        salt: settlementExtra.salt,
+        payTo: settlementExtra.payTo,
+        facilitatorFee: settlementExtra.facilitatorFee,
+        hook: settlementExtra.hook,
+        hookData: settlementExtra.hookData
+      });
+      if (evmPayload.authorization.nonce !== calculatedCommitment) {
+        return {
+          isValid: false,
+          invalidReason: "Commitment mismatch: nonce does not match calculated commitment",
+          payer
+        };
+      }
+    } catch (error) {
+      return {
+        isValid: false,
+        invalidReason: `Commitment verification failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        payer
+      };
+    }
+    try {
+      const balance = await publicClient.readContract({
+        address: requirements.asset,
+        abi: [
+          {
+            type: "function",
+            name: "balanceOf",
+            inputs: [{ name: "account", type: "address" }],
+            outputs: [{ name: "", type: "uint256" }],
+            stateMutability: "view"
+          }
+        ],
+        functionName: "balanceOf",
+        args: [payer]
+      });
+      const totalRequired = BigInt(requirements.amount) + BigInt(settlementExtra.facilitatorFee);
+      if (balance < totalRequired) {
+        return {
+          isValid: false,
+          invalidReason: `Insufficient balance: have ${balance}, need ${totalRequired}`,
+          payer
+        };
+      }
+    } catch (error) {
+      return {
+        isValid: false,
+        invalidReason: `Balance check failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        payer
+      };
+    }
+    return {
+      isValid: true,
+      payer
+    };
+  }
+  /**
+   * Verify payment for standard mode (fallback)
+   */
+  async verifyStandard(payload, requirements) {
+    const evmPayload = parseEvmExactPayload2(payload);
+    const payer = evmPayload.authorization.from;
+    const publicClient = createPublicClientForNetwork(requirements.network, this.config.rpcUrls);
+    try {
+      const parsedSignature = parseErc6492Signature(evmPayload.signature);
+      const extraAny = requirements.extra;
+      const domainName = extraAny?.name || "USD Coin";
+      const domainVersion = extraAny?.version || "3";
+      const typedData = {
+        types: authorizationTypes,
+        primaryType: "TransferWithAuthorization",
+        domain: {
+          name: domainName,
+          version: domainVersion,
+          chainId: parseInt(requirements.network.split(":")[1]),
+          verifyingContract: requirements.asset
+        },
+        message: {
+          from: payer,
+          to: requirements.payTo,
+          value: BigInt(requirements.amount),
+          validAfter: BigInt(evmPayload.authorization.validAfter || "0x0"),
+          validBefore: BigInt(evmPayload.authorization.validBefore || "0xFFFFFFFFFFFFFFFF"),
+          nonce: evmPayload.authorization.nonce
+        }
+      };
+      const isValidSignature = await verifyTypedData({
+        address: payer,
+        ...typedData,
+        signature: parsedSignature.signature
+      });
+      if (!isValidSignature) {
+        return {
+          isValid: false,
+          invalidReason: "Invalid signature",
+          payer
+        };
+      }
+      const balance = await publicClient.readContract({
+        address: requirements.asset,
+        abi: eip3009ABI,
+        functionName: "balanceOf",
+        args: [payer]
+      });
+      if (BigInt(balance) < BigInt(requirements.amount)) {
+        return {
+          isValid: false,
+          invalidReason: "Insufficient balance",
+          payer
+        };
+      }
+      return {
+        isValid: true,
+        payer
+      };
+    } catch (error) {
+      return {
+        isValid: false,
+        invalidReason: `Standard verification failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        payer
+      };
+    }
+  }
+  /**
+   * Settle payment using SettlementRouter
+   */
+  async settleWithRouter(payload, requirements) {
+    return await settleWithSettlementRouter(requirements, payload, this.config, {
+      gasMultiplier: this.config.gasConfig?.gasMultiplier,
+      timeoutMs: this.config.timeouts?.settle
+    });
+  }
+  /**
+   * Settle payment using standard method (fallback)
+   */
+  async settleStandard(payload, requirements) {
+    const evmPayload = parseEvmExactPayload2(payload);
+    const payer = evmPayload.authorization.from;
+    const walletClient = createWalletClientForNetwork(
+      requirements.network,
+      this.config.signer,
+      this.config.rpcUrls,
+      void 0,
+      this.config.privateKey
+    );
+    const publicClient = createPublicClientForNetwork(requirements.network, this.config.rpcUrls);
+    try {
+      const parsedSignature = parseErc6492Signature(evmPayload.signature);
+      const txHash = await walletClient.writeContract({
+        address: requirements.asset,
+        abi: eip3009ABI,
+        functionName: "transferWithAuthorization",
+        args: [
+          payer,
+          requirements.payTo,
+          BigInt(requirements.amount),
+          BigInt(evmPayload.authorization.validAfter || "0x0"),
+          BigInt(evmPayload.authorization.validBefore || "0xFFFFFFFFFFFFFFFF"),
+          evmPayload.authorization.nonce,
+          parsedSignature.signature
+        ],
+        chain: walletClient.chain,
+        account: walletClient.account ?? null
+      });
+      const receipt = await waitForSettlementReceipt(publicClient, txHash);
+      return {
+        success: receipt.success,
+        transaction: txHash,
+        network: requirements.network,
+        payer,
+        errorReason: receipt.success ? void 0 : "Transaction failed"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        transaction: "",
+        network: requirements.network,
+        payer,
+        errorReason: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+};
+function createRouterSettlementFacilitator(config) {
+  return new RouterSettlementFacilitator(config);
+}
+
+export { RouterSettlementFacilitator, calculateGasLimit, checkIfSettled, createPublicClientForNetwork, createRouterSettlementFacilitator, createWalletClientForNetwork, executeSettlementWithRouter, executeSettlementWithWalletClient, isValid256BitHex, isValid32ByteHex, isValidEthereumAddress, isValidHex, parseSettlementRouterParams, settleWithSettlementRouter, validateFacilitatorConfig, validateFeeAmount, validateGasLimit, validateGasMultiplier, validateNetwork, validateSettlementExtra, validateSettlementRouter, waitForSettlementReceipt };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map