@1delta/margin-fetcher 5.0.17 → 5.0.18

package/dist/index.js

@@ -7056,9 +7056,9 @@ var calculateRateForCompoundType2 = (n) => {
   const rate = Number(formatEther(BigInt(n)));
   return (Math.pow(rate * 60 * 60 * 24 / 12 + 1, 365) - 1) * 100;
 };
-var calculateRateForCompoundType = (n, chainId, scale2 = 1 /* SECOND */) => {
+var calculateRateForCompoundType = (n, chainId, scale3 = 1 /* SECOND */) => {
   const rate = Number(formatEther(BigInt(n)));
-  if (scale2 === 0 /* BLOCK */)
+  if (scale3 === 0 /* BLOCK */)
     return (Math.pow(
       rate * 60 * 60 * 24 / (BLOCK_TIMES[chainId] ?? "1") + 1,
       365
@@ -20624,8 +20624,8 @@ var TermSubgraphSource = class {
     const auction = data.termAuctions?.[0];
     const clearingRate = toNum(auction?.auctionClearingPrice);
     const aprPct = clearingRate > 0 ? clearingRate / WAD3 * 100 : 0;
-    const scale2 = Math.pow(10, config.loanDecimals);
-    const toLoan = (repoUnits) => Number(repoUnits * redemptionRatio / BigInt(WAD3)) / scale2;
+    const scale3 = Math.pow(10, config.loanDecimals);
+    const toLoan = (repoUnits) => Number(repoUnits * redemptionRatio / BigInt(WAD3)) / scale3;
     const orders = (data.termOrders ?? []).map((o) => ({
       remaining: toBig3(o.originalOrderAmount) - toBig3(o.filledAmount),
       isAsk: String(o.makerToken).toLowerCase() === repoToken
@@ -20714,7 +20714,7 @@ var TermSubgraphSource = class {
       { term, who }
     );
     if (!data) return null;
-    const scale2 = Math.pow(10, config.loanDecimals);
+    const scale3 = Math.pow(10, config.loanDecimals);
     const toOrder = (o, side, revealedRaw) => {
       const a = o.auction ?? {};
       const complete = Boolean(a.auctionComplete);
@@ -20726,7 +20726,7 @@ var TermSubgraphSource = class {
         auctionId: String(a.id ?? ""),
         account,
         amount: String(o.amount ?? "0"),
-        assets: Number(toBig3(o.amount)) / scale2,
+        assets: Number(toBig3(o.amount)) / scale3,
         assignedAmount: String(o.assignedAmount ?? "0"),
         locked: Boolean(o.locked),
         revealed,
@@ -24552,7 +24552,7 @@ function ratePerSecToApr(rate) {
   return Number(rate) / 1e18 * SECONDS_PER_YEAR9 * 100;
 }
 function buildRewardEntries(p, rsup, chainId, prices, tokens, collateralUsd, debtUsd) {
-  const priceOf = (address) => {
+  const priceOf2 = (address) => {
     const lower3 = address.toLowerCase();
     const token = tokens[lower3];
     const key2 = toOracleKey(token?.assetGroup) || toGenericPriceKey(lower3, chainId);
@@ -24561,7 +24561,7 @@ function buildRewardEntries(p, rsup, chainId, prices, tokens, collateralUsd, deb
   const collateral = [];
   if (collateralUsd > 0) {
     for (const r of p.collateralRewards ?? []) {
-      const price2 = priceOf(r.token);
+      const price2 = priceOf2(r.token);
       if (price2 <= 0) continue;
       const decimals = tokens[r.token.toLowerCase()]?.decimals ?? 18;
       const perSecond = Number(r.ratePerSecPerShare) * Number(p.totalCollateral ?? 0n) / 1e18;
@@ -24578,7 +24578,7 @@ function buildRewardEntries(p, rsup, chainId, prices, tokens, collateralUsd, deb
   }
   const borrow = [];
   if (rsup && debtUsd > 0 && (p.rsupWeight ?? 0n) > 0n) {
-    const price2 = priceOf(rsup.govToken);
+    const price2 = priceOf2(rsup.govToken);
     if (price2 > 0) {
       const decimals = tokens[rsup.govToken.toLowerCase()]?.decimals ?? 18;
       const perSecond = Number(rsup.rewardRate) * Number(p.rsupWeight) / Number(rsup.totalWeight);
@@ -47184,6 +47184,416 @@ var dtrinityRebateRewardFetcher = {
     return { byLender: merged };
   }
 };
+var SECONDS_PER_YEAR12 = 31536e3;
+var WAD14 = 10n ** 18n;
+var ZERO2 = "0x0000000000000000000000000000000000000000";
+var UNBOOSTED_FACTOR = 0.4;
+var MAX_BOOST = 2.5;
+var GAUGE_CONTROLLER = "0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB";
+var L1_CHAINS = /* @__PURE__ */ new Set([Chain.ETHEREUM_MAINNET]);
+var GAUGE_ABI = [
+  {
+    name: "inflation_rate",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "working_supply",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "totalSupply",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "is_killed",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "bool" }]
+  },
+  {
+    name: "reward_count",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "reward_tokens",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ type: "uint256" }],
+    outputs: [{ type: "address" }]
+  },
+  {
+    name: "reward_data",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ type: "address" }],
+    outputs: [
+      { name: "distributor", type: "address" },
+      { name: "period_finish", type: "uint256" },
+      { name: "rate", type: "uint256" },
+      { name: "last_update", type: "uint256" },
+      { name: "integral", type: "uint256" }
+    ]
+  },
+  {
+    name: "gauge_relative_weight",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ type: "address" }],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "convertToAssets",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ type: "uint256" }],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "decimals",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint8" }]
+  },
+  {
+    name: "symbol",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "string" }]
+  }
+];
+var scale2 = (v, decimals) => Number(v) / 10 ** decimals;
+function crvGaugeApr(params) {
+  const {
+    inflationRate,
+    relativeWeight,
+    workingSupply,
+    pricePerShare,
+    crvPriceUsd,
+    assetPriceUsd,
+    isKilled
+  } = params;
+  if (isKilled) return 0;
+  if (inflationRate <= 0n || relativeWeight <= 0n || workingSupply <= 0n) {
+    return 0;
+  }
+  if (!(crvPriceUsd > 0) || !(assetPriceUsd > 0)) return 0;
+  const crvPerYear = scale2(inflationRate, 18) * scale2(relativeWeight, 18) * SECONDS_PER_YEAR12;
+  const stakedUsd = scale2(workingSupply, 18) * scale2(pricePerShare, 18) * assetPriceUsd;
+  if (!(stakedUsd > 0)) return 0;
+  return crvPerYear * crvPriceUsd / stakedUsd * 100 * UNBOOSTED_FACTOR;
+}
+function extraRewardApr(params) {
+  const {
+    rate,
+    periodFinish,
+    rewardDecimals,
+    rewardPriceUsd,
+    totalSupply,
+    pricePerShare,
+    assetPriceUsd,
+    nowSeconds
+  } = params;
+  if (nowSeconds >= Number(periodFinish)) return 0;
+  if (rate <= 0n || totalSupply <= 0n) return 0;
+  if (!(rewardPriceUsd > 0) || !(assetPriceUsd > 0)) return 0;
+  const rewardPerYearUsd = scale2(rate, rewardDecimals) * SECONDS_PER_YEAR12 * rewardPriceUsd;
+  const stakedUsd = scale2(totalSupply, 18) * scale2(pricePerShare, 18) * assetPriceUsd;
+  if (!(stakedUsd > 0)) return 0;
+  return rewardPerYearUsd / stakedUsd * 100;
+}
+var LLAMA_CHAIN_SLUG = {
+  [Chain.ETHEREUM_MAINNET]: "ethereum",
+  [Chain.OP_MAINNET]: "optimism",
+  [Chain.ARBITRUM_ONE]: "arbitrum"
+};
+async function fetchPrices(keys) {
+  const ids = Array.from(
+    new Set(
+      keys.map(({ chainId, address }) => {
+        const slug = LLAMA_CHAIN_SLUG[chainId];
+        return slug ? `${slug}:${address.toLowerCase()}` : null;
+      }).filter((x) => !!x)
+    )
+  );
+  if (ids.length === 0) return {};
+  const out = {};
+  const CHUNK = 60;
+  for (let i = 0; i < ids.length; i += CHUNK) {
+    const slice2 = ids.slice(i, i + CHUNK);
+    try {
+      const res = await fetch(
+        `https://coins.llama.fi/prices/current/${slice2.join(",")}`,
+        { signal: AbortSignal.timeout(1e4) }
+      );
+      if (!res.ok) continue;
+      const json = await res.json();
+      for (const [id, v] of Object.entries(json?.coins ?? {})) {
+        if (typeof v?.price === "number") out[id.toLowerCase()] = v.price;
+      }
+    } catch (e) {
+      console.error("[llamalend-gauge] price fetch failed:", e);
+    }
+  }
+  return out;
+}
+var priceOf = (prices, chainId, address) => prices[`${LLAMA_CHAIN_SLUG[chainId]}:${address.toLowerCase()}`] ?? 0;
+function rosterFor(chainId) {
+  const markets = llamaLendChainData(Lender.LLAMALEND, chainId)?.markets ?? [];
+  return markets.filter((m) => m.gauge && m.gauge !== ZERO2).map((m) => ({
+    controller: m.controller,
+    vault: m.vault,
+    gauge: m.gauge,
+    borrowedToken: m.borrowedToken,
+    name: m.name
+  }));
+}
+var lenderKeyFor = (controller) => `${Lender.LLAMALEND}_${controller.replace(/^0x/i, "").toUpperCase()}`;
+async function fetchForChain(chainId, nowSeconds) {
+  const markets = rosterFor(chainId);
+  if (markets.length === 0) return {};
+  const isL1 = L1_CHAINS.has(chainId);
+  const week = BigInt(Math.floor(nowSeconds / 604800));
+  const round1 = markets.flatMap((m) => [
+    // L2 child gauges take the week; the L1 form takes none and reverts there.
+    isL1 ? { address: m.gauge, name: "inflation_rate", params: [] } : { address: m.gauge, name: "inflation_rate", params: [week] },
+    { address: m.gauge, name: "working_supply", params: [] },
+    { address: m.gauge, name: "totalSupply", params: [] },
+    { address: m.gauge, name: "is_killed", params: [] },
+    { address: m.gauge, name: "reward_count", params: [] },
+    { address: m.vault, name: "convertToAssets", params: [WAD14] },
+    isL1 ? {
+      address: GAUGE_CONTROLLER,
+      name: "gauge_relative_weight",
+      params: [m.gauge]
+    } : (
+      // No gauge controller off L1; the child gauge's rate is already its own.
+      { address: m.gauge, name: "totalSupply", params: [] }
+    )
+  ]);
+  const r1 = await multicallRetryUniversal({
+    chain: chainId,
+    calls: round1,
+    abi: GAUGE_ABI,
+    allowFailure: true
+  });
+  const big16 = (v) => {
+    try {
+      if (typeof v === "bigint") return v;
+      if (typeof v === "string" && v !== "0x") return BigInt(v);
+      if (typeof v === "number") return BigInt(Math.trunc(v));
+    } catch {
+    }
+    return 0n;
+  };
+  const STRIDE = 7;
+  const state = markets.map((m, i) => {
+    const b = i * STRIDE;
+    return {
+      market: m,
+      inflationRate: big16(r1[b]),
+      workingSupply: big16(r1[b + 1]),
+      totalSupply: big16(r1[b + 2]),
+      isKilled: r1[b + 3] === true,
+      rewardCount: Number(big16(r1[b + 4])),
+      pricePerShare: big16(r1[b + 5]),
+      // Off L1 the child gauge's own rate is already market-scoped, so the
+      // weight is the identity.
+      relativeWeight: isL1 ? big16(r1[b + 6]) : WAD14
+    };
+  });
+  const tokenCalls = state.flatMap(
+    (s) => Array.from({ length: s.rewardCount }, (_3, i) => ({
+      address: s.market.gauge,
+      name: "reward_tokens",
+      params: [BigInt(i)]
+    }))
+  );
+  const r2 = tokenCalls.length ? await multicallRetryUniversal({
+    chain: chainId,
+    calls: tokenCalls,
+    abi: GAUGE_ABI,
+    allowFailure: true
+  }) : [];
+  let cursor = 0;
+  const withTokens = state.map((s) => {
+    const tokens = r2.slice(cursor, cursor + s.rewardCount).filter((t) => typeof t === "string" && t !== ZERO2);
+    cursor += s.rewardCount;
+    return { ...s, tokens };
+  });
+  const dataCalls = withTokens.flatMap(
+    (s) => s.tokens.flatMap((t) => [
+      { address: s.market.gauge, name: "reward_data", params: [t] },
+      { address: t, name: "decimals", params: [] },
+      { address: t, name: "symbol", params: [] }
+    ])
+  );
+  const r3 = dataCalls.length ? await multicallRetryUniversal({
+    chain: chainId,
+    calls: dataCalls,
+    abi: GAUGE_ABI,
+    allowFailure: true
+  }) : [];
+  const priceKeys = [];
+  for (const s of withTokens) {
+    priceKeys.push({ chainId, address: s.market.borrowedToken });
+    for (const t of s.tokens) priceKeys.push({ chainId, address: t });
+  }
+  const CRV_ETH = "0xD533a949740bb3306d119CC777fa900bA034cd52";
+  if (isL1) priceKeys.push({ chainId, address: CRV_ETH });
+  const prices = await fetchPrices(priceKeys);
+  const crvPrice = isL1 ? priceOf(prices, chainId, CRV_ETH) : 0;
+  const out = {};
+  let dCursor = 0;
+  for (const s of withTokens) {
+    const assetPrice = priceOf(prices, chainId, s.market.borrowedToken);
+    const streams = [];
+    const crvApr = crvGaugeApr({
+      inflationRate: s.inflationRate,
+      relativeWeight: s.relativeWeight,
+      workingSupply: s.workingSupply,
+      pricePerShare: s.pricePerShare,
+      crvPriceUsd: crvPrice,
+      assetPriceUsd: assetPrice,
+      isKilled: s.isKilled
+    });
+    if (crvApr > 0) {
+      streams.push({
+        side: "deposit",
+        apr: crvApr,
+        kind: "token",
+        token: {
+          address: CRV_ETH.toLowerCase(),
+          symbol: "CRV",
+          decimals: 18,
+          priceUsd: crvPrice
+        },
+        source: {
+          id: "curve:gauge-crv",
+          label: "Curve gauge \xB7 CRV",
+          platform: "protocol",
+          link: `https://www.curve.finance/lend/ethereum/markets/${s.market.controller}/`,
+          refs: {
+            gauge: s.market.gauge,
+            // The headline is the UNBOOSTED rate; a maxed veCRV lock earns
+            // 2.5x it. Published so a consumer can show the range Curve does
+            // rather than re-deriving the factor.
+            maxBoostApr: crvApr * MAX_BOOST
+          }
+        },
+        claim: "accrual"
+      });
+    }
+    for (const token of s.tokens) {
+      const data = r3[dCursor];
+      const decRaw = r3[dCursor + 1];
+      const symRaw = r3[dCursor + 2];
+      dCursor += 3;
+      if (!data) continue;
+      const periodFinish = big16(
+        Array.isArray(data) ? data[1] : data?.period_finish
+      );
+      const rate = big16(Array.isArray(data) ? data[2] : data?.rate);
+      const decimals = typeof decRaw === "number" ? decRaw : Number(big16(decRaw) || 18n);
+      const rewardPrice = priceOf(prices, chainId, token);
+      const apr = extraRewardApr({
+        rate,
+        periodFinish,
+        rewardDecimals: decimals,
+        rewardPriceUsd: rewardPrice,
+        totalSupply: s.totalSupply,
+        pricePerShare: s.pricePerShare,
+        assetPriceUsd: assetPrice,
+        nowSeconds
+      });
+      if (apr <= 0) continue;
+      streams.push({
+        side: "deposit",
+        apr,
+        kind: "token",
+        token: {
+          address: token.toLowerCase(),
+          symbol: typeof symRaw === "string" ? symRaw : void 0,
+          decimals,
+          priceUsd: rewardPrice
+        },
+        source: {
+          id: "curve:gauge-extra",
+          label: `Curve gauge \xB7 ${typeof symRaw === "string" ? symRaw : "reward"}`,
+          platform: "protocol",
+          link: `https://www.curve.finance/lend/ethereum/markets/${s.market.controller}/`,
+          refs: { gauge: s.market.gauge, rewardToken: token }
+        },
+        claim: "accrual",
+        // The whole point of carrying this: the rate survives expiry.
+        endsAt: Number(periodFinish) || void 0
+      });
+    }
+    if (streams.length === 0) continue;
+    const deposit = streams.reduce((sum, st) => sum + st.apr, 0);
+    const lenderKey = lenderKeyFor(s.market.controller);
+    const asset = s.market.borrowedToken.toLowerCase();
+    const reward = {
+      distribution: "onchain-incentives",
+      deposit,
+      // Gauge rewards pay the LEND side only — the gauge stakes vault shares,
+      // and a borrower holds none.
+      borrow: 0,
+      additionalDepositData: void 0,
+      additionalBorrowData: void 0,
+      streams
+    };
+    if (!out[chainId]) out[chainId] = {};
+    if (!out[chainId][lenderKey]) out[chainId][lenderKey] = {};
+    out[chainId][lenderKey][asset] = reward;
+  }
+  return out;
+}
+var GAUGE_CHAINS = [
+  Chain.ETHEREUM_MAINNET,
+  Chain.OP_MAINNET,
+  Chain.ARBITRUM_ONE
+];
+var llamaLendGaugeRewardFetcher = {
+  label: "LLAMALEND_GAUGE",
+  // Lender-keyed: the gauge belongs to exactly one market, so there is no
+  // deployment ambiguity to resolve against reserve tokens.
+  fetch: async () => {
+    const nowSeconds = Math.floor(Date.now() / 1e3);
+    const results = await Promise.all(
+      GAUGE_CHAINS.map(async (chainId) => {
+        try {
+          return await fetchForChain(chainId, nowSeconds);
+        } catch (e) {
+          console.error(`[llamalend-gauge] read failed on chain ${chainId}:`, e);
+          return {};
+        }
+      })
+    );
+    const byLender = {};
+    for (const r of results) {
+      for (const [chainId, lenders] of Object.entries(r)) {
+        if (!byLender[chainId]) byLender[chainId] = {};
+        Object.assign(byLender[chainId], lenders);
+      }
+    }
+    return { byLender };
+  }
+};
 
 // src/yields/rewards/fetchLenderRewards.ts
 function mergeRewardResults(target, source) {
@@ -47199,7 +47609,8 @@ var rewardFetchers = [
   aaveMerklRewardFetcher,
   eulerMerklRewardFetcher,
   morphoCollateralMerklRewardFetcher,
-  dtrinityRebateRewardFetcher
+  dtrinityRebateRewardFetcher,
+  llamaLendGaugeRewardFetcher
 ];
 function mergeReserveTokenRewards(target, source) {
   for (const [chainId, byToken] of Object.entries(source)) {
@@ -53701,7 +54112,7 @@ query EvkByAssets($assets: [Bytes!]!) {
   }
 }
 `;
-var ZERO2 = 0n;
+var ZERO3 = 0n;
 var RAY_TO_PERCENT3 = 1e25;
 function readAddress2(field13) {
   if (!field13) return void 0;
@@ -53716,28 +54127,28 @@ function parseVaultFee(v) {
   return n;
 }
 function safeBigInt(v) {
-  if (v == null || v === "") return ZERO2;
+  if (v == null || v === "") return ZERO3;
   try {
     return BigInt(v);
   } catch {
-    return ZERO2;
+    return ZERO3;
   }
 }
 function computeWeightedSupplyApy(strategies, totalAssetsRaw, feePercent, evkIndex) {
   if (!strategies?.length) return 0;
   const totalAssets = safeBigInt(totalAssetsRaw);
-  if (totalAssets === ZERO2) return 0;
-  let weightedRay = ZERO2;
+  if (totalAssets === ZERO3) return 0;
+  let weightedRay = ZERO3;
   for (const s of strategies) {
     const evk = s.strategy?.toLowerCase();
     if (!evk) continue;
     const apyRay = evkIndex.bySupplyApyRay.get(evk);
     if (apyRay == null) continue;
     const allocated = safeBigInt(s.allocatedAssets);
-    if (allocated === ZERO2) continue;
+    if (allocated === ZERO3) continue;
     weightedRay += allocated * apyRay;
   }
-  if (weightedRay === ZERO2) return 0;
+  if (weightedRay === ZERO3) return 0;
   const apyRayPerAsset = weightedRay / totalAssets;
   const grossPercent = apyToAprPercent(Number(apyRayPerAsset) / RAY_TO_PERCENT3);
   const netPercent = grossPercent * (1 - feePercent / 100);
@@ -53745,24 +54156,24 @@ function computeWeightedSupplyApy(strategies, totalAssetsRaw, feePercent, evkInd
 }
 function computeRealLiquidity(strategies, totalAssetsRaw, evkIndex) {
   const totalAssets = safeBigInt(totalAssetsRaw);
-  if (totalAssets === ZERO2) return ZERO2;
+  if (totalAssets === ZERO3) return ZERO3;
   if (evkIndex.byCash.size === 0 && evkIndex.bySupplyApyRay.size === 0) {
     return totalAssets;
   }
   if (!strategies?.length) {
     return totalAssets;
   }
-  let allocSum = ZERO2;
-  let withdrawable = ZERO2;
+  let allocSum = ZERO3;
+  let withdrawable = ZERO3;
   for (const s of strategies) {
     const alloc = safeBigInt(s.allocatedAssets);
-    if (alloc === ZERO2) continue;
+    if (alloc === ZERO3) continue;
     allocSum += alloc;
     const evk = s.strategy?.toLowerCase();
     const cash = evk ? evkIndex.byCash.get(evk) : void 0;
     withdrawable += cash == null ? alloc : alloc < cash ? alloc : cash;
   }
-  const idle = totalAssets > allocSum ? totalAssets - allocSum : ZERO2;
+  const idle = totalAssets > allocSum ? totalAssets - allocSum : ZERO3;
   const result = idle + withdrawable;
   return result > totalAssets ? totalAssets : result;
 }
@@ -54102,19 +54513,19 @@ async function fetchTermMaxVaultsFromApi(chainId, prices = {}, tokenList = {}, f
     if (!address || !underlying) continue;
     if (r.isEnabled === false) continue;
     const assetDecimals = num4(r?.asset?.decimals) || 18;
-    const scale2 = 10 ** assetDecimals;
+    const scale3 = 10 ** assetDecimals;
     const assetEntry = tokenList[underlying];
     const priceKey = toOracleKey(assetEntry?.assetGroup) || toGenericPriceKey(underlying, chainId);
     const priceUsd = prices[priceKey];
     const totalAssets = big14(r.totalAssets);
     const totalSupply = big14(r.totalSupplyAmt);
-    const totalAssetsFormatted = Number(totalAssets) / scale2;
+    const totalAssetsFormatted = Number(totalAssets) / scale3;
     const supplyRate = num4(r.apr) * 100;
     const rewardsRate = num4(r?.incentiveData?.TMX_APR) * 100;
     const rawLiquidity = BigInt(big14(r.redeemableAmt ?? r.idleFunds ?? "0"));
     const totalAssetsBig = BigInt(totalAssets);
     const liquidity = (rawLiquidity > totalAssetsBig ? totalAssetsBig : rawLiquidity).toString();
-    const liquidityFormatted = Number(liquidity) / scale2;
+    const liquidityFormatted = Number(liquidity) / scale3;
     const totalSupplyValue = num4(r.totalSupplyValue);
     out[address] = {
       address,
@@ -54315,9 +54726,9 @@ var fetchTermMaxVaultsFromChain = async (chainId, multicallRetry, prices = {}, t
     if (r.aprRaw !== void 0 && r.aprRaw > 0n) {
       supplyRate = Number(r.aprRaw) / Number(DECIMAL_BASE2) * 100;
     }
-    const scale2 = 10 ** assetDecimals;
-    const totalAssetsFormatted = Number(r.totalAssets) / scale2;
-    const liquidityFormatted = Number(idle) / scale2;
+    const scale3 = 10 ** assetDecimals;
+    const totalAssetsFormatted = Number(r.totalAssets) / scale3;
+    const liquidityFormatted = Number(idle) / scale3;
     const convertToAssets = r.totalSupply > 0n ? (r.totalAssets * 10n ** BigInt(r.decimals) / r.totalSupply).toString() : "0";
     const entry = {
       address: r.address,
@@ -55439,7 +55850,7 @@ var readerVedaAccountant = (entry) => {
       }
     };
   }
-  const scale2 = 10n ** BigInt(18 - underlyingDec);
+  const scale3 = 10n ** BigInt(18 - underlyingDec);
   return {
     calls: [
       { address: entry.address, name: "totalSupply", params: [] },
@@ -55450,7 +55861,7 @@ var readerVedaAccountant = (entry) => {
       const totalSupply = toBigInt13(supply);
       const rawRate = toBigInt13(rate);
       if (totalSupply === void 0 || rawRate === void 0) return void 0;
-      const exchangeRate = rawRate * scale2;
+      const exchangeRate = rawRate * scale3;
       return {
         totalAssets: rescaleDecimals(
           totalSupply * exchangeRate / ONE_E189,
@@ -60686,8 +61097,8 @@ var deriveTotalSupply = (totalAssetsRaw, pricePerShareRaw, decimals) => {
     if (assets === 0n) return "0";
     const pps = BigInt(pricePerShareRaw || "0");
     if (pps <= 0n) return totalAssetsRaw;
-    const scale2 = 10n ** BigInt(decimals);
-    return (assets * scale2 / pps).toString();
+    const scale3 = 10n ** BigInt(decimals);
+    return (assets * scale3 / pps).toString();
   } catch {
     return totalAssetsRaw || "0";
   }