@provable-games/ekubo-sdk 0.1.0 → 0.1.8

package/dist/react.cjs

@@ -0,0 +1,1999 @@
+'use strict';
+
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/react/context.tsx
+
+// 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 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);
+  }
+};
+
+// 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));
+}
+
+// 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;
+}
+
+// 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);
+}
+
+// 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
+  }
+];
+
+// 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;
+}
+
+// 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);
+}
+
+// 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");
+  }
+};
+
+// 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);
+}
+var EkuboContext = react.createContext(null);
+function EkuboProvider({
+  children,
+  config,
+  client: providedClient
+}) {
+  const client = react.useMemo(() => {
+    if (providedClient) {
+      return providedClient;
+    }
+    return createEkuboClient(config);
+  }, [providedClient, config]);
+  return /* @__PURE__ */ jsxRuntime.jsx(EkuboContext.Provider, { value: client, children });
+}
+function useEkuboClient() {
+  const client = react.useContext(EkuboContext);
+  if (!client) {
+    throw new Error("useEkuboClient must be used within an EkuboProvider");
+  }
+  return client;
+}
+function useOptionalEkuboClient() {
+  return react.useContext(EkuboContext);
+}
+var defaultClientInstance = null;
+function getDefaultClient(config) {
+  if (!defaultClientInstance) {
+    defaultClientInstance = createEkuboClient(config);
+  }
+  return defaultClientInstance;
+}
+function useEkuboSwap({
+  sellToken,
+  buyToken,
+  amount,
+  enabled = true,
+  pollingInterval = 5e3,
+  defaultSlippagePercent = 5n,
+  config
+}) {
+  const contextClient = useOptionalEkuboClient();
+  const client = contextClient ?? getDefaultClient(config);
+  const [state, setState] = react.useState({
+    quote: null,
+    loading: false,
+    error: null,
+    priceImpact: null,
+    insufficientLiquidity: false
+  });
+  const pollerRef = react.useRef(null);
+  const abortControllerRef = react.useRef(null);
+  const latestQuoteRef = react.useRef(null);
+  const isSameToken = react.useMemo(() => {
+    if (!sellToken || !buyToken) return true;
+    try {
+      return normalizeAddress(sellToken).toLowerCase() === normalizeAddress(buyToken).toLowerCase();
+    } catch {
+      return false;
+    }
+  }, [sellToken, buyToken]);
+  const canFetch = react.useMemo(() => {
+    return !isSameToken && sellToken !== null && buyToken !== null && amount !== 0n;
+  }, [isSameToken, sellToken, buyToken, amount]);
+  const shouldPoll = enabled && canFetch;
+  const fetchQuote = react.useCallback(async () => {
+    if (!canFetch || !sellToken || !buyToken) return;
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+    }
+    abortControllerRef.current = new AbortController();
+    setState((prev) => ({ ...prev, loading: true, error: null }));
+    try {
+      const quote = await client.getQuote({
+        amount,
+        tokenFrom: sellToken,
+        tokenTo: buyToken,
+        signal: abortControllerRef.current.signal
+      });
+      latestQuoteRef.current = quote;
+      setState({
+        quote,
+        loading: false,
+        error: null,
+        priceImpact: quote.impact,
+        insufficientLiquidity: false
+      });
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        return;
+      }
+      const isInsufficient = err instanceof InsufficientLiquidityError;
+      setState((prev) => ({
+        ...prev,
+        quote: null,
+        loading: false,
+        error: err instanceof Error ? err : new Error("Unknown error"),
+        priceImpact: null,
+        insufficientLiquidity: isInsufficient
+      }));
+    }
+  }, [canFetch, sellToken, buyToken, amount, client]);
+  react.useEffect(() => {
+    if (pollerRef.current) {
+      clearInterval(pollerRef.current);
+      pollerRef.current = null;
+    }
+    if (!shouldPoll) {
+      if (!canFetch) {
+        setState({
+          quote: null,
+          loading: false,
+          error: null,
+          priceImpact: null,
+          insufficientLiquidity: false
+        });
+      }
+      return;
+    }
+    fetchQuote();
+    pollerRef.current = setInterval(fetchQuote, pollingInterval);
+    return () => {
+      if (pollerRef.current) {
+        clearInterval(pollerRef.current);
+        pollerRef.current = null;
+      }
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+        abortControllerRef.current = null;
+      }
+    };
+  }, [shouldPoll, canFetch, fetchQuote, pollingInterval]);
+  const generateCalls = react.useCallback(
+    (slippagePercent, minimumReceived) => {
+      const quote = latestQuoteRef.current;
+      if (!quote || !sellToken || !buyToken) return null;
+      try {
+        const minReceived = minimumReceived ?? (amount > 0n ? quote.total : amount);
+        return client.prepareSwapCalls({
+          sellToken,
+          buyToken,
+          quote,
+          minimumReceived: minReceived < 0n ? -minReceived : minReceived,
+          slippagePercent: slippagePercent ?? defaultSlippagePercent
+        });
+      } catch (err) {
+        console.error("Error generating swap calls:", err);
+        return null;
+      }
+    },
+    [sellToken, buyToken, amount, defaultSlippagePercent, client]
+  );
+  const refetch = react.useCallback(() => {
+    fetchQuote();
+  }, [fetchQuote]);
+  return react.useMemo(
+    () => ({
+      state,
+      generateCalls,
+      refetch
+    }),
+    [state, generateCalls, refetch]
+  );
+}
+var defaultClientInstance2 = null;
+function getDefaultClient2(config) {
+  if (!defaultClientInstance2) {
+    defaultClientInstance2 = createEkuboClient(config);
+  }
+  return defaultClientInstance2;
+}
+function useEkuboPrices({
+  tokens,
+  timeoutMs = 1e4,
+  config,
+  enabled = true,
+  standardAmount = 1000000000000000000n
+  // 1e18
+}) {
+  const contextClient = useOptionalEkuboClient();
+  const client = contextClient ?? getDefaultClient2(config);
+  const [prices, setPrices] = react.useState({});
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [tokenLoadingStates, setTokenLoadingStates] = react.useState({});
+  const [tokenErrorStates, setTokenErrorStates] = react.useState({});
+  const [fetchKey, setFetchKey] = react.useState(0);
+  const tokensKey = react.useMemo(() => JSON.stringify([...tokens].sort()), [tokens]);
+  const isTokenAvailable = react.useCallback(
+    (tokenAddress) => {
+      if (!tokens.includes(tokenAddress)) return false;
+      if (tokenLoadingStates[tokenAddress] === true) return false;
+      if (tokenErrorStates[tokenAddress] === true) return false;
+      if (prices[tokenAddress] === void 0) return false;
+      return true;
+    },
+    [tokens, tokenLoadingStates, tokenErrorStates, prices]
+  );
+  const isTokenLoading = react.useCallback(
+    (tokenAddress) => {
+      if (!tokens.includes(tokenAddress)) return true;
+      return tokenLoadingStates[tokenAddress] === true;
+    },
+    [tokens, tokenLoadingStates]
+  );
+  const hasTokenError = react.useCallback(
+    (tokenAddress) => {
+      if (!tokens.includes(tokenAddress)) return false;
+      return tokenErrorStates[tokenAddress] === true;
+    },
+    [tokens, tokenErrorStates]
+  );
+  const getPrice = react.useCallback(
+    (tokenAddress) => {
+      if (!isTokenAvailable(tokenAddress)) {
+        return void 0;
+      }
+      return prices[tokenAddress];
+    },
+    [isTokenAvailable, prices]
+  );
+  const refetch = react.useCallback(() => {
+    setFetchKey((prev) => prev + 1);
+  }, []);
+  react.useEffect(() => {
+    if (!enabled || !tokens || tokens.length === 0) {
+      setIsLoading(false);
+      setPrices({});
+      setTokenLoadingStates({});
+      setTokenErrorStates({});
+      return;
+    }
+    setIsLoading(true);
+    setTokenLoadingStates(
+      tokens.reduce((acc, address) => ({ ...acc, [address]: true }), {})
+    );
+    setTokenErrorStates(
+      tokens.reduce((acc, address) => ({ ...acc, [address]: false }), {})
+    );
+    let cancelled = false;
+    const fetchPrices = async () => {
+      const pricePromises = tokens.map(async (tokenAddress) => {
+        const timeoutPromise = new Promise((resolve) => {
+          setTimeout(() => {
+            resolve({
+              tokenAddress,
+              price: void 0,
+              error: true
+            });
+          }, timeoutMs);
+        });
+        const fetchPromise = (async () => {
+          try {
+            const usdcAmount = await client.getUsdcPrice(tokenAddress, standardAmount);
+            const price = Number(usdcAmount) / 1e6;
+            return { tokenAddress, price, error: false };
+          } catch (error) {
+            console.error(`Error fetching ${tokenAddress} price:`, error);
+            return { tokenAddress, price: void 0, error: true };
+          }
+        })();
+        return Promise.race([fetchPromise, timeoutPromise]);
+      });
+      const results = await Promise.all(pricePromises);
+      if (cancelled) return;
+      const newPrices = {};
+      const newLoadingStates = {};
+      const newErrorStates = {};
+      results.forEach(({ tokenAddress, price, error }) => {
+        newPrices[tokenAddress] = price;
+        newLoadingStates[tokenAddress] = false;
+        newErrorStates[tokenAddress] = error;
+      });
+      setPrices(newPrices);
+      setTokenLoadingStates(newLoadingStates);
+      setTokenErrorStates(newErrorStates);
+      setIsLoading(false);
+    };
+    fetchPrices();
+    return () => {
+      cancelled = true;
+    };
+  }, [tokensKey, enabled, timeoutMs, client, standardAmount, fetchKey]);
+  return react.useMemo(
+    () => ({
+      prices,
+      isLoading,
+      isTokenLoading,
+      hasTokenError,
+      isTokenAvailable,
+      getPrice,
+      refetch
+    }),
+    [prices, isLoading, isTokenLoading, hasTokenError, isTokenAvailable, getPrice, refetch]
+  );
+}
+var defaultClientInstance3 = null;
+function getDefaultClient3(config) {
+  if (!defaultClientInstance3) {
+    defaultClientInstance3 = createEkuboClient(config);
+  }
+  return defaultClientInstance3;
+}
+function useEkuboTokens({
+  config,
+  enabled = true
+} = {}) {
+  const contextClient = useOptionalEkuboClient();
+  const client = contextClient ?? getDefaultClient3(config);
+  const [tokens, setTokens] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const [fetchKey, setFetchKey] = react.useState(0);
+  const refetch = react.useCallback(() => {
+    setFetchKey((prev) => prev + 1);
+  }, []);
+  react.useEffect(() => {
+    if (!enabled) {
+      setIsLoading(false);
+      setTokens([]);
+      setError(null);
+      return;
+    }
+    let cancelled = false;
+    const fetchTokens2 = async () => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const result = await client.fetchTokens();
+        if (!cancelled) {
+          setTokens(result);
+          setIsLoading(false);
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setError(err instanceof Error ? err : new Error("Failed to fetch tokens"));
+          setIsLoading(false);
+        }
+      }
+    };
+    fetchTokens2();
+    return () => {
+      cancelled = true;
+    };
+  }, [enabled, client, fetchKey]);
+  const tokensByAddress = react.useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const token of tokens) {
+      map.set(token.address.toLowerCase(), token);
+    }
+    return map;
+  }, [tokens]);
+  const tokensBySymbol = react.useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const token of tokens) {
+      map.set(token.symbol.toUpperCase(), token);
+    }
+    return map;
+  }, [tokens]);
+  const getToken = react.useCallback(
+    (address) => {
+      return tokensByAddress.get(address.toLowerCase());
+    },
+    [tokensByAddress]
+  );
+  const getTokenBySymbol = react.useCallback(
+    (symbol) => {
+      return tokensBySymbol.get(symbol.toUpperCase());
+    },
+    [tokensBySymbol]
+  );
+  return react.useMemo(
+    () => ({
+      tokens,
+      isLoading,
+      error,
+      refetch,
+      getToken,
+      getTokenBySymbol
+    }),
+    [tokens, isLoading, error, refetch, getToken, getTokenBySymbol]
+  );
+}
+var defaultClientInstance4 = null;
+function getDefaultClient4(config) {
+  if (!defaultClientInstance4) {
+    defaultClientInstance4 = createEkuboClient(config);
+  }
+  return defaultClientInstance4;
+}
+function useEkuboStats({
+  config,
+  enabled = true,
+  fetchTvl: fetchTvl2 = true,
+  fetchVolume: fetchVolume2 = true,
+  fetchTopPairs: fetchTopPairs2 = true
+} = {}) {
+  const contextClient = useOptionalEkuboClient();
+  const client = contextClient ?? getDefaultClient4(config);
+  const [tvl, setTvl] = react.useState(null);
+  const [volume, setVolume] = react.useState(null);
+  const [topPairs, setTopPairs] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const [fetchKey, setFetchKey] = react.useState(0);
+  const refetch = react.useCallback(() => {
+    setFetchKey((prev) => prev + 1);
+  }, []);
+  react.useEffect(() => {
+    if (!enabled) {
+      setIsLoading(false);
+      setTvl(null);
+      setVolume(null);
+      setTopPairs([]);
+      setError(null);
+      return;
+    }
+    let cancelled = false;
+    const fetchStats = async () => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const promises = [];
+        if (fetchTvl2) {
+          promises.push(
+            client.getTvl().then((result) => {
+              if (!cancelled) setTvl(result);
+            })
+          );
+        }
+        if (fetchVolume2) {
+          promises.push(
+            client.getVolume().then((result) => {
+              if (!cancelled) setVolume(result);
+            })
+          );
+        }
+        if (fetchTopPairs2) {
+          promises.push(
+            client.getTopPairs().then((result) => {
+              if (!cancelled) setTopPairs(result);
+            })
+          );
+        }
+        await Promise.all(promises);
+        if (!cancelled) {
+          setIsLoading(false);
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setError(err instanceof Error ? err : new Error("Failed to fetch stats"));
+          setIsLoading(false);
+        }
+      }
+    };
+    fetchStats();
+    return () => {
+      cancelled = true;
+    };
+  }, [enabled, client, fetchKey, fetchTvl2, fetchVolume2, fetchTopPairs2]);
+  return react.useMemo(
+    () => ({
+      tvl,
+      volume,
+      topPairs,
+      isLoading,
+      error,
+      refetch
+    }),
+    [tvl, volume, topPairs, isLoading, error, refetch]
+  );
+}
+var defaultClientInstance5 = null;
+function getDefaultClient5(config) {
+  if (!defaultClientInstance5) {
+    defaultClientInstance5 = createEkuboClient(config);
+  }
+  return defaultClientInstance5;
+}
+function useEkuboPriceHistory({
+  token,
+  quoteToken,
+  interval = 7e3,
+  config,
+  enabled = true
+}) {
+  const contextClient = useOptionalEkuboClient();
+  const client = contextClient ?? getDefaultClient5(config);
+  const [data, setData] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const [fetchKey, setFetchKey] = react.useState(0);
+  const refetch = react.useCallback(() => {
+    setFetchKey((prev) => prev + 1);
+  }, []);
+  react.useEffect(() => {
+    if (!enabled || !token || !quoteToken) {
+      setIsLoading(false);
+      setData([]);
+      setError(null);
+      return;
+    }
+    let cancelled = false;
+    const fetchPriceHistory = async () => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const result = await client.getPriceHistory(token, quoteToken, interval);
+        if (!cancelled) {
+          setData(result.data);
+          setIsLoading(false);
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setError(err instanceof Error ? err : new Error("Failed to fetch price history"));
+          setIsLoading(false);
+        }
+      }
+    };
+    fetchPriceHistory();
+    return () => {
+      cancelled = true;
+    };
+  }, [enabled, token, quoteToken, interval, client, fetchKey]);
+  return react.useMemo(
+    () => ({
+      data,
+      isLoading,
+      error,
+      refetch
+    }),
+    [data, isLoading, error, refetch]
+  );
+}
+
+exports.EkuboProvider = EkuboProvider;
+exports.useEkuboClient = useEkuboClient;
+exports.useEkuboPriceHistory = useEkuboPriceHistory;
+exports.useEkuboPrices = useEkuboPrices;
+exports.useEkuboStats = useEkuboStats;
+exports.useEkuboSwap = useEkuboSwap;
+exports.useEkuboTokens = useEkuboTokens;
+exports.useOptionalEkuboClient = useOptionalEkuboClient;
+//# sourceMappingURL=react.cjs.map
+//# sourceMappingURL=react.cjs.map