@armory-sh/base 0.2.13 → 0.2.16

package/dist/index.js

@@ -104,6 +104,52 @@ function legacyToPaymentPayload(legacy) {
   };
 }
 
+// src/types/v2.ts
+var V2_HEADERS = {
+  PAYMENT_SIGNATURE: "PAYMENT-SIGNATURE",
+  PAYMENT_REQUIRED: "PAYMENT-REQUIRED",
+  PAYMENT_RESPONSE: "PAYMENT-RESPONSE"
+};
+function isCAIP2ChainId(value) {
+  return /^eip155:\d+$/.test(value);
+}
+function isCAIPAssetId(value) {
+  return /^eip155:\d+\/erc20:0x[a-fA-F0-9]+$/.test(value);
+}
+function isAddress(value) {
+  return /^0x[a-fA-F0-9]{40}$/.test(value);
+}
+function isPaymentRequiredV2(obj) {
+  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 2 && "resource" in obj && "accepts" in obj && Array.isArray(obj.accepts);
+}
+function isPaymentPayloadV2(obj) {
+  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 2 && "scheme" in obj && "network" in obj && "payload" in obj;
+}
+function assetIdToAddress(assetId) {
+  const match = assetId.match(/\/erc20:(0x[a-fA-F0-9]{40})$/);
+  if (!match) throw new Error(`Invalid CAIP asset ID: ${assetId}`);
+  return match[1];
+}
+function addressToAssetId(address, chainId) {
+  const chain = typeof chainId === "number" ? `eip155:${chainId}` : chainId;
+  if (!isCAIP2ChainId(chain)) throw new Error(`Invalid chain ID: ${chain}`);
+  return `${chain}/erc20:${address}`;
+}
+function parseSignature(signature) {
+  const sig = signature.slice(2);
+  return {
+    r: `0x${sig.slice(0, 64)}`,
+    s: `0x${sig.slice(64, 128)}`,
+    v: parseInt(sig.slice(128, 130), 16)
+  };
+}
+function combineSignature(v, r, s) {
+  const rClean = r.startsWith("0x") ? r.slice(2) : r;
+  const sClean = s.startsWith("0x") ? s.slice(2) : s;
+  const vHex = v.toString(16).padStart(2, "0");
+  return `0x${rClean}${sClean}${vHex}`;
+}
+
 // src/encoding/x402.ts
 function safeBase64Encode(str) {
   return Buffer.from(str).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
@@ -159,34 +205,14 @@ function decodeX402Response(encoded) {
   const decoded = safeBase64Decode(encoded);
   return JSON.parse(decoded);
 }
-var X402_HEADERS = {
-  PAYMENT: "X-PAYMENT",
-  PAYMENT_RESPONSE: "X-PAYMENT-RESPONSE",
-  PAYMENT_REQUIRED: "X-PAYMENT-REQUIRED"
-};
 function detectPaymentVersion(headers) {
   if (headers.has("PAYMENT-SIGNATURE")) {
     return 2;
   }
-  if (headers.has(X402_HEADERS.PAYMENT)) {
-    const encoded = headers.get(X402_HEADERS.PAYMENT);
-    if (encoded) {
-      try {
-        const decoded = decodePayment(encoded);
-        if (isPaymentPayload(decoded) && "x402Version" in decoded) {
-          return decoded.x402Version;
-        }
-        return 1;
-      } catch {
-        return 1;
-      }
-    }
-    return 1;
-  }
   return null;
 }
 function extractPaymentFromHeaders(headers) {
-  const encoded = headers.get(X402_HEADERS.PAYMENT);
+  const encoded = headers.get("PAYMENT-SIGNATURE");
   if (!encoded) return null;
   try {
     return decodePayment(encoded);
@@ -197,21 +223,18 @@ function extractPaymentFromHeaders(headers) {
 function createPaymentRequiredHeaders(requirements) {
   const accepts = Array.isArray(requirements) ? requirements : [requirements];
   const response = {
-    x402Version: 1,
+    x402Version: 2,
     accepts
   };
   return {
-    [X402_HEADERS.PAYMENT_REQUIRED]: safeBase64Encode(JSON.stringify(response))
+    [V2_HEADERS.PAYMENT_REQUIRED]: safeBase64Encode(JSON.stringify(response))
   };
 }
 function createSettlementHeaders(settlement) {
   return {
-    [X402_HEADERS.PAYMENT_RESPONSE]: encodeSettlementResponse(settlement)
+    [V2_HEADERS.PAYMENT_RESPONSE]: encodeSettlementResponse(settlement)
   };
 }
-function isLegacyV1(payload) {
-  return typeof payload === "object" && payload !== null && "v" in payload && typeof payload.v === "number";
-}
 function isLegacyV2(payload) {
   return typeof payload === "object" && payload !== null && "signature" in payload && typeof payload.signature === "object";
 }
@@ -289,107 +312,9 @@ function normalizeAddress(address) {
   return address.toLowerCase();
 }
 
-// src/types/v1.ts
-var V1_HEADERS = {
-  PAYMENT: "X-PAYMENT",
-  PAYMENT_RESPONSE: "X-PAYMENT-RESPONSE",
-  PAYMENT_REQUIRED: "X-PAYMENT-REQUIRED"
-};
-function encodeX402PaymentRequiredV1(data) {
-  return Buffer.from(JSON.stringify(data)).toString("base64");
-}
-function decodeX402PaymentRequiredV1(encoded) {
-  return JSON.parse(Buffer.from(encoded, "base64").toString("utf-8"));
-}
-function encodeX402PaymentPayloadV1(data) {
-  return Buffer.from(JSON.stringify(data)).toString("base64");
-}
-function decodeX402PaymentPayloadV1(encoded) {
-  return JSON.parse(Buffer.from(encoded, "base64").toString("utf-8"));
-}
-function encodeX402SettlementResponseV1(data) {
-  return Buffer.from(JSON.stringify(data)).toString("base64");
-}
-function decodeX402SettlementResponseV1(encoded) {
-  return JSON.parse(Buffer.from(encoded, "base64").toString("utf-8"));
-}
-function encodePaymentPayloadLegacy(payload) {
-  return Buffer.from(JSON.stringify(payload)).toString("base64");
-}
-function decodePaymentPayloadLegacy(encoded) {
-  return JSON.parse(Buffer.from(encoded, "base64").toString("utf-8"));
-}
-function encodeSettlementResponseLegacy(response) {
-  return Buffer.from(JSON.stringify(response)).toString("base64");
-}
-function decodeSettlementResponseLegacy(encoded) {
-  return JSON.parse(Buffer.from(encoded, "base64").toString("utf-8"));
-}
-function isX402PaymentRequiredV1(obj) {
-  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 1 && "accepts" in obj && Array.isArray(obj.accepts);
-}
-function isX402PaymentPayloadV1(obj) {
-  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 1 && "scheme" in obj && "network" in obj && "payload" in obj;
-}
-function isLegacyPaymentPayloadV1(obj) {
-  return typeof obj === "object" && obj !== null && "v" in obj && "r" in obj && "s" in obj && "chainId" in obj && "contractAddress" in obj;
-}
-
-// src/types/v2.ts
-var V2_HEADERS = {
-  PAYMENT_SIGNATURE: "PAYMENT-SIGNATURE",
-  PAYMENT_REQUIRED: "PAYMENT-REQUIRED",
-  PAYMENT_RESPONSE: "PAYMENT-RESPONSE"
-};
-function isCAIP2ChainId(value) {
-  return /^eip155:\d+$/.test(value);
-}
-function isCAIPAssetId(value) {
-  return /^eip155:\d+\/erc20:0x[a-fA-F0-9]+$/.test(value);
-}
-function isAddress(value) {
-  return /^0x[a-fA-F0-9]{40}$/.test(value);
-}
-function isPaymentRequiredV2(obj) {
-  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 2 && "resource" in obj && "accepts" in obj && Array.isArray(obj.accepts);
-}
-function isPaymentPayloadV2(obj) {
-  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 2 && "scheme" in obj && "network" in obj && "payload" in obj;
-}
-function assetIdToAddress(assetId) {
-  const match = assetId.match(/\/erc20:(0x[a-fA-F0-9]{40})$/);
-  if (!match) throw new Error(`Invalid CAIP asset ID: ${assetId}`);
-  return match[1];
-}
-function addressToAssetId(address, chainId) {
-  const chain = typeof chainId === "number" ? `eip155:${chainId}` : chainId;
-  if (!isCAIP2ChainId(chain)) throw new Error(`Invalid chain ID: ${chain}`);
-  return `${chain}/erc20:${address}`;
-}
-function parseSignature(signature) {
-  const sig = signature.slice(2);
-  return {
-    r: `0x${sig.slice(0, 64)}`,
-    s: `0x${sig.slice(64, 128)}`,
-    v: parseInt(sig.slice(128, 130), 16)
-  };
-}
-function combineSignature(v, r, s) {
-  const rClean = r.startsWith("0x") ? r.slice(2) : r;
-  const sClean = s.startsWith("0x") ? s.slice(2) : s;
-  const vHex = v.toString(16).padStart(2, "0");
-  return `0x${rClean}${sClean}${vHex}`;
-}
-
 // src/types/protocol.ts
-function isX402V1Payload(obj) {
-  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 1 && "scheme" in obj && "network" in obj && "payload" in obj;
-}
 function isX402V2Payload(obj) {
-  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 2 && "scheme" in obj && "network" in obj && "payload" in obj;
-}
-function isLegacyV1Payload(obj) {
-  return typeof obj === "object" && obj !== null && "v" in obj && "r" in obj && "s" in obj && "chainId" in obj && "contractAddress" in obj && !("x402Version" in obj);
+  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 2 && "signature" in obj && "chainId" in obj && "assetId" in obj;
 }
 function isLegacyV2Payload(obj) {
   if (typeof obj !== "object" || obj === null) return false;
@@ -397,85 +322,380 @@ function isLegacyV2Payload(obj) {
   const signature = record.signature;
   return "signature" in record && typeof signature === "object" && signature !== null && "v" in signature && "chainId" in record && typeof record.chainId === "string" && record.chainId.startsWith("eip155:") && "assetId" in record && !("x402Version" in record);
 }
-function getPaymentVersion(payload) {
-  if (isX402V1Payload(payload)) return 1;
-  if (isX402V2Payload(payload)) return 2;
-  return 1;
-}
-function isX402V1Requirements(obj) {
-  return typeof obj === "object" && obj !== null && "scheme" in obj && "network" in obj && typeof obj.network === "string" && !obj.network.includes(":") && // Not CAIP-2 format
-  "maxAmountRequired" in obj;
-}
 function isX402V2Requirements(obj) {
-  return typeof obj === "object" && obj !== null && "scheme" in obj && "network" in obj && typeof obj.network === "string" && obj.network.startsWith("eip155:") && // CAIP-2 format
-  "amount" in obj;
-}
-function getRequirementsVersion(requirements) {
-  if (isX402V1Requirements(requirements)) return 1;
-  if (isX402V2Requirements(requirements)) return 2;
-  return 1;
-}
-function isX402V1Settlement(obj) {
-  return typeof obj === "object" && obj !== null && "success" in obj && "network" in obj && typeof obj.network === "string" && !obj.network.includes(":");
+  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 && "network" in obj && typeof obj.network === "string" && obj.network.startsWith("eip155:");
-}
-function getSettlementVersion(response) {
-  if (isX402V1Settlement(response)) return 1;
-  if (isX402V2Settlement(response)) return 2;
-  return 1;
-}
-function isX402V1PaymentRequired(obj) {
-  return typeof obj === "object" && obj !== null && "x402Version" in obj && obj.x402Version === 1 && "accepts" in 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;
 }
-function getPaymentRequiredVersion(obj) {
-  if (isX402V1PaymentRequired(obj)) return 1;
-  if (isX402V2PaymentRequired(obj)) return 2;
-  return 1;
-}
-function getPaymentHeaderName(version) {
-  return version === 1 ? "X-PAYMENT" : "PAYMENT-SIGNATURE";
-}
-function getPaymentResponseHeaderName(version) {
-  return version === 1 ? "X-PAYMENT-RESPONSE" : "PAYMENT-RESPONSE";
-}
-function getPaymentRequiredHeaderName(version) {
-  return version === 1 ? "X-PAYMENT-REQUIRED" : "PAYMENT-REQUIRED";
-}
+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;
-  if ("txHash" in response) return response.txHash;
   return void 0;
 }
-function isV1(obj) {
-  return isX402V1Payload(obj) || isLegacyV1Payload(obj);
+
+// 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: "0x036CbD53842c5426634e7929541eA237834d2D14",
+    rpcUrl: "https://sepolia.base.org",
+    caip2Id: "eip155:84532",
+    caipAssetId: "eip155:84532/erc20:0x036CbD53842c5426634e7929541eA237834d2D14"
+  },
+  "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
+  };
+  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));
+
+// src/data/tokens.ts
+var USDC_BASE = {
+  symbol: "USDC",
+  name: "USD Coin",
+  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: "USD Coin",
+  version: "2",
+  contractAddress: "0x036CbD5d9A3b9231f83BefBE4F9E3FAA03eee2e0",
+  chainId: 84532,
+  decimals: 6
+};
+var USDC_SKALE_BASE = {
+  symbol: "USDC",
+  name: "USD Coin",
+  version: "2",
+  contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  chainId: 1187947933,
+  decimals: 6
+};
+var SKL_SKALE_BASE = {
+  symbol: "SKL",
+  name: "SKALE",
+  version: "1",
+  contractAddress: "0xaf2e1eb5c9f4a94dbf7400f76e4ec0d8de18fb8584",
+  chainId: 1187947933,
+  decimals: 18
+};
+var USDT_SKALE_BASE = {
+  symbol: "USDT",
+  name: "Tether USD",
+  version: "1",
+  contractAddress: "0x2bF5bF154b4881Ef4E3Ff28Ac1a60Fa1aDcb5fE5F6",
+  chainId: 1187947933,
+  decimals: 6
+};
+var WBTC_SKALE_BASE = {
+  symbol: "WBTC",
+  name: "Wrapped BTC",
+  version: "1",
+  contractAddress: "0x1aee79F6316aD699F96468A32F7BaF2fD8d55c0000",
+  chainId: 1187947933,
+  decimals: 8
+};
+var WETH_SKALE_BASE = {
+  symbol: "WETH",
+  name: "Wrapped Ether",
+  version: "1",
+  contractAddress: "0x8fF2237e4d845bc7Db6E1f1a93C8bCb288Bc5a400",
+  chainId: 1187947933,
+  decimals: 18
+};
+var SKL_SKALE_BASE_SEPOLIA = {
+  symbol: "SKL",
+  name: "SKALE",
+  version: "1",
+  contractAddress: "0xaf2e1eb5c9f4a94dbf7400f76e4ec0d8de18fb8584",
+  chainId: 324705682,
+  decimals: 18
+};
+var USDC_SKALE_BASE_SEPOLIA = {
+  symbol: "USDC",
+  name: "USD Coin",
+  version: "2",
+  contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  chainId: 324705682,
+  decimals: 6
+};
+var USDT_SKALE_BASE_SEPOLIA = {
+  symbol: "USDT",
+  name: "Tether USD",
+  version: "1",
+  contractAddress: "0xe8af39ca6558a983f6b5f8c0b828cc609f7a1c200",
+  chainId: 324705682,
+  decimals: 6
+};
+var WBTC_SKALE_BASE_SEPOLIA = {
+  symbol: "WBTC",
+  name: "Wrapped BTC",
+  version: "1",
+  contractAddress: "0x1aee79F6316aD699F96468A32F7BaF2fD8d55c0000",
+  chainId: 324705682,
+  decimals: 8
+};
+var WETH_SKALE_BASE_SEPOLIA = {
+  symbol: "WETH",
+  name: "Wrapped Ether",
+  version: "1",
+  contractAddress: "0x8fF2237e4d845bc7Db6E1f1a93C8bCb288Bc5a400",
+  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 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 isV2(obj) {
-  return isX402V2Payload(obj) || isLegacyV2Payload(obj);
+function getSKLTokens() {
+  return getTokensBySymbol("SKL");
 }
+function getUSDTTokens() {
+  return getTokensBySymbol("USDT");
+}
+function getWBTCTokens() {
+  return getTokensBySymbol("WBTC");
+}
+function getWETHTokens() {
+  return getTokensBySymbol("WETH");
+}
+
+// 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/types/networks.ts
-import { type as arkType2 } from "arktype";
+// 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: "uint256" }
+  ]
+};
+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: BigInt(params.nonce)
+});
+var isAddress2 = (value) => /^0x[a-fA-F0-9]{40}$/.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})`);
+  }
+  if (message.nonce < 0n) throw new Error(`"nonce" must be non-negative: ${message.nonce}`);
+  return true;
+};
 
 // src/validation.ts
-import { type as arkType } from "arktype";
-var CustomTokenSchema = arkType({
-  symbol: "string",
-  name: "string",
-  version: "string",
-  contractAddress: "/^0x[a-fA-F0-9]{40}$/",
-  chainId: "number.integer > 0",
-  decimals: "number.integer >= 0?"
-});
-var NetworkIdSchema = arkType("string | number | object");
-var TokenIdSchema = arkType("string | number | object");
+var isEvmAddress2 = (value) => /^0x[a-fA-F0-9]{40}$/.test(value);
 var createError = (code, message, details) => ({
   code,
   message,
@@ -483,14 +703,6 @@ var createError = (code, message, details) => ({
 });
 var normalizeNetworkName = (name) => name.toLowerCase().replace(/\s+/g, "-").replace("-mainnet", "").replace(/-mainnet/, "").replace("mainnet-", "").replace(/-sepolia$/, "-sepolia").replace(/^-|-$/g, "");
 var resolveNetwork = (input) => {
-  const inputCheck = NetworkIdSchema(input);
-  if (inputCheck instanceof arkType.errors) {
-    return createError(
-      "VALIDATION_FAILED",
-      "Invalid network input type",
-      { value: input, validOptions: ["string (name/CAIP-2)", "number (chainId)", "NetworkConfig"] }
-    );
-  }
   if (typeof input === "object" && input !== null && "chainId" in input) {
     const config = input;
     if (!config.chainId || !config.usdcAddress || !config.caip2Id) {
@@ -555,16 +767,7 @@ var resolveNetwork = (input) => {
 };
 var getAvailableNetworks = () => Object.keys(NETWORKS);
 var normalizeTokenSymbol = (symbol) => symbol.toUpperCase();
-var isEvmAddress = (value) => /^0x[a-fA-F0-9]{40}$/.test(value);
 var resolveToken = (input, network) => {
-  const inputCheck = TokenIdSchema(input);
-  if (inputCheck instanceof arkType.errors) {
-    return createError(
-      "VALIDATION_FAILED",
-      "Invalid token input type",
-      { value: input, validOptions: ["string (symbol/address/CAIP Asset)", "number (deprecated)", "CustomToken"] }
-    );
-  }
   if (typeof input === "object" && input !== null && "contractAddress" in input) {
     const config = input;
     if (!config.chainId || !config.contractAddress || !config.symbol) {
@@ -590,7 +793,7 @@ var resolveToken = (input, network) => {
     };
   }
   if (typeof input === "string") {
-    if (isEvmAddress(input)) {
+    if (isEvmAddress2(input)) {
       const contractAddress = input;
       if (network) {
         const customToken = getCustomToken(network.config.chainId, contractAddress);
@@ -830,13 +1033,13 @@ var validatePaymentConfig = (network, token, facilitators, payTo = "0x0000000000
     network: resolvedNetwork,
     token: resolvedToken,
     facilitators: resolvedFacilitators,
-    version: "auto",
+    version: 2,
     payTo,
     amount
   };
 };
 var validateAcceptConfig = (options, payTo, amount) => {
-  const { networks: networkInputs, tokens: tokenInputs, facilitators, version = "auto" } = 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 = [];
@@ -906,224 +1109,135 @@ var isResolvedToken = (value) => {
   return typeof value === "object" && value !== null && "config" in value && "caipAsset" in value;
 };
 
-// src/types/networks.ts
-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: "0x036CbD53842c5426634e7929541eA237834d2D14",
-    rpcUrl: "https://sepolia.base.org",
-    caip2Id: "eip155:84532",
-    caipAssetId: "eip155:84532/erc20:0x036CbD53842c5426634e7929541eA237834d2D14"
-  },
-  "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) => {
-  const validated = CustomTokenSchema(token);
-  if (validated instanceof arkType2.errors) {
-    throw new Error(`Invalid token: ${validated.summary}`);
-  }
-  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));
-
-// 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/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: "uint256" }
-  ]
-};
-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: BigInt(params.nonce)
-});
-var isAddress2 = (value) => /^0x[a-fA-F0-9]{40}$/.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})`);
-  }
-  if (message.nonce < 0n) throw new Error(`"nonce" must be non-negative: ${message.nonce}`);
-  return true;
-};
-
 // src/encoding.ts
