@armory-sh/base 0.2.28 → 0.2.30

package/dist/index.js

@@ -1,14 +1,373 @@
 import { randomBytes } from 'crypto';
 
-// src/types/x402.ts
-var X402_VERSION = 2;
-var SCHEMES = ["exact"];
-function isPaymentPayload(obj) {
-  return typeof obj === "object" && obj !== null && "x402Version" in obj && "accepted" in obj && "payload" in obj;
+// src/abi/erc20.ts
+var ERC20_ABI = [
+  {
+    type: "function",
+    name: "transferWithAuthorization",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "validAfter", type: "uint256" },
+      { name: "expiry", type: "uint256" },
+      { name: "v", type: "uint8" },
+      { name: "r", type: "bytes32" },
+      { name: "s", type: "bytes32" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "receiveWithAuthorization",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "validAfter", type: "uint256" },
+      { name: "expiry", type: "uint256" },
+      { name: "v", type: "uint8" },
+      { name: "r", type: "bytes32" },
+      { name: "s", type: "bytes32" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "balance", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "name",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  },
+  {
+    type: "function",
+    name: "symbol",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  }
+];
+
+// src/client-hooks-runtime.ts
+var notifyError = async (hooks, context) => {
+  if (!hooks?.length) {
+    return;
+  }
+  for (const hook of hooks) {
+    if (!hook.onError) {
+      continue;
+    }
+    await hook.onError(context);
+  }
+};
+var runOnPaymentRequiredHooks = async (hooks, context) => {
+  if (!hooks?.length) {
+    return;
+  }
+  for (const hook of hooks) {
+    if (!hook.onPaymentRequired) {
+      continue;
+    }
+    try {
+      await hook.onPaymentRequired(context);
+    } catch (error) {
+      await notifyError(hooks, { error, phase: "onPaymentRequired" });
+      throw error;
+    }
+  }
+};
+var selectRequirementWithHooks = async (hooks, context) => {
+  if (!context.accepts.length) {
+    throw new Error("No payment requirements found in accepts array");
+  }
+  let selected = context.accepts[0];
+  if (!hooks?.length) {
+    context.selectedRequirement = selected;
+    context.requirements = selected;
+    return selected;
+  }
+  for (const hook of hooks) {
+    if (!hook.selectRequirement) {
+      continue;
+    }
+    try {
+      const override = await hook.selectRequirement({
+        ...context,
+        selectedRequirement: selected,
+        requirements: selected
+      });
+      if (!override) {
+        continue;
+      }
+      const isValid = context.accepts.some((accept) => accept === override);
+      if (!isValid) {
+        throw new Error(
+          "Hook selectRequirement must return an item from accepts"
+        );
+      }
+      selected = override;
+    } catch (error) {
+      await notifyError(hooks, { error, phase: "selectRequirement" });
+      throw error;
+    }
+  }
+  context.selectedRequirement = selected;
+  context.requirements = selected;
+  return selected;
+};
+var runBeforeSignPaymentHooks = async (hooks, context) => {
+  if (!hooks?.length) {
+    return;
+  }
+  for (const hook of hooks) {
+    if (!hook.beforeSignPayment) {
+      continue;
+    }
+    try {
+      await hook.beforeSignPayment(context);
+    } catch (error) {
+      await notifyError(hooks, { error, phase: "beforeSignPayment" });
+      throw error;
+    }
+  }
+};
+var runAfterPaymentResponseHooks = async (hooks, context) => {
+  if (!hooks?.length) {
+    return;
+  }
+  for (const hook of hooks) {
+    if (!hook.afterPaymentResponse) {
+      continue;
+    }
+    try {
+      await hook.afterPaymentResponse(context);
+    } catch (error) {
+      await notifyError(hooks, { error, phase: "afterPaymentResponse" });
+      throw error;
+    }
+  }
+};
+
+// src/data/tokens.ts
+var USDC_BASE = {
+  symbol: "USDC",
+  name: "USDC",
+  version: "2",
+  contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  chainId: 8453,
+  decimals: 6
+};
+var EURC_BASE = {
+  symbol: "EURC",
+  name: "EURC",
+  version: "2",
+  contractAddress: "0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42",
+  chainId: 8453,
+  decimals: 6
+};
+var USDC_BASE_SEPOLIA = {
+  symbol: "USDC",
+  name: "USDC",
+  version: "2",
+  contractAddress: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+  chainId: 84532,
+  decimals: 6
+};
+var USDC_SKALE_BASE = {
+  symbol: "USDC",
+  name: "Bridged USDC (SKALE Bridge)",
+  version: "2",
+  contractAddress: "0x85889c8c714505E0c94b30fcfcF64fE3Ac8FCb20",
+  chainId: 1187947933,
+  decimals: 6
+};
+var SKL_SKALE_BASE = {
+  symbol: "SKL",
+  name: "SKALE",
+  version: "1",
+  contractAddress: "0xE0595a049d02b7674572b0d59cd4880Db60EDC50",
+  chainId: 1187947933,
+  decimals: 18
+};
+var USDT_SKALE_BASE = {
+  symbol: "USDT",
+  name: "Tether USD",
+  version: "1",
+  contractAddress: "0x2bF5bF154b515EaA82C31a65ec11554fF5aF7fCA",
+  chainId: 1187947933,
+  decimals: 6
+};
+var WBTC_SKALE_BASE = {
+  symbol: "WBTC",
+  name: "Wrapped BTC",
+  version: "1",
+  contractAddress: "0x1aeeCFE5454c83B42D8A316246CAc9739E7f690e",
+  chainId: 1187947933,
+  decimals: 8
+};
+var WETH_SKALE_BASE = {
+  symbol: "WETH",
+  name: "Wrapped Ether",
+  version: "1",
+  contractAddress: "0x7bD39ABBd0Dd13103542cAe3276C7fA332bCA486",
+  chainId: 1187947933,
+  decimals: 18
+};
+var SKL_SKALE_BASE_SEPOLIA = {
+  symbol: "SKL",
+  name: "SKALE",
+  version: "1",
+  contractAddress: "0xaf2e0ff5b5f51553fdb34ce7f04a6c3201cee57b",
+  chainId: 324705682,
+  decimals: 18
+};
+var USDC_SKALE_BASE_SEPOLIA = {
+  symbol: "USDC",
+  name: "Bridged USDC (SKALE Bridge)",
+  version: "2",
+  contractAddress: "0x2e08028E3C4c2356572E096d8EF835cD5C6030bD",
+  chainId: 324705682,
+  decimals: 6
+};
+var USDT_SKALE_BASE_SEPOLIA = {
+  symbol: "USDT",
+  name: "Tether USD",
+  version: "1",
+  contractAddress: "0x3ca0a49f511c2c89c4dcbbf1731120d8919050bf",
+  chainId: 324705682,
+  decimals: 6
+};
+var WBTC_SKALE_BASE_SEPOLIA = {
+  symbol: "WBTC",
+  name: "Wrapped BTC",
+  version: "1",
+  contractAddress: "0x4512eacd4186b025186e1cf6cc0d89497c530e87",
+  chainId: 324705682,
+  decimals: 8
+};
+var WETH_SKALE_BASE_SEPOLIA = {
+  symbol: "WETH",
+  name: "Wrapped Ether",
+  version: "1",
+  contractAddress: "0xf94056bd7f6965db3757e1b145f200b7346b4fc0",
+  chainId: 324705682,
+  decimals: 18
+};
+var TOKENS = {
+  USDC_BASE,
+  USDC_BASE_SEPOLIA,
+  EURC_BASE,
+  USDC_SKALE_BASE,
+  USDT_SKALE_BASE,
+  WBTC_SKALE_BASE,
+  WETH_SKALE_BASE,
+  SKL_SKALE_BASE,
+  SKL_SKALE_BASE_SEPOLIA,
+  USDC_SKALE_BASE_SEPOLIA,
+  USDT_SKALE_BASE_SEPOLIA,
+  WBTC_SKALE_BASE_SEPOLIA,
+  WETH_SKALE_BASE_SEPOLIA
+};
+function getToken(chainId, contractAddress) {
+  const tokens = Object.values(TOKENS);
+  return tokens.find(
+    (t) => t.chainId === chainId && t.contractAddress.toLowerCase() === contractAddress.toLowerCase()
+  );
 }
-function isExactEvmPayload(obj) {
-  return typeof obj === "object" && obj !== null && "signature" in obj && "authorization" in obj;
+function getAllTokens() {
+  return Object.values(TOKENS);
+}
+function getTokensBySymbol(symbol) {
+  return getAllTokens().filter(
+    (t) => t.symbol.toUpperCase() === symbol.toUpperCase()
+  );
+}
+function getTokensByChain(chainId) {
+  return getAllTokens().filter((t) => t.chainId === chainId);
+}
+function getUSDCTokens() {
+  return getTokensBySymbol("USDC");
+}
+function getEURCTokens() {
+  return getTokensBySymbol("EURC");
+}
+function getSKLTokens() {
+  return getTokensBySymbol("SKL");
+}
+function getUSDTTokens() {
+  return getTokensBySymbol("USDT");
+}
+function getWBTCTokens() {
+  return getTokensBySymbol("WBTC");
 }
+function getWETHTokens() {
+  return getTokensBySymbol("WETH");
+}
+
+// src/eip712.ts
+var EIP712_TYPES = {
+  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" }
+  ]
+};
+var USDC_DOMAIN = {
+  NAME: "USD Coin",
+  VERSION: "2"
+};
+var createEIP712Domain = (chainId, contractAddress) => ({
+  name: USDC_DOMAIN.NAME,
+  version: USDC_DOMAIN.VERSION,
+  chainId,
+  verifyingContract: contractAddress
+});
+var createTransferWithAuthorization = (params) => ({
+  from: params.from,
+  to: params.to,
+  value: BigInt(params.value),
+  validAfter: BigInt(params.validAfter),
+  validBefore: BigInt(params.validBefore),
+  nonce: params.nonce
+});
+var isAddress = (value) => /^0x[a-fA-F0-9]{40}$/.test(value);
+var isBytes32 = (value) => /^0x[a-fA-F0-9]{64}$/.test(value);
+var validateTransferWithAuthorization = (message) => {
+  if (!isAddress(message.from))
+    throw new Error(`Invalid "from" address: ${message.from}`);
+  if (!isAddress(message.to))
+    throw new Error(`Invalid "to" address: ${message.to}`);
+  if (message.value < 0n)
+    throw new Error(`"value" must be non-negative: ${message.value}`);
+  if (message.validAfter < 0n)
+    throw new Error(`"validAfter" must be non-negative: ${message.validAfter}`);
+  if (message.validBefore < 0n)
+    throw new Error(
+      `"validBefore" must be non-negative: ${message.validBefore}`
+    );
+  if (message.validAfter >= message.validBefore) {
+    throw new Error(
+      `"validAfter" (${message.validAfter}) must be before "validBefore" (${message.validBefore})`
+    );
+  }
+  if (!isBytes32(message.nonce))
+    throw new Error(
+      `"nonce" must be a valid bytes32 hex string: ${message.nonce}`
+    );
+  return true;
+};
 
 // src/types/v2.ts
 var V2_HEADERS = {
@@ -22,7 +381,7 @@ function isCAIP2ChainId(value) {
 function isCAIPAssetId(value) {
   return /^eip155:\d+\/erc20:0x[a-fA-F0-9]+$/.test(value);
 }
-function isAddress(value) {
+function isAddress2(value) {
   return /^0x[a-fA-F0-9]{40}$/.test(value);
 }
 function isPaymentRequiredV2(obj) {
@@ -56,36 +415,98 @@ function combineSignature(v, r, s) {
   return `0x${rClean}${sClean}${vHex}`;
 }
 
-// src/encoding/x402.ts
-function safeBase64Encode(str) {
-  return Buffer.from(str).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+// src/utils/base64.ts
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+function toBase64(bytes) {
+  if (typeof btoa === "function") {
+    let binary = "";
+    for (let index = 0; index < bytes.length; index += 1) {
+      binary += String.fromCharCode(bytes[index]);
+    }
+    return btoa(binary);
+  }
+  throw new Error("No base64 encoder available in this runtime");
 }
-function safeBase64Decode(str) {
-  const padding = 4 - str.length % 4;
-  if (padding !== 4) {
-    str += "=".repeat(padding);
+function fromBase64(base64) {
+  if (typeof atob === "function") {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+      bytes[index] = binary.charCodeAt(index);
+    }
+    return bytes;
   }
-  str = str.replace(/-/g, "+").replace(/_/g, "/");
-  return Buffer.from(str, "base64").toString("utf-8");
+  throw new Error("No base64 decoder available in this runtime");
+}
+function encodeUtf8ToBase64(value) {
+  const bytes = textEncoder.encode(value);
+  return toBase64(bytes);
+}
+function decodeBase64ToUtf8(value) {
+  const bytes = fromBase64(value);
+  return textDecoder.decode(bytes);
+}
+function toBase64Url(base64) {
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function normalizeBase64Url(value) {
+  return value.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(value.length / 4) * 4, "=");
+}
+
+// src/encoding.ts
+function safeBase64Decode(str) {
+  return decodeBase64ToUtf8(normalizeBase64Url(str));
+}
+function safeBase64Encode(str) {
+  return toBase64Url(encodeUtf8ToBase64(str));
+}
+var base64JsonEncode = (data) => safeBase64Encode(JSON.stringify(data));
+var base64JsonDecode = (encoded) => JSON.parse(safeBase64Decode(encoded));
+var encodePaymentV2 = (payload) => base64JsonEncode(payload);
+var decodePaymentV2 = (encoded) => base64JsonDecode(encoded);
+var encodeSettlementV2 = (response) => base64JsonEncode(response);
+var decodeSettlementV2 = (encoded) => base64JsonDecode(encoded);
+var isPaymentV2 = (payload) => "x402Version" in payload && payload.x402Version === 2 && "accepted" in payload && "payload" in payload;
+var isSettlementV2 = (response) => "success" in response && typeof response.success === "boolean" && "network" in response;
+
+// src/types/x402.ts
+var X402_VERSION = 2;
+var SCHEMES = ["exact"];
+function isPaymentPayload(obj) {
+  return typeof obj === "object" && obj !== null && "x402Version" in obj && "accepted" in obj && "payload" in obj;
+}
+function isExactEvmPayload(obj) {
+  return typeof obj === "object" && obj !== null && "signature" in obj && "authorization" in obj;
+}
+
+// src/encoding/x402.ts
+function safeBase64Encode2(str) {
+  return toBase64Url(encodeUtf8ToBase64(str));
+}
+function safeBase64Decode2(str) {
+  return decodeBase64ToUtf8(normalizeBase64Url(str));
 }
 function encodePayment(payload) {
   if (!isPaymentPayload(payload)) {
     throw new Error("Invalid payment payload format");
   }
-  const safePayload = JSON.parse(JSON.stringify(payload, (_, value) => {
-    if (typeof value === "bigint") {
-      return value.toString();
-    }
-    return value;
-  }));
-  return safeBase64Encode(JSON.stringify(safePayload));
+  const safePayload = JSON.parse(
+    JSON.stringify(payload, (_, value) => {
+      if (typeof value === "bigint") {
+        return value.toString();
+      }
+      return value;
+    })
+  );
+  return safeBase64Encode2(JSON.stringify(safePayload));
 }
 function decodePayment(encoded) {
   let parsed;
   try {
     parsed = JSON.parse(encoded);
   } catch {
-    const decoded = safeBase64Decode(encoded);
+    const decoded = safeBase64Decode2(encoded);
     parsed = JSON.parse(decoded);
   }
   if (!isPaymentPayload(parsed)) {
@@ -94,30 +515,32 @@ function decodePayment(encoded) {
   return parsed;
 }
 function encodeSettlementResponse(response) {
-  const safeResponse = JSON.parse(JSON.stringify(response, (_, value) => {
-    if (typeof value === "bigint") {
-      return value.toString();
-    }
-    return value;
-  }));
-  return safeBase64Encode(JSON.stringify(safeResponse));
+  const safeResponse = JSON.parse(
+    JSON.stringify(response, (_, value) => {
+      if (typeof value === "bigint") {
+        return value.toString();
+      }
+      return value;
+    })
+  );
+  return safeBase64Encode2(JSON.stringify(safeResponse));
 }
 function decodeSettlementResponse(encoded) {
   try {
     return JSON.parse(encoded);
   } catch {
-    const decoded = safeBase64Decode(encoded);
+    const decoded = safeBase64Decode2(encoded);
     return JSON.parse(decoded);
   }
 }
 function encodeX402Response(response) {
-  return safeBase64Encode(JSON.stringify(response));
+  return safeBase64Encode2(JSON.stringify(response));
 }
 function decodeX402Response(encoded) {
   try {
     return JSON.parse(encoded);
   } catch {
-    const decoded = safeBase64Decode(encoded);
+    const decoded = safeBase64Decode2(encoded);
     return JSON.parse(decoded);
   }
 }
@@ -140,467 +563,345 @@ function createPaymentRequiredHeaders(requirements, options) {
   const accepts = Array.isArray(requirements) ? requirements : [requirements];
   const response = {
     x402Version: 2,
-    error: options?.error ?? "Payment required",
-    resource: options?.resource ?? { url: "", mimeType: "application/json" },
-    accepts,
-    extensions: options?.extensions ?? {}
-  };
-  return {
-    [V2_HEADERS.PAYMENT_REQUIRED]: safeBase64Encode(JSON.stringify(response))
-  };
-}
-function createSettlementHeaders(settlement) {
-  return {
-    [V2_HEADERS.PAYMENT_RESPONSE]: encodeSettlementResponse(settlement)
-  };
-}
-function createNonce() {
-  const bytes = randomBytes(32);
-  return `0x${bytes.toString("hex")}`;
-}
-function toAtomicUnits(amount, decimals = 6) {
-  const parts = amount.split(".");
-  const whole = parts[0];
-  const fractional = parts[1] || "";
-  const paddedFractional = fractional.padEnd(decimals, "0").slice(0, decimals);
-  return `${whole}${paddedFractional}`;
-}
-function fromAtomicUnits(amount, decimals = 6) {
-  const value = BigInt(amount);
-  const divisor = BigInt(10 ** decimals);
-  const whole = (value / divisor).toString();
-  const fractional = (value % divisor).toString().padStart(decimals, "0").replace(/0+$/, "");
-  if (fractional.length === 0) {
-    return whole;
-  }
-  return `${whole}.${fractional}`;
-}
-function caip2ToNetwork(caip2Id) {
-  const match = caip2Id.match(/^eip155:(\d+)$/);
-  if (!match) {
-    return caip2Id;
-  }
-  const chainId = parseInt(match[1], 10);
-  const chainIdToNetwork = {
-    1: "ethereum",
-    8453: "base",
-    84532: "base-sepolia",
-    137: "polygon",
-    42161: "arbitrum",
-    421614: "arbitrum-sepolia",
-    10: "optimism",
-    11155420: "optimism-sepolia",
-    11155111: "ethereum-sepolia"
-  };
-  return chainIdToNetwork[chainId] || caip2Id;
-}
-function networkToCaip2(network) {
-  const networkToChainId = {
-    ethereum: 1,
-    base: 8453,
-    "base-sepolia": 84532,
-    polygon: 137,
-    arbitrum: 42161,
-    "arbitrum-sepolia": 421614,
-    optimism: 10,
-    "optimism-sepolia": 11155420,
-    "ethereum-sepolia": 11155111
-  };
-  const chainId = networkToChainId[network];
-  if (chainId) {
-    return `eip155:${chainId}`;
-  }
-  if (network.startsWith("eip155:")) {
-    return network;
-  }
-  return `eip155:0`;
-}
-function getCurrentTimestamp() {
-  return Math.floor(Date.now() / 1e3);
-}
-function isValidAddress(address) {
-  return /^0x[a-fA-F0-9]{40}$/.test(address);
-}
-function normalizeAddress(address) {
-  return address.toLowerCase();
-}
-
-// src/types/protocol.ts
-function isX402V2Payload(obj) {
-  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 2 && "accepted" in obj && "payload" in obj;
-}
-function isX402V2Requirements(obj) {
-  return typeof obj === "object" && obj !== null && "scheme" in obj && obj.scheme === "exact" && "network" in obj && typeof obj.network === "string" && obj.network.startsWith("eip155:") && // CAIP-2 format
-  "amount" in obj && "asset" in obj && "payTo" in obj && "maxTimeoutSeconds" in obj;
-}
-function isX402V2Settlement(obj) {
-  return typeof obj === "object" && obj !== null && "success" in obj && typeof obj.success === "boolean" && "network" in obj && typeof obj.network === "string" && obj.network.startsWith("eip155:");
-}
-function isX402V2PaymentRequired(obj) {
-  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 2 && "resource" in obj && "accepts" in obj;
-}
-var PAYMENT_SIGNATURE_HEADER = "PAYMENT-SIGNATURE";
-var PAYMENT_RESPONSE_HEADER = "PAYMENT-RESPONSE";
-var PAYMENT_REQUIRED_HEADER = "PAYMENT-REQUIRED";
-function isSettlementSuccessful(response) {
-  return "success" in response ? response.success : false;
-}
-function getTxHash(response) {
-  if ("transaction" in response) return response.transaction;
-  return void 0;
-}
-
-// src/types/networks.ts
-var isEvmAddress = (value) => /^0x[a-fA-F0-9]{40}$/.test(value);
-var tokenRegistry = /* @__PURE__ */ new Map();
-var tokenKey = (chainId, contractAddress) => `${chainId}:${contractAddress.toLowerCase()}`;
-var NETWORKS = {
-  ethereum: {
-    name: "Ethereum Mainnet",
-    chainId: 1,
-    usdcAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-    rpcUrl: "https://eth.llamarpc.com",
-    caip2Id: "eip155:1",
-    caipAssetId: "eip155:1/erc20:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
-  },
-  base: {
-    name: "Base Mainnet",
-    chainId: 8453,
-    usdcAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-    rpcUrl: "https://mainnet.base.org",
-    caip2Id: "eip155:8453",
-    caipAssetId: "eip155:8453/erc20:0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
-  },
-  "base-sepolia": {
-    name: "Base Sepolia",
-    chainId: 84532,
-    usdcAddress: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
-    rpcUrl: "https://sepolia.base.org",
-    caip2Id: "eip155:84532",
-    caipAssetId: "eip155:84532/erc20:0x036CbD53842c5426634e7929541eC2318f3dCF7e"
-  },
-  "skale-base": {
-    name: "SKALE Base",
-    chainId: 1187947933,
-    usdcAddress: "0x85889c8c714505E0c94b30fcfcF64fE3Ac8FCb20",
-    rpcUrl: "https://skale-base.skalenodes.com/v1/base",
-    caip2Id: "eip155:1187947933",
-    caipAssetId: "eip155:1187947933/erc20:0x85889c8c714505E0c94b30fcfcF64fE3Ac8FCb20"
-  },
-  "skale-base-sepolia": {
-    name: "SKALE Base Sepolia",
-    chainId: 324705682,
-    usdcAddress: "0x2e08028E3C4c2356572E096d8EF835cD5C6030bD",
-    rpcUrl: "https://base-sepolia-testnet.skalenodes.com/v1/jubilant-horrible-ancha",
-    caip2Id: "eip155:324705682",
-    caipAssetId: "eip155:324705682/erc20:0x2e08028E3C4c2356572E096d8EF835cD5C6030bD"
-  },
-  "ethereum-sepolia": {
-    name: "Ethereum Sepolia",
-    chainId: 11155111,
-    usdcAddress: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
-    rpcUrl: "https://rpc.sepolia.org",
-    caip2Id: "eip155:11155111",
-    caipAssetId: "eip155:11155111/erc20:0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238"
-  }
-};
-var getNetworkConfig = (name) => NETWORKS[name];
-var getNetworkByChainId = (chainId) => Object.values(NETWORKS).find((c) => c.chainId === chainId);
-var getMainnets = () => Object.values(NETWORKS).filter((c) => !c.name.toLowerCase().includes("sepolia"));
-var getTestnets = () => Object.values(NETWORKS).filter((c) => c.name.toLowerCase().includes("sepolia"));
-var registerToken = (token) => {
-  if (typeof token !== "object" || token === null) {
-    throw new Error("Invalid token: must be an object");
-  }
-  const t = token;
-  if (typeof t.symbol !== "string") {
-    throw new Error("Invalid token: symbol must be a string");
-  }
-  if (typeof t.name !== "string") {
-    throw new Error("Invalid token: name must be a string");
-  }
-  if (typeof t.version !== "string") {
-    throw new Error("Invalid token: version must be a string");
-  }
-  if (typeof t.contractAddress !== "string" || !isEvmAddress(t.contractAddress)) {
-    throw new Error("Invalid token: contractAddress must be a valid EVM address");
-  }
-  if (typeof t.chainId !== "number" || !Number.isInteger(t.chainId) || t.chainId <= 0) {
-    throw new Error("Invalid token: chainId must be a positive integer");
-  }
-  if (t.decimals !== void 0 && (typeof t.decimals !== "number" || !Number.isInteger(t.decimals) || t.decimals < 0)) {
-    throw new Error("Invalid token: decimals must be a non-negative integer");
-  }
-  const validated = {
-    symbol: t.symbol,
-    name: t.name,
-    version: t.version,
-    contractAddress: t.contractAddress,
-    chainId: t.chainId,
-    decimals: t.decimals
+    error: options?.error ?? "Payment required",
+    resource: options?.resource ?? { url: "", mimeType: "application/json" },
+    accepts,
+    extensions: options?.extensions ?? {}
   };
-  tokenRegistry.set(tokenKey(validated.chainId, validated.contractAddress), validated);
-  return validated;
-};
-var getCustomToken = (chainId, contractAddress) => tokenRegistry.get(tokenKey(chainId, contractAddress));
-var getAllCustomTokens = () => Array.from(tokenRegistry.values());
-var unregisterToken = (chainId, contractAddress) => tokenRegistry.delete(tokenKey(chainId, contractAddress));
-var isCustomToken = (chainId, contractAddress) => tokenRegistry.has(tokenKey(chainId, contractAddress));
+  return {
+    [V2_HEADERS.PAYMENT_REQUIRED]: safeBase64Encode2(JSON.stringify(response))
+  };
+}
+function createSettlementHeaders(settlement) {
+  return {
+    [V2_HEADERS.PAYMENT_RESPONSE]: encodeSettlementResponse(settlement)
+  };
+}
 
-// src/data/tokens.ts
-var USDC_BASE = {
-  symbol: "USDC",
-  name: "USDC",
-  version: "2",
-  contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-  chainId: 8453,
-  decimals: 6
-};
-var EURC_BASE = {
-  symbol: "EURC",
-  name: "EURC",
-  version: "2",
-  contractAddress: "0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42",
-  chainId: 8453,
-  decimals: 6
-};
-var USDC_BASE_SEPOLIA = {
-  symbol: "USDC",
-  name: "USDC",
-  version: "2",
-  contractAddress: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
-  chainId: 84532,
-  decimals: 6
-};
-var USDC_SKALE_BASE = {
-  symbol: "USDC",
-  name: "Bridged USDC (SKALE Bridge)",
-  version: "2",
-  contractAddress: "0x85889c8c714505E0c94b30fcfcF64fE3Ac8FCb20",
-  chainId: 1187947933,
-  decimals: 6
-};
-var SKL_SKALE_BASE = {
-  symbol: "SKL",
-  name: "SKALE",
-  version: "1",
-  contractAddress: "0xE0595a049d02b7674572b0d59cd4880Db60EDC50",
-  chainId: 1187947933,
-  decimals: 18
-};
-var USDT_SKALE_BASE = {
-  symbol: "USDT",
-  name: "Tether USD",
-  version: "1",
-  contractAddress: "0x2bF5bF154b515EaA82C31a65ec11554fF5aF7fCA",
-  chainId: 1187947933,
-  decimals: 6
-};
-var WBTC_SKALE_BASE = {
-  symbol: "WBTC",
-  name: "Wrapped BTC",
-  version: "1",
-  contractAddress: "0x1aeeCFE5454c83B42D8A316246CAc9739E7f690e",
-  chainId: 1187947933,
-  decimals: 8
-};
-var WETH_SKALE_BASE = {
-  symbol: "WETH",
-  name: "Wrapped Ether",
-  version: "1",
-  contractAddress: "0x7bD39ABBd0Dd13103542cAe3276C7fA332bCA486",
-  chainId: 1187947933,
-  decimals: 18
-};
-var SKL_SKALE_BASE_SEPOLIA = {
-  symbol: "SKL",
-  name: "SKALE",
-  version: "1",
-  contractAddress: "0xaf2e0ff5b5f51553fdb34ce7f04a6c3201cee57b",
-  chainId: 324705682,
-  decimals: 18
-};
-var USDC_SKALE_BASE_SEPOLIA = {
-  symbol: "USDC",
-  name: "Bridged USDC (SKALE Bridge)",
-  version: "2",
-  contractAddress: "0x2e08028E3C4c2356572E096d8EF835cD5C6030bD",
-  chainId: 324705682,
-  decimals: 6
-};
-var USDT_SKALE_BASE_SEPOLIA = {
-  symbol: "USDT",
-  name: "Tether USD",
-  version: "1",
-  contractAddress: "0x3ca0a49f511c2c89c4dcbbf1731120d8919050bf",
-  chainId: 324705682,
-  decimals: 6
-};
-var WBTC_SKALE_BASE_SEPOLIA = {
-  symbol: "WBTC",
-  name: "Wrapped BTC",
-  version: "1",
-  contractAddress: "0x4512eacd4186b025186e1cf6cc0d89497c530e87",
-  chainId: 324705682,
-  decimals: 8
+// src/errors.ts
+var X402ClientError = class extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "X402ClientError";
+    this.cause = cause;
+  }
 };
-var WETH_SKALE_BASE_SEPOLIA = {
-  symbol: "WETH",
-  name: "Wrapped Ether",
-  version: "1",
-  contractAddress: "0xf94056bd7f6965db3757e1b145f200b7346b4fc0",
-  chainId: 324705682,
-  decimals: 18
+var SigningError = class extends X402ClientError {
+  constructor(message, cause) {
+    super(`Signing failed: ${message}`, cause);
+    this.name = "SigningError";
+  }
 };
-var TOKENS = {
-  USDC_BASE,
-  USDC_BASE_SEPOLIA,
-  EURC_BASE,
-  USDC_SKALE_BASE,
-  USDT_SKALE_BASE,
-  WBTC_SKALE_BASE,
-  WETH_SKALE_BASE,
-  SKL_SKALE_BASE,
-  SKL_SKALE_BASE_SEPOLIA,
-  USDC_SKALE_BASE_SEPOLIA,
-  USDT_SKALE_BASE_SEPOLIA,
-  WBTC_SKALE_BASE_SEPOLIA,
-  WETH_SKALE_BASE_SEPOLIA
+var PaymentException = class extends X402ClientError {
+  constructor(message, cause) {
+    super(`Payment failed: ${message}`, cause);
+    this.name = "PaymentException";
+  }
 };
-function getToken(chainId, contractAddress) {
-  const tokens = Object.values(TOKENS);
-  return tokens.find(
-    (t) => t.chainId === chainId && t.contractAddress.toLowerCase() === contractAddress.toLowerCase()
-  );
-}
-function getAllTokens() {
-  return Object.values(TOKENS);
+
+// src/payment-client.ts
+var DEFAULT_FACILITATOR_URL = "https://facilitator.payai.network";
+function toJsonSafe(data) {
+  function convert(value) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      return Object.fromEntries(
+        Object.entries(value).map(([key, val]) => [key, convert(val)])
+      );
+    }
+    if (Array.isArray(value)) {
+      return value.map(convert);
+    }
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    return value;
+  }
+  return convert(data);
 }
-function getTokensBySymbol(symbol) {
-  return getAllTokens().filter((t) => t.symbol.toUpperCase() === symbol.toUpperCase());
+function resolveUrl(config) {
+  return config?.url ?? DEFAULT_FACILITATOR_URL;
 }
-function getTokensByChain(chainId) {
-  return getAllTokens().filter((t) => t.chainId === chainId);
+async function resolveHeaders(config) {
+  const base = { "Content-Type": "application/json" };
+  if (!config?.createHeaders) return base;
+  const extra = await config.createHeaders();
+  return { ...base, ...extra };
 }
-function getUSDCTokens() {
-  return getTokensBySymbol("USDC");
+async function verifyPayment(payload, requirements, config) {
+  const url = resolveUrl(config);
+  const headers = await resolveHeaders(config);
+  const response = await fetch(`${url}/verify`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      paymentPayload: toJsonSafe(payload),
+      paymentRequirements: toJsonSafe(requirements)
+    })
+  });
+  if (response.status !== 200) {
+    const text = await response.text().catch(() => response.statusText);
+    throw new Error(`Facilitator verify failed: ${response.status} ${text}`);
+  }
+  return await response.json();
 }
-function getEURCTokens() {
-  return getTokensBySymbol("EURC");
+async function settlePayment(payload, requirements, config) {
+  const url = resolveUrl(config);
+  const headers = await resolveHeaders(config);
+  const response = await fetch(`${url}/settle`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      paymentPayload: toJsonSafe(payload),
+      paymentRequirements: toJsonSafe(requirements)
+    })
+  });
+  if (response.status !== 200) {
+    const text = await response.text().catch(() => response.statusText);
+    throw new Error(`Facilitator settle failed: ${response.status} ${text}`);
+  }
+  return await response.json();
 }
-function getSKLTokens() {
-  return getTokensBySymbol("SKL");
+async function getSupported(config) {
+  const url = resolveUrl(config);
+  const headers = await resolveHeaders(config);
+  const response = await fetch(`${url}/supported`, {
+    method: "GET",
+    headers
+  });
+  if (response.status !== 200) {
+    throw new Error(`Facilitator supported failed: ${response.statusText}`);
+  }
+  return await response.json();
 }
-function getUSDTTokens() {
-  return getTokensBySymbol("USDT");
+function isCompactV2Payload(payload) {
+  if (typeof payload !== "object" || payload === null) return false;
+  const record = payload;
+  return typeof record.x402Version === "number" && "payload" in record && !("accepted" in record);
 }
-function getWBTCTokens() {
-  return getTokensBySymbol("WBTC");
+function decodePayloadHeader(headerValue, defaults) {
+  if (headerValue.startsWith("{")) {
+    const parsed = JSON.parse(headerValue);
+    if (isPaymentPayload(parsed)) return parsed;
+    if (isCompactV2Payload(parsed)) {
+      const compact = parsed;
+      if (!defaults?.accepted) {
+        throw new Error(
+          "Invalid payment payload: missing 'accepted' field and no defaults provided"
+        );
+      }
+      return {
+        x402Version: 2,
+        accepted: defaults.accepted,
+        payload: compact.payload
+      };
+    }
+    throw new Error("Invalid payment payload: unrecognized format");
+  }
+  const normalized = headerValue.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(headerValue.length / 4) * 4, "=");
+  try {
+    const decoded = JSON.parse(decodeBase64ToUtf8(normalized));
+    if (isPaymentPayload(decoded)) return decoded;
+    if (isCompactV2Payload(decoded)) {
+      const compact = decoded;
+      if (!defaults?.accepted) {
+        throw new Error(
+          "Invalid payment payload: missing 'accepted' field and no defaults provided"
+        );
+      }
+      return {
+        x402Version: 2,
+        accepted: defaults.accepted,
+        payload: compact.payload
+      };
+    }
+    throw new Error("Invalid payment payload: unrecognized format");
+  } catch {
+    throw new Error("Invalid payment payload: failed to decode");
+  }
 }
-function getWETHTokens() {
-  return getTokensBySymbol("WETH");
+function extractPayerAddress(payload) {
+  if (isExactEvmPayload(payload.payload)) {
+    return payload.payload.authorization.from;
+  }
+  throw new Error("Unable to extract payer address from payload");
 }
 
-// src/abi/erc20.ts
-var ERC20_ABI = [
-  {
-    type: "function",
-    name: "transferWithAuthorization",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "from", type: "address" },
-      { name: "to", type: "address" },
-      { name: "amount", type: "uint256" },
-      { name: "validAfter", type: "uint256" },
-      { name: "expiry", type: "uint256" },
-      { name: "v", type: "uint8" },
-      { name: "r", type: "bytes32" },
-      { name: "s", type: "bytes32" }
-    ],
-    outputs: []
+// src/types/networks.ts
+var isEvmAddress = (value) => /^0x[a-fA-F0-9]{40}$/.test(value);
+var tokenRegistry = /* @__PURE__ */ new Map();
+var tokenKey = (chainId, contractAddress) => `${chainId}:${contractAddress.toLowerCase()}`;
+var NETWORKS = {
+  ethereum: {
+    name: "Ethereum Mainnet",
+    chainId: 1,
+    usdcAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    rpcUrl: "https://eth.llamarpc.com",
+    caip2Id: "eip155:1",
+    caipAssetId: "eip155:1/erc20:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
   },
-  {
-    type: "function",
-    name: "receiveWithAuthorization",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "from", type: "address" },
-      { name: "to", type: "address" },
-      { name: "amount", type: "uint256" },
-      { name: "validAfter", type: "uint256" },
-      { name: "expiry", type: "uint256" },
-      { name: "v", type: "uint8" },
-      { name: "r", type: "bytes32" },
-      { name: "s", type: "bytes32" }
-    ],
-    outputs: []
+  base: {
+    name: "Base Mainnet",
+    chainId: 8453,
+    usdcAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    rpcUrl: "https://mainnet.base.org",
+    caip2Id: "eip155:8453",
+    caipAssetId: "eip155:8453/erc20:0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
   },
-  {
-    type: "function",
-    name: "balanceOf",
-    stateMutability: "view",
-    inputs: [{ name: "account", type: "address" }],
-    outputs: [{ name: "balance", type: "uint256" }]
+  "base-sepolia": {
+    name: "Base Sepolia",
+    chainId: 84532,
+    usdcAddress: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    rpcUrl: "https://sepolia.base.org",
+    caip2Id: "eip155:84532",
+    caipAssetId: "eip155:84532/erc20:0x036CbD53842c5426634e7929541eC2318f3dCF7e"
   },
-  {
-    type: "function",
-    name: "name",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [{ name: "", type: "string" }]
+  "skale-base": {
+    name: "SKALE Base",
+    chainId: 1187947933,
+    usdcAddress: "0x85889c8c714505E0c94b30fcfcF64fE3Ac8FCb20",
+    rpcUrl: "https://skale-base.skalenodes.com/v1/base",
+    caip2Id: "eip155:1187947933",
+    caipAssetId: "eip155:1187947933/erc20:0x85889c8c714505E0c94b30fcfcF64fE3Ac8FCb20"
   },
-  {
-    type: "function",
-    name: "symbol",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [{ name: "", type: "string" }]
+  "skale-base-sepolia": {
+    name: "SKALE Base Sepolia",
+    chainId: 324705682,
+    usdcAddress: "0x2e08028E3C4c2356572E096d8EF835cD5C6030bD",
+    rpcUrl: "https://base-sepolia-testnet.skalenodes.com/v1/jubilant-horrible-ancha",
+    caip2Id: "eip155:324705682",
+    caipAssetId: "eip155:324705682/erc20:0x2e08028E3C4c2356572E096d8EF835cD5C6030bD"
+  },
+  "ethereum-sepolia": {
+    name: "Ethereum Sepolia",
+    chainId: 11155111,
+    usdcAddress: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+    rpcUrl: "https://rpc.sepolia.org",
+    caip2Id: "eip155:11155111",
+    caipAssetId: "eip155:11155111/erc20:0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238"
   }
-];
-
-// src/eip712.ts
-var EIP712_TYPES = {
-  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" }
-  ]
-};
-var USDC_DOMAIN = {
-  NAME: "USD Coin",
-  VERSION: "2"
 };
-var createEIP712Domain = (chainId, contractAddress) => ({
-  name: USDC_DOMAIN.NAME,
-  version: USDC_DOMAIN.VERSION,
-  chainId,
-  verifyingContract: contractAddress
-});
-var createTransferWithAuthorization = (params) => ({
-  from: params.from,
-  to: params.to,
-  value: BigInt(params.value),
-  validAfter: BigInt(params.validAfter),
-  validBefore: BigInt(params.validBefore),
-  nonce: params.nonce
-});
-var isAddress2 = (value) => /^0x[a-fA-F0-9]{40}$/.test(value);
-var isBytes32 = (value) => /^0x[a-fA-F0-9]{64}$/.test(value);
-var validateTransferWithAuthorization = (message) => {
-  if (!isAddress2(message.from)) throw new Error(`Invalid "from" address: ${message.from}`);
-  if (!isAddress2(message.to)) throw new Error(`Invalid "to" address: ${message.to}`);
-  if (message.value < 0n) throw new Error(`"value" must be non-negative: ${message.value}`);
-  if (message.validAfter < 0n) throw new Error(`"validAfter" must be non-negative: ${message.validAfter}`);
-  if (message.validBefore < 0n) throw new Error(`"validBefore" must be non-negative: ${message.validBefore}`);
-  if (message.validAfter >= message.validBefore) {
-    throw new Error(`"validAfter" (${message.validAfter}) must be before "validBefore" (${message.validBefore})`);
+var getNetworkConfig = (name) => NETWORKS[name];
+var getNetworkByChainId = (chainId) => Object.values(NETWORKS).find((c) => c.chainId === chainId);
+var getMainnets = () => Object.values(NETWORKS).filter(
+  (c) => !c.name.toLowerCase().includes("sepolia")
+);
+var getTestnets = () => Object.values(NETWORKS).filter(
+  (c) => c.name.toLowerCase().includes("sepolia")
+);
+var registerToken = (token) => {
+  if (typeof token !== "object" || token === null) {
+    throw new Error("Invalid token: must be an object");
   }
-  if (!isBytes32(message.nonce)) throw new Error(`"nonce" must be a valid bytes32 hex string: ${message.nonce}`);
-  return true;
+  const t = token;
+  if (typeof t.symbol !== "string") {
+    throw new Error("Invalid token: symbol must be a string");
+  }
+  if (typeof t.name !== "string") {
+    throw new Error("Invalid token: name must be a string");
+  }
+  if (typeof t.version !== "string") {
+    throw new Error("Invalid token: version must be a string");
+  }
+  if (typeof t.contractAddress !== "string" || !isEvmAddress(t.contractAddress)) {
+    throw new Error(
+      "Invalid token: contractAddress must be a valid EVM address"
+    );
+  }
+  if (typeof t.chainId !== "number" || !Number.isInteger(t.chainId) || t.chainId <= 0) {
+    throw new Error("Invalid token: chainId must be a positive integer");
+  }
+  if (t.decimals !== void 0 && (typeof t.decimals !== "number" || !Number.isInteger(t.decimals) || t.decimals < 0)) {
+    throw new Error("Invalid token: decimals must be a non-negative integer");
+  }
+  const validated = {
+    symbol: t.symbol,
+    name: t.name,
+    version: t.version,
+    contractAddress: t.contractAddress,
+    chainId: t.chainId,
+    decimals: t.decimals
+  };
+  tokenRegistry.set(
+    tokenKey(validated.chainId, validated.contractAddress),
+    validated
+  );
+  return validated;
 };
+var getCustomToken = (chainId, contractAddress) => tokenRegistry.get(tokenKey(chainId, contractAddress));
+var getAllCustomTokens = () => Array.from(tokenRegistry.values());
+var unregisterToken = (chainId, contractAddress) => tokenRegistry.delete(tokenKey(chainId, contractAddress));
+var isCustomToken = (chainId, contractAddress) => tokenRegistry.has(tokenKey(chainId, contractAddress));
+function createNonce() {
+  const bytes = randomBytes(32);
+  return `0x${bytes.toString("hex")}`;
+}
+function toAtomicUnits(amount, decimals = 6) {
+  const parts = amount.split(".");
+  const whole = parts[0];
+  const fractional = parts[1] || "";
+  const paddedFractional = fractional.padEnd(decimals, "0").slice(0, decimals);
+  return `${whole}${paddedFractional}`;
+}
+function fromAtomicUnits(amount, decimals = 6) {
+  const value = BigInt(amount);
+  const divisor = BigInt(10 ** decimals);
+  const whole = (value / divisor).toString();
+  const fractional = (value % divisor).toString().padStart(decimals, "0").replace(/0+$/, "");
+  if (fractional.length === 0) {
+    return whole;
+  }
+  return `${whole}.${fractional}`;
+}
+function caip2ToNetwork(caip2Id) {
+  const match = caip2Id.match(/^eip155:(\d+)$/);
+  if (!match) {
+    return caip2Id;
+  }
+  const chainId = parseInt(match[1], 10);
+  const chainIdToNetwork = {
+    1: "ethereum",
+    8453: "base",
+    84532: "base-sepolia",
+    137: "polygon",
+    42161: "arbitrum",
+    421614: "arbitrum-sepolia",
+    10: "optimism",
+    11155420: "optimism-sepolia",
+    11155111: "ethereum-sepolia"
+  };
+  return chainIdToNetwork[chainId] || caip2Id;
+}
+function networkToCaip2(network) {
+  const networkToChainId = {
+    ethereum: 1,
+    base: 8453,
+    "base-sepolia": 84532,
+    polygon: 137,
+    arbitrum: 42161,
+    "arbitrum-sepolia": 421614,
+    optimism: 10,
+    "optimism-sepolia": 11155420,
+    "ethereum-sepolia": 11155111
+  };
+  const chainId = networkToChainId[network];
+  if (chainId) {
+    return `eip155:${chainId}`;
+  }
+  if (network.startsWith("eip155:")) {
+    return network;
+  }
+  return `eip155:0`;
+}
+function getCurrentTimestamp() {
+  return Math.floor(Date.now() / 1e3);
+}
+function isValidAddress(address) {
+  return /^0x[a-fA-F0-9]{40}$/.test(address);
+}
+function normalizeAddress(address) {
+  return address.toLowerCase();
+}
 
 // src/validation.ts
 var isEvmAddress2 = (value) => /^0x[a-fA-F0-9]{40}$/.test(value);
@@ -614,7 +915,9 @@ var resolveNetwork = (input) => {
   if (typeof input === "object" && input !== null && "chainId" in input) {
     const config = input;
     if (!config.chainId || !config.usdcAddress || !config.caip2Id) {
-      return createError("INVALID_CAIP_FORMAT", "Invalid network config", { value: config });
+      return createError("INVALID_CAIP_FORMAT", "Invalid network config", {
+        value: config
+      });
     }
     return {
       input,
@@ -626,11 +929,10 @@ var resolveNetwork = (input) => {
     const config = getNetworkByChainId(input);
     if (!config) {
       const validChainIds = Object.values(NETWORKS).map((n) => n.chainId);
-      return createError(
-        "UNKNOWN_NETWORK",
-        `Unknown chain ID: ${input}`,
-        { value: input, validOptions: validChainIds.map(String) }
-      );
+      return createError("UNKNOWN_NETWORK", `Unknown chain ID: ${input}`, {
+        value: input,
+        validOptions: validChainIds.map(String)
+      });
     }
     return {
       input,
@@ -641,13 +943,21 @@ var resolveNetwork = (input) => {
   if (typeof input === "string") {
     if (input.startsWith("eip155:")) {
       const parts = input.split(":");
-      if (parts.length !== 2 || isNaN(Number(parts[1]))) {
-        return createError("INVALID_CAIP_FORMAT", `Invalid CAIP-2 format: ${input}`, { value: input });
+      if (parts.length !== 2 || Number.isNaN(Number(parts[1]))) {
+        return createError(
+          "INVALID_CAIP_FORMAT",
+          `Invalid CAIP-2 format: ${input}`,
+          { value: input }
+        );
       }
       const chainId = Number(parts[1]);
       const config2 = getNetworkByChainId(chainId);
       if (!config2) {
-        return createError("UNKNOWN_NETWORK", `Unknown CAIP-2 network: ${input}`, { value: input });
+        return createError(
+          "UNKNOWN_NETWORK",
+          `Unknown CAIP-2 network: ${input}`,
+          { value: input }
+        );
       }
       return {
         input,
@@ -659,11 +969,10 @@ var resolveNetwork = (input) => {
     const config = getNetworkConfig(normalizedName);
     if (!config) {
       const validNames = Object.keys(NETWORKS);
-      return createError(
-        "UNKNOWN_NETWORK",
-        `Unknown network: "${input}"`,
-        { value: input, validOptions: validNames }
-      );
+      return createError("UNKNOWN_NETWORK", `Unknown network: "${input}"`, {
+        value: input,
+        validOptions: validNames
+      });
     }
     return {
       input,
@@ -671,7 +980,11 @@ var resolveNetwork = (input) => {
       caip2: config.caip2Id
     };
   }
-  return createError("UNKNOWN_NETWORK", `Invalid network identifier type: ${typeof input}`, { value: input });
+  return createError(
+    "UNKNOWN_NETWORK",
+    `Invalid network identifier type: ${typeof input}`,
+    { value: input }
+  );
 };
 var getAvailableNetworks = () => Object.keys(NETWORKS);
 var normalizeTokenSymbol = (symbol) => symbol.toUpperCase();
@@ -679,7 +992,9 @@ var resolveToken = (input, network) => {
   if (typeof input === "object" && input !== null && "contractAddress" in input) {
     const config = input;
     if (!config.chainId || !config.contractAddress || !config.symbol) {
-      return createError("VALIDATION_FAILED", "Invalid token config", { value: config });
+      return createError("VALIDATION_FAILED", "Invalid token config", {
+        value: config
+      });
     }
     if (network && config.chainId !== network.config.chainId) {
       return createError(
@@ -704,7 +1019,10 @@ var resolveToken = (input, network) => {
     if (isEvmAddress2(input)) {
       const contractAddress = input;
       if (network) {
-        const customToken = getCustomToken(network.config.chainId, contractAddress);
+        const customToken = getCustomToken(
+          network.config.chainId,
+          contractAddress
+        );
         const config = customToken || {
           symbol: "CUSTOM",
           name: "Custom Token",
@@ -747,7 +1065,11 @@ var resolveToken = (input, network) => {
     if (input.includes("/erc20:")) {
       const parts = input.split("/");
       if (parts.length !== 2) {
-        return createError("INVALID_CAIP_FORMAT", `Invalid CAIP Asset ID format: ${input}`, { value: input });
+        return createError(
+          "INVALID_CAIP_FORMAT",
+          `Invalid CAIP Asset ID format: ${input}`,
+          { value: input }
+        );
       }
       const chainId = Number(parts[0].split(":")[1]);
       const contractAddress = parts[1].split(":")[1];
@@ -789,7 +1111,7 @@ var resolveToken = (input, network) => {
         input,
         config: {
           symbol: normalizedSymbol,
-          name: network.config.name + " " + normalizedSymbol,
+          name: `${network.config.name} ${normalizedSymbol}`,
           version: "2",
           chainId: network.config.chainId,
           contractAddress: network.config.usdcAddress,
@@ -800,7 +1122,9 @@ var resolveToken = (input, network) => {
       };
     }
     const customTokens = getAllCustomTokens();
-    const matchingToken = customTokens.find((t) => t.symbol?.toUpperCase() === normalizedSymbol);
+    const matchingToken = customTokens.find(
+      (t) => t.symbol?.toUpperCase() === normalizedSymbol
+    );
     if (matchingToken) {
       const tokenNetwork = resolveNetwork(matchingToken.chainId);
       if ("code" in tokenNetwork) {
@@ -831,7 +1155,11 @@ var resolveToken = (input, network) => {
       network: baseNetwork
     };
   }
-  return createError("UNKNOWN_TOKEN", `Invalid token identifier type: ${typeof input}`, { value: input });
+  return createError(
+    "UNKNOWN_TOKEN",
+    `Invalid token identifier type: ${typeof input}`,
+    { value: input }
+  );
 };
 var getAvailableTokens = () => {
   const customTokens = getAllCustomTokens();
@@ -842,7 +1170,11 @@ var resolveFacilitator = (input, supportedNetworks, supportedTokens) => {
   try {
     new URL(input.url);
   } catch {
-    return createError("VALIDATION_FAILED", `Invalid facilitator URL: ${input.url}`, { value: input.url });
+    return createError(
+      "VALIDATION_FAILED",
+      `Invalid facilitator URL: ${input.url}`,
+      { value: input.url }
+    );
   }
   const networks = [];
   if (input.networks) {
@@ -900,12 +1232,18 @@ var checkFacilitatorSupport = (facilitator, network, token) => {
       (t) => t.config.contractAddress.toLowerCase() === token.config.contractAddress.toLowerCase() && t.network.config.chainId === token.network.config.chainId
     );
     if (!tokenSupported) {
-      const supportedTokens = facilitator.tokens.map((t) => `${t.config.symbol} (${t.network.config.name})`);
+      const supportedTokens = facilitator.tokens.map(
+        (t) => `${t.config.symbol} (${t.network.config.name})`
+      );
       return createError(
         "FACILITATOR_NO_TOKEN_SUPPORT",
         `Facilitator "${facilitator.url}" does not support token "${token.config.symbol}" on "${token.network.config.name}". Supported: ${supportedTokens.join(", ")}`,
         {
-          value: { facilitator: facilitator.url, token: token.config.symbol, network: token.network.config.name },
+          value: {
+            facilitator: facilitator.url,
+            token: token.config.symbol,
+            network: token.network.config.name
+          },
           validOptions: supportedTokens
         }
       );
@@ -926,11 +1264,19 @@ var validatePaymentConfig = (network, token, facilitators, payTo = "0x0000000000
   if (facilitators) {
     const facilitatorArray = Array.isArray(facilitators) ? facilitators : [facilitators];
     for (const facilitator of facilitatorArray) {
-      const resolved = resolveFacilitator(facilitator, [resolvedNetwork], [resolvedToken]);
+      const resolved = resolveFacilitator(
+        facilitator,
+        [resolvedNetwork],
+        [resolvedToken]
+      );
       if ("code" in resolved) {
         return resolved;
       }
-      const supportCheck = checkFacilitatorSupport(resolved, resolvedNetwork, resolvedToken);
+      const supportCheck = checkFacilitatorSupport(
+        resolved,
+        resolvedNetwork,
+        resolvedToken
+      );
       if ("code" in supportCheck) {
         return supportCheck;
       }
@@ -947,7 +1293,12 @@ var validatePaymentConfig = (network, token, facilitators, payTo = "0x0000000000
   };
 };
 var validateAcceptConfig = (options, payTo, amount) => {
-  const { networks: networkInputs, tokens: tokenInputs, facilitators, version = 2 } = options;
+  const {
+    networks: networkInputs,
+    tokens: tokenInputs,
+    facilitators,
+    version = 2
+  } = options;
   const networkIds = networkInputs?.length ? networkInputs : Object.keys(NETWORKS);
   const tokenIds = tokenInputs?.length ? tokenInputs : ["usdc"];
   const networks = [];
@@ -960,17 +1311,16 @@ var validateAcceptConfig = (options, payTo, amount) => {
   }
   const tokens = [];
   for (const tokenId of tokenIds) {
-    let found = false;
+    let matches = 0;
     for (const network of networks) {
       const resolved = resolveToken(tokenId, network);
       if ("code" in resolved) {
         continue;
       }
       tokens.push(resolved);
-      found = true;
-      break;
+      matches += 1;
     }
-    if (!found) {
+    if (matches === 0) {
       return {
         success: false,
         error: createError(
@@ -1017,6 +1367,343 @@ var isResolvedToken = (value) => {
   return typeof value === "object" && value !== null && "config" in value && "caipAsset" in value;
 };
 
+// src/payment-requirements.ts
+var DEFAULT_NETWORKS = [
+  "ethereum",
+  "base",
+  "base-sepolia",
+  "skale-base",
+  "skale-base-sepolia",
+  "ethereum-sepolia"
+];
+var DEFAULT_TOKENS = ["usdc"];
+var isValidationError2 = (value) => {
+  return typeof value === "object" && value !== null && "code" in value;
+};
+function resolvePayTo(config, network, token) {
+  const chainId = network.config.chainId;
+  if (config.payToByToken) {
+    for (const [chainKey, tokenMap] of Object.entries(config.payToByToken)) {
+      const resolvedChain = resolveNetwork(chainKey);
+      if (!isValidationError2(resolvedChain) && resolvedChain.config.chainId === chainId) {
+        for (const [tokenKey2, address] of Object.entries(tokenMap)) {
+          const resolvedToken = resolveToken(tokenKey2, network);
+          if (!isValidationError2(resolvedToken) && resolvedToken.config.contractAddress.toLowerCase() === token.config.contractAddress.toLowerCase()) {
+            return address;
+          }
+        }
+      }
+    }
+  }
+  if (config.payToByChain) {
+    for (const [chainKey, address] of Object.entries(config.payToByChain)) {
+      const resolvedChain = resolveNetwork(chainKey);
+      if (!isValidationError2(resolvedChain) && resolvedChain.config.chainId === chainId) {
+        return address;
+      }
+    }
+  }
+  return config.payTo;
+}
+function resolveFacilitatorUrl(config, network, token) {
+  const chainId = network.config.chainId;
+  if (config.facilitatorUrlByToken) {
+    for (const [chainKey, tokenMap] of Object.entries(
+      config.facilitatorUrlByToken
+    )) {
+      const resolvedChain = resolveNetwork(chainKey);
+      if (!isValidationError2(resolvedChain) && resolvedChain.config.chainId === chainId) {
+        for (const [tokenKey2, url] of Object.entries(tokenMap)) {
+          const resolvedToken = resolveToken(tokenKey2, network);
+          if (!isValidationError2(resolvedToken) && resolvedToken.config.contractAddress.toLowerCase() === token.config.contractAddress.toLowerCase()) {
+            return url;
+          }
+        }
+      }
+    }
+  }
+  if (config.facilitatorUrlByChain) {
+    for (const [chainKey, url] of Object.entries(
+      config.facilitatorUrlByChain
+    )) {
+      const resolvedChain = resolveNetwork(chainKey);
+      if (!isValidationError2(resolvedChain) && resolvedChain.config.chainId === chainId) {
+        return url;
+      }
+    }
+  }
+  return config.facilitatorUrl;
+}
+function resolveFacilitatorUrlFromRequirement(config, requirement) {
+  const chainId = parseInt(requirement.network.split(":")[1] || "0", 10);
+  const assetAddress = requirement.asset.toLowerCase();
+  if (config.facilitatorUrlByToken) {
+    for (const [chainKey, tokenMap] of Object.entries(
+      config.facilitatorUrlByToken
+    )) {
+      const resolvedChain = resolveNetwork(chainKey);
+      if (isValidationError2(resolvedChain) || resolvedChain.config.chainId !== chainId) {
+        continue;
+      }
+      for (const [tokenKey2, url] of Object.entries(tokenMap)) {
+        const resolvedToken = resolveToken(tokenKey2, resolvedChain);
+        if (!isValidationError2(resolvedToken) && resolvedToken.config.contractAddress.toLowerCase() === assetAddress) {
+          return url;
+        }
+      }
+    }
+  }
+  if (config.facilitatorUrlByChain) {
+    for (const [chainKey, url] of Object.entries(
+      config.facilitatorUrlByChain
+    )) {
+      const resolvedChain = resolveNetwork(chainKey);
+      if (!isValidationError2(resolvedChain) && resolvedChain.config.chainId === chainId) {
+        return url;
+      }
+    }
+  }
+  return config.facilitatorUrl;
+}
+function resolveNetworks(chainInputs) {
+  const resolvedNetworks = [];
+  const errors = [];
+  const networks = chainInputs?.length ? chainInputs : DEFAULT_NETWORKS;
+  for (const networkId of networks) {
+    const resolved = resolveNetwork(networkId);
+    if (isValidationError2(resolved)) {
+      errors.push(`Network "${networkId}": ${resolved.message}`);
+    } else {
+      resolvedNetworks.push(resolved);
+    }
+  }
+  if (errors.length > 0) {
+    return {
+      networks: resolvedNetworks,
+      error: {
+        code: "VALIDATION_FAILED",
+        message: errors.join("; ")
+      }
+    };
+  }
+  return { networks: resolvedNetworks };
+}
+function createPaymentRequirements(config) {
+  const {
+    payTo,
+    chains,
+    chain,
+    tokens,
+    token,
+    amount = "1.0",
+    maxTimeoutSeconds = 300
+  } = config;
+  const chainInputs = chain ? [chain] : chains;
+  const tokenInputs = token ? [token] : tokens;
+  const { networks, error: networksError } = resolveNetworks(chainInputs);
+  if (networksError) {
+    return { requirements: [], error: networksError };
+  }
+  const requirements = [];
+  for (const network of networks) {
+    const tokensToResolve = tokenInputs?.length ? tokenInputs : DEFAULT_TOKENS;
+    for (const tokenId of tokensToResolve) {
+      const resolvedToken = resolveToken(tokenId, network);
+      if (isValidationError2(resolvedToken)) {
+        continue;
+      }
+      const atomicAmount = toAtomicUnits(amount);
+      const tokenConfig = resolvedToken.config;
+      const resolvedPayTo = resolvePayTo(config, network, resolvedToken);
+      resolveFacilitatorUrl(
+        config,
+        network,
+        resolvedToken
+      );
+      const requirement = {
+        scheme: "exact",
+        network: network.caip2,
+        amount: atomicAmount,
+        asset: tokenConfig.contractAddress,
+        payTo: resolvedPayTo,
+        maxTimeoutSeconds,
+        extra: {
+          name: tokenConfig.name,
+          version: tokenConfig.version
+        }
+      };
+      requirements.push(requirement);
+    }
+  }
+  if (requirements.length === 0) {
+    return {
+      requirements: [],
+      error: {
+        code: "VALIDATION_FAILED",
+        message: "No valid network/token combinations found"
+      }
+    };
+  }
+  return { requirements };
+}
+function findRequirementByNetwork(requirements, network) {
+  const normalized = normalizeNetworkName(network);
+  const netConfig = getNetworkConfig(normalized);
+  if (!netConfig) return void 0;
+  return requirements.find((r) => r.network === netConfig.caip2Id);
+}
+function findRequirementByAccepted(requirements, accepted) {
+  const acceptedPayTo = typeof accepted.payTo === "string" ? accepted.payTo.toLowerCase() : "";
+  const exactMatch = requirements.find(
+    (requirement) => requirement.scheme === accepted.scheme && requirement.network === accepted.network && requirement.amount === accepted.amount && requirement.asset.toLowerCase() === accepted.asset.toLowerCase() && typeof requirement.payTo === "string" && requirement.payTo.toLowerCase() === acceptedPayTo
+  );
+  if (exactMatch) {
+    return exactMatch;
+  }
+  const payToAwareMatch = requirements.find(
+    (requirement) => requirement.scheme === accepted.scheme && requirement.network === accepted.network && acceptedPayTo.length > 0 && typeof requirement.payTo === "string" && requirement.payTo.toLowerCase() === acceptedPayTo
+  );
+  if (payToAwareMatch) {
+    return payToAwareMatch;
+  }
+  return requirements.find(
+    (requirement) => requirement.scheme === accepted.scheme && requirement.network === accepted.network
+  );
+}
+
+// src/facilitator-capabilities.ts
+var DEFAULT_CAPABILITY_TTL_MS = 5 * 60 * 1e3;
+var capabilityCache = /* @__PURE__ */ new Map();
+var normalizeNetwork = (network) => {
+  return network.toLowerCase();
+};
+async function getExtensionKeysForFacilitator(url, network, ttlMs) {
+  const cacheKey = `${url}|${normalizeNetwork(network)}`;
+  const now = Date.now();
+  const cached = capabilityCache.get(cacheKey);
+  if (cached && cached.expiresAt > now) {
+    return cached.keys;
+  }
+  try {
+    const supported = await getSupported({ url });
+    const extensionKeys = /* @__PURE__ */ new Set();
+    for (const kind of supported.kinds) {
+      if (normalizeNetwork(kind.network) !== normalizeNetwork(network)) {
+        continue;
+      }
+      if (kind.extra && typeof kind.extra === "object") {
+        for (const key of Object.keys(kind.extra)) {
+          extensionKeys.add(key);
+        }
+      }
+    }
+    capabilityCache.set(cacheKey, {
+      expiresAt: now + ttlMs,
+      keys: extensionKeys
+    });
+    return extensionKeys;
+  } catch {
+    capabilityCache.set(cacheKey, {
+      expiresAt: now + ttlMs,
+      keys: /* @__PURE__ */ new Set()
+    });
+    return /* @__PURE__ */ new Set();
+  }
+}
+async function filterExtensionsForFacilitator(extensions, facilitatorUrl, network, ttlMs = DEFAULT_CAPABILITY_TTL_MS) {
+  if (!extensions || !facilitatorUrl) {
+    return extensions ?? {};
+  }
+  const supportedKeys = await getExtensionKeysForFacilitator(
+    facilitatorUrl,
+    network,
+    ttlMs
+  );
+  const filtered = {};
+  for (const [key, value] of Object.entries(extensions)) {
+    if (supportedKeys.has(key)) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+async function filterExtensionsForFacilitators(extensions, facilitators, ttlMs = DEFAULT_CAPABILITY_TTL_MS) {
+  if (!extensions) {
+    return {};
+  }
+  let filtered = { ...extensions };
+  for (const facilitator of facilitators) {
+    filtered = await filterExtensionsForFacilitator(
+      filtered,
+      facilitator.url,
+      facilitator.network,
+      ttlMs
+    );
+    if (Object.keys(filtered).length === 0) {
+      return {};
+    }
+  }
+  return filtered;
+}
+async function filterExtensionsForRequirements(extensions, requirements, config, ttlMs = DEFAULT_CAPABILITY_TTL_MS) {
+  const facilitators = requirements.map((requirement) => ({
+    url: resolveFacilitatorUrlFromRequirement(config, requirement),
+    network: requirement.network
+  }));
+  return filterExtensionsForFacilitators(extensions, facilitators, ttlMs);
+}
+function clearFacilitatorCapabilityCache() {
+  capabilityCache.clear();
+}
+
+// src/protocol.ts
+function parseJsonOrBase64(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    const normalized = normalizeBase64Url(value);
+    return JSON.parse(decodeBase64ToUtf8(normalized));
+  }
+}
+function detectX402Version(_response) {
+  return 2;
+}
+function getPaymentHeaderName(_version) {
+  return V2_HEADERS.PAYMENT_SIGNATURE;
+}
+function generateNonce() {
+  const now = Math.floor(Date.now() / 1e3);
+  return `0x${(now * 1e3).toString(16).padStart(64, "0")}`;
+}
+function calculateValidBefore(expirySeconds = 3600) {
+  return Math.floor(Date.now() / 1e3) + expirySeconds;
+}
+
+// src/types/protocol.ts
+function isX402V2Payload(obj) {
+  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 2 && "accepted" in obj && "payload" in obj;
+}
+function isX402V2Requirements(obj) {
+  return typeof obj === "object" && obj !== null && "scheme" in obj && obj.scheme === "exact" && "network" in obj && typeof obj.network === "string" && obj.network.startsWith("eip155:") && // CAIP-2 format
+  "amount" in obj && "asset" in obj && "payTo" in obj && "maxTimeoutSeconds" in obj;
+}
+function isX402V2Settlement(obj) {
+  return typeof obj === "object" && obj !== null && "success" in obj && typeof obj.success === "boolean" && "network" in obj && typeof obj.network === "string" && obj.network.startsWith("eip155:");
+}
+function isX402V2PaymentRequired(obj) {
+  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 2 && "resource" in obj && "accepts" in obj;
+}
+var PAYMENT_SIGNATURE_HEADER = "PAYMENT-SIGNATURE";
+var PAYMENT_RESPONSE_HEADER = "PAYMENT-RESPONSE";
+var PAYMENT_REQUIRED_HEADER = "PAYMENT-REQUIRED";
+function isSettlementSuccessful(response) {
+  return "success" in response ? response.success : false;
+}
+function getTxHash(response) {
+  if ("transaction" in response) return response.transaction;
+  return void 0;
+}
+
 // src/utils/routes.ts
 var PRIORITY_EXACT = 3;
 var PRIORITY_PARAMETRIZED = 2;
@@ -1083,7 +1770,7 @@ function matchSegment(patternSegment, pathSegment) {
   }
   if (patternSegment.includes("*")) {
     const regex = new RegExp(
-      "^" + patternSegment.replace(/\*/g, ".*").replace(/:/g, "") + "$"
+      `^${patternSegment.replace(/\*/g, ".*").replace(/:/g, "")}$`
     );
     return regex.test(pathSegment);
   }
@@ -1096,7 +1783,7 @@ function matchWildcardPattern(patternSegments, pathSegments) {
   }
   for (let i = 0; i < requiredSegments.length; i++) {
     const patternIndex = patternSegments.indexOf(requiredSegments[i]);
-    if (pathSegments[patternIndex] !== requiredSegments[i].replace(/^\:/, "")) {
+    if (pathSegments[patternIndex] !== requiredSegments[i].replace(/^:/, "")) {
       if (!requiredSegments[i].startsWith(":") && requiredSegments[i] !== "*") {
         return false;
       }
@@ -1173,152 +1860,13 @@ function validateRouteConfig(config) {
       message: `Wildcard routes must use the routes array, not 'route'. Use 'routes: ["/api/*"]' instead of 'route: "/api/*"'.`,
       path: "route",
       value: route,
-      validOptions: ['routes: ["/api/*"]', 'routes: ["/api/users", "/api/posts"]']
+      validOptions: [
+        'routes: ["/api/*"]',
+        'routes: ["/api/users", "/api/posts"]'
+      ]
     };
   }
   return null;
 }
 
-// src/encoding.ts
-function safeBase64Decode2(str) {
-  const padding = 4 - str.length % 4;
-  if (padding !== 4) {
-    str += "=".repeat(padding);
-  }
-  str = str.replace(/-/g, "+").replace(/_/g, "/");
-  return Buffer.from(str, "base64").toString("utf-8");
-}
-function safeBase64Encode2(str) {
-  return Buffer.from(str).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
-}
-var base64JsonEncode = (data) => safeBase64Encode2(JSON.stringify(data));
-var base64JsonDecode = (encoded) => JSON.parse(safeBase64Decode2(encoded));
-var encodePaymentV2 = (payload) => base64JsonEncode(payload);
-var decodePaymentV2 = (encoded) => base64JsonDecode(encoded);
-var encodeSettlementV2 = (response) => base64JsonEncode(response);
-var decodeSettlementV2 = (encoded) => base64JsonDecode(encoded);
-var isPaymentV2 = (payload) => "x402Version" in payload && payload.x402Version === 2 && "accepted" in payload && "payload" in payload;
-var isSettlementV2 = (response) => "success" in response && typeof response.success === "boolean" && "network" in response;
-
-// src/payment-client.ts
-var DEFAULT_FACILITATOR_URL = "https://facilitator.payai.network";
-function toJsonSafe(data) {
-  function convert(value) {
-    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-      return Object.fromEntries(Object.entries(value).map(([key, val]) => [key, convert(val)]));
-    }
-    if (Array.isArray(value)) {
-      return value.map(convert);
-    }
-    if (typeof value === "bigint") {
-      return value.toString();
-    }
-    return value;
-  }
-  return convert(data);
-}
-function resolveUrl(config) {
-  return config?.url ?? DEFAULT_FACILITATOR_URL;
-}
-async function resolveHeaders(config) {
-  const base = { "Content-Type": "application/json" };
-  if (!config?.createHeaders) return base;
-  const extra = await config.createHeaders();
-  return { ...base, ...extra };
-}
-async function verifyPayment(payload, requirements, config) {
-  const url = resolveUrl(config);
-  const headers = await resolveHeaders(config);
-  const response = await fetch(`${url}/verify`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify({
-      paymentPayload: toJsonSafe(payload),
-      paymentRequirements: toJsonSafe(requirements)
-    })
-  });
-  if (response.status !== 200) {
-    const text = await response.text().catch(() => response.statusText);
-    throw new Error(`Facilitator verify failed: ${response.status} ${text}`);
-  }
-  return await response.json();
-}
-async function settlePayment(payload, requirements, config) {
-  const url = resolveUrl(config);
-  const headers = await resolveHeaders(config);
-  const response = await fetch(`${url}/settle`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify({
-      paymentPayload: toJsonSafe(payload),
-      paymentRequirements: toJsonSafe(requirements)
-    })
-  });
-  if (response.status !== 200) {
-    const text = await response.text().catch(() => response.statusText);
-    throw new Error(`Facilitator settle failed: ${response.status} ${text}`);
-  }
-  return await response.json();
-}
-async function getSupported(config) {
-  const url = resolveUrl(config);
-  const headers = await resolveHeaders(config);
-  const response = await fetch(`${url}/supported`, {
-    method: "GET",
-    headers
-  });
-  if (response.status !== 200) {
-    throw new Error(`Facilitator supported failed: ${response.statusText}`);
-  }
-  return await response.json();
-}
-function isCompactV2Payload(payload) {
-  if (typeof payload !== "object" || payload === null) return false;
-  const record = payload;
-  return typeof record.x402Version === "number" && "payload" in record && !("accepted" in record);
-}
-function decodePayloadHeader(headerValue, defaults) {
-  if (headerValue.startsWith("{")) {
-    const parsed = JSON.parse(headerValue);
-    if (isPaymentPayload(parsed)) return parsed;
-    if (isCompactV2Payload(parsed)) {
-      const compact = parsed;
-      if (!defaults?.accepted) {
-        throw new Error("Invalid payment payload: missing 'accepted' field and no defaults provided");
-      }
-      return {
-        x402Version: 2,
-        accepted: defaults.accepted,
-        payload: compact.payload
-      };
-    }
-    throw new Error("Invalid payment payload: unrecognized format");
-  }
-  const normalized = headerValue.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(headerValue.length / 4) * 4, "=");
-  try {
-    const decoded = JSON.parse(Buffer.from(normalized, "base64").toString("utf-8"));
-    if (isPaymentPayload(decoded)) return decoded;
-    if (isCompactV2Payload(decoded)) {
-      const compact = decoded;
-      if (!defaults?.accepted) {
-        throw new Error("Invalid payment payload: missing 'accepted' field and no defaults provided");
-      }
-      return {
-        x402Version: 2,
-        accepted: defaults.accepted,
-        payload: compact.payload
-      };
-    }
-    throw new Error("Invalid payment payload: unrecognized format");
-  } catch {
-    throw new Error("Invalid payment payload: failed to decode");
-  }
-}
-function extractPayerAddress(payload) {
-  if (isExactEvmPayload(payload.payload)) {
-    return payload.payload.authorization.from;
-  }
-  throw new Error("Unable to extract payer address from payload");
-}
-
-export { EIP712_TYPES, ERC20_ABI, EURC_BASE, NETWORKS, PAYMENT_REQUIRED_HEADER, PAYMENT_RESPONSE_HEADER, PAYMENT_SIGNATURE_HEADER, SCHEMES, SKL_SKALE_BASE, SKL_SKALE_BASE_SEPOLIA, TOKENS, USDC_BASE, USDC_BASE_SEPOLIA, USDC_DOMAIN, USDC_SKALE_BASE, USDC_SKALE_BASE_SEPOLIA, USDT_SKALE_BASE, USDT_SKALE_BASE_SEPOLIA, V2_HEADERS, WBTC_SKALE_BASE, WBTC_SKALE_BASE_SEPOLIA, WETH_SKALE_BASE, WETH_SKALE_BASE_SEPOLIA, X402_VERSION, addressToAssetId, assetIdToAddress, caip2ToNetwork, checkFacilitatorSupport, combineSignature as combineSignatureV2, createEIP712Domain, createError, createNonce, createPaymentRequiredHeaders, createSettlementHeaders, createTransferWithAuthorization, decodePayloadHeader, decodePayment, decodePaymentV2, decodeSettlementResponse, decodeSettlementV2, decodeX402Response, detectPaymentVersion, encodePayment, encodePaymentV2, encodeSettlementResponse, encodeSettlementV2, encodeX402Response, extractPayerAddress, extractPaymentFromHeaders, findMatchingRoute, fromAtomicUnits, getAllCustomTokens, getAllTokens, getAvailableNetworks, getAvailableTokens, getCurrentTimestamp, getCustomToken, getEURCTokens, getMainnets, getNetworkByChainId, getNetworkConfig, getSKLTokens, getSupported, getTestnets, getToken, getTokensByChain, getTokensBySymbol, getTxHash, getUSDCTokens, getUSDTTokens, getWBTCTokens, getWETHTokens, isAddress, isCAIP2ChainId, isCAIPAssetId, isCustomToken, isExactEvmPayload, isPaymentPayload, isPaymentPayloadV2, isPaymentRequiredV2, isPaymentV2, isResolvedNetwork, isResolvedToken, isSettlementSuccessful, isSettlementV2, isValidAddress, isValidationError, isX402V2Payload, isX402V2PaymentRequired, isX402V2Requirements, isX402V2Settlement, matchRoute, networkToCaip2, normalizeAddress, normalizeNetworkName, parseRoutePattern, parseSignature as parseSignatureV2, registerToken, resolveFacilitator, resolveNetwork, resolveToken, safeBase64Decode, safeBase64Encode, settlePayment, toAtomicUnits, unregisterToken, validateAcceptConfig, validatePaymentConfig, validateRouteConfig, validateTransferWithAuthorization, verifyPayment };
+export { EIP712_TYPES, ERC20_ABI, EURC_BASE, NETWORKS, PAYMENT_REQUIRED_HEADER, PAYMENT_RESPONSE_HEADER, PAYMENT_SIGNATURE_HEADER, PaymentException, SCHEMES, SKL_SKALE_BASE, SKL_SKALE_BASE_SEPOLIA, SigningError, TOKENS, USDC_BASE, USDC_BASE_SEPOLIA, USDC_DOMAIN, USDC_SKALE_BASE, USDC_SKALE_BASE_SEPOLIA, USDT_SKALE_BASE, USDT_SKALE_BASE_SEPOLIA, V2_HEADERS, WBTC_SKALE_BASE, WBTC_SKALE_BASE_SEPOLIA, WETH_SKALE_BASE, WETH_SKALE_BASE_SEPOLIA, X402ClientError, X402_VERSION, addressToAssetId, assetIdToAddress, caip2ToNetwork, calculateValidBefore, checkFacilitatorSupport, clearFacilitatorCapabilityCache, combineSignature as combineSignatureV2, createEIP712Domain, createError, createNonce, createPaymentRequiredHeaders, createPaymentRequirements, createSettlementHeaders, createTransferWithAuthorization, decodeBase64ToUtf8, decodePayloadHeader, decodePayment, decodePaymentV2, decodeSettlementResponse, decodeSettlementV2, decodeX402Response, detectPaymentVersion, detectX402Version, encodePayment, encodePaymentV2, encodeSettlementResponse, encodeSettlementV2, encodeUtf8ToBase64, encodeX402Response, extractPayerAddress, extractPaymentFromHeaders, filterExtensionsForFacilitator, filterExtensionsForFacilitators, filterExtensionsForRequirements, findMatchingRoute, findRequirementByAccepted, findRequirementByNetwork, fromAtomicUnits, generateNonce, getAllCustomTokens, getAllTokens, getAvailableNetworks, getAvailableTokens, getCurrentTimestamp, getCustomToken, getEURCTokens, getMainnets, getNetworkByChainId, getNetworkConfig, getPaymentHeaderName, getSKLTokens, getSupported, getTestnets, getToken, getTokensByChain, getTokensBySymbol, getTxHash, getUSDCTokens, getUSDTTokens, getWBTCTokens, getWETHTokens, isAddress2 as isAddress, isCAIP2ChainId, isCAIPAssetId, isCustomToken, isExactEvmPayload, isPaymentPayload, isPaymentPayloadV2, isPaymentRequiredV2, isPaymentV2, isResolvedNetwork, isResolvedToken, isSettlementSuccessful, isSettlementV2, isValidAddress, isValidationError, isX402V2Payload, isX402V2PaymentRequired, isX402V2Requirements, isX402V2Settlement, matchRoute, networkToCaip2, normalizeAddress, normalizeBase64Url, normalizeNetworkName, parseJsonOrBase64, parseRoutePattern, parseSignature as parseSignatureV2, registerToken, resolveFacilitator, resolveFacilitatorUrlFromRequirement, resolveNetwork, resolveToken, runAfterPaymentResponseHooks, runBeforeSignPaymentHooks, runOnPaymentRequiredHooks, safeBase64Decode2 as safeBase64Decode, safeBase64Encode2 as safeBase64Encode, selectRequirementWithHooks, settlePayment, toAtomicUnits, toBase64Url, unregisterToken, validateAcceptConfig, validatePaymentConfig, validateRouteConfig, validateTransferWithAuthorization, verifyPayment };