@provable-games/ekubo-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1592 @@
+'use strict';
+
+// src/errors/index.ts
+var EkuboError = class _EkuboError extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "EkuboError";
+    Object.setPrototypeOf(this, _EkuboError.prototype);
+  }
+};
+var InsufficientLiquidityError = class _InsufficientLiquidityError extends EkuboError {
+  constructor(message = "Insufficient liquidity for swap") {
+    super(message, "INSUFFICIENT_LIQUIDITY");
+    this.name = "InsufficientLiquidityError";
+    Object.setPrototypeOf(this, _InsufficientLiquidityError.prototype);
+  }
+};
+var ApiError = class _ApiError extends EkuboError {
+  constructor(message, statusCode, cause) {
+    super(message, "API_ERROR", cause);
+    this.statusCode = statusCode;
+    this.name = "ApiError";
+    Object.setPrototypeOf(this, _ApiError.prototype);
+  }
+};
+var RateLimitError = class _RateLimitError extends EkuboError {
+  constructor(message = "Rate limited by API", retryAfter) {
+    super(message, "RATE_LIMIT");
+    this.retryAfter = retryAfter;
+    this.name = "RateLimitError";
+    Object.setPrototypeOf(this, _RateLimitError.prototype);
+  }
+};
+var TimeoutError = class _TimeoutError extends EkuboError {
+  constructor(message = "Request timed out", timeout) {
+    super(message, "TIMEOUT");
+    this.timeout = timeout;
+    this.name = "TimeoutError";
+    Object.setPrototypeOf(this, _TimeoutError.prototype);
+  }
+};
+var AbortError = class _AbortError extends EkuboError {
+  constructor(message = "Request aborted") {
+    super(message, "ABORTED");
+    this.name = "AbortError";
+    Object.setPrototypeOf(this, _AbortError.prototype);
+  }
+};
+var TokenNotFoundError = class _TokenNotFoundError extends EkuboError {
+  constructor(tokenIdentifier, message = `Token not found: ${tokenIdentifier}`) {
+    super(message, "TOKEN_NOT_FOUND");
+    this.tokenIdentifier = tokenIdentifier;
+    this.name = "TokenNotFoundError";
+    Object.setPrototypeOf(this, _TokenNotFoundError.prototype);
+  }
+};
+var InvalidChainError = class _InvalidChainError extends EkuboError {
+  constructor(chainId, message = `Invalid or unsupported chain: ${chainId}`) {
+    super(message, "INVALID_CHAIN");
+    this.chainId = chainId;
+    this.name = "InvalidChainError";
+    Object.setPrototypeOf(this, _InvalidChainError.prototype);
+  }
+};
+function isNonRetryableError(error) {
+  if (error instanceof InsufficientLiquidityError) return true;
+  if (error instanceof AbortError) return true;
+  if (error instanceof TokenNotFoundError) return true;
+  if (error instanceof InvalidChainError) return true;
+  return false;
+}
+
+// src/utils/retry.ts
+var DEFAULT_FETCH_CONFIG = {
+  timeout: 1e4,
+  maxRetries: 3,
+  baseBackoff: 1e3,
+  maxBackoff: 5e3,
+  fetch: globalThis.fetch
+};
+function parseRetryAfter(retryAfter) {
+  if (!retryAfter) return null;
+  const trimmed = retryAfter.trim();
+  if (!trimmed) return null;
+  const seconds = parseInt(trimmed, 10);
+  if (!isNaN(seconds) && seconds >= 0) {
+    return seconds * 1e3;
+  }
+  try {
+    const date = new Date(trimmed);
+    const delay = date.getTime() - Date.now();
+    return delay > 0 ? delay : null;
+  } catch {
+    return null;
+  }
+}
+function calculateBackoff(attempt, baseBackoff, maxBackoff, retryAfter) {
+  if (retryAfter) {
+    const retryAfterDelay = parseRetryAfter(retryAfter);
+    if (retryAfterDelay !== null && retryAfterDelay > 0) {
+      return retryAfterDelay;
+    }
+  }
+  let delay = baseBackoff * Math.pow(2, attempt);
+  if (delay > maxBackoff) {
+    delay = maxBackoff;
+  }
+  const minDelay = delay / 2;
+  const jitter = Math.random() * (delay - minDelay);
+  return minDelay + jitter;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(fn, options) {
+  const { maxRetries, baseBackoff, maxBackoff, signal, onRetry } = options;
+  let lastError = null;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    if (signal?.aborted) {
+      throw new Error("Request aborted");
+    }
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (error instanceof Error && error.name === "AbortError") {
+        throw error;
+      }
+      if (isNonRetryableError(error)) {
+        throw error;
+      }
+      if (attempt === maxRetries - 1) {
+        break;
+      }
+      const delay = calculateBackoff(attempt, baseBackoff, maxBackoff);
+      onRetry?.(attempt, lastError, delay);
+      await sleep(delay);
+    }
+  }
+  throw lastError || new Error("Unknown error after retries");
+}
+
+// src/utils/bigint.ts
+function parseTotalCalculated(totalCalculated) {
+  let value;
+  if (typeof totalCalculated === "string") {
+    value = BigInt(totalCalculated);
+  } else {
+    value = BigInt(Math.floor(totalCalculated));
+  }
+  return value < 0n ? -value : value;
+}
+function abs(value) {
+  return value < 0n ? -value : value;
+}
+function addSlippage(amount, slippagePercent) {
+  return amount + amount * slippagePercent / 100n;
+}
+function subtractSlippage(amount, slippagePercent) {
+  return amount - amount * slippagePercent / 100n;
+}
+
+// src/utils/hex.ts
+function toHex(value) {
+  if (typeof value === "string") {
+    if (value.startsWith("0x") || value.startsWith("0X")) {
+      return "0x" + BigInt(value).toString(16);
+    }
+    return "0x" + BigInt(value).toString(16);
+  }
+  return "0x" + BigInt(value).toString(16);
+}
+function normalizeAddress(address) {
+  const normalized = toHex(address);
+  return normalized.toLowerCase();
+}
+function isAddress(value) {
+  return /^0x[0-9a-fA-F]+$/.test(value);
+}
+function splitU256(value) {
+  const low = value % 2n ** 128n;
+  const high = value >> 128n;
+  return {
+    low: toHex(low),
+    high: toHex(high)
+  };
+}
+
+// src/chains/constants.ts
+var CHAIN_IDS = {
+  MAINNET: "23448594291968334",
+  SEPOLIA: "393402133025997798000961"
+};
+var STARKNET_CHAIN_IDS = {
+  SN_MAIN: "0x534e5f4d41494e",
+  SN_SEPOLIA: "0x534e5f5345504f4c4941"
+};
+var ROUTER_ADDRESSES = {
+  [CHAIN_IDS.MAINNET]: "0x0199741822c2dc722f6f605204f35e56dbc23bceed54818168c4c49e4fb8737e",
+  [CHAIN_IDS.SEPOLIA]: "0x0045f933adf0607292468ad1c1dedaa74d5ad166392590e72676a34d01d7b763"
+};
+var USDC_ADDRESSES = {
+  [CHAIN_IDS.MAINNET]: "0x033068F6539f8e6e6b131e6B2B814e6c34A5224bC66947c47DaB9dFeE93b35fb",
+  [CHAIN_IDS.SEPOLIA]: "0x053b40a647cedfca6ca84f542a0fe36736031905a9639a7f19a3c1e66bfd5080"
+};
+var API_URLS = {
+  /** Quoter API for swap quotes */
+  QUOTER: "https://prod-api-quoter.ekubo.org",
+  /** Main API for tokens, prices, stats, etc. */
+  API: "https://prod-api.ekubo.org"
+};
+var CHAIN_CONFIGS = {
+  mainnet: {
+    chainId: CHAIN_IDS.MAINNET,
+    quoterApiUrl: API_URLS.QUOTER,
+    apiUrl: API_URLS.API,
+    routerAddress: ROUTER_ADDRESSES[CHAIN_IDS.MAINNET],
+    usdcAddress: USDC_ADDRESSES[CHAIN_IDS.MAINNET]
+  },
+  sepolia: {
+    chainId: CHAIN_IDS.SEPOLIA,
+    quoterApiUrl: API_URLS.QUOTER,
+    apiUrl: API_URLS.API,
+    routerAddress: ROUTER_ADDRESSES[CHAIN_IDS.SEPOLIA],
+    usdcAddress: USDC_ADDRESSES[CHAIN_IDS.SEPOLIA]
+  }
+};
+var STARKNET_TO_EKUBO_CHAIN = {
+  [STARKNET_CHAIN_IDS.SN_MAIN]: CHAIN_IDS.MAINNET,
+  [STARKNET_CHAIN_IDS.SN_SEPOLIA]: CHAIN_IDS.SEPOLIA
+};
+function getEkuboChainId(starknetChainId) {
+  return STARKNET_TO_EKUBO_CHAIN[starknetChainId];
+}
+function getChainConfig(chainOrId) {
+  if (chainOrId === "mainnet" || chainOrId === "sepolia") {
+    return CHAIN_CONFIGS[chainOrId];
+  }
+  if (chainOrId === CHAIN_IDS.MAINNET) {
+    return CHAIN_CONFIGS.mainnet;
+  }
+  if (chainOrId === CHAIN_IDS.SEPOLIA) {
+    return CHAIN_CONFIGS.sepolia;
+  }
+  const ekuboChainId = getEkuboChainId(chainOrId);
+  if (ekuboChainId === CHAIN_IDS.MAINNET) {
+    return CHAIN_CONFIGS.mainnet;
+  }
+  if (ekuboChainId === CHAIN_IDS.SEPOLIA) {
+    return CHAIN_CONFIGS.sepolia;
+  }
+  return void 0;
+}
+
+// src/api/quote.ts
+async function fetchSwapQuote(params) {
+  const {
+    amount,
+    tokenFrom,
+    tokenTo,
+    chainId = CHAIN_IDS.MAINNET,
+    signal,
+    fetchConfig = {}
+  } = params;
+  const config = { ...DEFAULT_FETCH_CONFIG, ...fetchConfig };
+  const fetchFn = config.fetch;
+  const receivedAmount = `-${amount.toString()}`;
+  const normalizedTokenFrom = normalizeAddress(tokenFrom);
+  const normalizedTokenTo = normalizeAddress(tokenTo);
+  const url = `${API_URLS.QUOTER}/${chainId}/${receivedAmount}/${normalizedTokenFrom}/${normalizedTokenTo}`;
+  let lastError = null;
+  for (let attempt = 0; attempt < config.maxRetries; attempt++) {
+    if (signal?.aborted) {
+      throw new AbortError("Request aborted");
+    }
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), config.timeout);
+      const combinedSignal = signal ? anySignal([signal, controller.signal]) : controller.signal;
+      const response = await fetchFn(url, {
+        method: "GET",
+        signal: combinedSignal,
+        mode: "cors",
+        credentials: "omit"
+      });
+      clearTimeout(timeoutId);
+      if (response.ok) {
+        const data = await response.json();
+        if ("error" in data) {
+          if (data.error.includes("Insufficient liquidity")) {
+            throw new InsufficientLiquidityError(data.error);
+          }
+          throw new ApiError(data.error);
+        }
+        return {
+          impact: data.price_impact,
+          total: parseTotalCalculated(data.total_calculated),
+          splits: data.splits
+        };
+      }
+      if (response.status === 404) {
+        try {
+          const data = await response.json();
+          if (data.error?.includes("Insufficient liquidity")) {
+            throw new InsufficientLiquidityError(data.error);
+          }
+        } catch (e) {
+          if (e instanceof InsufficientLiquidityError) {
+            throw e;
+          }
+        }
+        throw new ApiError(`Failed to fetch swap quote: 404 Not Found`, 404);
+      }
+      if (response.status === 429) {
+        if (attempt === config.maxRetries - 1) {
+          throw new RateLimitError("Rate limited (429) - max retries exceeded");
+        }
+        const retryAfter = response.headers.get("Retry-After");
+        const delay = calculateBackoff(
+          attempt,
+          config.baseBackoff,
+          config.maxBackoff,
+          retryAfter
+        );
+        await sleep(delay);
+        continue;
+      }
+      throw new ApiError(
+        `Failed to fetch swap quote: ${response.status}`,
+        response.status
+      );
+    } catch (error) {
+      lastError = error;
+      if (error instanceof Error && (error.name === "AbortError" || error instanceof AbortError)) {
+        throw new AbortError("Request aborted");
+      }
+      if (error instanceof InsufficientLiquidityError) {
+        throw error;
+      }
+      if (attempt === config.maxRetries - 1) {
+        break;
+      }
+      const delay = calculateBackoff(
+        attempt,
+        config.baseBackoff,
+        config.maxBackoff
+      );
+      await sleep(delay);
+    }
+  }
+  throw lastError || new ApiError("Failed to fetch swap quote: unknown error");
+}
+async function fetchSwapQuoteInUsdc(params) {
+  const { chainId = CHAIN_IDS.MAINNET, ...rest } = params;
+  const usdcAddress = USDC_ADDRESSES[chainId] ?? USDC_ADDRESSES[CHAIN_IDS.MAINNET];
+  const quote = await fetchSwapQuote({
+    ...rest,
+    tokenTo: usdcAddress,
+    chainId
+  });
+  return quote.total;
+}
+function anySignal(signals) {
+  const controller = new AbortController();
+  for (const signal of signals) {
+    if (signal.aborted) {
+      controller.abort();
+      return controller.signal;
+    }
+    signal.addEventListener("abort", () => controller.abort(), { once: true });
+  }
+  return controller.signal;
+}
+
+// src/api/price.ts
+async function getPriceHistory(params) {
+  const {
+    token,
+    otherToken,
+    chainId = CHAIN_IDS.MAINNET,
+    interval = 7e3,
+    apiUrl = API_URLS.API,
+    fetchConfig = {}
+  } = params;
+  const config = { ...DEFAULT_FETCH_CONFIG, ...fetchConfig };
+  const fetchFn = config.fetch;
+  const normalizedToken = normalizeAddress(token);
+  const normalizedOtherToken = normalizeAddress(otherToken);
+  const url = `${apiUrl}/price/${chainId}/${normalizedToken}/${normalizedOtherToken}/history?interval=${interval}`;
+  try {
+    const response = await fetchFn(url, {
+      method: "GET",
+      mode: "cors",
+      credentials: "omit"
+    });
+    if (!response.ok) {
+      throw new ApiError(
+        `Failed to fetch price history: ${response.status}`,
+        response.status
+      );
+    }
+    const data = await response.json();
+    return {
+      data: data?.data || []
+    };
+  } catch (error) {
+    if (error instanceof ApiError) {
+      throw error;
+    }
+    throw new ApiError(
+      `Failed to fetch price history: ${error instanceof Error ? error.message : "unknown error"}`
+    );
+  }
+}
+
+// src/api/tokens.ts
+async function fetchTokens(params = {}) {
+  const {
+    chainId = CHAIN_IDS.MAINNET,
+    apiUrl = API_URLS.API,
+    fetchConfig = {}
+  } = params;
+  const config = { ...DEFAULT_FETCH_CONFIG, ...fetchConfig };
+  const fetchFn = config.fetch;
+  const url = `${apiUrl}/tokens?chainId=${chainId}`;
+  try {
+    const response = await fetchFn(url, {
+      method: "GET",
+      mode: "cors",
+      credentials: "omit"
+    });
+    if (!response.ok) {
+      throw new ApiError(
+        `Failed to fetch tokens: ${response.status}`,
+        response.status
+      );
+    }
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    if (error instanceof ApiError) {
+      throw error;
+    }
+    throw new ApiError(
+      `Failed to fetch tokens: ${error instanceof Error ? error.message : "unknown error"}`
+    );
+  }
+}
+async function fetchToken(params) {
+  const {
+    tokenAddress,
+    chainId = CHAIN_IDS.MAINNET,
+    apiUrl = API_URLS.API,
+    fetchConfig = {}
+  } = params;
+  const config = { ...DEFAULT_FETCH_CONFIG, ...fetchConfig };
+  const fetchFn = config.fetch;
+  const url = `${apiUrl}/tokens/${chainId}/${tokenAddress}`;
+  try {
+    const response = await fetchFn(url, {
+      method: "GET",
+      mode: "cors",
+      credentials: "omit"
+    });
+    if (response.status === 404) {
+      return null;
+    }
+    if (!response.ok) {
+      throw new ApiError(
+        `Failed to fetch token: ${response.status}`,
+        response.status
+      );
+    }
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    if (error instanceof ApiError) {
+      throw error;
+    }
+    throw new ApiError(
+      `Failed to fetch token: ${error instanceof Error ? error.message : "unknown error"}`
+    );
+  }
+}
+async function fetchTokensBatch(params) {
+  const {
+    tokenAddresses,
+    chainId = CHAIN_IDS.MAINNET,
+    apiUrl = API_URLS.API,
+    fetchConfig = {}
+  } = params;
+  if (tokenAddresses.length === 0) {
+    return [];
+  }
+  const config = { ...DEFAULT_FETCH_CONFIG, ...fetchConfig };
+  const fetchFn = config.fetch;
+  const addressParams = tokenAddresses.map((addr) => `addresses=${encodeURIComponent(addr)}`).join("&");
+  const url = `${apiUrl}/tokens/batch?chainId=${chainId}&${addressParams}`;
+  try {
+    const response = await fetchFn(url, {
+      method: "GET",
+      mode: "cors",
+      credentials: "omit"
+    });
+    if (!response.ok) {
+      throw new ApiError(
+        `Failed to fetch tokens batch: ${response.status}`,
+        response.status
+      );
+    }
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    if (error instanceof ApiError) {
+      throw error;
+    }
+    throw new ApiError(
+      `Failed to fetch tokens batch: ${error instanceof Error ? error.message : "unknown error"}`
+    );
+  }
+}
+
+// src/api/stats.ts
+async function fetchTopPairs(params = {}) {
+  const {
+    chainId = CHAIN_IDS.MAINNET,
+    apiUrl = API_URLS.API,
+    fetchConfig = {}
+  } = params;
+  const config = { ...DEFAULT_FETCH_CONFIG, ...fetchConfig };
+  const fetchFn = config.fetch;
+  const url = `${apiUrl}/overview/pairs?chainId=${chainId}`;
+  try {
+    const response = await fetchFn(url, {
+      method: "GET",
+      mode: "cors",
+      credentials: "omit"
+    });
+    if (!response.ok) {
+      throw new ApiError(
+        `Failed to fetch top pairs: ${response.status}`,
+        response.status
+      );
+    }
+    return await response.json();
+  } catch (error) {
+    if (error instanceof ApiError) throw error;
+    throw new ApiError(
+      `Failed to fetch top pairs: ${error instanceof Error ? error.message : "unknown error"}`
+    );
+  }
+}
+async function fetchTvl(params = {}) {
+  const {
+    chainId = CHAIN_IDS.MAINNET,
+    apiUrl = API_URLS.API,
+    fetchConfig = {}
+  } = params;
+  const config = { ...DEFAULT_FETCH_CONFIG, ...fetchConfig };
+  const fetchFn = config.fetch;
+  const url = `${apiUrl}/overview/tvl?chainId=${chainId}`;
+  try {
+    const response = await fetchFn(url, {
+      method: "GET",
+      mode: "cors",
+      credentials: "omit"
+    });
+    if (!response.ok) {
+      throw new ApiError(
+        `Failed to fetch TVL: ${response.status}`,
+        response.status
+      );
+    }
+    return await response.json();
+  } catch (error) {
+    if (error instanceof ApiError) throw error;
+    throw new ApiError(
+      `Failed to fetch TVL: ${error instanceof Error ? error.message : "unknown error"}`
+    );
+  }
+}
+async function fetchVolume(params = {}) {
+  const {
+    chainId = CHAIN_IDS.MAINNET,
+    apiUrl = API_URLS.API,
+    fetchConfig = {}
+  } = params;
+  const config = { ...DEFAULT_FETCH_CONFIG, ...fetchConfig };
+  const fetchFn = config.fetch;
+  const url = `${apiUrl}/overview/volume?chainId=${chainId}`;
+  try {
+    const response = await fetchFn(url, {
+      method: "GET",
+      mode: "cors",
+      credentials: "omit"
+    });
+    if (!response.ok) {
+      throw new ApiError(
+        `Failed to fetch volume: ${response.status}`,
+        response.status
+      );
+    }
+    return await response.json();
+  } catch (error) {
+    if (error instanceof ApiError) throw error;
+    throw new ApiError(
+      `Failed to fetch volume: ${error instanceof Error ? error.message : "unknown error"}`
+    );
+  }
+}
+async function fetchPairTvl(params) {
+  const {
+    tokenA,
+    tokenB,
+    chainId = CHAIN_IDS.MAINNET,
+    apiUrl = API_URLS.API,
+    fetchConfig = {}
+  } = params;
+  const config = { ...DEFAULT_FETCH_CONFIG, ...fetchConfig };
+  const fetchFn = config.fetch;
+  const normalizedA = normalizeAddress(tokenA);
+  const normalizedB = normalizeAddress(tokenB);
+  const url = `${apiUrl}/pair/${chainId}/${normalizedA}/${normalizedB}/tvl`;
+  try {
+    const response = await fetchFn(url, {
+      method: "GET",
+      mode: "cors",
+      credentials: "omit"
+    });
+    if (!response.ok) {
+      throw new ApiError(
+        `Failed to fetch pair TVL: ${response.status}`,
+        response.status
+      );
+    }
+    return await response.json();
+  } catch (error) {
+    if (error instanceof ApiError) throw error;
+    throw new ApiError(
+      `Failed to fetch pair TVL: ${error instanceof Error ? error.message : "unknown error"}`
+    );
+  }
+}
+async function fetchPairVolume(params) {
+  const {
+    tokenA,
+    tokenB,
+    chainId = CHAIN_IDS.MAINNET,
+    apiUrl = API_URLS.API,
+    fetchConfig = {}
+  } = params;
+  const config = { ...DEFAULT_FETCH_CONFIG, ...fetchConfig };
+  const fetchFn = config.fetch;
+  const normalizedA = normalizeAddress(tokenA);
+  const normalizedB = normalizeAddress(tokenB);
+  const url = `${apiUrl}/pair/${chainId}/${normalizedA}/${normalizedB}/volume`;
+  try {
+    const response = await fetchFn(url, {
+      method: "GET",
+      mode: "cors",
+      credentials: "omit"
+    });
+    if (!response.ok) {
+      throw new ApiError(
+        `Failed to fetch pair volume: ${response.status}`,
+        response.status
+      );
+    }
+    return await response.json();
+  } catch (error) {
+    if (error instanceof ApiError) throw error;
+    throw new ApiError(
+      `Failed to fetch pair volume: ${error instanceof Error ? error.message : "unknown error"}`
+    );
+  }
+}
+async function fetchPairPools(params) {
+  const {
+    tokenA,
+    tokenB,
+    chainId = CHAIN_IDS.MAINNET,
+    apiUrl = API_URLS.API,
+    fetchConfig = {}
+  } = params;
+  const config = { ...DEFAULT_FETCH_CONFIG, ...fetchConfig };
+  const fetchFn = config.fetch;
+  const normalizedA = normalizeAddress(tokenA);
+  const normalizedB = normalizeAddress(tokenB);
+  const url = `${apiUrl}/pair/${chainId}/${normalizedA}/${normalizedB}/pools`;
+  try {
+    const response = await fetchFn(url, {
+      method: "GET",
+      mode: "cors",
+      credentials: "omit"
+    });
+    if (!response.ok) {
+      throw new ApiError(
+        `Failed to fetch pair pools: ${response.status}`,
+        response.status
+      );
+    }
+    return await response.json();
+  } catch (error) {
+    if (error instanceof ApiError) throw error;
+    throw new ApiError(
+      `Failed to fetch pair pools: ${error instanceof Error ? error.message : "unknown error"}`
+    );
+  }
+}
+
+// src/calls/encoder.ts
+function encodeRouteNode(routeNode, currentToken) {
+  const isToken1 = BigInt(currentToken) === BigInt(routeNode.pool_key.token1);
+  const nextToken = isToken1 ? routeNode.pool_key.token0 : routeNode.pool_key.token1;
+  const sqrtRatioLimit = BigInt(routeNode.sqrt_ratio_limit);
+  const calldata = [
+    routeNode.pool_key.token0,
+    routeNode.pool_key.token1,
+    routeNode.pool_key.fee,
+    toHex(routeNode.pool_key.tick_spacing),
+    routeNode.pool_key.extension,
+    toHex(sqrtRatioLimit % 2n ** 128n),
+    // low
+    toHex(sqrtRatioLimit >> 128n),
+    // high
+    toHex(routeNode.skip_ahead)
+  ];
+  return { nextToken, calldata };
+}
+function encodeRoute(route, targetToken) {
+  return route.reduce(
+    (memo, routeNode) => {
+      const { nextToken, calldata } = encodeRouteNode(routeNode, memo.token);
+      return {
+        token: nextToken,
+        encoded: memo.encoded.concat(calldata)
+      };
+    },
+    {
+      token: targetToken,
+      encoded: []
+    }
+  );
+}
+
+// src/calls/generator.ts
+var DEFAULT_SLIPPAGE_PERCENT = 5n;
+function generateSwapCalls(params) {
+  const {
+    sellToken,
+    buyToken,
+    minimumReceived,
+    quote,
+    chainId = CHAIN_IDS.MAINNET,
+    routerAddress: customRouterAddress,
+    slippagePercent = DEFAULT_SLIPPAGE_PERCENT
+  } = params;
+  const routerAddress = customRouterAddress ?? ROUTER_ADDRESSES[chainId];
+  if (!routerAddress) {
+    throw new InvalidChainError(
+      chainId,
+      `Router address not found for chain ID: ${chainId}`
+    );
+  }
+  const normalizedSellToken = normalizeAddress(sellToken);
+  const normalizedBuyToken = normalizeAddress(buyToken);
+  const totalWithSlippage = addSlippage(quote.total, slippagePercent);
+  const transferCall = {
+    contractAddress: normalizedSellToken,
+    entrypoint: "transfer",
+    calldata: [routerAddress, toHex(totalWithSlippage), "0x0"]
+  };
+  const clearCall = {
+    contractAddress: routerAddress,
+    entrypoint: "clear",
+    calldata: [normalizedSellToken]
+  };
+  if (!quote || quote.splits.length === 0) {
+    return {
+      transferCall,
+      swapCalls: [],
+      clearCall,
+      allCalls: [transferCall, clearCall]
+    };
+  }
+  const { splits } = quote;
+  const clearMinimumCall = {
+    contractAddress: routerAddress,
+    entrypoint: "clear_minimum",
+    calldata: [normalizedBuyToken, toHex(minimumReceived), "0x0"]
+  };
+  let swapCalls;
+  if (splits.length === 1) {
+    swapCalls = generateSingleRouteSwap(
+      splits[0],
+      normalizedBuyToken,
+      routerAddress
+    );
+  } else {
+    swapCalls = generateMultiRouteSwap(
+      splits,
+      normalizedBuyToken,
+      routerAddress
+    );
+  }
+  swapCalls.push(clearMinimumCall);
+  return {
+    transferCall,
+    swapCalls,
+    clearCall,
+    allCalls: [transferCall, ...swapCalls, clearCall]
+  };
+}
+function generateSingleRouteSwap(split, targetToken, routerAddress) {
+  const routeCalldata = encodeRoute(split.route, targetToken);
+  const amountSpecified = BigInt(split.amount_specified);
+  const absAmount = abs(amountSpecified);
+  return [
+    {
+      contractAddress: routerAddress,
+      entrypoint: "multihop_swap",
+      calldata: [
+        toHex(split.route.length),
+        ...routeCalldata.encoded,
+        targetToken,
+        toHex(absAmount),
+        "0x1"
+        // is_exact_amount_received flag
+      ]
+    }
+  ];
+}
+function generateMultiRouteSwap(splits, targetToken, routerAddress) {
+  const multiRouteCalldata = splits.reduce((memo, split) => {
+    const routeCalldata = encodeRoute(split.route, targetToken);
+    const amountSpecified = BigInt(split.amount_specified);
+    const absAmount = abs(amountSpecified);
+    return memo.concat([
+      toHex(split.route.length),
+      ...routeCalldata.encoded,
+      targetToken,
+      toHex(absAmount),
+      "0x1"
+      // is_exact_amount_received flag
+    ]);
+  }, []);
+  return [
+    {
+      contractAddress: routerAddress,
+      entrypoint: "multi_multihop_swap",
+      calldata: [toHex(splits.length), ...multiRouteCalldata]
+    }
+  ];
+}
+function prepareSwapCalls(params) {
+  const result = generateSwapCalls(params);
+  const {
+    sellToken,
+    quote,
+    chainId = CHAIN_IDS.MAINNET,
+    routerAddress: customRouterAddress,
+    slippagePercent = DEFAULT_SLIPPAGE_PERCENT
+  } = params;
+  const routerAddress = customRouterAddress ?? ROUTER_ADDRESSES[chainId];
+  if (!routerAddress) {
+    throw new InvalidChainError(
+      chainId,
+      `Router address not found for chain ID: ${chainId}`
+    );
+  }
+  const normalizedSellToken = normalizeAddress(sellToken);
+  const totalWithSlippage = addSlippage(quote.total, slippagePercent);
+  const approveCall = {
+    contractAddress: normalizedSellToken,
+    entrypoint: "approve",
+    calldata: [routerAddress, toHex(totalWithSlippage), "0x0"]
+  };
+  return {
+    ...result,
+    approveCall,
+    allCalls: [approveCall, ...result.allCalls]
+  };
+}
+
+// src/tokens/mainnet.ts
+var MAINNET_TOKENS = [
+  {
+    symbol: "ETH",
+    name: "Ether",
+    address: "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7",
+    decimals: 18
+  },
+  {
+    symbol: "STRK",
+    name: "Starknet Token",
+    address: "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d",
+    decimals: 18
+  },
+  {
+    symbol: "USDC",
+    name: "USD Coin",
+    address: "0x033068F6539f8e6e6b131e6B2B814e6c34A5224bC66947c47DaB9dFeE93b35fb",
+    decimals: 6
+  },
+  {
+    symbol: "USDC.e",
+    name: "Bridged USDC",
+    address: "0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8",
+    decimals: 6
+  },
+  {
+    symbol: "USDT",
+    name: "Tether USD",
+    address: "0x068f5c6a61780768455de69077e07e89787839bf8166decfbf92b645209c0fb8",
+    decimals: 6
+  },
+  {
+    symbol: "DAI",
+    name: "Dai Stablecoin",
+    address: "0x00da114221cb83fa859dbdb4c44beeaa0bb37c7537ad5ae66fe5e0efd20e6eb3",
+    decimals: 18
+  },
+  {
+    symbol: "WBTC",
+    name: "Wrapped Bitcoin",
+    address: "0x03fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac",
+    decimals: 8
+  },
+  {
+    symbol: "LORDS",
+    name: "Lords Token",
+    address: "0x0124aeb495b947201f5fac96fd1138e326ad86195b98df6dec9009158a533b49",
+    decimals: 18
+  },
+  {
+    symbol: "wstETH",
+    name: "Wrapped stETH",
+    address: "0x042b8f0484674ca266ac5d08e4ac6a3fe65bd3129795def2dca5c34ecc5f96d2",
+    decimals: 18
+  },
+  {
+    symbol: "EKUBO",
+    name: "Ekubo Protocol",
+    address: "0x075afe6402ad5a5c20dd25e10ec3b3986acaa647b77e4ae24b0cbc9a54a27a87",
+    decimals: 18
+  },
+  {
+    symbol: "ZEND",
+    name: "zkLend",
+    address: "0x00585c32b625999e6e5e78645ff8df7a9001cf5cf3eb6b80ccdd16cb64bd3a34",
+    decimals: 18
+  },
+  {
+    symbol: "NSTR",
+    name: "Nostra",
+    address: "0x04619e9ce4109590219c5263787050726be63382148538f3f936c22aa87d2fc2",
+    decimals: 18
+  }
+];
+function getMainnetTokensMap() {
+  const map = /* @__PURE__ */ new Map();
+  for (const token of MAINNET_TOKENS) {
+    map.set(token.symbol.toUpperCase(), token);
+  }
+  return map;
+}
+
+// src/tokens/registry.ts
+var TokenRegistry = class {
+  symbolMap = /* @__PURE__ */ new Map();
+  addressMap = /* @__PURE__ */ new Map();
+  constructor(tokens = []) {
+    for (const token of MAINNET_TOKENS) {
+      this.register(token);
+    }
+    for (const token of tokens) {
+      this.register(token);
+    }
+  }
+  /**
+   * Register a token
+   */
+  register(token) {
+    const upperSymbol = token.symbol.toUpperCase();
+    const normalizedAddress = normalizeAddress(token.address);
+    const normalizedToken = {
+      ...token,
+      address: normalizedAddress
+    };
+    this.symbolMap.set(upperSymbol, normalizedToken);
+    this.addressMap.set(normalizedAddress, normalizedToken);
+  }
+  /**
+   * Get token by symbol (case-insensitive)
+   */
+  getBySymbol(symbol) {
+    return this.symbolMap.get(symbol.toUpperCase());
+  }
+  /**
+   * Get token by address (normalized)
+   */
+  getByAddress(address) {
+    return this.addressMap.get(normalizeAddress(address));
+  }
+  /**
+   * Check if a token exists by symbol
+   */
+  hasSymbol(symbol) {
+    return this.symbolMap.has(symbol.toUpperCase());
+  }
+  /**
+   * Check if a token exists by address
+   */
+  hasAddress(address) {
+    return this.addressMap.has(normalizeAddress(address));
+  }
+  /**
+   * Get all registered tokens
+   */
+  getAll() {
+    return Array.from(this.symbolMap.values());
+  }
+  /**
+   * Get all registered symbols
+   */
+  getSymbols() {
+    return Array.from(this.symbolMap.keys());
+  }
+};
+var defaultRegistry = null;
+function getDefaultRegistry() {
+  if (!defaultRegistry) {
+    defaultRegistry = new TokenRegistry();
+  }
+  return defaultRegistry;
+}
+function createTokenRegistry(customTokens = []) {
+  return new TokenRegistry(customTokens);
+}
+
+// src/tokens/resolver.ts
+function resolveToken(tokenIdentifier, registry) {
+  const reg = registry ?? getDefaultRegistry();
+  if (isAddress(tokenIdentifier)) {
+    return normalizeAddress(tokenIdentifier);
+  }
+  const token = reg.getBySymbol(tokenIdentifier);
+  if (token) {
+    return token.address;
+  }
+  throw new TokenNotFoundError(tokenIdentifier);
+}
+function resolveTokenInfo(tokenIdentifier, registry) {
+  const reg = registry ?? getDefaultRegistry();
+  if (isAddress(tokenIdentifier)) {
+    return reg.getByAddress(tokenIdentifier);
+  }
+  return reg.getBySymbol(tokenIdentifier);
+}
+function canResolveToken(tokenIdentifier, registry) {
+  if (isAddress(tokenIdentifier)) {
+    return true;
+  }
+  const reg = registry ?? getDefaultRegistry();
+  return reg.hasSymbol(tokenIdentifier);
+}
+
+// src/polling/poller.ts
+var DEFAULT_POLLING_CONFIG = {
+  interval: 5e3,
+  maxConsecutiveErrors: 3
+};
+var QuotePoller = class {
+  intervalId = null;
+  abortController = null;
+  consecutiveErrors = 0;
+  isRunning = false;
+  params;
+  callbacks;
+  config;
+  fetchConfig;
+  constructor(params, callbacks, config = {}, fetchConfig) {
+    this.params = params;
+    this.callbacks = callbacks;
+    this.config = { ...DEFAULT_POLLING_CONFIG, ...config };
+    this.fetchConfig = fetchConfig;
+  }
+  /**
+   * Start polling for quotes
+   */
+  start() {
+    if (this.isRunning) {
+      return;
+    }
+    this.isRunning = true;
+    this.consecutiveErrors = 0;
+    this.abortController = new AbortController();
+    void this.fetchQuote();
+    this.intervalId = setInterval(() => {
+      void this.fetchQuote();
+    }, this.config.interval);
+  }
+  /**
+   * Stop polling
+   */
+  stop() {
+    if (!this.isRunning) {
+      return;
+    }
+    this.isRunning = false;
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    this.callbacks.onStop?.("manual");
+  }
+  /**
+   * Check if currently polling
+   */
+  get running() {
+    return this.isRunning;
+  }
+  /**
+   * Update polling parameters (requires restart)
+   */
+  updateParams(params) {
+    Object.assign(this.params, params);
+    if (this.isRunning) {
+      this.stop();
+      this.start();
+    }
+  }
+  /**
+   * Fetch a quote
+   */
+  async fetchQuote() {
+    if (!this.isRunning || !this.abortController) {
+      return;
+    }
+    try {
+      const quote = await fetchSwapQuote({
+        amount: this.params.amount,
+        tokenFrom: this.params.tokenFrom,
+        tokenTo: this.params.tokenTo,
+        chainId: this.params.chainId,
+        signal: this.abortController.signal,
+        fetchConfig: this.fetchConfig
+      });
+      this.consecutiveErrors = 0;
+      this.callbacks.onQuote(quote);
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        return;
+      }
+      this.consecutiveErrors++;
+      this.callbacks.onError?.(error);
+      if (this.consecutiveErrors >= this.config.maxConsecutiveErrors) {
+        this.stopDueToErrors();
+      }
+    }
+  }
+  /**
+   * Stop due to consecutive errors
+   */
+  stopDueToErrors() {
+    this.isRunning = false;
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    this.callbacks.onStop?.("errors");
+  }
+};
+function createQuotePoller(params, callbacks, config, fetchConfig) {
+  return new QuotePoller(params, callbacks, config, fetchConfig);
+}
+
+// src/client.ts
+var DEFAULT_CONFIG = {
+  chain: "mainnet",
+  defaultSlippagePercent: 5n
+};
+var EkuboClient = class {
+  config;
+  tokenRegistry;
+  constructor(config = {}) {
+    this.config = this.resolveConfig(config);
+    this.tokenRegistry = new TokenRegistry(config.customTokens);
+  }
+  /**
+   * Resolve configuration with defaults
+   */
+  resolveConfig(config) {
+    const chain = config.chain ?? DEFAULT_CONFIG.chain;
+    const chainConfig = config.chainId ? getChainConfig(config.chainId) : getChainConfig(chain);
+    if (!chainConfig && !config.chainId) {
+      throw new InvalidChainError(chain);
+    }
+    return {
+      chainId: config.chainId ?? chainConfig?.chainId ?? CHAIN_IDS.MAINNET,
+      quoterApiUrl: config.quoterApiUrl ?? chainConfig?.quoterApiUrl ?? "https://prod-api-quoter.ekubo.org",
+      apiUrl: config.apiUrl ?? chainConfig?.apiUrl ?? "https://prod-api.ekubo.org",
+      routerAddress: config.routerAddress ?? chainConfig?.routerAddress ?? "",
+      defaultSlippagePercent: config.defaultSlippagePercent ?? DEFAULT_CONFIG.defaultSlippagePercent,
+      fetch: { ...DEFAULT_FETCH_CONFIG, ...config.fetch },
+      polling: { ...DEFAULT_POLLING_CONFIG, ...config.polling }
+    };
+  }
+  /**
+   * Get the current chain ID
+   */
+  get chainId() {
+    return this.config.chainId;
+  }
+  /**
+   * Get the router contract address
+   */
+  get routerAddress() {
+    return this.config.routerAddress;
+  }
+  /**
+   * Get the token registry
+   */
+  get tokens() {
+    return this.tokenRegistry;
+  }
+  /**
+   * Resolve a token identifier (symbol or address) to an address
+   */
+  resolveToken(tokenIdentifier) {
+    return resolveToken(tokenIdentifier, this.tokenRegistry);
+  }
+  // ==========================================================================
+  // Swap Quotes
+  // ==========================================================================
+  /**
+   * Fetch a swap quote
+   *
+   * @param params - Quote parameters (supports symbols or addresses)
+   * @returns Swap quote
+   */
+  async getQuote(params) {
+    const tokenFrom = this.resolveToken(params.tokenFrom);
+    const tokenTo = this.resolveToken(params.tokenTo);
+    return fetchSwapQuote({
+      amount: params.amount,
+      tokenFrom,
+      tokenTo,
+      chainId: this.config.chainId,
+      signal: params.signal,
+      fetchConfig: this.config.fetch
+    });
+  }
+  /**
+   * Fetch a token price in USDC
+   *
+   * @param tokenIdentifier - Token symbol or address
+   * @param amount - Amount of token
+   * @param signal - Optional abort signal
+   * @returns Price in USDC (as bigint)
+   */
+  async getUsdcPrice(tokenIdentifier, amount, signal) {
+    const tokenFrom = this.resolveToken(tokenIdentifier);
+    return fetchSwapQuoteInUsdc({
+      amount,
+      tokenFrom,
+      chainId: this.config.chainId,
+      signal,
+      fetchConfig: this.config.fetch
+    });
+  }
+  /**
+   * Fetch price history
+   *
+   * @param token - Token symbol or address
+   * @param otherToken - Quote token symbol or address
+   * @param interval - Time interval in seconds (default: 7000)
+   * @returns Price history data
+   */
+  async getPriceHistory(token, otherToken, interval) {
+    const resolvedToken = this.resolveToken(token);
+    const resolvedOtherToken = this.resolveToken(otherToken);
+    return getPriceHistory({
+      token: resolvedToken,
+      otherToken: resolvedOtherToken,
+      chainId: this.config.chainId,
+      interval,
+      apiUrl: this.config.apiUrl,
+      fetchConfig: this.config.fetch
+    });
+  }
+  // ==========================================================================
+  // Swap Call Generation
+  // ==========================================================================
+  /**
+   * Generate swap calls from a quote
+   *
+   * @param params - Call generation parameters (supports symbols or addresses)
+   * @returns Swap calls result
+   */
+  generateSwapCalls(params) {
+    const sellToken = this.resolveToken(params.sellToken);
+    const buyToken = this.resolveToken(params.buyToken);
+    return generateSwapCalls({
+      ...params,
+      sellToken,
+      buyToken,
+      chainId: this.config.chainId,
+      routerAddress: this.config.routerAddress,
+      slippagePercent: params.slippagePercent ?? this.config.defaultSlippagePercent
+    });
+  }
+  /**
+   * Prepare swap calls with approval included
+   *
+   * @param params - Call generation parameters (supports symbols or addresses)
+   * @returns Swap calls result with approve call
+   */
+  prepareSwapCalls(params) {
+    const sellToken = this.resolveToken(params.sellToken);
+    const buyToken = this.resolveToken(params.buyToken);
+    return prepareSwapCalls({
+      ...params,
+      sellToken,
+      buyToken,
+      chainId: this.config.chainId,
+      routerAddress: this.config.routerAddress,
+      slippagePercent: params.slippagePercent ?? this.config.defaultSlippagePercent
+    });
+  }
+  // ==========================================================================
+  // Quote Polling
+  // ==========================================================================
+  /**
+   * Create a quote poller for real-time updates
+   *
+   * @param params - Quote parameters (supports symbols or addresses)
+   * @param callbacks - Poller callbacks
+   * @param config - Optional polling configuration
+   * @returns QuotePoller instance
+   */
+  createQuotePoller(params, callbacks, config) {
+    const tokenFrom = this.resolveToken(params.tokenFrom);
+    const tokenTo = this.resolveToken(params.tokenTo);
+    return new QuotePoller(
+      {
+        amount: params.amount,
+        tokenFrom,
+        tokenTo,
+        chainId: this.config.chainId
+      },
+      callbacks,
+      { ...this.config.polling, ...config },
+      this.config.fetch
+    );
+  }
+  // ==========================================================================
+  // Token Management
+  // ==========================================================================
+  /**
+   * Register a custom token in the local registry
+   */
+  registerToken(token) {
+    this.tokenRegistry.register(token);
+  }
+  /**
+   * Fetch all tokens from the Ekubo API
+   *
+   * @returns Array of token metadata from the API
+   */
+  async fetchTokens() {
+    return fetchTokens({
+      chainId: this.config.chainId,
+      apiUrl: this.config.apiUrl,
+      fetchConfig: this.config.fetch
+    });
+  }
+  /**
+   * Fetch metadata for a single token from the API
+   *
+   * @param tokenAddress - Token contract address
+   * @returns Token metadata or null if not found
+   */
+  async fetchToken(tokenAddress) {
+    const resolved = this.resolveToken(tokenAddress);
+    return fetchToken({
+      tokenAddress: resolved,
+      chainId: this.config.chainId,
+      apiUrl: this.config.apiUrl,
+      fetchConfig: this.config.fetch
+    });
+  }
+  /**
+   * Fetch metadata for multiple tokens at once
+   *
+   * @param tokenAddresses - Array of token addresses
+   * @returns Array of token metadata
+   */
+  async fetchTokensBatch(tokenAddresses) {
+    const resolved = tokenAddresses.map((addr) => this.resolveToken(addr));
+    return fetchTokensBatch({
+      tokenAddresses: resolved,
+      chainId: this.config.chainId,
+      apiUrl: this.config.apiUrl,
+      fetchConfig: this.config.fetch
+    });
+  }
+  /**
+   * Fetch tokens from API and register them in the local registry
+   *
+   * @returns Number of tokens registered
+   */
+  async syncTokensFromApi() {
+    const apiTokens = await this.fetchTokens();
+    for (const token of apiTokens) {
+      this.tokenRegistry.register({
+        symbol: token.symbol,
+        address: token.address,
+        decimals: token.decimals,
+        name: token.name
+      });
+    }
+    return apiTokens.length;
+  }
+  // ==========================================================================
+  // Protocol Statistics
+  // ==========================================================================
+  /**
+   * Fetch top trading pairs by volume
+   *
+   * @returns Array of pair statistics
+   */
+  async getTopPairs() {
+    return fetchTopPairs({
+      chainId: this.config.chainId,
+      apiUrl: this.config.apiUrl,
+      fetchConfig: this.config.fetch
+    });
+  }
+  /**
+   * Fetch protocol TVL overview
+   *
+   * @returns TVL statistics
+   */
+  async getTvl() {
+    return fetchTvl({
+      chainId: this.config.chainId,
+      apiUrl: this.config.apiUrl,
+      fetchConfig: this.config.fetch
+    });
+  }
+  /**
+   * Fetch protocol volume overview
+   *
+   * @returns Volume statistics
+   */
+  async getVolume() {
+    return fetchVolume({
+      chainId: this.config.chainId,
+      apiUrl: this.config.apiUrl,
+      fetchConfig: this.config.fetch
+    });
+  }
+  /**
+   * Fetch TVL history for a trading pair
+   *
+   * @param tokenA - First token (symbol or address)
+   * @param tokenB - Second token (symbol or address)
+   * @returns TVL data points
+   */
+  async getPairTvl(tokenA, tokenB) {
+    const resolvedA = this.resolveToken(tokenA);
+    const resolvedB = this.resolveToken(tokenB);
+    return fetchPairTvl({
+      tokenA: resolvedA,
+      tokenB: resolvedB,
+      chainId: this.config.chainId,
+      apiUrl: this.config.apiUrl,
+      fetchConfig: this.config.fetch
+    });
+  }
+  /**
+   * Fetch volume history for a trading pair
+   *
+   * @param tokenA - First token (symbol or address)
+   * @param tokenB - Second token (symbol or address)
+   * @returns Volume data points
+   */
+  async getPairVolume(tokenA, tokenB) {
+    const resolvedA = this.resolveToken(tokenA);
+    const resolvedB = this.resolveToken(tokenB);
+    return fetchPairVolume({
+      tokenA: resolvedA,
+      tokenB: resolvedB,
+      chainId: this.config.chainId,
+      apiUrl: this.config.apiUrl,
+      fetchConfig: this.config.fetch
+    });
+  }
+  /**
+   * Fetch pools for a trading pair
+   *
+   * @param tokenA - First token (symbol or address)
+   * @param tokenB - Second token (symbol or address)
+   * @returns Pool information
+   */
+  async getPairPools(tokenA, tokenB) {
+    const resolvedA = this.resolveToken(tokenA);
+    const resolvedB = this.resolveToken(tokenB);
+    return fetchPairPools({
+      tokenA: resolvedA,
+      tokenB: resolvedB,
+      chainId: this.config.chainId,
+      apiUrl: this.config.apiUrl,
+      fetchConfig: this.config.fetch
+    });
+  }
+};
+function createEkuboClient(config) {
+  return new EkuboClient(config);
+}
+
+exports.API_URLS = API_URLS;
+exports.AbortError = AbortError;
+exports.ApiError = ApiError;
+exports.CHAIN_CONFIGS = CHAIN_CONFIGS;
+exports.CHAIN_IDS = CHAIN_IDS;
+exports.DEFAULT_POLLING_CONFIG = DEFAULT_POLLING_CONFIG;
+exports.EkuboClient = EkuboClient;
+exports.EkuboError = EkuboError;
+exports.InsufficientLiquidityError = InsufficientLiquidityError;
+exports.InvalidChainError = InvalidChainError;
+exports.MAINNET_TOKENS = MAINNET_TOKENS;
+exports.QuotePoller = QuotePoller;
+exports.ROUTER_ADDRESSES = ROUTER_ADDRESSES;
+exports.RateLimitError = RateLimitError;
+exports.STARKNET_CHAIN_IDS = STARKNET_CHAIN_IDS;
+exports.STARKNET_TO_EKUBO_CHAIN = STARKNET_TO_EKUBO_CHAIN;
+exports.TimeoutError = TimeoutError;
+exports.TokenNotFoundError = TokenNotFoundError;
+exports.TokenRegistry = TokenRegistry;
+exports.USDC_ADDRESSES = USDC_ADDRESSES;
+exports.abs = abs;
+exports.addSlippage = addSlippage;
+exports.calculateBackoff = calculateBackoff;
+exports.canResolveToken = canResolveToken;
+exports.createEkuboClient = createEkuboClient;
+exports.createQuotePoller = createQuotePoller;
+exports.createTokenRegistry = createTokenRegistry;
+exports.encodeRoute = encodeRoute;
+exports.encodeRouteNode = encodeRouteNode;
+exports.fetchPairPools = fetchPairPools;
+exports.fetchPairTvl = fetchPairTvl;
+exports.fetchPairVolume = fetchPairVolume;
+exports.fetchSwapQuote = fetchSwapQuote;
+exports.fetchSwapQuoteInUsdc = fetchSwapQuoteInUsdc;
+exports.fetchToken = fetchToken;
+exports.fetchTokens = fetchTokens;
+exports.fetchTokensBatch = fetchTokensBatch;
+exports.fetchTopPairs = fetchTopPairs;
+exports.fetchTvl = fetchTvl;
+exports.fetchVolume = fetchVolume;
+exports.generateSwapCalls = generateSwapCalls;
+exports.getChainConfig = getChainConfig;
+exports.getDefaultRegistry = getDefaultRegistry;
+exports.getEkuboChainId = getEkuboChainId;
+exports.getMainnetTokensMap = getMainnetTokensMap;
+exports.getPriceHistory = getPriceHistory;
+exports.isAddress = isAddress;
+exports.isNonRetryableError = isNonRetryableError;
+exports.normalizeAddress = normalizeAddress;
+exports.parseTotalCalculated = parseTotalCalculated;
+exports.prepareSwapCalls = prepareSwapCalls;
+exports.resolveToken = resolveToken;
+exports.resolveTokenInfo = resolveTokenInfo;
+exports.sleep = sleep;
+exports.splitU256 = splitU256;
+exports.subtractSlippage = subtractSlippage;
+exports.toHex = toHex;
+exports.withRetry = withRetry;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map