-var base64Encode = (data) => Buffer.from(JSON.stringify(data)).toString("base64");
-var base64Decode = (encoded) => JSON.parse(Buffer.from(encoded, "base64").toString("utf-8"));
 var jsonEncode = (data) => JSON.stringify(data);
 var jsonDecode = (encoded) => JSON.parse(encoded);
-var encodePaymentV1 = (payload) => base64Encode(payload);
-var decodePaymentV1 = (encoded) => base64Decode(encoded);
-var encodeSettlementV1 = (response) => base64Encode(response);
-var decodeSettlementV1 = (encoded) => base64Decode(encoded);
 var encodePaymentV2 = (payload) => jsonEncode(payload);
 var decodePaymentV2 = (encoded) => jsonDecode(encoded);
 var encodeSettlementV2 = (response) => jsonEncode(response);
 var decodeSettlementV2 = (encoded) => jsonDecode(encoded);
-var detectPaymentVersion2 = (headers) => {
-  if (headers.has(V1_HEADERS.PAYMENT)) return 1;
-  if (headers.has(V2_HEADERS.PAYMENT_SIGNATURE)) return 2;
-  return null;
-};
-var decodePayment2 = (headers) => {
-  const version = detectPaymentVersion2(headers);
-  if (version === null) {
-    throw new Error("No valid payment headers found. Expected X-PAYMENT (v1) or PAYMENT-SIGNATURE (v2)");
+var isPaymentV2 = (payload) => "signature" in payload && typeof payload.signature === "object";
+var isSettlementV2 = (response) => "status" in response;
+
+// src/fixtures/payloads.ts
+var TEST_PRIVATE_KEY = "0x0000000000000000000000000000000000000000000000000000000000000000001";
+var TEST_PAYER_ADDRESS = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1";
+var TEST_PAY_TO_ADDRESS = "0x1234567890123456789012345678901234567890";
+var TEST_CONTRACT_ADDRESS = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+var createV2Authorization = (nonce) => ({
+  from: TEST_PAYER_ADDRESS,
+  to: TEST_PAY_TO_ADDRESS,
+  value: "1000000",
+  validAfter: Math.floor(Date.now() / 1e3).toString(),
+  validBefore: (Math.floor(Date.now() / 1e3) + 3600).toString(),
+  nonce: `0x${Buffer.from(nonce).toString("hex").padStart(64, "0")}`
+});
+var createV2SchemePayload = (nonce) => ({
+  signature: `0x${"b".repeat(130)}`,
+  authorization: createV2Authorization(nonce)
+});
+var createX402V2Payload = (nonce) => ({
+  x402Version: 2,
+  scheme: "exact",
+  network: "eip155:84532",
+  payload: createV2SchemePayload(nonce ?? "test_v2_nonce"),
+  resource: {
+    url: "https://example.com/api/test",
+    description: "Test resource"
   }
-  const headerName = version === 1 ? V1_HEADERS.PAYMENT : V2_HEADERS.PAYMENT_SIGNATURE;
-  const encoded = headers.get(headerName);
-  if (!encoded) throw new Error(`Header ${headerName} is empty`);
-  return version === 1 ? decodePaymentV1(encoded) : decodePaymentV2(encoded);
+});
+var createLegacyV2Payload = (nonce) => ({
+  from: TEST_PAYER_ADDRESS,
+  to: TEST_PAY_TO_ADDRESS,
+  amount: "1000000",
+  nonce: nonce ?? "test_legacy_v2_nonce",
+  expiry: Math.floor(Date.now() / 1e3) + 3600,
+  signature: {
+    v: 27,
+    r: `0x${"f".repeat(64)}`,
+    s: `0x${"0".repeat(64)}`
+  },
+  chainId: "eip155:84532",
+  assetId: `eip155:84532/erc20:${TEST_CONTRACT_ADDRESS.slice(2)}`
+});
+var INVALID_PAYLOADS = {
+  missingFields: {},
+  invalidAddress: {
+    x402Version: 2,
+    scheme: "exact",
+    network: "eip155:84532",
+    payload: {
+      signature: `0x${"i".repeat(130)}`,
+      authorization: {
+        from: "not-an-address",
+        to: TEST_PAY_TO_ADDRESS,
+        value: "1000000",
+        validAfter: Math.floor(Date.now() / 1e3).toString(),
+        validBefore: (Math.floor(Date.now() / 1e3) + 3600).toString(),
+        nonce: `0x${"1".repeat(64)}`
+      }
+    }
+  },
+  expired: (() => {
+    const payload = createX402V2Payload("test_expired_nonce");
+    payload.payload.authorization.validBefore = (Math.floor(Date.now() / 1e3) - 100).toString();
+    return payload;
+  })(),
+  malformedSignature: (() => {
+    const payload = createX402V2Payload("test_malformed_sig_nonce");
+    payload.payload.signature = "not-hex";
+    return payload;
+  })()
 };
-var decodeSettlement = (headers) => {
-  const v1Response = headers.get(V1_HEADERS.PAYMENT_RESPONSE);
-  if (v1Response) return decodeSettlementV1(v1Response);
-  const v2Response = headers.get(V2_HEADERS.PAYMENT_RESPONSE);
-  if (v2Response) return decodeSettlementV2(v2Response);
-  throw new Error("No valid settlement response headers found. Expected X-PAYMENT-RESPONSE (v1) or PAYMENT-RESPONSE (v2)");
+
+// src/fixtures/config.ts
+var TEST_PRIVATE_KEY2 = process.env.TEST_PRIVATE_KEY || "0x0000000000000000000000000000000000000000000000000000000000000000000001";
+var TEST_PAY_TO_ADDRESS2 = "0x1234567890123456789012345678901234567890";
+var TEST_NETWORK = "base-sepolia";
+var TEST_AMOUNT_DECIMAL = "1.0";
+var FACILITATOR_URL = process.env.FACILITATOR_URL || "https://facilitator.payai.network";
+var TEST_RPC_URL = process.env.TEST_RPC_URL || "https://sepolia.base.org";
+var DEFAULT_PAYMENT_CONFIG = {
+  payTo: TEST_PAY_TO_ADDRESS2,
+  amount: TEST_AMOUNT_DECIMAL,
+  network: TEST_NETWORK,
+  defaultVersion: 2,
+  accept: {
+    networks: [TEST_NETWORK],
+    tokens: ["usdc"],
+    facilitators: [{ url: FACILITATOR_URL }]
+  }
 };
-var isPaymentV1 = (payload) => "v" in payload && typeof payload.v === "number";
-var isPaymentV2 = (payload) => "signature" in payload && typeof payload.signature === "object";
-var isSettlementV1 = (response) => "success" in response;
-var isSettlementV2 = (response) => "status" in response;
 export {
+  DEFAULT_PAYMENT_CONFIG,
   EIP712_TYPES,
   ERC20_ABI,
+  EURC_BASE,
+  INVALID_PAYLOADS,
   NETWORKS,
+  PAYMENT_REQUIRED_HEADER,
+  PAYMENT_RESPONSE_HEADER,
+  PAYMENT_SIGNATURE_HEADER,
   SCHEMES,
+  SKL_SKALE_BASE,
+  SKL_SKALE_BASE_SEPOLIA,
+  TEST_CONTRACT_ADDRESS,
+  TEST_PAYER_ADDRESS,
+  TEST_PAY_TO_ADDRESS,
+  TEST_PRIVATE_KEY,
+  TOKENS,
+  USDC_BASE,
+  USDC_BASE_SEPOLIA,
   USDC_DOMAIN,
-  V1_HEADERS,
+  USDC_SKALE_BASE,
+  USDC_SKALE_BASE_SEPOLIA,
+  USDT_SKALE_BASE,
+  USDT_SKALE_BASE_SEPOLIA,
   V2_HEADERS,
-  X402_HEADERS,
+  WBTC_SKALE_BASE,
+  WBTC_SKALE_BASE_SEPOLIA,
+  WETH_SKALE_BASE,
+  WETH_SKALE_BASE_SEPOLIA,
   X402_VERSION,
   addressToAssetId,
   assetIdToAddress,
@@ -1132,88 +1246,62 @@ export {
   combineSignature as combineSignatureV2,
   createEIP712Domain,
   createError,
+  createLegacyV2Payload,
   createNonce,
   createPaymentRequiredHeaders,
   createSettlementHeaders,
   createTransferWithAuthorization,
+  createX402V2Payload,
   decodePayment,
-  decodePayment2 as decodePaymentLegacy,
-  decodePaymentPayloadLegacy as decodePaymentPayload,
-  decodePaymentPayloadLegacy,
-  decodePaymentV1,
   decodePaymentV2,
-  decodeSettlement as decodeSettlementLegacy,
   decodeSettlementResponse,
-  decodeSettlementResponseLegacy,
-  decodeSettlementV1,
   decodeSettlementV2,
-  decodeX402PaymentPayloadV1,
-  decodeX402PaymentRequiredV1,
   decodeX402Response,
-  decodeX402SettlementResponseV1,
   detectPaymentVersion,
-  detectPaymentVersion2 as detectPaymentVersionLegacy,
   encodePayment,
-  encodePaymentPayloadLegacy as encodePaymentPayload,
-  encodePaymentPayloadLegacy,
-  encodePaymentV1,
   encodePaymentV2,
   encodeSettlementResponse,
-  encodeSettlementResponseLegacy,
-  encodeSettlementV1,
   encodeSettlementV2,
-  encodeX402PaymentPayloadV1,
-  encodeX402PaymentRequiredV1,
   encodeX402Response,
-  encodeX402SettlementResponseV1,
   extractPaymentFromHeaders,
   fromAtomicUnits,
   getAllCustomTokens,
+  getAllTokens,
   getAvailableNetworks,
   getAvailableTokens,
   getCurrentTimestamp,
   getCustomToken,
+  getEURCTokens,
   getMainnets,
   getNetworkByChainId,
   getNetworkConfig,
-  getPaymentHeaderName,
-  getPaymentRequiredHeaderName,
-  getPaymentRequiredVersion,
-  getPaymentResponseHeaderName,
-  getPaymentVersion,
-  getRequirementsVersion,
-  getSettlementVersion,
+  getSKLTokens,
   getTestnets,
+  getToken,
+  getTokensByChain,
+  getTokensBySymbol,
   getTxHash,
+  getUSDCTokens,
+  getUSDTTokens,
+  getWBTCTokens,
+  getWETHTokens,
   isAddress,
   isCAIP2ChainId,
   isCAIPAssetId,
   isCustomToken,
   isExactEvmPayload,
-  isLegacyPaymentPayloadV1,
-  isLegacyV1,
-  isLegacyV1Payload,
   isLegacyV2,
+  isLegacyV2Payload,
   isPaymentPayload,
   isPaymentPayloadV2,
   isPaymentRequiredV2,
-  isPaymentV1,
   isPaymentV2,
   isResolvedNetwork,
   isResolvedToken,
   isSettlementSuccessful,
-  isSettlementV1,
   isSettlementV2,
-  isV1,
-  isV2,
   isValidAddress,
   isValidationError,
-  isX402PaymentPayloadV1,
-  isX402PaymentRequiredV1,
-  isX402V1Payload,
-  isX402V1PaymentRequired,
-  isX402V1Requirements,
-  isX402V1Settlement,
   isX402V2Payload,
   isX402V2PaymentRequired,
   isX402V2Requirements,