@1delta/margin-fetcher 5.0.16 → 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
@@ -17642,7 +17642,16 @@ function buildEModes(borrowVaults, cluster) {
   }
   return eModes;
 }
+var OP_DEPOSIT = 1 << 0;
+var OP_MINT = 1 << 1;
+var OP_BORROW = 1 << 6;
+function isOperationDisabled(info, operation) {
+  const hookedOps = Number(info.hookedOperations ?? 0n);
+  return (hookedOps & operation) !== 0 && info.hookTarget.toLowerCase() === zeroAddress;
+}
 function buildMetadata(info) {
+  const hookedOperations = Number(info.hookedOperations ?? 0n);
+  const hookTarget = info.hookTarget.toLowerCase();
   return {
     vault: info.vault.toLowerCase(),
     dToken: info.dToken.toLowerCase(),
@@ -17650,7 +17659,9 @@ function buildMetadata(info) {
     interestRateModel: info.interestRateModel.toLowerCase(),
     unitOfAccount: info.unitOfAccount.toLowerCase(),
     evc: info.evc.toLowerCase(),
-    governorAdmin: info.governorAdmin.toLowerCase()
+    governorAdmin: info.governorAdmin.toLowerCase(),
+    ...hookedOperations !== 0 ? { hookedOperations } : {},
+    ...hookTarget !== zeroAddress ? { hookTarget } : {}
   };
 }
 function buildTokenEntry(info, config, collateralActive, borrowVaults, opts) {
@@ -17707,13 +17718,32 @@ function buildTokenEntry(info, config, collateralActive, borrowVaults, opts) {
     lastUpdateTimestamp: Number(info.timestamp),
     config,
     collateralActive,
-    borrowingEnabled: isBorrowVault,
-    depositsEnabled: true,
+    // A governor can switch either side of a vault off through the hook system
+    // without ever touching the caps, so these flags are read from
+    // `hookedOperations`/`hookTarget` rather than assumed. A vault that takes no
+    // deposits is not a collateral candidate and must not rank as one, however
+    // attractive its rate — `maxDeposit`/`maxMint` return 0 for it on-chain.
+    borrowingEnabled: isBorrowVault && !isOperationDisabled(info, OP_BORROW),
+    // Gated on OP_DEPOSIT alone, not on `OP_DEPOSIT || OP_MINT`: every supply
+    // route we encode calls `deposit`, so a vault that disabled only that leg is
+    // unusable to us even while share-minting stays open.
+    depositsEnabled: !isOperationDisabled(info, OP_DEPOSIT),
     hasStable: false,
     isActive: true,
-    isFrozen: false,
+    // Supply AND borrow both off is the closest EVK analogue of an Aave-style
+    // freeze: the vault still prices and still lets existing positions unwind.
+    isFrozen: isOperationDisabled(info, OP_DEPOSIT) && isOperationDisabled(info, OP_MINT) && isOperationDisabled(info, OP_BORROW),
     borrowCap: toTokenAmount(info.borrowCap, info.assetDecimals),
-    supplyCap: toTokenAmount(info.supplyCap, info.assetDecimals),
+    // Supply switched off reports as ZERO CAPACITY, not merely as a false flag.
+    // Consumers that rank markets (the pair book) can only compare capacity
+    // across lenders — `depositsEnabled` means different things per provider
+    // (Gearbox marks collateral-only tokens false because they have no lend
+    // side, while they remain perfectly good collateral), so it cannot be a
+    // cross-lender gate. Capacity can, and 0 is exactly what the vault's own
+    // `maxDeposit`/`maxMint` return here. Note this is already the shape Euler
+    // itself emits for a cap-disabled vault: `caps() = (1, …)` resolves to a
+    // supply cap of 0.
+    supplyCap: isOperationDisabled(info, OP_DEPOSIT) ? 0 : toTokenAmount(info.supplyCap, info.assetDecimals),
     debtCeiling: 0,
     eMode: selfEMode,
     decimals: Number(info.assetDecimals),
@@ -20594,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
@@ -20684,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);
@@ -20696,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,
@@ -22978,7 +23008,6 @@ function num(api, key2) {
   const v = api?.[key2];
   return typeof v === "number" && Number.isFinite(v) ? v : null;
 }
-var BANDS_ENDPOINTS = [4, 10, 20, 50];
 var DEFAULT_BANDS = 10;
 var LLAMALEND_READ_ABI = [
   ...LlamaLendControllerAbi,
@@ -22989,6 +23018,8 @@ var LLAMALEND_READ_ABI = [
   ...Erc20Abi
 ];
 var ZERO = "0x0000000000000000000000000000000000000000";
+var WAD8 = 10n ** 18n;
+var CALLS_PER_MARKET = 6;
 var fetchJson2 = async (url, timeoutMs = 8e3) => {
   const res = await fetch(url, {
     headers: { accept: "application/json" },
@@ -23005,25 +23036,12 @@ var toBig5 = (v) => {
 };
 var human = (v, decimals) => v === null ? null : Number(v) / 10 ** decimals;
 var bandsFor = (m) => m.defaultBands && m.defaultBands >= 4 && m.defaultBands <= 50 ? m.defaultBands : DEFAULT_BANDS;
-var bandGrid = (m) => {
-  const set = /* @__PURE__ */ new Set([...BANDS_ENDPOINTS, bandsFor(m)]);
-  return [...set].sort((a, b) => a - b);
-};
 var MIN_BANDS = 4;
 var MAX_BANDS = 50;
 var LTV_CURVE_BANDS = Array.from(
   { length: MAX_BANDS - MIN_BANDS + 1 },
   (_3, i) => MIN_BANDS + i
 );
-var maxBorrowableCall = (m, oneUnit, n) => m.version === 1 ? {
-  address: m.controller,
-  name: "max_borrowable",
-  params: [oneUnit, BigInt(n), 0n, ZERO]
-} : {
-  address: m.controller,
-  name: "max_borrowable",
-  params: [oneUnit, BigInt(n), ZERO]
-};
 var buildBandLtv = (market) => {
   if (!market.ammA || !market.loanDiscount) return null;
   try {
@@ -23044,8 +23062,6 @@ var buildBandLtv = (market) => {
 };
 async function fetchChainExtras(chainId, markets) {
   const perMarketCalls = markets.map((m) => {
-    const grid = bandGrid(m);
-    const oneUnit = 10n ** BigInt(m.collateralDecimals);
     const calls = [
       { address: m.amm, name: "price_oracle", params: [] },
       { address: m.amm, name: "active_band", params: [] },
@@ -23054,9 +23070,17 @@ async function fetchChainExtras(chainId, markets) {
       // v1 controllers have no `borrow_cap`; allowFailure turns that into a
       // null rather than sinking the whole batch.
       { address: m.controller, name: "borrow_cap", params: [] },
-      ...grid.map((n) => maxBorrowableCall(m, oneUnit, n))
+      /**
+       * Price per share, read ONCE PER MARKET rather than per user.
+       *
+       * Vault shares run ~1000x the asset scale (`DEAD_SHARES`), so a share
+       * balance is never an amount — every consumer needs this multiplier to
+       * turn a lender's holding into assets. Reading it here keeps the
+       * per-user call to two plain `balanceOf`s.
+       */
+      { address: m.vault, name: "convertToAssets", params: [WAD8] }
     ];
-    return { market: m, grid, calls };
+    return { market: m, calls };
   });
   const flat = perMarketCalls.flatMap((x) => x.calls);
   if (flat.length === 0) return {};
@@ -23077,13 +23101,14 @@ async function fetchChainExtras(chainId, markets) {
   }
   const out = {};
   let cursor = 0;
-  for (const { market, grid } of perMarketCalls) {
+  for (const { market } of perMarketCalls) {
     const priceRaw = toBig5(results[cursor]);
     const activeBandRaw = toBig5(results[cursor + 1]);
     const nLoansRaw = toBig5(results[cursor + 2]);
     const maxDepositRaw = toBig5(results[cursor + 3]);
     const borrowCapRaw = toBig5(results[cursor + 4]);
-    cursor += 5 + grid.length;
+    const pricePerShareRaw = toBig5(results[cursor + 5]);
+    cursor += CALLS_PER_MARKET;
     const collateralPrice = priceRaw === null ? null : Number(priceRaw) / 1e18;
     const bandLtv = buildBandLtv(market);
     const defaultN = String(bandsFor(market));
@@ -23094,7 +23119,11 @@ async function fetchChainExtras(chainId, markets) {
       borrowCap: human(borrowCapRaw, market.borrowedDecimals),
       maxDeposit: human(maxDepositRaw, market.borrowedDecimals),
       nLoans: nLoansRaw === null ? null : Number(nLoansRaw),
-      activeBand: activeBandRaw === null ? null : Number(activeBandRaw)
+      activeBand: activeBandRaw === null ? null : Number(activeBandRaw),
+      // Assets-per-WAD-shares. Kept as a ratio (not scaled to the borrowed
+      // token's decimals) so a consumer multiplies a raw share balance by it
+      // and divides by 1e18 exactly once.
+      pricePerShare: pricePerShareRaw === null ? null : Number(pricePerShareRaw) / 1e18
     };
   }
   return out;
@@ -23159,7 +23188,8 @@ async function fetchLlamaLendMarkets(lender, chainId) {
           ),
           maxDeposit: ex?.maxDeposit ?? null,
           nLoans: ex?.nLoans ?? null,
-          activeBand: ex?.activeBand ?? null
+          activeBand: ex?.activeBand ?? null,
+          pricePerShare: ex?.pricePerShare ?? null
         };
       });
       return { lender, config, chainData, markets: rows, source: "api" };
@@ -23219,7 +23249,8 @@ async function fetchLlamaLendMarkets(lender, chainId) {
         ),
         maxDeposit: ex?.maxDeposit ?? null,
         nLoans: ex?.nLoans ?? null,
-        activeBand: ex?.activeBand ?? null
+        activeBand: ex?.activeBand ?? null,
+        pricePerShare: ex?.pricePerShare ?? null
       };
     });
     return { lender, config, chainData, markets: rows, source: "chain" };
@@ -24411,6 +24442,13 @@ function convertLlamaLendMarketsToResponse(raw, chainId, prices = {}, additional
           collateralPrice: m.collateralPrice !== null ? String(m.collateralPrice) : void 0,
           /** v2 only; `0` means borrowing is switched off. */
           borrowCap: m.borrowCap !== null ? String(m.borrowCap) : void 0,
+          /**
+           * Assets per 1e18 vault shares — what a lender's share balance is
+           * worth. Published because the SUPPLY side of a LlamaLend market is
+           * an ERC-4626 vault whose shares run ~1000x the asset scale, so a
+           * raw balance is meaningless without it.
+           */
+          pricePerShare: m.pricePerShare !== null ? String(m.pricePerShare) : void 0,
           addresses: {
             controller: market.controller,
             vault: market.vault,
@@ -24514,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);
@@ -24523,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;
@@ -24540,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);
@@ -25109,7 +25147,7 @@ function dssKeyParts(key2) {
   if (!m) return void 0;
   return { lender: m[1], chainId: m[2], ilk: keySegmentToIlk(m[3]) };
 }
-var WAD9 = 1e18;
+var WAD10 = 1e18;
 var RAY4 = 1e27;
 var RAD = 1e45;
 var YEAR_SECONDS2 = 31536e3;
@@ -25153,7 +25191,7 @@ function convertDssMarketsToResponse(raw, chainId, prices = {}, _additionalYield
     const totalColl = m.joinBalance !== null ? toHuman4(m.joinBalance, collDecimals) : 0;
     const mat = m.mat !== null ? Number(m.mat) / RAY4 : Number(market.mat) / RAY4 || 1.5;
     const ltv = mat > 0 ? 1 / mat : 0;
-    const chop = market.chop ? Number(market.chop) / WAD9 : 0;
+    const chop = market.chop ? Number(market.chop) / WAD10 : 0;
     const liqPenalty = chop > 1 ? chop - 1 : 0;
     const duty = m.duty !== null ? m.duty : BigInt(market.duty ?? 0);
     const borrowApr = duty > BigInt(1e27) ? Number(duty - BigInt(10) ** BigInt(27)) / RAY4 * YEAR_SECONDS2 * 100 : 0;
@@ -27885,7 +27923,7 @@ var buildRiverUserCall = (chainId, lender, account) => {
   });
   return calls;
 };
-var LLAMALEND_CALLS_PER_MARKET = 5;
+var LLAMALEND_CALLS_PER_MARKET = 8;
 var buildLlamaLendUserCall = (chainId, lender, account, spender) => {
   const cfg = llamaLendConfigFor(lender, chainId);
   const markets = llamaLendChainData(lender, chainId)?.markets ?? [];
@@ -27896,7 +27934,16 @@ var buildLlamaLendUserCall = (chainId, lender, account, spender) => {
     { address: m.controller, name: "health", params: [account, true] },
     { address: m.controller, name: "user_prices", params: [account] },
     { address: m.amm, name: "read_user_tick_numbers", params: [account] },
-    { address: m.controller, name: "approval", params: [account, delegate] }
+    { address: m.controller, name: "approval", params: [account, delegate] },
+    { address: m.vault, name: "balanceOf", params: [account] },
+    // A market without a gauge would call address(0), which returns '0x' and
+    // parses as zero — the layout stays fixed either way.
+    {
+      address: m.gauge ?? "0x0000000000000000000000000000000000000000",
+      name: "balanceOf",
+      params: [account]
+    },
+    { address: m.vault, name: "convertToAssets", params: [10n ** 18n] }
   ]);
 };
 var INVERSE_CALLS_PER_MARKET = 4;
@@ -31073,7 +31120,7 @@ var getMidnightUserDataConverter = (_lender, chainId, account, meta) => {
     totalCalls
   ];
 };
-var WAD10 = 1000000000000000000n;
+var WAD11 = 1000000000000000000n;
 function toBigInt11(v) {
   if (v === void 0 || v === null || v === "0x") return 0n;
   if (typeof v === "bigint") return v;
@@ -31115,8 +31162,8 @@ var getTermUserDataConverter = (_lender, chainId, account, meta) => {
         const debtStr = parseRawAmount(debtUnits.toString(), market.loanDecimals);
         const debtNum = Number(debtStr);
         const repoBalance = toBigInt11(balanceResult);
-        const redemptionValue = toBigInt11(redemptionResult) || toBigInt11(market.redemptionValue) || WAD10;
-        const lentUnits = repoBalance * redemptionValue / WAD10;
+        const redemptionValue = toBigInt11(redemptionResult) || toBigInt11(market.redemptionValue) || WAD11;
+        const lentUnits = repoBalance * redemptionValue / WAD11;
         const depositsStr = parseRawAmount(lentUnits.toString(), market.loanDecimals);
         const depositsNum = Number(depositsStr);
         const posData = {};
@@ -31194,7 +31241,7 @@ var getTermUserDataConverter = (_lender, chainId, account, meta) => {
 };
 var nowSec6 = () => Math.floor(Date.now() / 1e3);
 var DAY_SECONDS = 86400n;
-var WAD11 = 10n ** 18n;
+var WAD12 = 10n ** 18n;
 function sumPreview(positions) {
   return positions.reduce((acc, p) => acc + p.previewValue, 0n);
 }
@@ -31218,7 +31265,7 @@ function toDetail(positions, kind, now, penaltyRate, penaltyApr) {
       ...kind === "borrow" ? {
         ...overdue ? { latePenalty: excess.toString() } : { earlyRepayDiscount: gap.toString() },
         // face × penaltyRate × 1 day — what another day of being late adds.
-        latePenaltyPerDay: (face * penaltyRate * DAY_SECONDS / WAD11).toString(),
+        latePenaltyPerDay: (face * penaltyRate * DAY_SECONDS / WAD12).toString(),
         latePenaltyApr: penaltyApr
       } : {
         ...overdue ? {} : { earlyExitCost: gap.toString() },
@@ -31347,7 +31394,7 @@ var getExactlyUserDataConverter = (_lender, chainId, account, meta) => {
               latePenalty: penalty,
               /** further penalty per day overdue — linear on face */
               latePenaltyPerDay: parseRawAmount(
-                (face * m.penaltyRate * DAY_SECONDS / WAD11).toString(),
+                (face * m.penaltyRate * DAY_SECONDS / WAD12).toString(),
                 decimals
               ),
               latePenaltyApr: penaltyApr,
@@ -31875,7 +31922,13 @@ var getLlamaLendUserDataConverter = (lender, chainId, account, meta) => {
         const bandBorrowed = big7(stateRaw[1]);
         const debt = big7(stateRaw[2]);
         const bandCount = Number(big7(stateRaw[3]));
-        if (collateral === 0n && debt === 0n && bandBorrowed === 0n) return;
+        const vaultSharesRaw = data[base + 5];
+        const gaugeSharesRaw = data[base + 6];
+        const vaultShares = isFailedCall(vaultSharesRaw) ? 0n : big7(vaultSharesRaw);
+        const gaugeShares = isFailedCall(gaugeSharesRaw) ? 0n : big7(gaugeSharesRaw);
+        const lendShares = vaultShares + gaugeShares;
+        if (collateral === 0n && debt === 0n && bandBorrowed === 0n && lendShares === 0n)
+          return;
         const healthRaw = data[base + 1];
         const health = isFailedCall(healthRaw) ? 0n : big7(healthRaw);
         const pricesRaw = data[base + 2];
@@ -31902,6 +31955,15 @@ var getLlamaLendUserDataConverter = (lender, chainId, account, meta) => {
         const loanDisplay = loanMeta ? getDisplayPrice(loanMeta) : 0;
         const loanOracle = loanMeta ? getOraclePrice(loanMeta) : 0;
         const loanHist = loanMeta?.price?.priceUsd24h ?? loanDisplay;
+        const shareToAssetRaw = data[base + 7];
+        const shareToAsset = isFailedCall(shareToAssetRaw) ? 0n : big7(shareToAssetRaw);
+        const lendAssets = shareToAsset === 0n ? 0n : lendShares * shareToAsset / 10n ** 18n;
+        const lendStr = parseRawAmount(lendAssets.toString(), loanDecimals);
+        const depositStr = parseRawAmount(
+          (lendAssets + bandBorrowed).toString(),
+          loanDecimals
+        );
+        const depositNum = Number(depositStr);
         const llamalendInfo = {
           health: health.toString(),
           priceUpper: priceUpper.toString(),
@@ -31909,6 +31971,9 @@ var getLlamaLendUserDataConverter = (lender, chainId, account, meta) => {
           bands,
           bandCount,
           bandCollateralInBorrowed: bandBorrowed.toString(),
+          lendAssets: lendStr,
+          lendShares: lendShares.toString(),
+          lendStaked: gaugeShares > 0n,
           softLiquidating: bandBorrowed > 0n,
           delegated,
           supportsDelegation: market.supportsDelegation === true,
@@ -31918,11 +31983,10 @@ var getLlamaLendUserDataConverter = (lender, chainId, account, meta) => {
         const collNum = Number(collStr);
         const debtStr = parseRawAmount(debt.toString(), loanDecimals);
         const debtNum = Number(debtStr);
-        const bandBorrowedStr = parseRawAmount(
+        parseRawAmount(
           bandBorrowed.toString(),
           loanDecimals
         );
-        const bandBorrowedNum = Number(bandBorrowedStr);
         const lendingPositions = {
           "0": {
             [collUid]: {
@@ -31944,16 +32008,18 @@ var getLlamaLendUserDataConverter = (lender, chainId, account, meta) => {
             [loanUid]: {
               marketUid: loanUid,
               underlying: loanAddr,
-              deposits: bandBorrowedStr,
+              deposits: depositStr,
               debt: debtStr,
               debtStable: "0",
-              depositsUSD: bandBorrowedNum * loanDisplay,
+              depositsUSD: depositNum * loanDisplay,
               debtUSD: debtNum * loanDisplay,
               debtStableUSD: 0,
-              depositsUSDOracle: bandBorrowedNum * loanOracle,
+              depositsUSDOracle: depositNum * loanOracle,
               debtUSDOracle: debtNum * loanOracle,
               debtStableUSDOracle: 0,
               stableBorrowRate: "0",
+              // The borrowed token is never collateral in a LlamaLend market —
+              // supplying it earns the lend rate, it does not back a loan.
               collateralEnabled: false,
               claimableRewards: 0,
               llamalendInfo
@@ -31963,7 +32029,7 @@ var getLlamaLendUserDataConverter = (lender, chainId, account, meta) => {
         const modes = { "0": bandCount };
         const hist = {
           "0": {
-            totalDeposits24h: collNum * collHist + bandBorrowedNum * loanHist,
+            totalDeposits24h: collNum * collHist + depositNum * loanHist,
             totalDebt24h: debtNum * loanHist
           }
         };
@@ -32111,7 +32177,7 @@ var getResupplyUserDataConverter = (lender, chainId, account, meta) => {
     expected
   ];
 };
-var WAD12 = 10n ** 18n;
+var WAD13 = 10n ** 18n;
 var big9 = (v) => {
   try {
     if (typeof v === "bigint") return v;
@@ -32182,7 +32248,7 @@ var getCurvanceUserDataConverter = (lender, chainId, account, meta) => {
           const display = getDisplayPrice(rowMeta);
           const oracle = getOraclePrice(rowMeta);
           const histPrice = rowMeta.price?.priceUsd24h ?? display;
-          const toUnderlying = (s) => exchangeRate > 0n ? s * exchangeRate / WAD12 : s;
+          const toUnderlying = (s) => exchangeRate > 0n ? s * exchangeRate / WAD13 : s;
           const depositsRaw = toUnderlying(collateralShares);
           const depositsStr = parseRawAmount(
             depositsRaw.toString(),
@@ -47118,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) {
@@ -47133,7 +47609,8 @@ var rewardFetchers = [
   aaveMerklRewardFetcher,
   eulerMerklRewardFetcher,
   morphoCollateralMerklRewardFetcher,
-  dtrinityRebateRewardFetcher
+  dtrinityRebateRewardFetcher,
+  llamaLendGaugeRewardFetcher
 ];
 function mergeReserveTokenRewards(target, source) {
   for (const [chainId, byToken] of Object.entries(source)) {
@@ -53635,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;
@@ -53650,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);
@@ -53679,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;
 }
@@ -54036,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,
@@ -54249,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,
@@ -55373,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: [] },
@@ -55384,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,
@@ -60620,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";
   }