@x402x/extensions 2.0.0

package/dist/index.mjs

@@ -0,0 +1,1458 @@
+import { defineChain, encodeAbiParameters, keccak256, encodePacked } from 'viem';
+import * as allChains from 'viem/chains';
+
+// src/types.ts
+var SettlementExtraError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SettlementExtraError";
+  }
+};
+
+// src/middleware-utils.ts
+function computeRoutePatterns(routes) {
+  const normalizedRoutes = Object.fromEntries(
+    Object.entries(routes).map(([pattern, value]) => [
+      pattern,
+      typeof value === "string" || typeof value === "number" ? { price: value, network: "base-sepolia" } : value
+    ])
+  );
+  return Object.entries(normalizedRoutes).map(([pattern, routeConfig]) => {
+    const [verb, path] = pattern.includes(" ") ? pattern.split(/\s+/) : ["*", pattern];
+    if (!path) {
+      throw new Error(`Invalid route pattern: ${pattern}`);
+    }
+    return {
+      verb: verb.toUpperCase(),
+      pattern: new RegExp(
+        `^${path.replace(/\\/g, "\\\\").replace(/[$()+.?^{|}]/g, "\\$&").replace(/\*/g, ".*?").replace(/\[([^\]]+)\]/g, "[^/]+").replace(/\//g, "\\/")}$`,
+        "i"
+      ),
+      config: routeConfig
+    };
+  });
+}
+function findMatchingRoute(routePatterns, path, method) {
+  let normalizedPath;
+  try {
+    const pathWithoutQuery = path.split(/[?#]/)[0];
+    const decodedPath = decodeURIComponent(pathWithoutQuery);
+    normalizedPath = decodedPath.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/(.+?)\/+$/, "$1");
+  } catch {
+    return void 0;
+  }
+  const matchingRoutes = routePatterns.filter(({ pattern, verb }) => {
+    const matchesPath = pattern.test(normalizedPath);
+    const upperMethod = method.toUpperCase();
+    const matchesVerb = verb === "*" || upperMethod === verb;
+    return matchesPath && matchesVerb;
+  });
+  return matchingRoutes[0];
+}
+function findMatchingPaymentRequirements(requirements, network) {
+  return requirements[0];
+}
+function toJsonSafe(value) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return value.map(toJsonSafe);
+  }
+  if (typeof value === "object") {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      result[key] = toJsonSafe(val);
+    }
+    return result;
+  }
+  return value;
+}
+function calculateCommitment(params) {
+  return keccak256(
+    encodePacked(
+      [
+        "string",
+        // Protocol identifier
+        "uint256",
+        // Chain ID
+        "address",
+        // Hub address
+        "address",
+        // Token address
+        "address",
+        // From (payer)
+        "uint256",
+        // Value
+        "uint256",
+        // Valid after
+        "uint256",
+        // Valid before
+        "bytes32",
+        // Salt
+        "address",
+        // Pay to
+        "uint256",
+        // Facilitator fee
+        "address",
+        // Hook
+        "bytes32"
+        // keccak256(hookData)
+      ],
+      [
+        "X402/settle/v1",
+        BigInt(params.chainId),
+        params.hub,
+        params.asset,
+        params.from,
+        BigInt(params.value),
+        BigInt(params.validAfter),
+        BigInt(params.validBefore),
+        params.salt,
+        params.payTo,
+        BigInt(params.facilitatorFee),
+        params.hook,
+        keccak256(params.hookData)
+      ]
+    )
+  );
+}
+function generateSalt() {
+  const globalCrypto = typeof crypto !== "undefined" ? crypto : void 0;
+  if (globalCrypto?.getRandomValues) {
+    const bytes2 = new Uint8Array(32);
+    globalCrypto.getRandomValues(bytes2);
+    return `0x${Array.from(bytes2).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+  }
+  console.warn(
+    "[generateSalt] Using Math.random() fallback - consider upgrading to Node.js 15+ or use in browser"
+  );
+  const bytes = new Uint8Array(32);
+  for (let i = 0; i < 32; i++) {
+    bytes[i] = Math.floor(Math.random() * 256);
+  }
+  return `0x${Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+function validateCommitmentParams(params) {
+  if (!isValidAddress(params.hub)) {
+    throw new Error("Invalid hub address");
+  }
+  if (!isValidAddress(params.asset)) {
+    throw new Error("Invalid asset address");
+  }
+  if (!isValidAddress(params.from)) {
+    throw new Error("Invalid from address");
+  }
+  if (!isValidAddress(params.payTo)) {
+    throw new Error("Invalid payTo address");
+  }
+  if (!isValidAddress(params.hook)) {
+    throw new Error("Invalid hook address");
+  }
+  try {
+    BigInt(params.value);
+    BigInt(params.validAfter);
+    BigInt(params.validBefore);
+    BigInt(params.facilitatorFee);
+  } catch (e) {
+    throw new Error("Invalid numeric parameter");
+  }
+  if (!isValidHex(params.salt) || params.salt.length !== 66) {
+    throw new Error("Invalid salt: must be bytes32 (0x + 64 hex chars)");
+  }
+  if (!isValidHex(params.hookData)) {
+    throw new Error("Invalid hookData: must be hex string");
+  }
+}
+function isValidAddress(address) {
+  return /^0x[0-9a-fA-F]{40}$/.test(address);
+}
+function isValidHex(hex) {
+  return /^0x[0-9a-fA-F]*$/.test(hex);
+}
+
+// src/network-utils.ts
+var NETWORK_IDS = {
+  "base-sepolia": "eip155:84532",
+  "x-layer-testnet": "eip155:1952",
+  "skale-base-sepolia": "eip155:324705682",
+  "base": "eip155:8453",
+  "x-layer": "eip155:196",
+  "bsc-testnet": "eip155:97",
+  "bsc": "eip155:56"
+};
+var NETWORK_NAMES = {
+  "eip155:84532": "base-sepolia",
+  "eip155:1952": "x-layer-testnet",
+  "eip155:324705682": "skale-base-sepolia",
+  "eip155:8453": "base",
+  "eip155:196": "x-layer",
+  "eip155:97": "bsc-testnet",
+  "eip155:56": "bsc"
+};
+var DEFAULT_ASSETS = {
+  "eip155:84532": {
+    address: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    decimals: 6,
+    eip712: {
+      name: "USDC",
+      version: "2"
+    }
+  },
+  "eip155:1952": {
+    address: "0xcb8bf24c6ce16ad21d707c9505421a17f2bec79d",
+    decimals: 6,
+    eip712: {
+      name: "USDC_TEST",
+      version: "2"
+    }
+  },
+  "eip155:324705682": {
+    address: "0x2e08028E3C4c2356572E096d8EF835cD5C6030bD",
+    decimals: 6,
+    eip712: {
+      name: "Bridged USDC (SKALE Bridge)",
+      version: "2"
+    }
+  },
+  "eip155:8453": {
+    address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    decimals: 6,
+    eip712: {
+      name: "USD Coin",
+      version: "2"
+    }
+  },
+  "eip155:196": {
+    address: "0x74b7f16337b8972027f6196a17a631ac6de26d22",
+    decimals: 6,
+    eip712: {
+      name: "USD Coin",
+      version: "2"
+    }
+  },
+  "eip155:97": {
+    address: "0xdac693b5f14e7ee5923a4830cd2f82ff178f5098",
+    decimals: 18,
+    eip712: {
+      name: "x402 Wrapped USDT",
+      version: "1"
+    }
+  },
+  "eip155:56": {
+    address: "0x2fDb94bAa9D664a1879BEe1f944F5F5d2dad4451",
+    decimals: 18,
+    eip712: {
+      name: "x402 Wrapped USDT",
+      version: "1"
+    }
+  }
+};
+function getNetworkId(networkName) {
+  const networkId = NETWORK_IDS[networkName];
+  if (!networkId) {
+    throw new Error(
+      `Unsupported network: ${networkName}. Supported networks: ${Object.keys(NETWORK_IDS).join(", ")}`
+    );
+  }
+  return networkId;
+}
+function getNetworkName(network) {
+  const networkName = NETWORK_NAMES[network];
+  if (!networkName) {
+    throw new Error(
+      `Unsupported network ID: ${network}. Supported network IDs: ${Object.keys(NETWORK_NAMES).join(", ")}`
+    );
+  }
+  return networkName;
+}
+function getDefaultAsset(network) {
+  const assetInfo = DEFAULT_ASSETS[network];
+  if (!assetInfo) {
+    throw new Error(`No default asset configured for network: ${network}`);
+  }
+  return assetInfo;
+}
+function parseMoneyToDecimal(money) {
+  if (typeof money === "number") {
+    return money;
+  }
+  const cleanMoney = money.replace(/^\$/, "").trim();
+  const amount = parseFloat(cleanMoney);
+  if (isNaN(amount)) {
+    throw new Error(`Invalid money format: ${money}`);
+  }
+  return amount;
+}
+function processPriceToAtomicAmount(price, network) {
+  try {
+    const amount = parseMoneyToDecimal(price);
+    const asset = getDefaultAsset(network);
+    const decimals = asset.decimals;
+    const [whole, fractional = "0"] = amount.toString().split(".");
+    const paddedFractional = fractional.padEnd(decimals, "0").slice(0, decimals);
+    const atomicAmount = BigInt(whole) * BigInt(10 ** decimals) + BigInt(paddedFractional);
+    return { amount: atomicAmount.toString() };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error.message : "Unknown error processing price"
+    };
+  }
+}
+var NETWORK_ALIASES_V1_TO_V2 = {
+  // V1 human-readable names -> V2 CAIP-2 canonical keys
+  "base-sepolia": "eip155:84532",
+  "x-layer-testnet": "eip155:1952",
+  "skale-base-sepolia": "eip155:324705682",
+  "base": "eip155:8453",
+  "x-layer": "eip155:196",
+  "bsc-testnet": "eip155:97",
+  "bsc": "eip155:56"
+};
+function getSupportedNetworkIds() {
+  return Object.keys(NETWORK_NAMES);
+}
+function getSupportedNetworksV2() {
+  return getSupportedNetworkIds();
+}
+function getNetworkAliasesV1ToV2() {
+  return { ...NETWORK_ALIASES_V1_TO_V2 };
+}
+function toCanonicalNetworkKey(network) {
+  if (network.startsWith("eip155:")) {
+    const canonicalNetwork2 = network;
+    if (canonicalNetwork2 in NETWORK_NAMES) {
+      return canonicalNetwork2;
+    }
+    throw new Error(
+      `Unsupported CAIP-2 network: ${network}. Supported networks: ${Object.keys(NETWORK_NAMES).join(", ")}`
+    );
+  }
+  const canonicalNetwork = NETWORK_ALIASES_V1_TO_V2[network];
+  if (!canonicalNetwork) {
+    throw new Error(
+      `Unsupported network: ${network}. Supported networks: ${Object.keys(NETWORK_ALIASES_V1_TO_V2).join(", ")}`
+    );
+  }
+  return canonicalNetwork;
+}
+
+// src/networks.ts
+function getDefaultAssetConfig(network) {
+  const defaultAsset = getDefaultAsset(network);
+  return {
+    address: defaultAsset.address,
+    decimals: defaultAsset.decimals,
+    eip712: {
+      name: defaultAsset.eip712.name,
+      version: defaultAsset.eip712.version
+    }
+  };
+}
+var networks = {
+  "base-sepolia": {
+    chainId: parseInt(getNetworkId("base-sepolia").split(":")[1]),
+    name: "Base Sepolia",
+    type: "testnet",
+    addressExplorerBaseUrl: "https://sepolia.basescan.org/address/",
+    txExplorerBaseUrl: "https://sepolia.basescan.org/tx/",
+    settlementRouter: "0x817e4f0ee2fbdaac426f1178e149f7dc98873ecb",
+    defaultAsset: getDefaultAssetConfig(getNetworkId("base-sepolia")),
+    hooks: {
+      transfer: "0x4DE234059C6CcC94B8fE1eb1BD24804794083569"
+    },
+    demoHooks: {
+      nftMint: "0x261206558E6eEd104Cba4AD913b2Eec85D21108e",
+      randomNFT: "0x5756A67a33118F5Ad9840411f252E14d84Dd7c02",
+      reward: "0xf05cE06e7ee4ffCb67a509003DbD73A6d95Cc960",
+      rewardToken: "0xb6854e33BfD428d15B4f5398cFf8e84d4196FDA6"
+    },
+    metadata: {
+      gasModel: "eip1559",
+      nativeToken: "ETH"
+    }
+  },
+  "x-layer-testnet": {
+    chainId: parseInt(getNetworkId("x-layer-testnet").split(":")[1]),
+    name: "X Layer Testnet",
+    type: "testnet",
+    addressExplorerBaseUrl: "https://www.oklink.com/xlayer-test/address/",
+    txExplorerBaseUrl: "https://www.oklink.com/xlayer-test/tx/",
+    settlementRouter: "0xba9980fb08771e2fd10c17450f52d39bcb9ed576",
+    defaultAsset: getDefaultAssetConfig(getNetworkId("x-layer-testnet")),
+    hooks: {
+      transfer: "0xD4b98dd614c1Ea472fC4547a5d2B93f3D3637BEE"
+    },
+    demoHooks: {
+      nftMint: "0x468F666314b070338841422012AB2f6539bfcE48",
+      randomNFT: "0xBA931bB5B2F2DC5354aFAED1d3996B0c6e417518",
+      reward: "0xda8B270Ec442Ff797807b95604E3319e36Aad05d",
+      rewardToken: "0x348AFDE3B4B70dCb02053aF95588a4ab41e95FbC"
+    },
+    metadata: {
+      gasModel: "eip1559",
+      nativeToken: "OKB"
+    }
+  },
+  "skale-base-sepolia": {
+    chainId: parseInt(getNetworkId("skale-base-sepolia").split(":")[1]),
+    name: "SKALE Base Sepolia",
+    type: "testnet",
+    addressExplorerBaseUrl: "https://base-sepolia-testnet-explorer.skalenodes.com/address/",
+    txExplorerBaseUrl: "https://base-sepolia-testnet-explorer.skalenodes.com/tx/",
+    settlementRouter: "0x1Ae0E196dC18355aF3a19985faf67354213F833D",
+    defaultAsset: getDefaultAssetConfig(getNetworkId("skale-base-sepolia")),
+    hooks: {
+      transfer: "0x2f05fe5674aE756E25C26855258B4877E9e021Fd"
+    },
+    demoHooks: {
+      nftMint: "0x73fc659cd5494e69852be8d9d23fe05aab14b29b",
+      randomNFT: "0x081258287f692d61575387ee2a4075f34dd7aef7",
+      reward: "0xc20634ea518985901e32fbc1ba27fa673d37601a",
+      rewardToken: "0x9fc2c199170b039f093abcd54008038f0c0a31d6"
+    },
+    metadata: {
+      gasModel: "legacy",
+      nativeToken: "Credits"
+    }
+  },
+  "bsc-testnet": {
+    chainId: parseInt(getNetworkId("bsc-testnet").split(":")[1]),
+    name: "BSC Testnet",
+    type: "testnet",
+    addressExplorerBaseUrl: "https://testnet.bscscan.com/address/",
+    txExplorerBaseUrl: "https://testnet.bscscan.com/tx/",
+    settlementRouter: "0x1Ae0E196dC18355aF3a19985faf67354213F833D",
+    defaultAsset: getDefaultAssetConfig(getNetworkId("bsc-testnet")),
+    hooks: {
+      transfer: "0x2f05fe5674aE756E25C26855258B4877E9e021Fd"
+    },
+    demoHooks: {
+      nftMint: "0x73fc659Cd5494E69852bE8D9D23FE05Aab14b29B",
+      randomNFT: "0x081258287F692D61575387ee2a4075f34dd7Aef7",
+      reward: "0xC20634ea518985901e32Fbc1bA27fa673D37601A",
+      rewardToken: "0x9Fc2c199170B039f093ABCd54008038F0C0a31d6"
+    },
+    metadata: {
+      gasModel: "legacy",
+      nativeToken: "BNB"
+    }
+  },
+  // Mainnet configurations
+  base: {
+    chainId: parseInt(getNetworkId("base").split(":")[1]),
+    name: "Base Mainnet",
+    type: "mainnet",
+    addressExplorerBaseUrl: "https://basescan.org/address/",
+    txExplorerBaseUrl: "https://basescan.org/tx/",
+    settlementRouter: "0x73fc659Cd5494E69852bE8D9D23FE05Aab14b29B",
+    defaultAsset: getDefaultAssetConfig(getNetworkId("base")),
+    hooks: {
+      transfer: "0x081258287F692D61575387ee2a4075f34dd7Aef7"
+    },
+    demoHooks: {
+      nftMint: "0xC20634ea518985901e32Fbc1bA27fa673D37601A",
+      randomNFT: "0x9Fc2c199170B039f093ABCd54008038F0C0a31d6",
+      reward: "0x4B566FD5eFf76e3BdF20Ca5c3F2FA7cdbb3bD99A",
+      rewardToken: "0x12d41108f9F12064f792418C9BA0ACF6EdcE7790"
+    },
+    metadata: {
+      gasModel: "eip1559",
+      nativeToken: "ETH"
+    }
+  },
+  "x-layer": {
+    chainId: parseInt(getNetworkId("x-layer").split(":")[1]),
+    name: "X Layer Mainnet",
+    type: "mainnet",
+    addressExplorerBaseUrl: "https://www.oklink.com/xlayer/address/",
+    txExplorerBaseUrl: "https://www.oklink.com/xlayer/tx/",
+    settlementRouter: "0x73fc659Cd5494E69852bE8D9D23FE05Aab14b29B",
+    defaultAsset: getDefaultAssetConfig(getNetworkId("x-layer")),
+    hooks: {
+      transfer: "0x081258287F692D61575387ee2a4075f34dd7Aef7"
+    },
+    demoHooks: {
+      nftMint: "0xC20634ea518985901e32Fbc1bA27fa673D37601A",
+      randomNFT: "0x9Fc2c199170B039f093ABCd54008038F0C0a31d6",
+      reward: "0x4B566FD5eFf76e3BdF20Ca5c3F2FA7cdbb3bD99A",
+      rewardToken: "0x12d41108f9F12064f792418C9BA0ACF6EdcE7790"
+    },
+    metadata: {
+      gasModel: "eip1559",
+      nativeToken: "OKB"
+    }
+  },
+  bsc: {
+    chainId: parseInt(getNetworkId("bsc").split(":")[1]),
+    name: "BSC Mainnet",
+    type: "mainnet",
+    addressExplorerBaseUrl: "https://bscscan.com/address/",
+    txExplorerBaseUrl: "https://bscscan.com/tx/",
+    settlementRouter: "0x1Ae0E196dC18355aF3a19985faf67354213F833D",
+    defaultAsset: getDefaultAssetConfig(getNetworkId("bsc")),
+    hooks: {
+      transfer: "0x2f05fe5674aE756E25C26855258B4877E9e021Fd"
+    },
+    demoHooks: {
+      nftMint: "0x73fc659Cd5494E69852bE8D9D23FE05Aab14b29B",
+      randomNFT: "0x081258287F692D61575387ee2a4075f34dd7Aef7",
+      reward: "0xC20634ea518985901e32Fbc1bA27fa673D37601A",
+      rewardToken: "0x9Fc2c199170B039f093ABCd54008038F0C0a31d6"
+    },
+    metadata: {
+      gasModel: "legacy",
+      nativeToken: "BNB"
+    }
+  }
+};
+function getNetworkConfig(network) {
+  const config = networks[network];
+  if (!config) {
+    throw new Error(
+      `Unsupported network: ${network}. Supported networks: ${Object.keys(networks).join(", ")}`
+    );
+  }
+  return config;
+}
+function isNetworkSupported(network) {
+  return network in networks;
+}
+function getSupportedNetworkNames() {
+  return Object.keys(networks);
+}
+function getSupportedNetworks() {
+  return getSupportedNetworkNames();
+}
+var customChains = {
+  // X Layer Testnet
+  1952: defineChain({
+    id: 1952,
+    name: "X Layer Testnet",
+    nativeCurrency: { name: "OKB", symbol: "OKB", decimals: 18 },
+    rpcUrls: {
+      default: { http: ["https://testrpc.xlayer.tech"] }
+    },
+    blockExplorers: {
+      default: { name: "OKLink", url: "https://www.oklink.com/xlayer-test" }
+    },
+    testnet: true
+  }),
+  // SKALE Nebula Testnet (Base Sepolia)
+  324705682: defineChain({
+    id: 324705682,
+    name: "SKALE Nebula Testnet",
+    nativeCurrency: { name: "sFUEL", symbol: "sFUEL", decimals: 18 },
+    rpcUrls: {
+      default: {
+        http: ["https://testnet.skalenodes.com/v1/lanky-ill-funny-testnet"]
+      }
+    },
+    blockExplorers: {
+      default: {
+        name: "SKALE Explorer",
+        url: "https://lanky-ill-funny-testnet.explorer.testnet.skalenodes.com"
+      }
+    },
+    testnet: true
+  }),
+  // X Layer Mainnet
+  196: defineChain({
+    id: 196,
+    name: "X Layer",
+    nativeCurrency: { name: "OKB", symbol: "OKB", decimals: 18 },
+    rpcUrls: {
+      default: { http: ["https://rpc.xlayer.tech"] }
+    },
+    blockExplorers: {
+      default: { name: "OKLink", url: "https://www.oklink.com/xlayer" }
+    },
+    testnet: false
+  })
+};
+function getChain(network) {
+  const networkId = getNetworkId(network);
+  const chainId = parseInt(networkId.split(":")[1]);
+  if (customChains[chainId]) {
+    return customChains[chainId];
+  }
+  const chain = Object.values(allChains).find((c) => c.id === chainId);
+  if (!chain) {
+    throw new Error(
+      `Unsupported network: ${network} (chain ID: ${chainId}). Please add custom chain definition in chains.ts`
+    );
+  }
+  return chain;
+}
+function getChainById(chainId) {
+  if (customChains[chainId]) {
+    return customChains[chainId];
+  }
+  const chain = Object.values(allChains).find((c) => c.id === chainId);
+  if (!chain) {
+    throw new Error(
+      `Unsupported chain ID: ${chainId}. Please add custom chain definition in chains.ts`
+    );
+  }
+  return chain;
+}
+function getCustomChains() {
+  return { ...customChains };
+}
+function isCustomChain(chainId) {
+  return chainId in customChains;
+}
+var TransferHook;
+((TransferHook2) => {
+  function encode(splits) {
+    if (!splits || splits.length === 0) {
+      return "0x";
+    }
+    let totalBips = 0;
+    for (const split of splits) {
+      if (!split.recipient || split.recipient === "0x0000000000000000000000000000000000000000") {
+        throw new Error(`Invalid recipient address: ${split.recipient}`);
+      }
+      if (split.bips <= 0) {
+        throw new Error(`Bips must be greater than 0, got: ${split.bips}`);
+      }
+      if (split.bips > 1e4) {
+        throw new Error(`Individual bips cannot exceed 10000, got: ${split.bips}`);
+      }
+      totalBips += split.bips;
+    }
+    if (totalBips > 1e4) {
+      throw new Error(`Total bips (${totalBips}) exceeds 10000 (100%)`);
+    }
+    return encodeAbiParameters(
+      [
+        {
+          type: "tuple[]",
+          name: "splits",
+          components: [
+            { name: "recipient", type: "address" },
+            { name: "bips", type: "uint16" }
+          ]
+        }
+      ],
+      [splits.map((s) => ({ recipient: s.recipient, bips: s.bips }))]
+    );
+  }
+  TransferHook2.encode = encode;
+  function getAddress(network) {
+    const config = getNetworkConfig(network);
+    return config.hooks.transfer;
+  }
+  TransferHook2.getAddress = getAddress;
+})(TransferHook || (TransferHook = {}));
+var NFTMintHook;
+((NFTMintHook2) => {
+  function getAddress(network) {
+    const config = getNetworkConfig(network);
+    if (!config.demoHooks?.nftMint) {
+      throw new Error(
+        `NFTMintHook not configured for network "${network}". Demo hooks are optional and may not be deployed on all networks.`
+      );
+    }
+    return config.demoHooks.nftMint;
+  }
+  NFTMintHook2.getAddress = getAddress;
+  function getNFTContractAddress(network) {
+    const config = getNetworkConfig(network);
+    if (!config.demoHooks?.randomNFT) {
+      throw new Error(
+        `RandomNFT contract not configured for network "${network}". Demo hooks are optional and may not be deployed on all networks.`
+      );
+    }
+    return config.demoHooks.randomNFT;
+  }
+  NFTMintHook2.getNFTContractAddress = getNFTContractAddress;
+  function encode(config) {
+    return encodeAbiParameters(
+      [
+        {
+          type: "tuple",
+          components: [{ name: "nftContract", type: "address" }]
+        }
+      ],
+      [
+        {
+          nftContract: config.nftContract
+        }
+      ]
+    );
+  }
+  NFTMintHook2.encode = encode;
+})(NFTMintHook || (NFTMintHook = {}));
+var RewardHook;
+((RewardHook2) => {
+  function getAddress(network) {
+    const config = getNetworkConfig(network);
+    if (!config.demoHooks?.reward) {
+      throw new Error(
+        `RewardHook not configured for network "${network}". Demo hooks are optional and may not be deployed on all networks.`
+      );
+    }
+    return config.demoHooks.reward;
+  }
+  RewardHook2.getAddress = getAddress;
+  function getTokenAddress(network) {
+    const config = getNetworkConfig(network);
+    if (!config.demoHooks?.rewardToken) {
+      throw new Error(
+        `Reward token not configured for network "${network}". Demo hooks are optional and may not be deployed on all networks.`
+      );
+    }
+    return config.demoHooks.rewardToken;
+  }
+  RewardHook2.getTokenAddress = getTokenAddress;
+  function encode(config) {
+    return encodeAbiParameters(
+      [
+        {
+          type: "tuple",
+          components: [{ name: "rewardToken", type: "address" }]
+        }
+      ],
+      [
+        {
+          rewardToken: config.rewardToken
+        }
+      ]
+    );
+  }
+  RewardHook2.encode = encode;
+})(RewardHook || (RewardHook = {}));
+
+// src/validation.ts
+function isValidAddress2(address) {
+  return /^0x[a-fA-F0-9]{40}$/.test(address);
+}
+function isValidHex2(hex) {
+  return /^0x[a-fA-F0-9]*$/.test(hex) && hex.length % 2 === 0;
+}
+function isValid32ByteHex(hex) {
+  return /^0x[a-fA-F0-9]{64}$/.test(hex);
+}
+function isValidNumericString(value) {
+  return /^\d+$/.test(value);
+}
+function validateSettlementExtra(extra) {
+  if (!extra.settlementRouter) {
+    return { valid: false, error: "settlementRouter is required" };
+  }
+  if (!isValidAddress2(extra.settlementRouter)) {
+    return { valid: false, error: "settlementRouter must be a valid Ethereum address" };
+  }
+  if (!extra.payTo) {
+    return { valid: false, error: "payTo is required" };
+  }
+  if (!isValidAddress2(extra.payTo)) {
+    return { valid: false, error: "payTo must be a valid Ethereum address" };
+  }
+  if (extra.facilitatorFee === void 0 || extra.facilitatorFee === null) {
+    return { valid: false, error: "facilitatorFee is required" };
+  }
+  if (!isValidNumericString(extra.facilitatorFee)) {
+    return { valid: false, error: "facilitatorFee must be a non-negative numeric string" };
+  }
+  if (!extra.hook) {
+    return { valid: false, error: "hook is required" };
+  }
+  if (!isValidAddress2(extra.hook)) {
+    return { valid: false, error: "hook must be a valid Ethereum address" };
+  }
+  if (extra.hookData === void 0 || extra.hookData === null) {
+    return { valid: false, error: "hookData is required" };
+  }
+  if (!isValidHex2(extra.hookData)) {
+    return { valid: false, error: "hookData must be a valid hex string" };
+  }
+  if (!extra.name) {
+    return { valid: false, error: "name is required (EIP-712 domain name)" };
+  }
+  if (typeof extra.name !== "string" || extra.name.trim().length === 0) {
+    return { valid: false, error: "name must be a non-empty string" };
+  }
+  if (!extra.version) {
+    return { valid: false, error: "version is required (EIP-712 domain version)" };
+  }
+  if (typeof extra.version !== "string" || extra.version.trim().length === 0) {
+    return { valid: false, error: "version must be a non-empty string" };
+  }
+  if (!extra.salt) {
+    return { valid: false, error: "salt is required" };
+  }
+  if (!isValid32ByteHex(extra.salt)) {
+    return { valid: false, error: "salt must be a 32-byte hex string (0x followed by 64 hex characters)" };
+  }
+  return { valid: true };
+}
+function assertValidSettlementExtra(extra) {
+  const result = validateSettlementExtra(extra);
+  if (!result.valid) {
+    throw new SettlementExtraError(result.error || "Invalid settlement extra");
+  }
+}
+
+// src/utils.ts
+function addSettlementExtra(requirements, params) {
+  const networkName = getNetworkName(requirements.network);
+  const config = getNetworkConfig(networkName);
+  const existingExtra = requirements.extra || {};
+  const name = existingExtra.name || config.defaultAsset.eip712.name;
+  const version = existingExtra.version || config.defaultAsset.eip712.version;
+  const extra = {
+    // Asset EIP-712 domain info (preserve existing if available)
+    name,
+    version,
+    // Settlement parameters
+    settlementRouter: config.settlementRouter,
+    salt: params.salt || generateSalt(),
+    payTo: params.payTo || requirements.payTo,
+    facilitatorFee: params.facilitatorFee || "0",
+    hook: params.hook,
+    hookData: params.hookData
+  };
+  assertValidSettlementExtra(extra);
+  return {
+    ...requirements,
+    // Override payTo to point to SettlementRouter
+    payTo: config.settlementRouter,
+    extra: {
+      ...requirements.extra,
+      ...extra
+    }
+  };
+}
+
+// src/extensions.ts
+function createRouterSettlementExtension(params) {
+  const info = {
+    schemaVersion: 1
+  };
+  if (params?.description !== void 0) {
+    info.description = params.description;
+  }
+  if (params?.settlementRouter) info.settlementRouter = params.settlementRouter;
+  if (params?.hook) info.hook = params.hook;
+  if (params?.hookData) info.hookData = params.hookData;
+  if (params?.finalPayTo) info.finalPayTo = params.finalPayTo;
+  if (params?.facilitatorFee !== void 0) info.facilitatorFee = params.facilitatorFee;
+  let schema = params?.schema;
+  if (!schema && params?.settlementRouter) {
+    schema = {
+      type: "object",
+      properties: {
+        schemaVersion: { type: "number" },
+        description: { type: "string" },
+        salt: { type: "string", pattern: "^0x[a-fA-F0-9]{64}$" },
+        settlementRouter: { type: "string", pattern: "^0x[a-fA-F0-9]{40}$" },
+        hook: { type: "string", pattern: "^0x[a-fA-F0-9]{40}$" },
+        hookData: { type: "string", pattern: "^0x[a-fA-F0-9]*$" },
+        finalPayTo: { type: "string", pattern: "^0x[a-fA-F0-9]{40}$" },
+        facilitatorFee: { type: "string" }
+      },
+      // Salt is required in the final enriched version but not in the initial declaration
+      required: ["schemaVersion", "settlementRouter", "hook", "hookData", "finalPayTo"]
+    };
+  }
+  return {
+    info,
+    ...schema !== void 0 && { schema }
+  };
+}
+function getRouterSettlementExtensionKey() {
+  return "x402x-router-settlement";
+}
+
+// src/server-extension.ts
+var ROUTER_SETTLEMENT_KEY = "x402x-router-settlement";
+var routerSettlementServerExtension = {
+  key: ROUTER_SETTLEMENT_KEY,
+  enrichDeclaration: (declaration, transportContext) => {
+    const extension = declaration;
+    const salt = generateSalt();
+    const enriched = {
+      ...extension,
+      info: {
+        schemaVersion: 1,
+        ...extension.info || {},
+        // Add the generated salt to the info
+        salt
+      }
+    };
+    return enriched;
+  }
+};
+function registerRouterSettlement(server) {
+  server.registerExtension(routerSettlementServerExtension);
+  return server;
+}
+function createExtensionDeclaration(params) {
+  return {
+    [ROUTER_SETTLEMENT_KEY]: createRouterSettlementExtension(params)
+  };
+}
+
+// src/settlement-routes.ts
+function createSettlementRouteConfig(baseConfig, settlementOptions) {
+  const acceptsArray = Array.isArray(baseConfig.accepts) ? baseConfig.accepts : [baseConfig.accepts];
+  const firstOption = acceptsArray[0];
+  const firstNetwork = firstOption.network;
+  const networkConfig = getNetworkConfig(firstNetwork);
+  if (!networkConfig) {
+    throw new Error(`Network configuration not found for: ${firstNetwork}`);
+  }
+  const hook = settlementOptions.hook || TransferHook.getAddress(firstNetwork);
+  const hookData = settlementOptions.hookData || TransferHook.encode();
+  const enhancedAccepts = acceptsArray.map((option) => {
+    const network = typeof option.network === "string" ? option.network : option.network;
+    const optionNetworkConfig = getNetworkConfig(network);
+    if (!optionNetworkConfig) {
+      throw new Error(`Network configuration not found for: ${network}`);
+    }
+    const enhancedOption = {
+      ...option,
+      // Override payTo to use settlementRouter as the immediate recipient
+      payTo: optionNetworkConfig.settlementRouter,
+      // Only include EIP-712 domain info in extra
+      extra: {
+        ...option.extra || {},
+        name: optionNetworkConfig.defaultAsset.eip712.name,
+        version: optionNetworkConfig.defaultAsset.eip712.version
+      }
+    };
+    return enhancedOption;
+  });
+  const extensions = {
+    ...baseConfig.extensions || {},
+    ...createExtensionDeclaration({
+      description: settlementOptions.description || "Router settlement with atomic fee distribution",
+      // Pass settlement parameters to be included in extension info
+      settlementRouter: networkConfig.settlementRouter,
+      hook,
+      hookData,
+      finalPayTo: settlementOptions.finalPayTo,
+      facilitatorFee: settlementOptions.facilitatorFee || "0"
+    })
+  };
+  return {
+    ...baseConfig,
+    accepts: enhancedAccepts.length === 1 ? enhancedAccepts[0] : enhancedAccepts,
+    extensions
+  };
+}
+function registerSettlementHooks(server, config = {}) {
+  const {
+    enableSaltExtraction = true,
+    validateSettlementParams = true
+  } = config;
+  if (enableSaltExtraction) {
+    server.onBeforeVerify(async (context) => {
+      const { paymentPayload, requirements } = context;
+      if (paymentPayload.extensions && "x402x-router-settlement" in paymentPayload.extensions) {
+        const extension = paymentPayload.extensions["x402x-router-settlement"];
+        if (extension?.info) {
+          if (!requirements.extra) {
+            requirements.extra = {};
+          }
+          const info = extension.info;
+          if (info.salt) requirements.extra.salt = info.salt;
+          if (info.settlementRouter) requirements.extra.settlementRouter = info.settlementRouter;
+          if (info.hook) requirements.extra.hook = info.hook;
+          if (info.hookData) requirements.extra.hookData = info.hookData;
+          if (info.finalPayTo) requirements.extra.payTo = info.finalPayTo;
+          if (info.facilitatorFee !== void 0) requirements.extra.facilitatorFee = info.facilitatorFee;
+        }
+      }
+      return void 0;
+    });
+  }
+  if (validateSettlementParams) {
+    server.onBeforeSettle(async (context) => {
+      const { paymentPayload, requirements } = context;
+      let settlementParams = {};
+      if (paymentPayload.extensions && "x402x-router-settlement" in paymentPayload.extensions) {
+        const extension = paymentPayload.extensions["x402x-router-settlement"];
+        if (extension?.info) {
+          settlementParams = extension.info;
+        }
+      }
+      if (!settlementParams.settlementRouter && requirements.extra) {
+        settlementParams = requirements.extra;
+      }
+      const requiredFields = ["settlementRouter", "hook", "hookData"];
+      const payToField = "finalPayTo" in settlementParams ? "finalPayTo" : "payTo";
+      const missingFields = requiredFields.filter((field) => !settlementParams[field]);
+      if (!settlementParams[payToField]) {
+        missingFields.push(payToField);
+      }
+      if (missingFields.length > 0) {
+        return {
+          abort: true,
+          reason: `Missing settlement parameters: ${missingFields.join(", ")}`
+        };
+      }
+      return void 0;
+    });
+  }
+}
+
+// src/helpers.ts
+function registerRouterSettlement2(server) {
+  return registerRouterSettlement(server);
+}
+async function createX402xFacilitator(config) {
+  try {
+    const importFn = new Function("specifier", "return import(specifier)");
+    const facilitatorModule = await importFn("@x402x/facilitator-sdk");
+    return facilitatorModule.createRouterSettlementFacilitator(config);
+  } catch (error) {
+    throw new Error(
+      "createX402xFacilitator requires @x402x/facilitator-sdk to be installed. Please install it using your package manager."
+    );
+  }
+}
+function withRouterSettlement(requirements, options) {
+  if (!requirements.network) {
+    throw new Error("Network is required in payment requirements");
+  }
+  if (!requirements.asset) {
+    throw new Error("Asset is required in payment requirements");
+  }
+  const networkConfig = getNetworkConfig(requirements.network);
+  if (!networkConfig) {
+    throw new Error(`Network configuration not found for network: ${requirements.network}`);
+  }
+  const salt = options.salt || generateSalt();
+  const settlementExtra = {
+    settlementRouter: networkConfig.settlementRouter,
+    salt,
+    payTo: options.payTo,
+    facilitatorFee: options.facilitatorFee,
+    hook: options.hook,
+    hookData: options.hookData,
+    name: options.name || networkConfig.defaultAsset.eip712.name,
+    version: options.version || networkConfig.defaultAsset.eip712.version
+  };
+  const extensionKey = getRouterSettlementExtensionKey();
+  const extensionDeclaration = createRouterSettlementExtension({
+    description: "Router settlement with atomic fee distribution"
+  });
+  const reqWithExtensions = requirements;
+  return {
+    ...requirements,
+    extra: {
+      ...reqWithExtensions.extra || {},
+      ...settlementExtra
+    },
+    extensions: {
+      ...reqWithExtensions.extensions || {},
+      [extensionKey]: extensionDeclaration
+    }
+  };
+}
+function isRouterSettlement(requirements) {
+  return !!(requirements.extra && "settlementRouter" in requirements.extra);
+}
+
+// src/amount.ts
+var AmountError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AmountError";
+  }
+};
+function parseDefaultAssetAmount(amount, network) {
+  if (amount === null || amount === void 0 || amount === "") {
+    throw new AmountError("Amount is required");
+  }
+  const result = processPriceToAtomicAmount(amount, network);
+  if ("error" in result) {
+    throw new AmountError(`Invalid amount format: ${result.error}`);
+  }
+  return result.amount;
+}
+function formatDefaultAssetAmount(amount, network) {
+  const atomicAmount = BigInt(amount);
+  if (atomicAmount < 0n) {
+    throw new AmountError("Amount cannot be negative");
+  }
+  const asset = getDefaultAsset(network);
+  const decimals = asset.decimals;
+  const amountStr = atomicAmount.toString().padStart(decimals + 1, "0");
+  const integerPart = amountStr.slice(0, -decimals) || "0";
+  const decimalPart = amountStr.slice(-decimals);
+  const trimmedDecimal = decimalPart.replace(/0+$/, "");
+  if (trimmedDecimal) {
+    return `${integerPart}.${trimmedDecimal}`;
+  }
+  return integerPart;
+}
+
+// src/facilitator.ts
+function isSettlementMode(paymentRequirements) {
+  return !!paymentRequirements.extra?.settlementRouter;
+}
+function parseSettlementExtra(extra) {
+  if (!extra || typeof extra !== "object") {
+    throw new SettlementExtraError("Missing or invalid extra field");
+  }
+  const e = extra;
+  if (!e.settlementRouter || typeof e.settlementRouter !== "string") {
+    throw new SettlementExtraError("Missing or invalid settlementRouter");
+  }
+  if (!e.salt || typeof e.salt !== "string") {
+    throw new SettlementExtraError("Missing or invalid salt");
+  }
+  if (!e.payTo || typeof e.payTo !== "string") {
+    throw new SettlementExtraError("Missing or invalid payTo");
+  }
+  if (!e.facilitatorFee || typeof e.facilitatorFee !== "string") {
+    throw new SettlementExtraError("Missing or invalid facilitatorFee");
+  }
+  if (!e.hook || typeof e.hook !== "string") {
+    throw new SettlementExtraError("Missing or invalid hook");
+  }
+  if (!e.hookData || typeof e.hookData !== "string") {
+    throw new SettlementExtraError("Missing or invalid hookData");
+  }
+  return {
+    settlementRouter: e.settlementRouter,
+    salt: e.salt,
+    payTo: e.payTo,
+    facilitatorFee: e.facilitatorFee,
+    hook: e.hook,
+    hookData: e.hookData
+  };
+}
+var FeeCache = class {
+  constructor(ttlSeconds = 60) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.ttlMs = ttlSeconds * 1e3;
+  }
+  getCacheKey(network, hook, hookData) {
+    return `${network}:${hook}:${hookData || ""}`;
+  }
+  get(network, hook, hookData) {
+    const key = this.getCacheKey(network, hook, hookData);
+    const cached = this.cache.get(key);
+    if (!cached) {
+      return null;
+    }
+    if (Date.now() > cached.expiresAt) {
+      this.cache.delete(key);
+      return null;
+    }
+    return cached.result;
+  }
+  set(result) {
+    const key = this.getCacheKey(result.network, result.hook, result.hookData);
+    this.cache.set(key, {
+      result,
+      expiresAt: Date.now() + this.ttlMs
+    });
+  }
+  clear() {
+    this.cache.clear();
+  }
+};
+var feeCache = new FeeCache(60);
+async function calculateFacilitatorFee(facilitatorUrl, network, hook, hookData, useCache = true) {
+  if (useCache) {
+    const cached = feeCache.get(network, hook, hookData);
+    if (cached) {
+      return cached;
+    }
+  }
+  const baseUrl = facilitatorUrl.endsWith("/") ? facilitatorUrl.slice(0, -1) : facilitatorUrl;
+  const params = new URLSearchParams({
+    network,
+    hook
+  });
+  if (hookData) {
+    params.append("hookData", hookData);
+  }
+  const url = `${baseUrl}/calculate-fee?${params.toString()}`;
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      // Add timeout
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Facilitator fee calculation failed: ${response.status} ${response.statusText} - ${errorText}`
+      );
+    }
+    const result = await response.json();
+    if (!result.facilitatorFee || !result.network || !result.hook) {
+      throw new Error("Invalid response from facilitator service");
+    }
+    if (useCache) {
+      feeCache.set(result);
+    }
+    return result;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to calculate facilitator fee: ${error.message}`);
+    }
+    throw error;
+  }
+}
+function clearFeeCache() {
+  feeCache.clear();
+}
+async function verify(facilitatorUrl, paymentPayload, paymentRequirements) {
+  const baseUrl = facilitatorUrl.endsWith("/") ? facilitatorUrl.slice(0, -1) : facilitatorUrl;
+  const url = `${baseUrl}/verify`;
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        paymentPayload,
+        paymentRequirements
+      }),
+      // Add timeout
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Facilitator verify failed: ${response.status} ${response.statusText} - ${errorText}`
+      );
+    }
+    const result = await response.json();
+    if (typeof result.isValid !== "boolean") {
+      throw new Error("Invalid response from facilitator: missing isValid field");
+    }
+    if (typeof result.payer !== "string") {
+      throw new Error("Invalid response from facilitator: missing payer field");
+    }
+    return result;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to verify with facilitator: ${error.message}`);
+    }
+    throw error;
+  }
+}
+async function settle(facilitatorUrl, paymentPayload, paymentRequirements, timeout = 3e4) {
+  const baseUrl = facilitatorUrl.endsWith("/") ? facilitatorUrl.slice(0, -1) : facilitatorUrl;
+  const url = `${baseUrl}/settle`;
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        paymentPayload,
+        paymentRequirements
+      }),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    const result = await response.json();
+    if (!response.ok) {
+      throw new Error(
+        result.error || result.message || `Facilitator settle failed: ${response.status}`
+      );
+    }
+    if (typeof result.success !== "boolean") {
+      throw new Error("Invalid response from facilitator: missing success field");
+    }
+    if (!result.success) {
+      throw new Error(result.errorReason || "Settlement failed");
+    }
+    if (!result.transaction) {
+      throw new Error("Invalid response from facilitator: missing transaction hash");
+    }
+    return {
+      success: result.success,
+      transaction: result.transaction,
+      network: result.network || paymentRequirements.network,
+      payer: result.payer || "",
+      errorReason: result.errorReason
+    };
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        throw new Error(`Facilitator settle timed out after ${timeout}ms`);
+      }
+      throw new Error(`Failed to settle with facilitator: ${error.message}`);
+    }
+    throw error;
+  }
+}
+
+// src/abi.ts
+var SETTLEMENT_ROUTER_ABI = [
+  {
+    type: "function",
+    name: "settleAndExecute",
+    inputs: [
+      { name: "token", type: "address" },
+      { name: "from", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "validAfter", type: "uint256" },
+      { name: "validBefore", type: "uint256" },
+      { name: "nonce", type: "bytes32" },
+      { name: "signature", type: "bytes" },
+      { name: "salt", type: "bytes32" },
+      { name: "payTo", type: "address" },
+      { name: "facilitatorFee", type: "uint256" },
+      { name: "hook", type: "address" },
+      { name: "hookData", type: "bytes" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "calculateCommitment",
+    inputs: [
+      { name: "token", type: "address" },
+      { name: "from", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "validAfter", type: "uint256" },
+      { name: "validBefore", type: "uint256" },
+      { name: "salt", type: "bytes32" },
+      { name: "payTo", type: "address" },
+      { name: "facilitatorFee", type: "uint256" },
+      { name: "hook", type: "address" },
+      { name: "hookData", type: "bytes" }
+    ],
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "calculateContextKey",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "token", type: "address" },
+      { name: "nonce", type: "bytes32" }
+    ],
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "pure"
+  },
+  {
+    type: "function",
+    name: "isSettled",
+    inputs: [{ name: "contextKey", type: "bytes32" }],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getPendingFees",
+    inputs: [
+      { name: "facilitator", type: "address" },
+      { name: "token", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "claimFees",
+    inputs: [{ name: "tokens", type: "address[]" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  }
+];
+
+// src/facilitator-types.ts
+var FacilitatorValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FacilitatorValidationError";
+  }
+};
+var SettlementRouterError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "SettlementRouterError";
+  }
+};
+
+// src/legacy-compat.ts
+var SupportedEVMNetworks = [
+  "eip155:84532",
+  // Base Sepolia
+  "eip155:1444673419",
+  // SKALE Base Sepolia
+  "eip155:8453"
+  // Base Mainnet
+];
+var moneySchema = {
+  parse: (value) => {
+    if (typeof value === "string" || typeof value === "number") {
+      return value;
+    }
+    throw new Error("Invalid money value");
+  }
+};
+var settleResponseHeader = "X-Payment-Response";
+var evm = {
+  /**
+   * Check if a value is a valid EVM address
+   */
+  isAddress: (value) => {
+    if (typeof value !== "string") return false;
+    return /^0x[a-fA-F0-9]{40}$/.test(value);
+  }
+};
+var exact = {
+  name: "exact"
+  // Additional scheme properties would go here
+};
+var ChainIdToNetwork = {
+  84532: "eip155:84532",
+  // Base Sepolia
+  1444673419: "eip155:1444673419",
+  // SKALE Base Sepolia  
+  8453: "eip155:8453"
+  // Base Mainnet
+};
+function isMultiNetworkSigner(signer) {
+  return !!(signer && typeof signer === "object" && "signTransaction" in signer);
+}
+function isSvmSignerWallet(signer) {
+  return !!(signer && typeof signer === "object" && "publicKey" in signer);
+}
+function createPaymentHeader(_requirements, _signer) {
+  throw new Error("createPaymentHeader is not implemented in v2 - use x402Client instead");
+}
+function selectPaymentRequirements(_requirements, _selector) {
+  throw new Error("selectPaymentRequirements is not implemented in v2 - use x402Client instead");
+}
+function decodeXPaymentResponse(_header) {
+  throw new Error("decodeXPaymentResponse is not implemented in v2 - use x402HTTPClient instead");
+}
+function useFacilitator(_config) {
+  throw new Error("useFacilitator is not implemented in v2 - use FacilitatorClient instead");
+}
+function createSigner(_config) {
+  throw new Error("createSigner is not implemented in v2 - use appropriate v2 signer patterns");
+}
+
+export { AmountError, ChainIdToNetwork, FacilitatorValidationError, NETWORK_ALIASES_V1_TO_V2, NFTMintHook, ROUTER_SETTLEMENT_KEY, RewardHook, SETTLEMENT_ROUTER_ABI, SettlementExtraError, SettlementRouterError, SupportedEVMNetworks, TransferHook, addSettlementExtra, assertValidSettlementExtra, calculateCommitment, calculateFacilitatorFee, clearFeeCache, computeRoutePatterns, createExtensionDeclaration, createPaymentHeader, createRouterSettlementExtension, createSettlementRouteConfig, createSigner, createX402xFacilitator, decodeXPaymentResponse, evm, exact, findMatchingPaymentRequirements, findMatchingRoute, formatDefaultAssetAmount, generateSalt, getChain, getChainById, getCustomChains, getDefaultAsset, getNetworkAliasesV1ToV2, getNetworkConfig, getNetworkId, getNetworkName, getRouterSettlementExtensionKey, getSupportedNetworkIds, getSupportedNetworkNames, getSupportedNetworks, getSupportedNetworksV2, isCustomChain, isMultiNetworkSigner, isNetworkSupported, isRouterSettlement, isSettlementMode, isSvmSignerWallet, isValid32ByteHex, isValidAddress2 as isValidAddress, isValidHex2 as isValidHex, isValidNumericString, moneySchema, networks, parseDefaultAssetAmount, parseSettlementExtra, processPriceToAtomicAmount, registerRouterSettlement2 as registerRouterSettlement, registerSettlementHooks, routerSettlementServerExtension, selectPaymentRequirements, settle, settleResponseHeader, toCanonicalNetworkKey, toJsonSafe, useFacilitator, validateCommitmentParams, validateSettlementExtra, verify, withRouterSettlement };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map