@tokemak/queries 0.5.0 → 0.6.0

package/dist/safe.mjs

@@ -0,0 +1,848 @@
+// utils/mergeArraysWithKey.ts
+function mergeArraysWithKey(objectsArray, arraysArray, key) {
+  if (objectsArray.length !== arraysArray.length) {
+    throw new Error("Both arrays must have the same length.");
+  }
+  return objectsArray.map((obj, index) => ({
+    ...obj,
+    [key]: arraysArray[index]
+  }));
+}
+
+// utils/mergeArrays.ts
+function mergeArrays(objectsArray, objectsToMergeArray) {
+  if (objectsArray.length !== objectsToMergeArray.length) {
+    throw new Error("Both arrays must have the same length.");
+  }
+  return objectsArray.map((obj, index) => ({
+    ...obj,
+    ...objectsToMergeArray[index]
+  }));
+}
+
+// utils/getChainsForEnv.ts
+import {
+  SUPPORTED_DEV_CHAINS,
+  SUPPORTED_PROD_CHAINS
+} from "@tokemak/constants";
+function getChainsForEnv({
+  includeTestnet = false
+}) {
+  let chains;
+  chains = includeTestnet ? [...SUPPORTED_DEV_CHAINS] : [...SUPPORTED_PROD_CHAINS];
+  return chains;
+}
+
+// utils/getAutopoolCategory.ts
+var ETH_BASE_ASSETS = ["ETH", "WETH"];
+var USD_BASE_ASSETS = ["USDC", "DOLA", "USDT0"];
+var EUR_BASE_ASSETS = ["EURC"];
+var getAutopoolCategory = (baseAsset) => {
+  if (ETH_BASE_ASSETS.includes(baseAsset?.toUpperCase())) {
+    return "eth" /* ETH */;
+  } else if (USD_BASE_ASSETS.includes(baseAsset?.toUpperCase()) || EUR_BASE_ASSETS.includes(baseAsset?.toUpperCase())) {
+    return "stables" /* STABLES */;
+  }
+  return "crypto" /* CRYPTO */;
+};
+
+// utils/convertBaseAssetToTokenPrices.ts
+var convertBaseAssetToTokenPrices = (baseAssetValue, baseAssetPrice, prices) => {
+  const baseAssetToTokenPrices = Object.fromEntries(
+    Object.entries(prices).map(([tokenSymbol, tokenPrice]) => [
+      tokenSymbol,
+      baseAssetPrice / tokenPrice
+    ])
+  );
+  return {
+    baseAsset: baseAssetValue,
+    USD: baseAssetValue * baseAssetPrice,
+    ...Object.fromEntries(
+      Object.entries(baseAssetToTokenPrices).map(([tokenSymbol, price]) => [
+        tokenSymbol.toUpperCase(),
+        baseAssetValue * price
+      ])
+    )
+  };
+};
+
+// utils/convertBaseAssetToTokenPricesAndDenom.ts
+var convertBaseAssetToTokenPricesAndDenom = (baseAsset, baseAssetPrice, denomPrice, prices) => {
+  const baseAssetToDenom = baseAssetPrice / denomPrice;
+  return {
+    ...convertBaseAssetToTokenPrices(baseAsset, baseAssetPrice, prices),
+    denom: baseAsset * baseAssetToDenom
+  };
+};
+
+// utils/getAutopoolInfo.ts
+import { ALL_AUTOPOOLS } from "@tokemak/tokenlist";
+var getAutopoolInfo = (symbol) => {
+  const autopool = ALL_AUTOPOOLS.find((pool) => pool.symbol === symbol);
+  return autopool;
+};
+
+// utils/paginateQuery.ts
+async function paginateQuery(queryFn, arrayKey, options = {}) {
+  const { first = 1e3, maxPages = 100, onPage } = options;
+  const results = [];
+  let skip = 0;
+  let pageNumber = 0;
+  let hasMoreData = true;
+  while (hasMoreData && pageNumber < maxPages) {
+    const pageResult = await queryFn({ first, skip });
+    const pageData = pageResult[arrayKey];
+    if (!pageData || Array.isArray(pageData) && pageData.length === 0) {
+      hasMoreData = false;
+    } else {
+      if (Array.isArray(pageData)) {
+        const pageArray = pageData;
+        results.push(...pageArray);
+        if (pageArray.length < first) {
+          hasMoreData = false;
+        }
+      } else {
+        return pageData;
+      }
+      onPage?.(pageData, pageNumber);
+      skip += first;
+      pageNumber++;
+    }
+  }
+  return results;
+}
+
+// functions/getChainAutopools.ts
+import {
+  formatEtherNum,
+  formatPoolName,
+  formatUnitsNum,
+  getNetwork,
+  getProtocol,
+  getToken
+} from "@tokemak/utils";
+import { getAddress } from "viem";
+
+// constants/tokenOrders.ts
+var UITokenOrder = [
+  "ETH",
+  "WETH",
+  "STETH",
+  "WSTETH",
+  "RETH",
+  "SWETH",
+  "FRXETH",
+  "SFRXETH",
+  "EETH",
+  "CBETH",
+  "OSETH",
+  "PXETH",
+  "OETH",
+  "EZETH",
+  "RSETH",
+  "RSWETH",
+  "ETHX",
+  "RSWETH",
+  "PUFETH",
+  "USDC",
+  "DOLA",
+  "USDT",
+  "DAI"
+];
+var protocolOrder = [
+  "Balancer",
+  "Curve",
+  "Aerodrome",
+  "Pendle",
+  "Aave",
+  "Morpho",
+  "Fluid"
+];
+
+// functions/getGenStratAprs.ts
+import { TOKEMAK_GENSTRAT_APRS_API_URL } from "@tokemak/constants";
+var getGenStratAprs = async ({
+  chainId = 1
+}) => {
+  try {
+    const params = new URLSearchParams({
+      chainId: chainId.toString(),
+      systemName: "gen3"
+    });
+    const response = await fetch(`${TOKEMAK_GENSTRAT_APRS_API_URL}?${params}`);
+    const data = await response.json();
+    if (data && data.success) {
+      return data.aprs.reduce((p, c) => {
+        if (!p[c.autopoolAddress]) {
+          p[c.autopoolAddress] = {};
+        }
+        for (const d of c.destinations) {
+          p[c.autopoolAddress][d.address] = {
+            name: d.name,
+            apr: d.apr
+          };
+        }
+        return p;
+      }, {});
+    } else {
+      return void 0;
+    }
+  } catch (error) {
+    console.log(error);
+    return void 0;
+  }
+};
+
+// functions/getTokenPrice.ts
+import { TOKEMAK_SWAP_PRICING_URL } from "@tokemak/constants";
+
+// functions/getDefillamaPrice.ts
+var getDefillamaPrice = async (tokenAddress) => {
+  const response = await fetch(
+    `https://coins.llama.fi/prices/current/ethereum:${tokenAddress}`
+  );
+  const data = await response.json();
+  return data.coins[`ethereum:${tokenAddress}`].price;
+};
+
+// functions/getTokenPrice.ts
+var getTokenPrice = async ({
+  chainId = 1,
+  tokenAddress,
+  includedSources,
+  excludedSources
+}) => {
+  try {
+    const params = new URLSearchParams({
+      chainId: chainId.toString(),
+      systemName: "gen3",
+      token: tokenAddress
+    });
+    if (includedSources) {
+      params.set("includedSources", includedSources.join(","));
+    }
+    if (excludedSources) {
+      params.set("excludedSources", excludedSources.join(","));
+    }
+    const response = await fetch(`${TOKEMAK_SWAP_PRICING_URL}?${params}`);
+    const data = await response.json();
+    return data.price;
+  } catch (error) {
+    try {
+      const defillamaPrice = await getDefillamaPrice(tokenAddress);
+      return defillamaPrice;
+    } catch (error2) {
+      console.log(error2);
+      return void 0;
+    }
+  }
+};
+
+// functions/getChainAutopoolsApr.ts
+import { AUTOPOOLS_APR_URL } from "@tokemak/constants";
+var getChainAutopoolsApr = async (chainId) => {
+  try {
+    const response = await fetch(`${AUTOPOOLS_APR_URL}/${chainId}/gen3`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch getChainAutopoolsApr: ${response.status}`
+      );
+    }
+    return await response.json();
+  } catch (e) {
+    console.error("Failed to fetch getChainAutopoolsApr:", e);
+    return void 0;
+  }
+};
+
+// functions/getChainAutopools.ts
+import {
+  ALL_TOKENS,
+  BEETS_PROTOCOL,
+  ETH_TOKEN,
+  S_TOKEN,
+  WETH_TOKEN,
+  WS_TOKEN,
+  WXPL_TOKEN,
+  XPL_TOKEN
+} from "@tokemak/tokenlist";
+import { getSdkByChainId } from "@tokemak/graph-cli";
+import { sonic } from "viem/chains";
+
+// functions/getPoolsAndDestinations.ts
+import { getCoreConfig } from "@tokemak/config";
+import { lensAbi } from "@tokemak/abis";
+var getPoolsAndDestinations = async (client, { chainId }) => {
+  try {
+    const { lens } = getCoreConfig(chainId);
+    const { autoPools, destinations } = await client.readContract({
+      address: lens,
+      abi: lensAbi,
+      functionName: "getPoolsAndDestinations"
+    });
+    const autopoolsAndDestinations = mergeArraysWithKey(
+      autoPools,
+      destinations,
+      "destinations"
+    );
+    return autopoolsAndDestinations;
+  } catch (error) {
+    console.error(`Error on ${chainId} in getPoolsAndDestinations:`, error);
+  }
+};
+
+// functions/getChainAutopools.ts
+import {
+  NEW_AUTOPOOL_THRESHOLD_DAYS,
+  DAYS_PER_YEAR,
+  DEAD_ADDRESS,
+  ZERO_ADDRESS
+} from "@tokemak/constants";
+var getChainAutopools = async (client, {
+  chainId,
+  prices
+}) => {
+  const { GetVaultAddeds, GetAutopoolsInactiveDestinations } = getSdkByChainId(chainId);
+  try {
+    const { vaultAddeds } = await GetVaultAddeds();
+    const autopoolsAprResponse = await getChainAutopoolsApr(chainId);
+    const autopoolsApr = autopoolsAprResponse?.autopools || [];
+    const { GetAutopoolsApr } = getSdkByChainId(chainId);
+    const { autopools: autopoolsDenomination } = await GetAutopoolsApr();
+    const genStratAprs = await getGenStratAprs({
+      chainId
+    });
+    const autopoolsAndDestinations = await getPoolsAndDestinations(client, {
+      chainId
+    });
+    if (!autopoolsAndDestinations) {
+      throw new Error(`No autopools and destinations found for ${chainId}`);
+    }
+    const vaultAddedMapping = vaultAddeds.reduce(
+      (acc, vaultAdded) => {
+        acc[vaultAdded.vault.toLowerCase()] = Number(vaultAdded.blockTimestamp);
+        return acc;
+      },
+      {}
+    );
+    const autopools = await Promise.all(
+      autopoolsAndDestinations.map(async (autopool) => {
+        let baseAsset = getToken(autopool.baseAsset);
+        if (!baseAsset?.symbol) {
+          console.error(
+            "FIX THIS BEFORE PROD: base asset not found",
+            autopool.baseAsset
+          );
+        }
+        let baseAssetPrice = prices[(baseAsset?.symbol || "").toUpperCase()];
+        if (!baseAssetPrice) {
+          baseAssetPrice = await getTokenPrice({
+            chainId: baseAsset.chainId,
+            tokenAddress: baseAsset.address
+          }) || 0;
+        }
+        const timestamp = vaultAddedMapping[autopool.poolAddress.toLowerCase()];
+        const totalAssets = formatUnitsNum(
+          autopool.totalAssets,
+          baseAsset.decimals
+        );
+        const tvl = totalAssets * baseAssetPrice;
+        const totalIdleAssets = formatUnitsNum(
+          autopool.totalIdle,
+          baseAsset.decimals
+        );
+        const exchangeValues = {};
+        const destinations = autopool.destinations.map((destination) => {
+          const debtValueHeldByVaultEth = formatUnitsNum(
+            destination.debtValueHeldByVault,
+            baseAsset.decimals
+          );
+          if (!exchangeValues[destination.exchangeName.toLowerCase()]) {
+            exchangeValues[destination.exchangeName.toLowerCase()] = 0;
+          }
+          exchangeValues[destination.exchangeName.toLowerCase()] += debtValueHeldByVaultEth;
+          const tokensWithValue = mergeArrays(
+            destination.underlyingTokens,
+            destination.underlyingTokenValueHeld
+          );
+          let underlyingTokens = tokensWithValue.map((token) => {
+            const tokenDetails = getToken(token.tokenAddress);
+            let value = formatUnitsNum(
+              token.valueHeldInEth,
+              baseAsset.decimals
+            );
+            let valueUsd = value * baseAssetPrice;
+            return {
+              ...tokenDetails,
+              valueUsd,
+              value
+            };
+          });
+          if (destination.underlyingTokenSymbols.length === 1) {
+            const underlyingTokenAddress = tokensWithValue[0].tokenAddress;
+            if (underlyingTokenAddress) {
+              underlyingTokens = [
+                {
+                  ...getToken(underlyingTokenAddress, chainId),
+                  valueUsd: debtValueHeldByVaultEth * baseAssetPrice,
+                  value: debtValueHeldByVaultEth
+                }
+              ];
+            }
+          }
+          const isGenStrat = autopool.strategy.toLowerCase() === DEAD_ADDRESS || autopool.strategy === ZERO_ADDRESS;
+          return {
+            ...destination,
+            debtValueHeldByVaultUsd: debtValueHeldByVaultEth * baseAssetPrice,
+            debtValueHeldByVaultEth,
+            compositeReturn: isGenStrat ? genStratAprs?.[autopool.poolAddress]?.[destination.vaultAddress]?.apr || 0 : formatEtherNum(destination.compositeReturn),
+            debtValueHeldByVaultAllocation: debtValueHeldByVaultEth / totalAssets,
+            underlyingTokens,
+            poolName: formatPoolName(destination.lpTokenName),
+            exchange: getProtocol(destination.exchangeName)
+          };
+        });
+        const HIDDEN_DESTINATION_SYMBOLS = ["USR", "WSTUSR"];
+        const filteredDestinations = destinations.filter(
+          (d) => !d.underlyingTokens.some(
+            (t) => HIDDEN_DESTINATION_SYMBOLS.includes(t.symbol?.toUpperCase())
+          )
+        );
+        const uniqueExchanges = Array.from(
+          new Set(
+            filteredDestinations.map((d) => getProtocol(d.exchangeName)).filter(Boolean)
+          )
+        );
+        const uniqueExchangesWithValueHeld = uniqueExchanges.map((exchange) => {
+          const exchangeName = exchange.name.toLowerCase();
+          let exchangeInfo = exchange;
+          const value = exchangeValues[exchangeName];
+          if (chainId === sonic.id) {
+            if (exchangeName === "balancerv3" || exchangeName === "balancer") {
+              exchangeInfo = BEETS_PROTOCOL;
+            }
+          }
+          return {
+            ...exchangeInfo,
+            valueUsd: value * baseAssetPrice,
+            value,
+            allocation: value / totalAssets
+          };
+        });
+        const groupedExchanges = uniqueExchangesWithValueHeld.reduce(
+          (acc, exchange) => {
+            const exchangeName = exchange.name.toLowerCase();
+            const existingExchange = acc.find(
+              (e) => e.name.toLowerCase() === exchangeName
+            );
+            if (existingExchange) {
+              existingExchange.valueUsd += exchange.valueUsd;
+              existingExchange.value += exchange.value;
+              existingExchange.allocation += exchange.allocation;
+            } else {
+              acc.push(exchange);
+            }
+            return acc;
+          },
+          []
+        );
+        const uniqueTokensWithValueHeldMap = filteredDestinations.flatMap((d) => d.underlyingTokens).reduce(
+          (acc, token) => {
+            if (acc[token.address]) {
+              acc[token.address].valueUsd += token.valueUsd;
+              acc[token.address].value += token.value;
+            } else {
+              acc[token.address] = { ...token };
+            }
+            return acc;
+          },
+          {}
+        );
+        const HIDDEN_TOKEN_SYMBOLS = ["USR", "WSTUSR"];
+        const uniqueTokens = Object.values(uniqueTokensWithValueHeldMap).filter(
+          (token) => !HIDDEN_TOKEN_SYMBOLS.includes(token.symbol?.toUpperCase())
+        ).map((token) => {
+          let valueUsd = token.valueUsd;
+          let value = token.value;
+          const allocation = value / totalAssets;
+          return {
+            ...token,
+            valueUsd,
+            value,
+            allocation
+          };
+        });
+        let UIBaseAsset = baseAsset;
+        if (baseAsset.symbol?.toLowerCase() === WETH_TOKEN.symbol.toLowerCase()) {
+          UIBaseAsset = ETH_TOKEN;
+        }
+        if (baseAsset.symbol?.toLowerCase() === WS_TOKEN.symbol.toLowerCase()) {
+          UIBaseAsset = S_TOKEN;
+        }
+        if (baseAsset.symbol?.toLowerCase() === WXPL_TOKEN.symbol.toLowerCase()) {
+          UIBaseAsset = XPL_TOKEN;
+        }
+        const isNew = (Date.now() / 1e3 - timestamp) / 60 / 60 / 24 < NEW_AUTOPOOL_THRESHOLD_DAYS;
+        const aprs = autopoolsApr.find(
+          (autopoolApr) => getAddress(autopoolApr.id) === getAddress(autopool.poolAddress)
+        );
+        const baseApr = aprs?.baseApy !== void 0 ? aprs.baseApy / 100 : void 0;
+        let extraApr = 0;
+        let extraRewards = [];
+        if (aprs?.rewards && aprs.rewards.length > 0) {
+          extraRewards = aprs.rewards.map((reward) => {
+            const token = getToken(reward.rewardToken, chainId);
+            return {
+              ...token,
+              apr: reward.rewardApy / 100
+            };
+          });
+        }
+        extraApr = extraRewards.reduce((acc, reward) => acc + reward.apr, 0);
+        const baseForMath = baseApr ?? 0;
+        const combinedApr = baseForMath + extraApr;
+        let denominatedToken = ETH_TOKEN;
+        let useDenominatedValues = false;
+        const denominationData = autopoolsDenomination.find(
+          (autopoolDenom) => getAddress(autopoolDenom.id) === getAddress(autopool.poolAddress)
+        );
+        const denominatedIn = denominationData?.denominatedIn;
+        if (denominatedIn?.symbol?.toLowerCase() === "weth") {
+          denominatedToken = ETH_TOKEN;
+        } else {
+          denominatedToken = getToken(denominatedIn?.id);
+          if (denominatedToken) {
+            useDenominatedValues = true;
+          }
+        }
+        let denominatedTokenPrice = 0;
+        const tokenSymbol = denominatedToken.symbol?.toUpperCase();
+        if (tokenSymbol in prices) {
+          denominatedTokenPrice = prices[tokenSymbol];
+        } else {
+          denominatedTokenPrice = await getTokenPrice({
+            chainId: denominatedToken.chainId,
+            tokenAddress: denominatedToken.address
+          }) || 0;
+        }
+        const navPerShareBaseAsset = formatUnitsNum(
+          autopool.navPerShare,
+          baseAsset.decimals
+        );
+        const assets = convertBaseAssetToTokenPricesAndDenom(
+          formatUnitsNum(autopool.totalAssets, baseAsset.decimals),
+          baseAssetPrice,
+          denominatedTokenPrice,
+          prices
+        );
+        const navPerShare = convertBaseAssetToTokenPricesAndDenom(
+          navPerShareBaseAsset,
+          baseAssetPrice,
+          denominatedTokenPrice,
+          prices
+        );
+        const idle = convertBaseAssetToTokenPricesAndDenom(
+          totalIdleAssets,
+          baseAssetPrice,
+          denominatedTokenPrice,
+          prices
+        );
+        const idleAllocation = totalIdleAssets / totalAssets;
+        const combinedDailyEarnings = convertBaseAssetToTokenPricesAndDenom(
+          totalAssets * combinedApr / DAYS_PER_YEAR,
+          baseAssetPrice,
+          denominatedTokenPrice,
+          prices
+        );
+        const baseDailyEarnings = convertBaseAssetToTokenPricesAndDenom(
+          totalAssets * baseForMath / DAYS_PER_YEAR,
+          baseAssetPrice,
+          denominatedTokenPrice,
+          prices
+        );
+        const tokenOrder = [UIBaseAsset.symbol, ...UITokenOrder].filter(
+          (value, index, array) => array.indexOf(value) === index
+        );
+        const UITokens = uniqueTokens.reduce(
+          (acc, token) => {
+            try {
+              const parentAsset = token.extensions?.parentAsset;
+              if (parentAsset) {
+                const parentToken = ALL_TOKENS.find(
+                  (t) => t.symbol.toLowerCase() === parentAsset.toLowerCase()
+                );
+                if (parentToken && !acc.some(
+                  (t) => t?.address?.toLowerCase() === parentToken?.address?.toLowerCase()
+                )) {
+                  acc.push({
+                    ...parentToken,
+                    valueUsd: 0,
+                    value: 0,
+                    allocation: 0
+                  });
+                }
+              } else if (!acc.some(
+                (t) => t?.address?.toLowerCase() === token?.address?.toLowerCase()
+              )) {
+                acc.push(token);
+              }
+            } catch (error) {
+              console.warn(
+                `Error processing token: ${token?.symbol || "unknown"}`,
+                error
+              );
+            }
+            return acc;
+          },
+          []
+        ).sort((a, b) => {
+          try {
+            const aIndex = tokenOrder.indexOf(a.symbol.toUpperCase());
+            const bIndex = tokenOrder.indexOf(b.symbol.toUpperCase());
+            if (aIndex !== -1 && bIndex !== -1) {
+              return aIndex - bIndex;
+            }
+            if (aIndex !== -1) return -1;
+            if (bIndex !== -1) return 1;
+            return 0;
+          } catch (error) {
+            console.warn("Error sorting tokens:", error);
+            return 0;
+          }
+        });
+        const UIExchanges = groupedExchanges.filter((exchange) => {
+          try {
+            return exchange.type === "Lending Market" || exchange.type === "DEX";
+          } catch (error) {
+            console.warn(
+              `Error filtering exchange: ${exchange?.name || "unknown"}`,
+              error
+            );
+            return false;
+          }
+        }).sort((a, b) => {
+          try {
+            const aIndex = protocolOrder.indexOf(a.name);
+            const bIndex = protocolOrder.indexOf(b.name);
+            return aIndex - bIndex;
+          } catch (error) {
+            console.warn("Error sorting exchanges:", error);
+            return 0;
+          }
+        });
+        const finalUIExchanges = UIExchanges.filter((exchange) => {
+          if (exchange.name === "BalancerV3") {
+            return !UIExchanges.some((e) => e.name === "Balancer");
+          }
+          return true;
+        });
+        const autopoolInfo = getAutopoolInfo(autopool.symbol);
+        if (autopoolInfo && !autopoolInfo.description) {
+          autopoolInfo.description = `Autopool featuring ${UIBaseAsset.symbol} deployed across integrated DEXs and lending protocols on ${getNetwork(chainId)?.name}.`;
+        }
+        return {
+          ...autopool,
+          tvl,
+          totalAssets: assets,
+          destinations: filteredDestinations,
+          exchanges: groupedExchanges,
+          timestamp,
+          isNew,
+          extraRewarders: denominationData?.rewarder?.extraRewarders,
+          autopoolRewarderDisabled: aprs?.autopoolRewarderDisabled ?? false,
+          createdAt: new Date(timestamp * 1e3),
+          baseAsset: {
+            ...baseAsset,
+            price: baseAssetPrice
+          },
+          denomination: {
+            ...denominatedToken,
+            price: denominatedTokenPrice
+          },
+          useDenomination: useDenominatedValues,
+          UIBaseAsset,
+          UITokens,
+          UIExchanges: finalUIExchanges,
+          tokens: uniqueTokens,
+          chain: getNetwork(chainId),
+          apr: {
+            base: baseApr ?? null,
+            extraAprs: extraRewards,
+            combined: combinedApr,
+            hasExtraAprs: extraRewards.length > 0
+          },
+          dailyEarnings: {
+            combined: combinedDailyEarnings,
+            base: baseDailyEarnings
+          },
+          navPerShare,
+          idle: {
+            ...idle,
+            allocation: idleAllocation,
+            token: UIBaseAsset
+          },
+          category: getAutopoolCategory(baseAsset.symbol),
+          ...autopoolInfo,
+          isShutdown: autopool.symbol === "sonicUSD" ? false : autopool.isShutdown
+        };
+      })
+    );
+    return autopools;
+  } catch (e) {
+    console.error(e);
+    return [];
+  }
+};
+
+// functions/getEthPriceAtBlock.ts
+import { getCoreConfig as getCoreConfig2 } from "@tokemak/config";
+import { rootPriceOracleAbi } from "@tokemak/abis";
+import { USDC_TOKEN } from "@tokemak/tokenlist";
+var getEthPriceAtBlock = async (client, blockNumber, chainId) => {
+  const config = getCoreConfig2(chainId);
+  const rootPriceOracle = config.rootPriceOracle;
+  const weth = config.weth;
+  const usdc = USDC_TOKEN.extensions?.bridgeInfo?.[chainId]?.tokenAddress || USDC_TOKEN.address;
+  const priceAtBlock = await client.readContract({
+    address: rootPriceOracle,
+    abi: rootPriceOracleAbi,
+    functionName: "getPriceInQuote",
+    args: [weth, usdc],
+    blockNumber
+  });
+  return priceAtBlock;
+};
+
+// functions/getRebalanceStats.ts
+import { getSdkByChainId as getSdkByChainId2 } from "@tokemak/graph-cli";
+import { formatEtherNum as formatEtherNum2, formatUnitsNum as formatUnitsNum2 } from "@tokemak/utils";
+import { USDC_TOKEN as USDC_TOKEN2 } from "@tokemak/tokenlist";
+import { sonic as sonic2 } from "viem/chains";
+var BATCH_SIZE = 500;
+var fetchChainRebalances = async (chainId) => {
+  const { GetAllAutopoolRebalances } = getSdkByChainId2(chainId);
+  const allRebalances = await paginateQuery(
+    GetAllAutopoolRebalances,
+    "autopoolRebalances"
+  );
+  if (allRebalances.length === 0) {
+    return [];
+  }
+  return allRebalances;
+};
+function inferBaseAssetDecimals(rebalance, chainId) {
+  if (BigInt(rebalance.tokenOutValueBaseAsset) === BigInt(rebalance.tokenOutValueInEth)) {
+    return 18;
+  }
+  if (chainId === sonic2.id) {
+    return rebalance.tokenOut.decimals;
+  }
+  return USDC_TOKEN2.decimals;
+}
+var getRebalanceValueUsd = async (rebalance, chainId, client) => {
+  const ethWei = BigInt(rebalance.tokenOutValueInEth || "0");
+  if (ethWei === 0n) return null;
+  try {
+    const price = await getEthPriceAtBlock(
+      client,
+      BigInt(rebalance.blockNumber),
+      chainId
+    );
+    const ethUsd = Number(formatUnitsNum2(price, USDC_TOKEN2.decimals));
+    const ethAmt = Number(formatEtherNum2(ethWei));
+    const usd = ethAmt * ethUsd;
+    return usd;
+  } catch (e) {
+    console.warn(`WETH/USDC oracle unavailable for chainId: ${chainId}`);
+    return null;
+  }
+};
+var processRebalance = async (rebalance, chainId, client) => {
+  const baseDecimals = inferBaseAssetDecimals(rebalance, chainId);
+  const baseAssetAmount = Number(
+    formatUnitsNum2(
+      BigInt(rebalance.tokenOutValueBaseAsset || "0"),
+      baseDecimals
+    )
+  );
+  const ethPathUsd = await getRebalanceValueUsd(rebalance, chainId, client);
+  if (ethPathUsd != null) {
+    return {
+      autopool: rebalance.autopool,
+      timestamp: rebalance.timestamp,
+      blockNumber: rebalance.blockNumber,
+      chainId,
+      valueInUsd: ethPathUsd,
+      valueInAsset: baseAssetAmount
+    };
+  }
+  return {
+    autopool: rebalance.autopool,
+    timestamp: rebalance.timestamp,
+    blockNumber: rebalance.blockNumber,
+    chainId,
+    valueInUsd: baseAssetAmount,
+    valueInAsset: baseAssetAmount
+  };
+};
+var processRebalancesInBatches = async (rebalances, chainId, client) => {
+  const processedRebalances = [];
+  for (let i = 0; i < rebalances.length; i += BATCH_SIZE) {
+    const batch = rebalances.slice(i, i + BATCH_SIZE);
+    const batchPromises = batch.map(
+      async (rebalance) => processRebalance(rebalance, chainId, client)
+    );
+    const batchResults = await Promise.all(batchPromises);
+    processedRebalances.push(...batchResults);
+    console.log(
+      `Processed ${Math.min(i + BATCH_SIZE, rebalances.length)} of ${rebalances.length} rebalances...`
+    );
+    if (i + BATCH_SIZE < rebalances.length) {
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+    }
+  }
+  return processedRebalances;
+};
+var calculateRebalanceStats = (rebalances) => {
+  const totalRebalances = rebalances.length;
+  const totalRebalanceVolume = rebalances.reduce(
+    (acc, curr) => acc + curr.valueInUsd,
+    0
+  );
+  return {
+    totalRebalances,
+    totalRebalanceVolume,
+    rebalances
+  };
+};
+var getRebalanceStats = async (getClient, {
+  includeTestnet = false
+}) => {
+  const chains = getChainsForEnv({ includeTestnet });
+  const rebalances = await Promise.all(
+    chains.map(async (chain) => {
+      const rawRebalances = await fetchChainRebalances(chain.chainId);
+      const client = getClient(chain.chainId);
+      return processRebalancesInBatches(rawRebalances, chain.chainId, client);
+    })
+  );
+  const allRebalances = rebalances.flat();
+  return calculateRebalanceStats(allRebalances);
+};
+export {
+  calculateRebalanceStats,
+  fetchChainRebalances,
+  getChainAutopools,
+  getChainAutopoolsApr,
+  getDefillamaPrice,
+  getEthPriceAtBlock,
+  getGenStratAprs,
+  getPoolsAndDestinations,
+  getRebalanceStats,
+  getTokenPrice
+};