@tokemak/queries 0.0.9 → 0.0.11

package/dist/index.rn.js

@@ -0,0 +1,2063 @@
+import { sepolia, mainnet, sonic, base } from 'viem/chains';
+import { TOKEMAK_SWAP_PRICING_URL, SUPPORTED_DEV_CHAINS, SUPPORTED_PROD_CHAINS, TOKEMAK_GENSTRAT_APRS_API_URL } from '@tokemak/constants';
+import { ETH_TOKEN, PXETH_TOKEN, USDC_TOKEN, DOLA_TOKEN, S_TOKEN, EURC_TOKEN, USDT_TOKEN, USDT0_TOKEN, TOKE_TOKEN, SILO_TOKEN, XPL_TOKEN, WXPL_TOKEN, WETH_TOKEN, WS_TOKEN, BEETS_PROTOCOL, ALL_TOKENS, ALL_AUTOPOOLS } from '@tokemak/tokenlist';
+import { formatEtherNum, formatUnitsNum, convertTimestampToDate, formatDateToReadable, getToken, formatPoolName, getProtocol, getNetwork } from '@tokemak/utils';
+import { getAddress, hexToBigInt, formatUnits, erc20Abi } from 'viem';
+import { getSdkByChainId } from '@tokemak/graph-cli';
+import { AUTOPOOLS_WHITELIST_PROD, getMainnetConfig, getCoreConfig } from '@tokemak/config';
+import { readContract, readContracts } from '@wagmi/core';
+import { stakingV1Abi, rewardsV1Abi, accTokeV1Abi, autopoolEthAbi, rewardsV1HashAbi, systemRegistryAbi, lensAbi } from '@tokemak/abis';
+
+// functions/getEthPrice.ts
+
+// 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/getTokenPriceFallback.ts
+async function getTokenPriceFallback(tokenSymbol) {
+  try {
+    const response = await fetch(
+      "https://tokemakmarketdata.s3.amazonaws.com/current.json"
+    );
+    if (!response.ok) {
+      console.error(
+        `Request failed with status: ${response.status} - ${response.statusText}. Returning fallback.`
+      );
+      return 0;
+    }
+    const data = await response.json();
+    if (!data.prices || !(tokenSymbol in data.prices)) {
+      console.warn(
+        `Token symbol "${tokenSymbol}" not found in price data. Returning fallback.`
+      );
+      return 0;
+    }
+    return data.prices[tokenSymbol];
+  } catch (error) {
+    console.error(`Error fetching or parsing price data:`, error);
+    return 0;
+  }
+}
+
+// functions/getEthPrice.ts
+var getEthPrice = async () => {
+  try {
+    return await getTokenPrice({
+      chainId: sepolia.id,
+      tokenAddress: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"
+    });
+  } catch (error) {
+    console.warn("Primary price fetch failed. Attempting fallback...", error);
+    try {
+      const fallbackPrice = await getTokenPriceFallback("eth");
+      return fallbackPrice;
+    } catch (fallbackError) {
+      console.error("Fallback fetch also failed:", fallbackError);
+      return 0;
+    }
+  }
+};
+var getTokePrice = async () => {
+  try {
+    return await getTokenPrice({ tokenAddress: TOKE_TOKEN.address });
+  } catch (error) {
+    console.warn("Primary price fetch failed. Attempting fallback...", error);
+    try {
+      const fallbackPrice = await getTokenPriceFallback("toke");
+      return fallbackPrice;
+    } catch (fallbackError) {
+      console.error("Fallback fetch also failed:", fallbackError);
+      return 0;
+    }
+  }
+};
+
+// utils/fillMissingDates.ts
+function fillMissingDates(data) {
+  data.sort((a, b) => a.date.getTime() - b.date.getTime());
+  let filledData = [];
+  let currentDate;
+  const today = /* @__PURE__ */ new Date();
+  data.forEach((entry, index) => {
+    currentDate = new Date(entry.date);
+    filledData.push(entry);
+    let nextDay = new Date(currentDate);
+    nextDay.setDate(nextDay.getDate() + 1);
+    let nextEntry = data[index + 1];
+    while (nextEntry && nextDay < nextEntry.date) {
+      let newTimestamp = Math.floor(nextDay.getTime() / 1e3).toString();
+      let newEntry = {
+        ...entry,
+        date: new Date(nextDay),
+        timestamp: newTimestamp
+      };
+      filledData.push(newEntry);
+      nextDay.setDate(nextDay.getDate() + 1);
+    }
+    if (!nextEntry) {
+      while (nextDay <= today) {
+        let newTimestamp = Math.floor(nextDay.getTime() / 1e3).toString();
+        let newEntry = {
+          ...entry,
+          date: new Date(nextDay),
+          timestamp: newTimestamp
+        };
+        filledData.push(newEntry);
+        nextDay.setDate(nextDay.getDate() + 1);
+      }
+    }
+  });
+  return filledData;
+}
+
+// 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]
+  }));
+}
+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
+  };
+};
+var getAutopoolInfo = (symbol) => {
+  const autopool = ALL_AUTOPOOLS.find((pool) => pool.symbol === symbol);
+  return autopool;
+};
+
+// utils/findClosestEntry.ts
+function findClosestEntry(data, targetValue, propertyKey, maxDifference = Infinity, getValue) {
+  if (!data || data.length === 0)
+    return null;
+  let closestEntry = null;
+  let minDiff = Infinity;
+  for (const entry of data) {
+    const value = getValue ? getValue(entry) : entry[propertyKey];
+    if (typeof value !== "number" || isNaN(value))
+      continue;
+    const diff = Math.abs(value - targetValue);
+    if (diff < minDiff && diff <= maxDifference) {
+      minDiff = diff;
+      closestEntry = entry;
+    }
+  }
+  return closestEntry;
+}
+function findClosestTimestampEntry(data, targetTimestamp, maxDifferenceInSeconds = 3600 * 12) {
+  return findClosestEntry(
+    data,
+    targetTimestamp,
+    "timestamp",
+    maxDifferenceInSeconds
+  );
+}
+function findClosestDateEntry(data, targetDate, maxDifferenceInMs = 24 * 60 * 60 * 1e3) {
+  return findClosestEntry(
+    data,
+    targetDate.getTime(),
+    "date",
+    maxDifferenceInMs,
+    (item) => item.date.getTime()
+  );
+}
+
+// functions/getBlobData.ts
+var getBlobData = async (blobName) => {
+  try {
+    const blobUrl = `https://kg4e5p7eknl8rdgg.public.blob.vercel-storage.com/${blobName}`;
+    const response = await fetch(blobUrl, { cache: "no-store" });
+    if (!response.ok) {
+      console.warn(
+        `Failed to fetch blob data for ${blobName}: ${response.status} ${response.statusText}`
+      );
+      return null;
+    }
+    const data = await response.text();
+    return JSON.parse(data);
+  } catch (error) {
+    console.warn(`Failed to fetch blob data for ${blobName}:`, error);
+    return null;
+  }
+};
+
+// functions/getPoolsAndDestinationsBackup.ts
+var getPoolsAndDestinationsBackup = async (chainId) => {
+  try {
+    const networkName = getNetwork(chainId)?.name.toLowerCase();
+    const backupData = await getBlobData(
+      `${networkName}-getPoolsAndDestinations-latest-success.json`
+    );
+    return backupData?.data;
+  } catch (e) {
+    console.error(e);
+  }
+};
+
+// 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"
+];
+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;
+  }
+};
+var getPoolsAndDestinations = async (wagmiConfig, { chainId }) => {
+  try {
+    const { lens } = getCoreConfig(chainId);
+    const { autoPools, destinations } = await readContract(wagmiConfig, {
+      address: lens,
+      abi: lensAbi,
+      functionName: "getPoolsAndDestinations",
+      chainId
+    });
+    const autopoolsAndDestinations = mergeArraysWithKey(
+      autoPools,
+      destinations,
+      "destinations"
+    );
+    return autopoolsAndDestinations;
+  } catch (error) {
+    console.error(`Error on ${chainId} in getPoolsAndDestinations:`, error);
+  }
+};
+var getBackupApr = async (chainId, poolAddress) => {
+  try {
+    const networkName = getNetwork(chainId)?.name.toLowerCase();
+    const backupData = await getBlobData(
+      `${networkName}-getChainAutopools-latest-success.json`
+    );
+    if (backupData) {
+      const backupApr = backupData.data.find(
+        (item) => item.poolAddress.toLowerCase() === poolAddress.toLowerCase()
+      )?.apr.base;
+      return backupApr || 0;
+    }
+  } catch (e) {
+    console.error(e);
+    return 0;
+  }
+  return null;
+};
+
+// functions/getChainAutopools.ts
+var getChainAutopools = async (wagmiConfig, {
+  chainId,
+  prices
+}) => {
+  const { GetVaultAddeds, GetAutopoolsInactiveDestinations } = getSdkByChainId(chainId);
+  try {
+    const { vaultAddeds } = await GetVaultAddeds();
+    const { GetAutopoolsApr } = getSdkByChainId(chainId);
+    const { autopools: autopoolsApr } = await GetAutopoolsApr();
+    const genStratAprs = await getGenStratAprs({
+      chainId
+    });
+    let autopoolsAndDestinations = await getPoolsAndDestinations(wagmiConfig, {
+      chainId
+    });
+    if (!autopoolsAndDestinations) {
+      const backupData = await getPoolsAndDestinationsBackup(chainId);
+      if (backupData) {
+        autopoolsAndDestinations = backupData;
+      } else {
+        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() === "0x000000000000000000000000000000000000dead" || autopool.strategy === "0x0000000000000000000000000000000000000000";
+          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 uniqueExchanges = Array.from(
+          new Set(
+            destinations.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 = destinations.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 uniqueTokens = Object.values(uniqueTokensWithValueHeldMap).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 < 45;
+        const aprs = autopoolsApr.find(
+          (autopoolApr) => getAddress(autopoolApr.id) === getAddress(autopool.poolAddress)
+        );
+        let baseApr = aprs?.currentApy;
+        let boostedApr = 0;
+        let extraApr = 0;
+        const formattedRewarder7DayMAApy = formatEtherNum(
+          BigInt(Number(aprs?.rewarder?.day7MAApy) || 0)
+        );
+        const formattedRewarder30DayMAApy = formatEtherNum(
+          BigInt(Number(aprs?.rewarder?.day30MAApy) || 0)
+        );
+        if (formattedRewarder7DayMAApy > 0) {
+          boostedApr = formattedRewarder7DayMAApy;
+        }
+        if (formattedRewarder30DayMAApy > 0) {
+          boostedApr = formattedRewarder30DayMAApy;
+        }
+        if (!baseApr) {
+          const weightedCrNum = destinations.reduce((acc, cur) => {
+            return acc + cur.debtValueHeldByVaultAllocation * cur.compositeReturn;
+          }, 0);
+          const periodicFeeBps = autopool.periodicFeeBps || 0n;
+          const streamingFeeBps = autopool.streamingFeeBps || 0n;
+          baseApr = (weightedCrNum / (1 - totalIdleAssets / totalAssets) - Number(formatUnits(periodicFeeBps, 4))) * (1 - Number(formatUnits(streamingFeeBps, 4)));
+        } else {
+          baseApr = Number(formatUnits(BigInt(baseApr), baseAsset.decimals));
+        }
+        if (!baseApr) {
+          baseApr = 0;
+        }
+        if (baseApr === 0) {
+          try {
+            const backupApr = await getBackupApr(chainId, autopool.poolAddress);
+            if (backupApr) {
+              baseApr = backupApr;
+              console.log("using backup apr", backupApr);
+            }
+          } catch (e) {
+            console.error(e);
+            console.log("unable to retrieve backup apr");
+          }
+        }
+        if (baseApr === 0 && autopool.symbol.toLowerCase() === "baseusd") {
+          baseApr = 0.0914;
+        }
+        let extraRewards = [];
+        if (aprs?.rewarder?.extraRewarders?.length && aprs?.rewarder?.extraRewarders?.length > 0) {
+          extraRewards = aprs?.rewarder?.extraRewarders.map((reward) => {
+            const token = getToken(reward?.rewardToken?.id, chainId);
+            return {
+              ...token,
+              apr: formatEtherNum(BigInt(reward.currentApy || 0))
+            };
+          });
+        }
+        if (autopool?.symbol?.toLowerCase() === "plasmausd") {
+          boostedApr = 0;
+        }
+        extraApr = extraRewards.reduce((acc, reward) => acc + reward.apr, 0);
+        const combinedApr = baseApr + boostedApr + extraApr;
+        let denominatedToken = ETH_TOKEN;
+        let useDenominatedValues = false;
+        const denominatedIn = aprs?.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 / 365,
+          baseAssetPrice,
+          denominatedTokenPrice,
+          prices
+        );
+        const baseDailyEarnings = convertBaseAssetToTokenPricesAndDenom(
+          totalAssets * baseApr / 365,
+          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,
+          exchanges: groupedExchanges,
+          timestamp,
+          isNew,
+          extraRewarders: aprs?.rewarder?.extraRewarders,
+          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,
+            boosted: boostedApr,
+            extraAprs: extraRewards,
+            combined: combinedApr,
+            hasBoostedApr: boostedApr > 1e-4,
+            hasExtraAprs: extraRewards.length > 0
+          },
+          dailyEarnings: {
+            combined: combinedDailyEarnings,
+            base: baseDailyEarnings
+          },
+          navPerShare,
+          idle: {
+            ...idle,
+            allocation: idleAllocation,
+            token: UIBaseAsset
+          },
+          category: getAutopoolCategory(baseAsset.symbol),
+          ...autopoolInfo
+        };
+      })
+    );
+    return autopools;
+  } catch (e) {
+    console.error(e);
+    return [];
+  }
+};
+var getAutopools = async (wagmiConfig, {
+  prices,
+  includeTestnet = false
+}) => {
+  try {
+    const chains = getChainsForEnv({ includeTestnet });
+    const autopools = (await Promise.all(
+      chains.map(
+        (chain) => getChainAutopools(wagmiConfig, {
+          prices,
+          chainId: chain?.chainId
+        })
+      )
+    )).flat();
+    const sortedAutopoolsByTimestamp = autopools.sort(
+      (a, b) => b.timestamp - a.timestamp
+    );
+    if (includeTestnet) {
+      return sortedAutopoolsByTimestamp;
+    } else {
+      return sortedAutopoolsByTimestamp.filter((pool) => {
+        return AUTOPOOLS_WHITELIST_PROD.includes(getAddress(pool.poolAddress));
+      });
+    }
+  } catch (e) {
+    console.error(e);
+  }
+};
+var getChainUserAutopools = async ({
+  address,
+  chainId = 1
+}) => {
+  const { GetUserVaultInfo } = getSdkByChainId(chainId);
+  try {
+    if (address) {
+      const { userInfo } = await GetUserVaultInfo({
+        address
+      });
+      return userInfo?.vaults || [];
+    }
+    return [];
+  } catch (e) {
+    console.error(e);
+    return [];
+  }
+};
+var BASE_ASSETS = [
+  { ...ETH_TOKEN, symbol: "ETH", coinGeckoId: "ethereum" },
+  { ...PXETH_TOKEN, symbol: "PXETH", coinGeckoId: "dinero-staked-eth" },
+  { ...USDC_TOKEN, symbol: "USDC", coinGeckoId: "usd-coin" },
+  { ...DOLA_TOKEN, symbol: "DOLA", coinGeckoId: "dola-usd" },
+  { ...S_TOKEN, symbol: "S" },
+  { ...EURC_TOKEN, symbol: "EURC", coinGeckoId: "euro-coin" },
+  { ...USDT_TOKEN, symbol: "USDT", coinGeckoId: "tether" },
+  { ...USDT0_TOKEN, symbol: "USDT0", coinGeckoId: "tether" }
+];
+var PRICED_TOKENS = [
+  ...BASE_ASSETS,
+  { ...TOKE_TOKEN, symbol: "TOKE" },
+  { ...SILO_TOKEN, symbol: "SILO" },
+  { ...XPL_TOKEN, address: WXPL_TOKEN.address, symbol: "XPL" },
+  { ...USDT0_TOKEN, symbol: "USDT0" }
+];
+[
+  { ...WETH_TOKEN, symbol: "WETH" },
+  { ...WS_TOKEN, symbol: "WS" },
+  { ...WXPL_TOKEN, symbol: "WXPL" }
+];
+var getUserAutopool = async (wagmiConfig, {
+  address,
+  autopool
+}) => {
+  try {
+    if (autopool && address) {
+      const autopoolContract = {
+        address: autopool?.poolAddress,
+        abi: autopoolEthAbi,
+        chainId: autopool?.chain?.chainId
+      };
+      const [
+        { result: autopoolRewarderContract },
+        { result: pastRewarders },
+        { result: unstakedPoolShares, error: unstakedPoolSharesError }
+      ] = await readContracts(wagmiConfig, {
+        contracts: [
+          {
+            ...autopoolContract,
+            functionName: "rewarder",
+            args: []
+          },
+          {
+            ...autopoolContract,
+            functionName: "getPastRewarders",
+            args: []
+          },
+          {
+            ...autopoolContract,
+            functionName: "balanceOf",
+            args: [address]
+          }
+        ]
+      });
+      if (!autopoolRewarderContract) {
+        throw new Error("No rewarder contract found");
+      }
+      if (unstakedPoolSharesError) {
+        throw new Error("Error fetching unstaked pool shares");
+      }
+      const stakedPoolShares = await readContract(wagmiConfig, {
+        address: autopoolRewarderContract,
+        abi: erc20Abi,
+        functionName: "balanceOf",
+        args: [address],
+        chainId: autopool?.chain?.chainId
+      });
+      const stakedShares = formatEtherNum(stakedPoolShares);
+      const stakedNav = stakedShares * (autopool?.navPerShare.baseAsset || 0);
+      const stakedNavUsd = stakedShares * (autopool?.navPerShare.USD || 0);
+      const unstakedShares = formatEtherNum(unstakedPoolShares || 0n);
+      const unstakedNav = unstakedShares * (autopool?.navPerShare.USD || 0);
+      const unstakedNavUsd = unstakedShares * (autopool?.navPerShare.USD || 0);
+      const totalShares = unstakedShares + stakedShares;
+      const totalNav = totalShares * (autopool?.navPerShare.baseAsset || 0);
+      const totalNavUsd = totalShares * (autopool?.navPerShare.USD || 0);
+      const totalNavDenominated = totalShares * (autopool?.navPerShare.denom || 0);
+      let pastRewarderBalances = [];
+      if (pastRewarders && pastRewarders?.length > 0) {
+        const pastRewardBalances = pastRewarders.map((rewarder) => ({
+          address: rewarder,
+          abi: erc20Abi,
+          functionName: "balanceOf",
+          args: [address],
+          chainId: autopool?.chain?.chainId
+        }));
+        const pastRewards = await readContracts(wagmiConfig, {
+          contracts: pastRewardBalances
+        });
+        pastRewarderBalances = pastRewards.map(({ result }, index) => {
+          const balance = result;
+          const shares = formatEtherNum(result);
+          const nav = shares * (autopool?.navPerShare.baseAsset || 0);
+          const navUsd = shares * (autopool?.navPerShare.USD || 0);
+          return {
+            rewarderContract: pastRewarders[index],
+            balance,
+            shares,
+            nav,
+            navUsd
+          };
+        });
+      }
+      return {
+        staked: {
+          balance: stakedPoolShares,
+          shares: stakedShares,
+          nav: stakedNav,
+          navUsd: stakedNavUsd
+        },
+        unstaked: {
+          balance: unstakedPoolShares,
+          shares: unstakedShares,
+          nav: unstakedNav,
+          navUsd: unstakedNavUsd
+        },
+        pastRewarderBalances,
+        totalShares,
+        totalNav,
+        totalNavUsd,
+        totalNavDenominated,
+        useDenomination: autopool?.useDenomination,
+        denomination: autopool?.denomination
+      };
+    }
+    return {
+      staked: {
+        balance: 0n,
+        shares: 0,
+        nav: 0,
+        navUsd: 0
+      },
+      unstaked: {
+        balance: 0n,
+        shares: 0,
+        nav: 0,
+        navUsd: 0
+      },
+      totalNavDenominated: 0,
+      totalShares: 0,
+      totalNav: 0,
+      totalNavUsd: 0
+    };
+  } catch (e) {
+    console.error(e);
+  }
+};
+
+// functions/getUserAutopools.ts
+function accumulateMap(dest, delta, multiplier = 1) {
+  for (const [key, val] of Object.entries(delta)) {
+    dest[key] = (dest[key] ?? 0) + val * multiplier;
+  }
+}
+var createInitialCurrencyValues = () => {
+  const currencies = Object.fromEntries([
+    ...PRICED_TOKENS.map((token) => [token.symbol, 0]),
+    ["USD", 0]
+  ]);
+  return currencies;
+};
+var initialAutopoolsValue = {
+  nav: createInitialCurrencyValues(),
+  supplied: createInitialCurrencyValues(),
+  returns: createInitialCurrencyValues(),
+  idle: { ...createInitialCurrencyValues(), allocation: 0 },
+  avgDailyReturns: createInitialCurrencyValues(),
+  apr: 0,
+  totalDeposits: 0,
+  totalWithdrawals: 0
+};
+var getUserAutopools = async ({
+  address,
+  includeTestnet = false,
+  autopools,
+  userActivity,
+  prices,
+  config
+}) => {
+  try {
+    const chains = getChainsForEnv({ includeTestnet });
+    const userAutopools = (await Promise.all(
+      chains.map(
+        (chain) => getChainUserAutopools({
+          address,
+          chainId: chain.chainId
+        })
+      )
+    )).flat();
+    const userExchanges = {};
+    const userTokens = {};
+    const userPools = {};
+    if (autopools && autopools.length > 0 && userAutopools.length > 0 && prices) {
+      const userAutoDOLA = await getUserAutopool(config, {
+        address,
+        autopool: autopools.find((autopool) => autopool.symbol === "autoDOLA")
+      });
+      let categories = {
+        usd: { ...initialAutopoolsValue },
+        eth: { ...initialAutopoolsValue },
+        crypto: { ...initialAutopoolsValue },
+        stables: { ...initialAutopoolsValue }
+      };
+      const userAutopoolsWithData = userAutopools.map((userAutopool) => {
+        const autopoolData = autopools.find(
+          (autopool) => autopool.poolAddress.toLowerCase() === userAutopool.vaultAddress.toLowerCase()
+        );
+        if (autopoolData) {
+          const isDOLA = autopoolData.symbol === "autoDOLA" && userAutoDOLA;
+          const userShares = isDOLA ? userAutoDOLA?.totalShares : formatEtherNum(userAutopool?.totalShares);
+          const totalVaultShares = formatEtherNum(autopoolData?.totalSupply);
+          const userShareOfVault = userShares / totalVaultShares;
+          const totalDeposits = formatUnitsNum(
+            userActivity?.totals[userAutopool.vaultAddress]?.totalDeposits || 0n,
+            autopoolData?.baseAsset.decimals
+          );
+          const totalWithdrawals = formatUnitsNum(
+            userActivity?.totals[userAutopool.vaultAddress]?.totalWithdrawals || 0n,
+            autopoolData?.baseAsset.decimals
+          );
+          const poolEvents = userActivity?.events.filter(
+            (event) => event.vaultAddress === userAutopool.vaultAddress
+          );
+          let lastDeposit;
+          if (poolEvents && poolEvents?.length > 0) {
+            lastDeposit = convertTimestampToDate(
+              poolEvents[poolEvents.length - 1].timestamp
+            ).toLocaleDateString("en-US", {
+              day: "2-digit",
+              month: "short",
+              year: "numeric"
+            });
+          }
+          autopoolData?.exchanges.forEach((exchange) => {
+            if (userExchanges[exchange.name]) {
+              userExchanges[exchange.name].value += userShareOfVault * exchange.value;
+              userExchanges[exchange.name].valueUsd += userShareOfVault * exchange.valueUsd;
+            } else {
+              userExchanges[exchange.name] = {
+                ...exchange,
+                value: userShareOfVault * exchange.value,
+                valueUsd: userShareOfVault * exchange.valueUsd
+              };
+            }
+          });
+          let categoryKey = autopoolData.category;
+          autopoolData?.tokens.forEach((token) => {
+            if (userTokens[token.address]) {
+              userTokens[token.address].value += userShareOfVault * token.value;
+              userTokens[token.address].valueUsd += userShareOfVault * token.valueUsd;
+            } else {
+              userTokens[token.address] = {
+                ...token,
+                value: userShareOfVault * token.value,
+                valueUsd: userShareOfVault * token.valueUsd
+              };
+            }
+          });
+          autopoolData?.destinations.forEach((pool) => {
+            if (userPools[pool.vaultAddress]) {
+              userPools[pool.vaultAddress].debtValueHeldByVaultEth += userShareOfVault * pool.debtValueHeldByVaultEth;
+              userPools[pool.vaultAddress].debtValueHeldByVaultUsd += userShareOfVault * pool.debtValueHeldByVaultUsd;
+            } else {
+              userPools[pool.vaultAddress] = {
+                ...pool,
+                debtValueHeldByVaultEth: userShareOfVault * pool.debtValueHeldByVaultEth,
+                debtValueHeldByVaultUsd: userShareOfVault * pool.debtValueHeldByVaultUsd
+              };
+            }
+          });
+          const userNav = userShares * autopoolData?.navPerShare.baseAsset;
+          const userReturns = userNav + totalWithdrawals - totalDeposits;
+          const userSupplied = totalDeposits - totalWithdrawals;
+          const userIdle = userShareOfVault * autopoolData?.idle.baseAsset;
+          let nav2 = convertBaseAssetToTokenPricesAndDenom(
+            userNav,
+            autopoolData?.baseAsset.price,
+            autopoolData.denomination.price,
+            prices
+          );
+          const returns2 = convertBaseAssetToTokenPricesAndDenom(
+            userReturns,
+            autopoolData?.baseAsset.price,
+            autopoolData.denomination.price,
+            prices
+          );
+          const supplied2 = convertBaseAssetToTokenPricesAndDenom(
+            userSupplied,
+            autopoolData?.baseAsset.price,
+            autopoolData.denomination.price,
+            prices
+          );
+          const idle2 = convertBaseAssetToTokenPricesAndDenom(
+            userIdle,
+            autopoolData?.baseAsset.price,
+            autopoolData.denomination.price,
+            prices
+          );
+          const prev = categories[categoryKey];
+          const idleDelta = {
+            [autopoolData.UIBaseAsset.symbol]: autopoolData.idle.baseAsset,
+            USD: autopoolData.idle.USD
+          };
+          const navDelta = nav2;
+          const returnsDelta = returns2;
+          const suppliedDelta = supplied2;
+          const updatedIdle = { ...prev.idle };
+          accumulateMap(updatedIdle, idleDelta, userShareOfVault);
+          updatedIdle.allocation = 0;
+          const updatedNav = { ...prev.nav };
+          accumulateMap(updatedNav, navDelta);
+          const updatedReturns = { ...prev.returns };
+          accumulateMap(updatedReturns, returnsDelta);
+          const updatedSupplied = { ...prev.supplied };
+          accumulateMap(updatedSupplied, suppliedDelta);
+          categories[categoryKey] = {
+            ...prev,
+            idle: updatedIdle,
+            nav: updatedNav,
+            returns: updatedReturns,
+            supplied: updatedSupplied,
+            totalDeposits: prev.totalDeposits + totalDeposits,
+            totalWithdrawals: prev.totalWithdrawals + totalWithdrawals
+          };
+          const stakedBalance = isDOLA ? userAutoDOLA?.staked.balance : BigInt(userAutopool?.stakedShares);
+          const stakedShares = isDOLA ? userAutoDOLA?.staked.shares : formatEtherNum(stakedBalance);
+          const stakedNav = stakedShares * (autopoolData?.navPerShare.baseAsset || 0);
+          const staked = convertBaseAssetToTokenPrices(
+            stakedNav,
+            autopoolData?.baseAsset.price,
+            prices
+          );
+          const unstakedBalance = isDOLA ? userAutoDOLA?.unstaked.balance : BigInt(userAutopool?.walletShares);
+          const unstakedShares = isDOLA ? userAutoDOLA?.unstaked.shares : formatEtherNum(unstakedBalance);
+          const unstakedNav = unstakedShares * (autopoolData?.navPerShare.baseAsset || 0);
+          const unstaked = convertBaseAssetToTokenPrices(
+            unstakedNav,
+            autopoolData?.baseAsset.price,
+            prices
+          );
+          const stakedRatio = stakedShares / userShares;
+          const unstakedRatio = 1 - stakedRatio;
+          const isSilo = autopoolData?.symbol === "siloETH" || autopoolData?.symbol === "siloUSD";
+          const baseApr = autopoolData?.apr?.base ?? 0;
+          const stakedAprForBlend = isSilo ? baseApr : autopoolData?.apr?.combined ?? 0;
+          const blendedApr = stakedRatio * stakedAprForBlend + unstakedRatio * baseApr;
+          return {
+            name: autopoolData?.name,
+            symbol: autopoolData?.symbol,
+            poolAddress: autopoolData?.poolAddress,
+            shares: userShares,
+            nav: nav2,
+            returns: returns2,
+            supplied: supplied2,
+            idle: idle2,
+            totalDeposits,
+            totalWithdrawals,
+            staked: {
+              balance: stakedBalance,
+              shares: stakedShares,
+              nav: staked
+            },
+            unstaked: {
+              balance: unstakedBalance,
+              shares: unstakedShares,
+              nav: unstaked
+            },
+            useDenomination: autopoolData?.useDenomination,
+            baseApr,
+            blendedApr,
+            rewardsClaimed: userAutopool?.rewardsClaimed,
+            lastDeposit,
+            baseAsset: autopoolData?.UIBaseAsset,
+            denomination: autopoolData?.denomination,
+            category: categoryKey
+          };
+        }
+      });
+      let denominatedToken = ETH_TOKEN;
+      const useDenomination = userAutopoolsWithData.filter((autopool) => autopool?.useDenomination).length === 1 && userAutopoolsWithData.length === 1;
+      if (useDenomination) {
+        const autopoolWithDenomination = userAutopoolsWithData.find(
+          (autopool) => autopool?.useDenomination
+        );
+        if (autopoolWithDenomination) {
+          denominatedToken = autopoolWithDenomination?.denomination;
+        }
+      }
+      const nav = Object.values(categories).reduce((acc, { nav: nav2 }) => {
+        return Object.keys(nav2).reduce((sumAcc, key) => {
+          const typedKey = key;
+          sumAcc[typedKey] = (sumAcc[typedKey] || 0) + nav2[typedKey];
+          return sumAcc;
+        }, acc);
+      }, {});
+      const idleWithTokenPrices = userAutopoolsWithData.reduce(
+        (acc, userAutopool) => {
+          if (!userAutopool)
+            return acc;
+          const baseAssetSymbol = userAutopool.baseAsset.symbol;
+          const existingEntry = acc.find(
+            (entry) => entry.token.symbol === baseAssetSymbol
+          );
+          if (existingEntry) {
+            Object.entries(userAutopool.idle).forEach(([key, value]) => {
+              if (key in existingEntry) {
+                existingEntry[key] += value || 0;
+              }
+            });
+          } else {
+            acc.push({
+              ...userAutopool.idle,
+              token: userAutopool.baseAsset
+            });
+          }
+          return acc;
+        },
+        []
+      );
+      const idle = idleWithTokenPrices.map((idle2) => ({
+        ...idle2,
+        allocation: idle2.USD / nav.USD
+      }));
+      const returns = Object.values(categories).reduce((acc, { returns: returns2 }) => {
+        return Object.keys(returns2).reduce((sumAcc, key) => {
+          const typedKey = key;
+          sumAcc[typedKey] = (sumAcc[typedKey] || 0) + returns2[typedKey];
+          return sumAcc;
+        }, acc);
+      }, {});
+      const supplied = Object.values(categories).reduce((acc, { supplied: supplied2 }) => {
+        return Object.keys(supplied2).reduce((sumAcc, key) => {
+          const typedKey = key;
+          sumAcc[typedKey] = (sumAcc[typedKey] || 0) + supplied2[typedKey];
+          return sumAcc;
+        }, acc);
+      }, {});
+      const userExchangesWithAllocations = Object.values(userExchanges).map(
+        (userExchange) => {
+          return {
+            ...userExchange,
+            allocation: userExchange.valueUsd / nav.USD
+          };
+        }
+      );
+      const userTokensWithAllocations = Object.values(userTokens).map(
+        (userToken) => {
+          return {
+            ...userToken,
+            allocation: userToken.valueUsd / nav.USD
+          };
+        }
+      );
+      const userPoolsWithAllocations = Object.values(userPools).map(
+        (userPool) => {
+          return {
+            ...userPool,
+            debtValueHeldByVaultAllocation: userPool.debtValueHeldByVaultUsd / nav.USD
+          };
+        }
+      );
+      const userWeightedApr = userAutopoolsWithData.reduce((acc, autopool) => {
+        if (!autopool)
+          return acc;
+        return acc + autopool?.blendedApr * (autopool?.nav.USD / nav.USD);
+      }, 0);
+      let [lowestApr, highestApr] = [0, 0];
+      const aprValues = userAutopoolsWithData.map((autopool) => autopool?.blendedApr).filter((apr) => apr !== void 0 && apr !== null);
+      lowestApr = Math.min(...aprValues);
+      highestApr = Math.max(...aprValues);
+      const avgDailyReturns = userWeightedApr / 365;
+      const avgDailyReturnsUsd = avgDailyReturns * nav.USD;
+      const activeBaseAssets = Object.values(categories).filter(
+        (category) => category.nav.USD > 0
+      );
+      const hasMultipleBaseAssets = activeBaseAssets.length > 1;
+      const categoryAprs = Object.keys(categories).reduce(
+        (acc, categoryKey) => {
+          const apr = userAutopoolsWithData.reduce((aprAcc, autopool) => {
+            if (!autopool)
+              return aprAcc;
+            if (autopool?.category === categoryKey) {
+              return aprAcc + autopool?.blendedApr * (autopool?.nav.USD / categories[categoryKey].nav.USD);
+            }
+            return aprAcc;
+          }, 0);
+          return {
+            ...acc,
+            [categoryKey]: apr
+          };
+        },
+        {}
+      );
+      Object.keys(categories).forEach((categoryKey) => {
+        const categoryData = categories[categoryKey];
+        const apr = categoryAprs[categoryKey] || 0;
+        const dailyRate = apr / 365;
+        categories[categoryKey] = {
+          ...categoryData,
+          apr,
+          avgDailyReturns: Object.keys(categoryData.nav).reduce((acc, key) => {
+            const typedKey = key;
+            acc[typedKey] = dailyRate * categoryData.nav[typedKey];
+            return acc;
+          }, {})
+        };
+      });
+      return {
+        nav,
+        idle,
+        supplied,
+        returns,
+        categories,
+        exchanges: userExchangesWithAllocations,
+        tokens: userTokensWithAllocations,
+        pools: userPoolsWithAllocations,
+        autopools: userAutopoolsWithData,
+        avgDailyReturnsUsd,
+        useDenomination,
+        denominatedToken,
+        weightedApr: userWeightedApr,
+        lowestApr,
+        highestApr,
+        hasMultipleBaseAssets
+      };
+    }
+  } catch (e) {
+    console.log(e);
+  }
+};
+var getChainUserAutopoolsHistory = async ({
+  address,
+  chainId = 1
+}) => {
+  const { GetUserVaultsDayData } = getSdkByChainId(chainId);
+  const oneYearAgoTimestamp = Math.floor(Date.now() / 1e3) - 365 * 24 * 60 * 60;
+  try {
+    if (address) {
+      const { userVaultDayDatas } = await GetUserVaultsDayData({
+        address,
+        timestamp: oneYearAgoTimestamp
+      });
+      return userVaultDayDatas;
+    }
+    return [];
+  } catch (e) {
+    console.error(e);
+    return [];
+  }
+};
+var getTokenValueDayDatas = async (tokenAddress, chainId = mainnet.id) => {
+  const { GetTokenValueDayDatas } = getSdkByChainId(chainId);
+  try {
+    const { tokenValueDayDatas } = await GetTokenValueDayDatas({
+      tokenAddress: tokenAddress.toLowerCase()
+    });
+    const historicalPrice = tokenValueDayDatas.map((tokenValueDayData) => {
+      const date = convertTimestampToDate(
+        tokenValueDayData.lastSnapshotTimestamp
+      );
+      const usdPrice = formatUnits(tokenValueDayData.priceInUsd, 8);
+      return {
+        timestamp: Number(tokenValueDayData.lastSnapshotTimestamp),
+        date,
+        price: usdPrice
+      };
+    });
+    return historicalPrice;
+  } catch (e) {
+    console.error(e);
+  }
+};
+var hasCoinGeckoId = (asset) => typeof asset?.coinGeckoId === "string" && asset.coinGeckoId.length > 0;
+var getBlobHistoricalTokenPrices = async (tokenSymbol) => {
+  const blobName = `historical_v2/${tokenSymbol}-latest-success.json`;
+  const res = await getBlobData(blobName);
+  if (!res?.data || !Array.isArray(res.data))
+    return [];
+  return res.data.map(({ timestamp, date, price }) => ({
+    timestamp,
+    date,
+    price
+  }));
+};
+var getHistoricalTokenPrices = async () => {
+  const ETH_ADDRESS_IN_SUBGRAPH = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+  const historicalBaseAssetPrices = await Promise.all(
+    BASE_ASSETS.map(async (baseAsset) => {
+      if (!hasCoinGeckoId(baseAsset)) {
+        const address = baseAsset.address === ETH_TOKEN.address ? ETH_ADDRESS_IN_SUBGRAPH : baseAsset.address;
+        const prices2 = await getTokenValueDayDatas(
+          address,
+          baseAsset.chainId
+        );
+        return { ...baseAsset, prices: prices2 ?? [] };
+      }
+      const prices = await getBlobHistoricalTokenPrices(baseAsset.symbol);
+      return { ...baseAsset, prices };
+    })
+  );
+  const allTimestamps = /* @__PURE__ */ new Set();
+  historicalBaseAssetPrices.forEach((asset) => {
+    asset.prices?.forEach((priceData) => {
+      if (priceData?.timestamp) {
+        allTimestamps.add(priceData.timestamp);
+      }
+    });
+  });
+  const sortedTimestamps = Array.from(allTimestamps).sort((a, b) => a - b);
+  const historicalTokenPrices = sortedTimestamps.map(
+    (timestamp) => {
+      const prices = {};
+      const baseAssetsWithUsd = [
+        ...BASE_ASSETS.map((asset) => asset.symbol),
+        "USD"
+      ];
+      const usdPrices = /* @__PURE__ */ new Map();
+      baseAssetsWithUsd.forEach((asset) => {
+        if (asset !== "USD") {
+          const assetData = historicalBaseAssetPrices.find(
+            (a) => a.symbol === asset
+          );
+          const priceData = findClosestTimestampEntry(
+            assetData?.prices || [],
+            timestamp
+          );
+          usdPrices.set(asset, priceData ? parseFloat(priceData.price) : 0);
+        }
+      });
+      baseAssetsWithUsd.forEach((asset1) => {
+        prices[asset1] = {};
+        baseAssetsWithUsd.forEach((asset2) => {
+          if (asset1 === asset2) {
+            prices[asset1][asset2] = 1;
+          } else if (asset1 === "USD") {
+            prices[asset1][asset2] = usdPrices.get(asset2) || 0;
+          } else if (asset2 === "USD") {
+            prices[asset1][asset2] = usdPrices.get(asset1) || 0;
+          } else {
+            const asset1UsdPrice = usdPrices.get(asset1) || 0;
+            const asset2UsdPrice = usdPrices.get(asset2) || 0;
+            prices[asset1][asset2] = asset2UsdPrice > 0 ? asset1UsdPrice / asset2UsdPrice : 0;
+          }
+        });
+      });
+      return {
+        timestamp,
+        date: new Date(timestamp * 1e3),
+        prices
+      };
+    }
+  );
+  return historicalTokenPrices;
+};
+
+// functions/getUserAutopoolsHistory.ts
+var ONE_DAY_IN_MS = 24 * 60 * 60 * 1e3;
+function validateEnhancedUserHistoryEntry(entry) {
+  return entry && typeof entry === "object" && entry.date instanceof Date && typeof entry.timestamp === "string" && Array.isArray(entry.autopools) && entry.nav && typeof entry.nav.ETH === "number" && typeof entry.nav.USD === "number" && typeof entry.nav.PXETH === "number" && typeof entry.nav.USDC === "number" && typeof entry.nav.EURC === "number" && typeof entry.nav.USDT === "number" && Array.isArray(entry.events) && typeof entry.differential === "number";
+}
+var getUserAutopoolsHistory = async (address, autopoolsHistory, events, includeTestnet = false) => {
+  if (!autopoolsHistory) {
+    throw new Error("No autopools history found");
+  }
+  if (!events) {
+    throw new Error("No events found");
+  }
+  const chains = getChainsForEnv({ includeTestnet });
+  const userHistory = (await Promise.all(
+    chains.map(
+      (chain) => getChainUserAutopoolsHistory({
+        address,
+        chainId: chain.chainId
+      })
+    )
+  )).flat();
+  const groupedByVault = userHistory.reduce((acc, data) => {
+    const vaultId = data.vaultAddress.toLowerCase();
+    if (!acc[vaultId]) {
+      acc[vaultId] = [];
+    }
+    acc[vaultId].push({
+      ...data,
+      date: new Date(data.timestamp * 1e3),
+      timestamp: data.timestamp,
+      vaultAddress: data.vaultAddress
+    });
+    return acc;
+  }, {});
+  const filledDataByVault = Object.entries(groupedByVault).reduce(
+    (acc, [vaultId, vaultData]) => {
+      acc[vaultId] = fillMissingDates(vaultData);
+      return acc;
+    },
+    {}
+  );
+  const historicalBaseAssetPrices = await getHistoricalTokenPrices();
+  const mergedHistory = Object.keys(filledDataByVault).reduce(
+    (acc, vaultId) => {
+      if (autopoolsHistory[vaultId]) {
+        const autopoolHistory = autopoolsHistory[vaultId];
+        const userHistory2 = filledDataByVault[vaultId];
+        userHistory2.sort((a, b) => a.date.getTime() - b.date.getTime());
+        const mergedData = autopoolHistory.reduce((result2, dayData) => {
+          const userHistoryData = findClosestDateEntry(
+            userHistory2,
+            dayData.date,
+            ONE_DAY_IN_MS
+          );
+          if (userHistoryData) {
+            const DECIMALS = BigInt(dayData.baseAsset.decimals);
+            const SCALE = 10n ** DECIMALS;
+            const sharesRatio = userHistoryData.totalShares / dayData.totalSupply;
+            const sharesRatioBigInt = BigInt(
+              Math.floor(sharesRatio * Number(SCALE))
+            );
+            const navBigInt = sharesRatioBigInt * BigInt(dayData.nav) / SCALE;
+            const navNum = formatUnitsNum(
+              navBigInt,
+              dayData.baseAsset.decimals
+            );
+            if (!historicalBaseAssetPrices) {
+              throw new Error("No historical price data found");
+            }
+            const historicalPriceData = findClosestTimestampEntry(
+              historicalBaseAssetPrices,
+              Number(dayData.timestamp)
+            );
+            if (!historicalPriceData) {
+              throw new Error("No historical price data found");
+            }
+            let pricesOfBaseAsset = historicalPriceData.prices[dayData.baseAsset.symbol.toUpperCase()];
+            if (!pricesOfBaseAsset) {
+              pricesOfBaseAsset = historicalPriceData.prices[dayData.baseAsset.extensions?.parentAsset?.toUpperCase()];
+            }
+            let nav = {};
+            nav = Object.keys(pricesOfBaseAsset).reduce((acc2, currency) => {
+              acc2[currency] = navNum * pricesOfBaseAsset[currency];
+              return acc2;
+            }, {});
+            result2.push({
+              id: dayData.id + `-${address}`,
+              vaultAddress: dayData.vault.id,
+              timestamp: dayData.timestamp,
+              baseAsset: dayData.baseAsset,
+              date: dayData.date,
+              nav,
+              shares: userHistoryData.totalShares,
+              rewardsClaimed: userHistoryData.rewardsClaimed
+            });
+          }
+          return result2;
+        }, []);
+        acc[vaultId] = mergedData;
+      }
+      return acc;
+    },
+    {}
+  );
+  const aggregatedHistoryArray = Object.values(mergedHistory).flat().reduce((acc, dayData) => {
+    const timestampKey = dayData.timestamp;
+    if (!acc[timestampKey]) {
+      acc[timestampKey] = {
+        timestamp: dayData.timestamp,
+        nav: {
+          ETH: 0,
+          USD: 0,
+          PXETH: 0,
+          USDC: 0,
+          EURC: 0,
+          USDT: 0
+        },
+        date: dayData.date,
+        autopools: {}
+      };
+    }
+    acc[timestampKey].autopools[dayData.vaultAddress] = dayData;
+    acc[timestampKey].nav.USD += dayData.nav.USD;
+    acc[timestampKey].nav.ETH += dayData.nav.ETH;
+    acc[timestampKey].nav.PXETH += dayData.nav.PXETH;
+    acc[timestampKey].nav.USDC += dayData.nav.USDC;
+    acc[timestampKey].nav.EURC += dayData.nav.EURC;
+    acc[timestampKey].nav.USDT += dayData.nav.USDT;
+    return acc;
+  }, {});
+  let finalAggregatedHistoryArray = Object.keys(aggregatedHistoryArray).map(
+    (dateKey) => ({
+      date: aggregatedHistoryArray[dateKey].date,
+      formattedDate: formatDateToReadable(aggregatedHistoryArray[dateKey].date),
+      nav: {
+        ETH: aggregatedHistoryArray[dateKey].nav.ETH,
+        USD: aggregatedHistoryArray[dateKey].nav.USD,
+        PXETH: aggregatedHistoryArray[dateKey].nav.PXETH,
+        USDC: aggregatedHistoryArray[dateKey].nav.USDC,
+        EURC: aggregatedHistoryArray[dateKey].nav.EURC,
+        USDT: aggregatedHistoryArray[dateKey].nav.USDT
+      },
+      timestamp: aggregatedHistoryArray[dateKey].timestamp,
+      autopools: Object.values(aggregatedHistoryArray[dateKey].autopools)
+    })
+  );
+  let updatedAggregatedHistoryArray = finalAggregatedHistoryArray.map(
+    (dayData) => {
+      return {
+        ...dayData,
+        nav: {
+          ETH: dayData.nav.ETH,
+          USD: dayData.nav.USD,
+          PXETH: dayData.nav.PXETH,
+          USDC: dayData.nav.USDC,
+          EURC: dayData.nav.EURC,
+          USDT: dayData.nav.USDT
+        }
+      };
+    }
+  );
+  updatedAggregatedHistoryArray = updatedAggregatedHistoryArray.map(
+    (dayData) => {
+      const eventsForDay = events?.filter((event) => {
+        const eventDate = new Date(Number(event.timestamp) * 1e3);
+        return eventDate.getTime() >= dayData.date.getTime() && eventDate.getTime() < dayData.date.getTime() + 24 * 60 * 60 * 1e3;
+      });
+      const differential = eventsForDay.reduce(
+        (sum, event) => sum + formatEtherNum(BigInt(event?.assetChange || 0n)),
+        0
+      );
+      return {
+        ...dayData,
+        events: eventsForDay,
+        differential
+      };
+    }
+  );
+  const result = updatedAggregatedHistoryArray;
+  const allValid = result.every(validateEnhancedUserHistoryEntry);
+  if (!allValid) {
+    throw new Error(
+      "Invalid history entry detected: missing required properties"
+    );
+  }
+  return result;
+};
+
+// functions/getRewardsPayloadV1.ts
+var getRewardsPayloadV1 = async (cycleHash, account, rewardsV1Url) => {
+  const userRewardUrl = `${rewardsV1Url}/${cycleHash}/${account.toLowerCase()}.json`;
+  try {
+    const response = await fetch(userRewardUrl, { method: "GET" });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    return data;
+  } catch (e) {
+    console.log("Error fetching rewards payload:", e);
+    return null;
+  }
+};
+
+// functions/getUserRewardsV1.ts
+var getUserRewardsV1 = async (wagmiConfig, {
+  address,
+  rewardsCycleIndex,
+  rewardsV1,
+  rewardsV1Url,
+  rewardsV1Hash,
+  chainId
+}) => {
+  try {
+    const [latestClaimableHash, cycleRewardsHash] = await readContract(
+      wagmiConfig,
+      {
+        address: rewardsV1Hash,
+        abi: rewardsV1HashAbi,
+        functionName: "cycleHashes",
+        args: [rewardsCycleIndex],
+        chainId
+      }
+    );
+    const rewardsPayload = await getRewardsPayloadV1(
+      cycleRewardsHash,
+      address,
+      rewardsV1Url
+    );
+    const latestClaimablePayload = await getRewardsPayloadV1(
+      latestClaimableHash,
+      address,
+      rewardsV1Url
+    );
+    if (latestClaimablePayload) {
+      const {
+        payload: { chainId: payloadChainId, cycle, wallet, amount }
+      } = latestClaimablePayload;
+      const claimable = await readContract(wagmiConfig, {
+        address: rewardsV1,
+        abi: rewardsV1Abi,
+        functionName: "getClaimableAmount",
+        args: [{ chainId: payloadChainId, cycle, wallet, amount }],
+        chainId
+      });
+      return { claimable, rewardsPayload, latestClaimablePayload };
+    }
+    return { rewardsPayload, latestClaimablePayload };
+  } catch (e) {
+    console.log(e);
+  }
+};
+var getUserV1 = async (wagmiConfig, {
+  currentCycleIndex,
+  address,
+  chainId
+}) => {
+  const {
+    stakingV1,
+    rewardsV1Url,
+    accTokeV1RewardsHash,
+    rewardsV1Hash,
+    accTokeV1Rewards,
+    autoEthGuardedRewards,
+    rewardsV1,
+    missedTokeRewards
+  } = getMainnetConfig(mainnet.id);
+  try {
+    const userStakedTokeV1 = await readContract(wagmiConfig, {
+      address: stakingV1,
+      abi: stakingV1Abi,
+      functionName: "availableForWithdrawal",
+      args: [address, 0n],
+      chainId: mainnet.id
+    });
+    const tokeRewards = await getUserRewardsV1(wagmiConfig, {
+      address,
+      rewardsCycleIndex: currentCycleIndex - 1n,
+      rewardsV1,
+      rewardsV1Url,
+      rewardsV1Hash,
+      chainId
+    });
+    const ethRewards = await getUserRewardsV1(wagmiConfig, {
+      address,
+      rewardsCycleIndex: 306n,
+      rewardsV1: accTokeV1Rewards,
+      rewardsV1Url,
+      rewardsV1Hash: accTokeV1RewardsHash,
+      chainId
+    });
+    const autoEthGuardedRewardsPayload = await getRewardsPayloadV1(
+      "QmcJgQ42aGTsqngSBa98qxnbv2CHyk9DmSg1jDD569bnpp",
+      address,
+      rewardsV1Url
+    );
+    const payloadChainId = autoEthGuardedRewardsPayload?.payload?.chainId;
+    const cycle = autoEthGuardedRewardsPayload?.payload?.cycle;
+    const wallet = autoEthGuardedRewardsPayload?.payload?.wallet;
+    const amount = autoEthGuardedRewardsPayload?.payload?.amount;
+    const claimableAutoEth = await readContract(wagmiConfig, {
+      address: autoEthGuardedRewards,
+      abi: rewardsV1Abi,
+      functionName: "getClaimableAmount",
+      args: [
+        {
+          chainId: payloadChainId || 0n,
+          cycle: cycle || 0n,
+          wallet: wallet || "0x0000000000000000000000000000000000000000",
+          amount: amount || 0n
+        }
+      ],
+      chainId
+    });
+    const missedTokeRewardsPayload = await getRewardsPayloadV1(
+      "QmRpVjVhFqbUTtLnQ4addEwBtvF2CC7t6rbQWYiju9nAqd",
+      address,
+      rewardsV1Url
+    );
+    let claimableMissedToke = 0n;
+    if (missedTokeRewardsPayload) {
+      const {
+        payload: { chainId: payloadChainId2, cycle: cycle2, wallet: wallet2, amount: amount2 }
+      } = missedTokeRewardsPayload;
+      claimableMissedToke = await readContract(wagmiConfig, {
+        address: missedTokeRewards,
+        abi: rewardsV1Abi,
+        functionName: "getClaimableAmount",
+        args: [
+          {
+            chainId: payloadChainId2,
+            cycle: cycle2,
+            wallet: wallet2,
+            amount: amount2 || 0n
+          }
+        ],
+        chainId
+      });
+    }
+    return {
+      stakedToke: userStakedTokeV1,
+      claimableToke: tokeRewards?.claimable,
+      claimableEth: ethRewards?.claimable,
+      claimableAutoEth,
+      tokeRewardsPayload: tokeRewards?.rewardsPayload,
+      ethRewardsPayload: ethRewards?.rewardsPayload,
+      missedTokeRewardsPayload,
+      autoEthGuardedRewardsPayload,
+      claimableMissedToke
+    };
+  } catch (e) {
+  }
+};
+var networkToAlchemyUrl = (chainId, apiKey) => {
+  switch (chainId) {
+    case mainnet.id:
+      return `https://eth-mainnet.g.alchemy.com/v2/${apiKey}`;
+    case base.id:
+      return `https://base-mainnet.g.alchemy.com/v2/${apiKey}`;
+    case sonic.id:
+      return `https://sonic-mainnet.g.alchemy.com/v2/${apiKey}`;
+    default:
+      throw new Error("Unsupported network");
+  }
+};
+var getUserTokenBalances = async ({
+  address,
+  apiKey,
+  chainId
+}) => {
+  if (!address)
+    throw new Error("Address is not defined");
+  if (!apiKey)
+    throw new Error("Alchemy API key is not defined");
+  const url = networkToAlchemyUrl(chainId, apiKey);
+  const body = {
+    jsonrpc: "2.0",
+    method: "alchemy_getTokenBalances",
+    params: [address],
+    id: 1
+  };
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok)
+    throw new Error(`Alchemy RPC error: ${res.statusText}`);
+  const data = await res.json();
+  if (!data.result || !data.result.tokenBalances) {
+    throw new Error("No token balances found in response");
+  }
+  const tokenBalances = data.result.tokenBalances.reduce(
+    (acc, balance) => {
+      if (balance.tokenBalance && BigInt(balance.tokenBalance) !== BigInt(0)) {
+        acc[balance.contractAddress] = hexToBigInt(
+          balance.tokenBalance
+        );
+      }
+      return acc;
+    },
+    {}
+  );
+  return tokenBalances;
+};
+var getChainUserActivity = async (address, chainId = 1) => {
+  const { GetUserBalanceChangeHistory } = getSdkByChainId(chainId);
+  try {
+    const { userAutopoolBalanceChanges } = await GetUserBalanceChangeHistory({
+      userAddress: address
+    });
+    let userActivityTotals = {};
+    let events = [];
+    userAutopoolBalanceChanges.forEach((activity) => {
+      if (!userActivityTotals[activity.vaultAddress]) {
+        userActivityTotals[activity.vaultAddress] = {
+          totalDeposits: 0n,
+          totalWithdrawals: 0n,
+          totalStakes: 0n,
+          totalUnstakes: 0n,
+          chainId
+        };
+      }
+      activity.items.forEach((item) => {
+        if (item.staked && item.assetChange > 0n) {
+          userActivityTotals[activity.vaultAddress].totalStakes += BigInt(
+            item.assetChange
+          );
+        } else if (item.staked && item.assetChange < 0n) {
+          userActivityTotals[activity.vaultAddress].totalUnstakes += BigInt(
+            BigInt(item.assetChange) * -1n
+          );
+        } else if (!item.staked && item.assetChange > 0n) {
+          userActivityTotals[activity.vaultAddress].totalDeposits += BigInt(
+            item.assetChange
+          );
+        } else if (!item.staked && item.assetChange < 0n) {
+          userActivityTotals[activity.vaultAddress].totalWithdrawals += BigInt(
+            BigInt(item.assetChange) * -1n
+          );
+        }
+        if (!item.staked) {
+          events.push({
+            timestamp: activity.timestamp,
+            shareChange: item.shareChange,
+            assetChange: item.assetChange,
+            vaultAddress: activity.vaultAddress
+            // staked: item.staked,
+          });
+        }
+      });
+    });
+    return { events, totals: userActivityTotals };
+  } catch (e) {
+    console.log(e);
+  }
+};
+
+// functions/getUserActivity.ts
+var getUserActivity = async ({
+  address,
+  includeTestnet = false
+}) => {
+  const chains = getChainsForEnv({ includeTestnet });
+  const userActivities = await Promise.all(
+    chains.map(
+      (chain) => getChainUserActivity(address, chain.chainId)
+    )
+  );
+  const mergedActivity = userActivities.reduce(
+    (acc, chainActivity) => {
+      if (chainActivity?.events) {
+        acc.events.push(...chainActivity.events);
+      }
+      if (chainActivity?.totals) {
+        acc.totals = { ...acc.totals, ...chainActivity.totals };
+      }
+      return acc;
+    },
+    {
+      events: [],
+      totals: {}
+    }
+  );
+  mergedActivity.events.sort((a, b) => a.timestamp - b.timestamp);
+  return mergedActivity;
+};
+var systemRegistryFunctionNames = [
+  "asyncSwapperRegistry",
+  "autoPoolRouter",
+  "autoPoolRegistry",
+  "swapRouter",
+  "weth"
+];
+var getSystemConfig = async (wagmiConfig, { systemRegistry }) => {
+  const systemRegistryContract = {
+    address: systemRegistry,
+    abi: systemRegistryAbi
+  };
+  const systemRegistryCalls = systemRegistryFunctionNames.map(
+    (functionName) => ({
+      ...systemRegistryContract,
+      functionName
+    })
+  );
+  try {
+    const [
+      { result: asyncSwapperRegistry },
+      { result: autopoolRouter },
+      { result: autopoolRegistry },
+      { result: swapRouter }
+    ] = await readContracts(wagmiConfig, {
+      contracts: systemRegistryCalls
+    });
+    return {
+      asyncSwapperRegistry,
+      autopoolRouter,
+      autopoolRegistry,
+      swapRouter
+    };
+  } catch (e) {
+    console.log(e);
+  }
+};
+var getCurrentCycleId = async (wagmiConfig, {
+  stoke,
+  chainId
+}) => {
+  return readContract(wagmiConfig, {
+    address: stoke,
+    abi: accTokeV1Abi,
+    chainId,
+    functionName: "getCurrentCycleID"
+  });
+};
+
+export { getAutopools, getCurrentCycleId, getEthPrice, getSystemConfig, getTokePrice, getTokenPrice, getUserActivity, getUserAutopools, getUserAutopoolsHistory, getUserTokenBalances, getUserV1, systemRegistryFunctionNames };