@1delta/margin-fetcher 5.0.11 → 5.0.13

package/dist/index.js

@@ -23006,6 +23006,12 @@ 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",
@@ -23025,7 +23031,8 @@ var buildBandLtv = (market) => {
       // negligible at any realistic position size and converges as it grows.
       collateral: 10n ** BigInt(market.collateralDecimals + 3),
       collateralDecimals: market.collateralDecimals,
-      bandCounts: bandGrid(market)
+      // The FULL domain, not the multicall grid — see `LTV_CURVE_BANDS`.
+      bandCounts: LTV_CURVE_BANDS
     });
     return Object.keys(curve).length > 0 ? curve : null;
   } catch {
@@ -24326,7 +24333,19 @@ function convertLlamaLendMarketsToResponse(raw, chainId, prices = {}, additional
         // this as a number gets NaN and can branch, where "0" would silently
         // become a zero LTV. The real curve is in `llamalend.bandLtv`.
         lltv: ltv !== null ? String(ltv) : "",
-        oracle: market.priceOracle ?? market.amm,
+        /**
+         * The AMM, deliberately — LlamaLend's price feed is `price_oracle()` on
+         * the LLAMMA itself, so that is the only address a reader can call.
+         *
+         * This used to read `market.priceOracle ?? market.amm`, but
+         * `priceOracle` was never assigned anywhere in this pipeline (the name
+         * is used elsewhere for the price VALUE, not the contract), so the
+         * fallback was doing all the work. Naming it directly removes the trap:
+         * a Curve `price_oracle_contract` exposes `price()` and NOT
+         * `price_oracle()`, so populating that field would have silently
+         * pointed every oracle reader at an interface it cannot call.
+         */
+        oracle: market.amm,
         irm: market.monetaryPolicy ?? zeroAddress,
         collateralAddress: collAddr,
         loanAddress: loanAddr,
@@ -24382,7 +24401,6 @@ function convertLlamaLendMarketsToResponse(raw, chainId, prices = {}, additional
              */
             amm: market.amm,
             monetaryPolicy: market.monetaryPolicy,
-            priceOracle: market.priceOracle,
             /**
              * Curve's deployed v1 leverage zaps and the aggregator routers
              * they are hard-wired to. We route leverage through these rather
@@ -40699,6 +40717,40 @@ var fraxSavingsFetcher = {
   }
 };
 
+// src/yields/intrinsic/fetchers/binance.ts
+var HISTORY_URL2 = "https://www.binance.com/bapi/earn/v1/public/pos/cftoken/project/exchange-rate/history";
+var WBETH = "Wrapped Binance Beacon ETH::wBETH";
+var LLAMA_POOL = "80b8bf92-b953-4c20-98ea-c9653ef2bb98";
+var DAY_MS = 864e5;
+var LOOKBACK_MS = 14 * DAY_MS;
+var TIMEOUT_MS2 = 8e3;
+var wbethFetcher = {
+  label: "WBETH",
+  fetch: async () => {
+    const now = Date.now();
+    const url = `${HISTORY_URL2}?startTime=${now - LOOKBACK_MS}&endTime=${now}`;
+    try {
+      const res = await fetch(url, {
+        method: "GET",
+        headers: { Accept: "application/json" },
+        signal: AbortSignal.timeout(TIMEOUT_MS2)
+      }).then((r) => r.json());
+      const points = res.data ?? [];
+      if (points.length > 0) {
+        const latest = points.reduce(
+          (a, b) => Number(b.calcDate) > Number(a.calcDate) ? b : a
+        );
+        const apr = Number(latest.apr) * 100;
+        if (Number.isFinite(apr) && apr > 0) return { [WBETH]: apr };
+      }
+    } catch (e) {
+      console.log("WBETH history failed, falling back to DefiLlama", e);
+    }
+    const apy = await fetchDefiLlamaApy(LLAMA_POOL);
+    return { [WBETH]: apyToAprPercent(apy) };
+  }
+};
+
 // src/vaults/lst/registry.ts
 var LST_REGISTRY = {
   // Monad (143) — native-MON LSTs. shMON / aprMON are ERC-4626 over native
@@ -41101,6 +41153,46 @@ var LST_REGISTRY = {
       yieldFetcher: cbethFetcher,
       yieldKey: "CBETH"
     },
+    {
+      // Binance wBETH — the *other* exchange LST, and unlike cbETH above
+      // it is genuinely permissionless on-chain in both directions:
+      //   mint   `deposit(address referral)` payable, no allowlist
+      //   redeem `requestWithdrawEth(uint256)` → the UnwrapTokenV1ETH
+      //          queue at 0x79973d557CD9dd87eb61E250cc2572c990e20196
+      // (both simulated against mainnet — `deposit` succeeds from an
+      // arbitrary EOA, `requestWithdrawEth` reverts only on balance).
+      //
+      // A FiatTokenProxy (Circle's USDC codebase) + Binance's
+      // StakedTokenV3 mixin, so it inherits USDC-style `blacklist(address)`
+      // and `pause()` on BOTH the token and the unwrap queue — Binance can
+      // freeze any holder. Same trust class as USDC; that is the live risk
+      // for anything treating wBETH as collateral.
+      //
+      // The `queued` exit has two teeth that a plain cooldown does not:
+      //   * the ETH owed is FROZEN at request time (`ethAmount` is stored,
+      //     not recomputed), so the position stops earning for the whole
+      //     `lockTime()` — currently 864000s / 10 days, admin-settable down
+      //     to MIN_LOCK_TIME = 172800s / 2 days. Read it live.
+      //   * a request is only auto-allocated while
+      //     `availableAllocateAmount` covers it (~3 ETH on Ethereum today);
+      //     anything larger waits for Binance's operator to `allocate()`,
+      //     with no SLA.
+      address: "0xa2e3356610840701bdf5611a53974510ae27e2e1",
+      underlying: "0x0000000000000000000000000000000000000000",
+      symbol: "wBETH",
+      brand: "Binance",
+      decimals: 18,
+      reader: "binanceWbeth",
+      isErc4626: false,
+      isRebasing: false,
+      isMintable: true,
+      isNativeUnderlying: true,
+      mintContract: "0xa2e3356610840701bdf5611a53974510ae27e2e1",
+      mintInputAsset: "native",
+      withdrawalMode: "queued",
+      yieldFetcher: wbethFetcher,
+      yieldKey: "Wrapped Binance Beacon ETH::wBETH"
+    },
     {
       address: "0xa43a7c62d56df036c187e1966c03e2799d8987ed",
       // TruFin TruStake MATIC Vault uses the MATIC ERC-20 (not POL).
@@ -41667,6 +41759,37 @@ var LST_REGISTRY = {
         listaStakeManager: "0x1adb950d8bb3da4be104211d5ab038628e477fe6"
       }
     },
+    {
+      // Binance wBETH on BNB — SAME token address as Ethereum, but a
+      // different implementation behind the proxy (`WrapTokenV2BSC` vs
+      // `WrapTokenV3ETH`), so the mint leg is NOT portable:
+      //   Ethereum  `deposit(address referral)`          payable, native ETH
+      //   BNB       `deposit(uint256 amount, address referral)` nonpayable,
+      //             pulls the Binance-pegged ETH ERC-20 below → needs approve
+      // The read surface and the pushed rate ARE identical (one oracle
+      // 0x81720695… writes both chains, and `exchangeRate()` returns the
+      // same value), hence the shared reader and the shared `yieldKey`.
+      //
+      // Exit is the same UnwrapTokenV1 queue at the same address, with the
+      // same frozen-amount / 10-day-lock / operator-allocation caveats as
+      // the Ethereum entry — see there.
+      address: "0xa2e3356610840701bdf5611a53974510ae27e2e1",
+      // Binance-pegged ETH on BSC — the deposit input, not native BNB.
+      underlying: "0x2170ed0880ac9a755fd29b2688956bd959f933f8",
+      symbol: "wBETH",
+      brand: "Binance",
+      decimals: 18,
+      reader: "binanceWbeth",
+      isErc4626: false,
+      isRebasing: false,
+      isMintable: true,
+      isNativeUnderlying: false,
+      mintContract: "0xa2e3356610840701bdf5611a53974510ae27e2e1",
+      mintInputAsset: "0x2170ed0880ac9a755fd29b2688956bd959f933f8",
+      withdrawalMode: "queued",
+      yieldFetcher: wbethFetcher,
+      yieldKey: "Wrapped Binance Beacon ETH::wBETH"
+    },
     {
       // YieldNest ynBNB — ERC-4626 vault over slisBNB (Lista), restaked
       // via Kernel. Redeems to slisBNB synchronously; the BNB unstake
@@ -46061,32 +46184,85 @@ var upshiftFetcher = {
   }
 };
 
-// src/yields/yieldTypes.ts
-var addressToAssetYearn = {
-  "0xe007ca01894c863d7898045ed5a3b4abf0b18f37": "vbETH yVault::yvvbETH",
-  "0x80c34bd3a3569e126e7055831036aa7b212cb159": "vbUSDC yVault::yvvbUSDC",
-  "0x9a6bd7b6fd5c4f87eb66356441502fc7dcdd185b": "vbUSDT yVault::yvvbUSDT",
-  "0xaa0362ecc584b985056e47812931270b99c91f9d": "vbWBTC yVault::yvvbWBTC",
-  "0x93fec6639717b6215a48e5a72a162c50dcc40d68": "vbAUSD yVault::yvvbAUSD"
-};
+// src/vaults/yearn/api.ts
+var YEARN_YDAEMON_BASE = "https://ydaemon.yearn.fi";
+var YEARN_CHAIN_IDS = /* @__PURE__ */ new Set([
+  "1",
+  // Ethereum
+  "137",
+  // Polygon
+  "8453",
+  // Base
+  "42161",
+  // Arbitrum
+  "100",
+  // Gnosis
+  "146",
+  // Sonic
+  "747474"
+  // Katana
+]);
+var hasYearnVaults = (chainId) => YEARN_CHAIN_IDS.has(String(chainId));
+var isYearnV3 = (v) => typeof v?.version === "string" && v.version.startsWith("3.");
+var PAGE_SIZE = 2e3;
+async function fetchYearnApiVaults(chainId) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let page = 1; page <= 20; page++) {
+    const url = `${YEARN_YDAEMON_BASE}/${chainId}/vaults/all?limit=${PAGE_SIZE}&page=${page}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(
+        `Yearn yDaemon API failed: ${response.status} - ${response.statusText}`
+      );
+    }
+    const body = await response.text();
+    if (!body.trim()) break;
+    const items = JSON.parse(body);
+    if (!Array.isArray(items)) break;
+    for (const v of items) {
+      const address = (v?.address ?? "").toLowerCase();
+      if (!address || seen.has(address)) continue;
+      if (isYearnV3(v) && v.endorsed) {
+        seen.add(address);
+        out.push(v);
+      }
+    }
+    if (items.length < PAGE_SIZE) break;
+  }
+  return out;
+}
 
-// src/yields/intrinsic/fetchers/yearnKatana.ts
-var YEARN_KATANA_URL = "https://katana-apr-service.vercel.app/api/vaults";
-var yearnKatanaFetcher = {
-  label: "YEARN_KATANA",
+// src/yields/intrinsic/fetchers/yearn.ts
+var toPct = (v) => typeof v === "number" && Number.isFinite(v) ? v * 100 : null;
+var yearnVaultApr = (v) => toPct(v.apr?.netAPR) ?? toPct(v.apr?.forwardAPR?.netAPR);
+var yearnFetcher = {
+  label: "YEARN",
   fetch: async () => {
-    const res = await fetch(
-      YEARN_KATANA_URL
-    ).then((r) => r.json());
-    let map = {};
-    Object.entries(res).forEach(([addr2, data]) => {
-      const key2 = addressToAssetYearn[addr2.toLowerCase()];
-      if (key2) {
-        const apr = ((data.apr.netAPR ?? 0) + (data.apr.extra?.extrinsicYield ?? 0) + (data.apr.extra?.katanaNativeYield ?? 0)) * 100;
-        map[key2] = apr;
-      }
-    });
-    return map;
+    const chainIds = [...YEARN_CHAIN_IDS];
+    const lists = await getListsMulti(chainIds);
+    const perChain = await Promise.all(
+      chainIds.map(async (chainId) => {
+        const out = {};
+        let vaults = [];
+        try {
+          vaults = await fetchYearnApiVaults(chainId);
+        } catch (e) {
+          console.error(`Error fetching YEARN vaults on chain ${chainId}:`, e);
+          return out;
+        }
+        for (const v of vaults) {
+          const address = (v.address ?? "").toLowerCase();
+          const assetKey = lists[chainId]?.list?.[address]?.assetGroup;
+          if (!assetKey) continue;
+          const apr = yearnVaultApr(v);
+          if (apr == null) continue;
+          out[assetKey] = apr;
+        }
+        return out;
+      })
+    );
+    return Object.assign({}, ...perChain);
   }
 };
 
@@ -46150,7 +46326,9 @@ var LENDING_ONLY_FETCHERS = [
   nestFetcher,
   accountableFetcher,
   upshiftFetcher,
-  yearnKatanaFetcher,
+  // Every endorsed Yearn V3 vault on every Yearn chain (Katana included —
+  // it superseded the Katana-only fetcher, which double-counted).
+  yearnFetcher,
   // DefiLlama-mapped intrinsic yields for classifier assets lacking a bespoke source
   lsethFetcher,
   tethFetcher,
@@ -46251,6 +46429,76 @@ function extractRewardBreakdowns(opp) {
     distributionType: b.distributionType
   }));
 }
+function unixSeconds(v) {
+  if (v === void 0 || v === null) return void 0;
+  const n = typeof v === "number" ? v : Number(v);
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+function buildMerklStreams(opp, side, totalApr, source) {
+  const rewardBreakdowns = opp.rewardsRecord?.breakdowns ?? [];
+  const endsAt = unixSeconds(opp.earliestCampaignEnd ?? opp.latestCampaignEnd);
+  const startsAt = unixSeconds(
+    opp.earliestCampaignStart ?? opp.latestCampaignStart
+  );
+  const base = {
+    side,
+    kind: "token",
+    claim: "merkl",
+    endsAt,
+    startsAt
+  };
+  if (!rewardBreakdowns.length) {
+    return [{ ...base, apr: totalApr, token: void 0, source }];
+  }
+  const aprByCampaign = /* @__PURE__ */ new Map();
+  for (const b of opp.aprRecord?.breakdowns ?? []) {
+    if (b?.identifier && Number.isFinite(b.value))
+      aprByCampaign.set(b.identifier.toLowerCase(), b.value);
+  }
+  const totalDaily = rewardBreakdowns.reduce((s, b) => s + (b.value || 0), 0);
+  return rewardBreakdowns.map((b) => {
+    const campaignApr = b.onChainCampaignId ? aprByCampaign.get(b.onChainCampaignId.toLowerCase()) : void 0;
+    const apr = campaignApr ?? (totalDaily > 0 ? totalApr * (b.value || 0) / totalDaily : totalApr / rewardBreakdowns.length);
+    return {
+      ...base,
+      apr,
+      token: {
+        address: b.token.address.toLowerCase(),
+        chainId: String(opp.chainId),
+        symbol: b.token.symbol,
+        decimals: b.token.decimals,
+        logoURI: b.token.icon,
+        priceUsd: b.token.price ?? void 0
+      },
+      dailyRewardsUsd: b.value,
+      source: {
+        ...source,
+        refs: {
+          ...source.refs ?? {},
+          ...b.onChainCampaignId ? { onChainCampaignId: b.onChainCampaignId } : {},
+          ...b.campaignId ? { campaignId: b.campaignId } : {},
+          ...b.distributionType ? { distributionType: b.distributionType } : {}
+        }
+      }
+    };
+  });
+}
+function merklSourceRef(opp, merklProtocolId) {
+  const protocolName = opp.protocol?.name ?? merklProtocolId;
+  return {
+    id: `merkl:${merklProtocolId}`,
+    label: `Merkl \xB7 ${protocolName}`,
+    link: getMerkleUrl(opp),
+    platform: "merkl",
+    refs: {
+      opportunityId: opp.identifier,
+      opportunityType: opp.type,
+      chain: opp.chain?.name ?? String(opp.chainId),
+      ...opp.name ? { opportunityName: opp.name } : {},
+      ...opp.liveCampaigns ? { liveCampaigns: opp.liveCampaigns } : {}
+    }
+  };
+}
 function resolveUnderlyingFromOpportunity(opp) {
   if (!opp.tokens?.length) return void 0;
   if (opp.depositUrl) {
@@ -46316,6 +46564,11 @@ function createMerklRewardFetcher(config) {
             );
             const breakdowns = extractRewardBreakdowns(opp);
             reward.link = getMerkleUrl(opp);
+            const source = merklSourceRef(opp, config.merklProtocolId);
+            if (!reward.streams) reward.streams = [];
+            reward.streams.push(
+              ...buildMerklStreams(opp, bucket, opp.apr, source)
+            );
             if (bucket === "deposit") {
               reward.deposit += opp.apr;
               reward.additionalDepositData.push(...breakdowns);
@@ -46520,8 +46773,21 @@ var ABI = [
     stateMutability: "view",
     inputs: [],
     outputs: [{ type: "uint8" }]
+  },
+  {
+    name: "symbol",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "string" }]
   }
 ];
+var DTRINITY_SOURCE = {
+  id: "dtrinity:rebate",
+  label: "dTRINITY borrow rebate",
+  link: "https://docs.dtrinity.org/protocol-components/dlend",
+  platform: "protocol"
+};
 var isZero = (a) => !a || a.toLowerCase() === ZERO_ADDRESS5;
 var scale = (raw, decimals) => Number(raw) / 10 ** decimals;
 function emptyReward2() {
@@ -46635,19 +46901,25 @@ async function fetchForPool(chainId, lender, pool, nowSeconds) {
     calls: pairs.flatMap((p) => [
       call(p.leg.controller, "getRewardsData", [p.leg.balanceToken, p.reward]),
       call(p.reward, "decimals"),
-      call(oracle, "getAssetPrice", [p.reward])
+      call(oracle, "getAssetPrice", [p.reward]),
+      call(p.reward, "symbol")
     ]),
     allowFailure: false
   });
+  const STRIDE = 4;
   const result = {};
   pairs.forEach((p, i) => {
-    const data = round5[i * 3];
+    const data = round5[i * STRIDE];
     if (!data) return;
+    const rewardDecimals = Number(round5[i * STRIDE + 1] ?? 18);
+    const rewardPrice = Number(round5[i * STRIDE + 2] ?? 0n);
+    const rewardSymbol = round5[i * STRIDE + 3];
+    const distributionEnd = Number(data[3] ?? 0);
     const apr = rebateApr({
       emissionPerSecond: BigInt(data[1] ?? 0),
       distributionEnd: BigInt(data[3] ?? 0),
-      rewardDecimals: Number(round5[i * 3 + 1] ?? 18),
-      rewardPrice: Number(round5[i * 3 + 2] ?? 0n),
+      rewardDecimals,
+      rewardPrice,
       balanceTotalSupply: BigInt(p.leg.totalSupply ?? 0),
       balanceDecimals: p.leg.decimals,
       assetPrice: priceByAsset[p.leg.asset] ?? 0,
@@ -46662,9 +46934,34 @@ async function fetchForPool(chainId, lender, pool, nowSeconds) {
     const breakdown = {
       tokenAddress: p.reward.toLowerCase(),
       emissionPerSecond: String(data[1]),
-      distributionEnd: Number(data[3]),
+      distributionEnd,
       distributionType: "aave-incentives"
     };
+    if (!entry.streams) entry.streams = [];
+    entry.streams.push({
+      side: p.leg.bucket,
+      apr,
+      kind: "token",
+      token: {
+        address: p.reward.toLowerCase(),
+        chainId,
+        symbol: rewardSymbol,
+        decimals: rewardDecimals,
+        // The pool's AaveOracle is 1e8-based on every dLEND deployment.
+        priceUsd: rewardPrice > 0 ? rewardPrice / 1e8 : void 0
+      },
+      source: {
+        ...DTRINITY_SOURCE,
+        refs: {
+          incentivesController: p.leg.controller.toLowerCase(),
+          balanceToken: p.leg.balanceToken.toLowerCase(),
+          emissionPerSecond: String(data[1])
+        }
+      },
+      claim: "accrual",
+      endsAt: distributionEnd > 0 ? distributionEnd : void 0,
+      dailyRewardsUsd: rewardPrice > 0 ? Number(data[1] ?? 0) / 10 ** rewardDecimals * 86400 * (rewardPrice / 1e8) : void 0
+    });
     if (p.leg.bucket === "deposit") {
       entry.deposit += apr;
       entry.additionalDepositData.push(breakdown);
@@ -48220,6 +48517,79 @@ var listaFetcher = {
   parse: parseListaResults,
   getAbi: getListaAbi
 };
+function generateLlamaLendLenderKey(marketId) {
+  return `${Lender.LLAMALEND}_${marketId.replace(/^0x/i, "").toUpperCase()}`;
+}
+function getLlamaLendMarketsForChain(chainId, marketOverrides) {
+  return marketOverrides?.[chainId] ?? [];
+}
+function getLlamaLendCalls(chainId, context) {
+  const markets = getLlamaLendMarketsForChain(chainId, context?.marketOverrides);
+  if (markets.length === 0) return [];
+  return markets.map((market) => {
+    const call = {
+      address: market.amm,
+      name: "price_oracle",
+      params: []
+    };
+    return {
+      calls: [call],
+      meta: { markets: [market] },
+      lender: generateLlamaLendLenderKey(market.marketId)
+    };
+  });
+}
+function parseLlamaLendResults(data, meta, context) {
+  const { chainId, usdPrices, tokenList } = context;
+  const entries = [];
+  const rawPrice = data[0];
+  if (rawPrice === void 0 || rawPrice === null || rawPrice === "0x") {
+    return entries;
+  }
+  for (const market of meta.markets) {
+    const loanAsset = market.loanAsset.toLowerCase();
+    const collateralAsset = market.collateralAsset.toLowerCase();
+    let collateralInLoan;
+    try {
+      collateralInLoan = Number(formatUnits(BigInt(rawPrice.toString()), 18));
+    } catch {
+      continue;
+    }
+    if (!Number.isFinite(collateralInLoan) || collateralInLoan === 0) continue;
+    const loanOracleKey = tokenList?.[loanAsset]?.assetGroup ?? `${chainId}-${loanAsset}`;
+    const loanAssetUSD = usdPrices[loanOracleKey] ?? usdPrices[loanAsset];
+    if (!loanAssetUSD) continue;
+    const lenderKey = generateLlamaLendLenderKey(market.marketId);
+    entries.push({
+      asset: loanAsset,
+      price: 1,
+      priceUSD: loanAssetUSD,
+      marketUid: createMarketUid(chainId, lenderKey, loanAsset),
+      targetLender: lenderKey,
+      description: "LlamaLend borrowed asset",
+      staticBase: true,
+      baseAsset: loanAsset
+    });
+    entries.push({
+      asset: collateralAsset,
+      price: collateralInLoan,
+      priceUSD: collateralInLoan * loanAssetUSD,
+      marketUid: createMarketUid(chainId, lenderKey, collateralAsset),
+      targetLender: lenderKey,
+      description: "LlamaLend collateral (AMM EMA oracle)",
+      baseAsset: loanAsset
+    });
+  }
+  return entries;
+}
+function getLlamaLendAbi() {
+  return LlamaLendAmmAbi;
+}
+var llamaLendFetcher = {
+  getCalls: getLlamaLendCalls,
+  parse: parseLlamaLendResults,
+  getAbi: getLlamaLendAbi
+};
 
 // src/abis/euler/priceLens.ts
 var priceLensAbi = [
@@ -49580,7 +49950,7 @@ async function executeGroup(group, chainId, chainBatchSize, retries, allowFailur
     };
   }
 }
-async function fetchOraclePrices(chainIds, rpcOverrides, lists = {}, retries = 3, batchSize = void 0, allowFailure = true, basePrices = {}, morphoMarketOverrides, listaMarketOverrides, stalenessThresholdSeconds = 3600, onlyFetchers, probeFeedStaleness = true) {
+async function fetchOraclePrices(chainIds, rpcOverrides, lists = {}, retries = 3, batchSize = void 0, allowFailure = true, basePrices = {}, morphoMarketOverrides, listaMarketOverrides, stalenessThresholdSeconds = 3600, onlyFetchers, probeFeedStaleness = true, llamaLendMarketOverrides) {
   const totalStart = Date.now();
   const result = {};
   const chainPromises = chainIds.map(async (chainId) => {
@@ -49625,6 +49995,13 @@ async function fetchOraclePrices(chainIds, rpcOverrides, lists = {}, retries = 3
       }),
       getCallsErrors
     ) : [];
+    const llamaLendResults = isActive("llamalend") ? safeGetCalls(
+      "llamaLend",
+      () => llamaLendFetcher.getCalls(chainId, {
+        marketOverrides: llamaLendMarketOverrides
+      }),
+      getCallsErrors
+    ) : [];
     const eulerResults = isActive("eulerv2") ? safeGetCalls(
       "eulerV2",
       () => eulerV2Fetcher.getCalls(chainId),
@@ -49745,6 +50122,13 @@ async function fetchOraclePrices(chainIds, rpcOverrides, lists = {}, retries = 3
       ProxyOracleAbi,
       "direct"
     );
+    const llamaLendGroup = buildGroup(
+      "llamaLend",
+      llamaLendResults,
+      llamaLendFetcher.parse,
+      getLlamaLendAbi(),
+      "derived"
+    );
     const eulerGroup = buildGroup(
       "eulerV2",
       eulerResults,
@@ -49871,6 +50255,7 @@ async function fetchOraclePrices(chainIds, rpcOverrides, lists = {}, retries = 3
       compoundV2Group,
       compoundV3Group,
       listaGroup,
+      llamaLendGroup,
       eulerGroup,
       aaveV4Group,
       morphoGroup,
@@ -49918,6 +50303,7 @@ async function fetchOraclePrices(chainIds, rpcOverrides, lists = {}, retries = 3
       compoundV2Data,
       compoundV3Data,
       listaData,
+      llamaLendData,
       eulerData,
       aaveV4Data,
       fluidData,
@@ -49968,6 +50354,14 @@ async function fetchOraclePrices(chainIds, rpcOverrides, lists = {}, retries = 3
         allowFailure,
         rpcOverrides
       ),
+      executeGroup(
+        llamaLendGroup,
+        chainId,
+        chainBatchSize,
+        retries,
+        allowFailure,
+        rpcOverrides
+      ),
       executeGroup(
         eulerGroup,
         chainId,
@@ -50125,6 +50519,7 @@ async function fetchOraclePrices(chainIds, rpcOverrides, lists = {}, retries = 3
       { group: compoundV2Group, data: compoundV2Data },
       { group: compoundV3Group, data: compoundV3Data },
       { group: listaGroup, data: listaData },
+      { group: llamaLendGroup, data: llamaLendData },
       { group: eulerGroup, data: eulerData },
       { group: aaveV4Group, data: aaveV4Data },
       { group: fluidGroup, data: fluidData },
@@ -50317,6 +50712,7 @@ async function fetchOraclePrices(chainIds, rpcOverrides, lists = {}, retries = 3
     }
     parseTrackers(midnightGroup, midnightData.results, false);
     parseTrackers(tellerGroup, tellerData.results, false);
+    parseTrackers(llamaLendGroup, llamaLendData.results, false);
     if (stalenessThresholdSeconds > 0) {
       const feedTimestamps = await feedTimestampsPromise;
       for (const [lender, assetMap] of Object.entries(feedTimestamps)) {
@@ -51506,7 +51902,7 @@ var fetchGearboxV3Pools = async (chainId, multicallRetry, prices = {}, tokenList
 // src/vaults/morpho/fetchFromApi.ts
 var MORPHO_SHARE_DECIMALS = 18;
 var MORPHO_API_URL = "https://blue-api.morpho.org/graphql";
-var PAGE_SIZE = 200;
+var PAGE_SIZE2 = 200;
 var vaultsQuery = (first, skip, chainId) => `
 query GetVaults {
   vaults(
@@ -51671,14 +52067,14 @@ async function fetchMorphoVaultsFromApi(chainId, prices = {}, tokenList = {}, ma
   const out = {};
   let skip = 0;
   while (skip < maxItems) {
-    const page = await fetchPage(chainId, PAGE_SIZE, skip);
+    const page = await fetchPage(chainId, PAGE_SIZE2, skip);
     if (page.length === 0) break;
     for (const v of page) {
       const parsed = parseVault2(v, chainId, prices, tokenList);
       if (parsed) out[parsed.address] = parsed;
     }
-    if (page.length < PAGE_SIZE) break;
-    skip += PAGE_SIZE;
+    if (page.length < PAGE_SIZE2) break;
+    skip += PAGE_SIZE2;
   }
   return out;
 }
@@ -54808,6 +55204,38 @@ var readerAnkrRatio = (entry) => ({
   }
 });
 
+// src/vaults/lst/abis/binance.ts
+var WbethExchangeRateAbi = [
+  {
+    name: "exchangeRate",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  }
+];
+
+// src/vaults/lst/readers/binance.ts
+var readerBinanceWbeth = (entry) => ({
+  calls: [
+    { address: entry.address, name: "totalSupply", params: [] },
+    { address: entry.address, name: "exchangeRate", params: [] }
+  ],
+  abis: [TotalSupplyAbi, WbethExchangeRateAbi],
+  parse: ([supply, rate]) => {
+    const totalSupply = toBigInt13(supply);
+    const exchangeRate = toBigInt13(rate);
+    if (totalSupply === void 0 || exchangeRate === void 0) {
+      return void 0;
+    }
+    return {
+      totalAssets: totalSupply * exchangeRate / ONE_E189,
+      totalSupply,
+      exchangeRate
+    };
+  }
+});
+
 // src/vaults/lst/abis/core.ts
 var CoreEarnRateAbi = [
   {
@@ -54930,6 +55358,8 @@ var buildReader = (entry) => {
       return readerKelpRsEth(entry);
     case "swellGetRate":
       return readerSwellGetRate(entry);
+    case "binanceWbeth":
+      return readerBinanceWbeth(entry);
     case "stakewiseOsEth":
       return readerStakeWiseOsEth(entry);
     case "staderEthx":
@@ -55827,6 +56257,96 @@ var readerBenqi = {
   }
 };
 
+// src/vaults/lst/withdrawals/abis/binance.ts
+var BinanceUnwrapQueueAbi = [
+  {
+    name: "getUserWithdrawRequests",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ type: "address", name: "recipient" }],
+    outputs: [
+      {
+        type: "tuple[]",
+        components: [
+          { type: "address", name: "recipient" },
+          { type: "uint256", name: "wbethAmount" },
+          { type: "uint256", name: "ethAmount" },
+          { type: "uint256", name: "triggerTime" },
+          { type: "uint256", name: "claimTime" },
+          { type: "bool", name: "allocated" }
+        ]
+      }
+    ]
+  },
+  {
+    // Currently 864000 (10 days). Admin-settable down to
+    // `MIN_LOCK_TIME` = 172800 (2 days) — always read it, never hardcode.
+    name: "lockTime",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "claimWithdraw",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ type: "uint256", name: "index" }],
+    outputs: [{ type: "uint256" }]
+  }
+];
+
+// src/vaults/lst/withdrawals/readers/binance.ts
+var readerBinanceWbeth2 = {
+  fetch: async (user, multicallRetry, chainId, entry) => {
+    if (!entry.withdrawalContract) return [];
+    const res = await multicallRetry({
+      chain: chainId,
+      calls: [
+        {
+          address: entry.withdrawalContract,
+          name: "getUserWithdrawRequests",
+          params: [user]
+        },
+        {
+          address: entry.withdrawalContract,
+          name: "lockTime",
+          params: []
+        }
+      ],
+      abi: [BinanceUnwrapQueueAbi, BinanceUnwrapQueueAbi]
+    });
+    const reqs = res[0];
+    const lockTime = toNumber(res[1]);
+    if (!Array.isArray(reqs) || lockTime === void 0) return [];
+    const out = [];
+    for (let i = 0; i < reqs.length; i++) {
+      const r = reqs[i];
+      const triggerTime = toNumber(r.triggerTime);
+      const ethAmount = toBigInt14(r.ethAmount);
+      const wbethAmount = toBigInt14(r.wbethAmount);
+      if (triggerTime === void 0 || ethAmount === void 0) continue;
+      const readyAt = triggerTime + lockTime;
+      const claimed = (toNumber(r.claimTime) ?? 0) > 0;
+      const allocated = r.allocated === true;
+      out.push({
+        lst: entry.lst,
+        brand: entry.brand,
+        symbol: entry.symbol,
+        // Positional — see note 1 above.
+        requestId: String(i),
+        amountUnderlying: ethAmount.toString(),
+        shares: wbethAmount?.toString(),
+        // Claimed requests are popped from the array, so this branch is
+        // defensive only.
+        status: claimed ? "claimed" : allocated ? computeStatus(readyAt) : "pending",
+        readyAt
+      });
+    }
+    return out;
+  }
+};
+
 // src/vaults/lst/withdrawals/abis/berapaw.ts
 var BeraPawForgeWithdrawalAbi = [
   {
@@ -57968,6 +58488,8 @@ var readerYieldNest = {
 // src/vaults/lst/withdrawals/readers/index.ts
 var buildWithdrawalReader = (entry) => {
   switch (entry.reader) {
+    case "binanceWbethQueue":
+      return readerBinanceWbeth2;
     case "lidoQueue":
       return readerLido;
     case "etherfiNft":
@@ -58033,6 +58555,20 @@ var buildWithdrawalReader = (entry) => {
 // src/vaults/lst/withdrawals/registry.ts
 var LST_WITHDRAWAL_REGISTRY = {
   "1": [
+    {
+      // wBETH — Binance's UnwrapTokenV1 queue, the SAME contract address
+      // on Ethereum and BNB. Entered via `wBETH.requestWithdrawEth`;
+      // `getUserWithdrawRequests(user)` enumerates open requests, and
+      // `claimWithdraw(index)` takes the user's ARRAY POSITION (swap-and-pop,
+      // so ids shift on every claim — never cache them). `lockTime()` is
+      // 10 days today but is admin-settable down to 2, and the ETH owed is
+      // frozen at request time, so the position stops earning meanwhile.
+      lst: "0xa2e3356610840701bdf5611a53974510ae27e2e1",
+      brand: "Binance",
+      symbol: "wBETH",
+      reader: "binanceWbethQueue",
+      withdrawalContract: "0x79973d557cd9dd87eb61e250cc2572c990e20196"
+    },
     // Ankr ankrETH — Ankr unstake queue; reader not yet implemented.
     {
       lst: "0xe95a203b1a91a908f9b9ce46459d101078c2c3cb",
@@ -58405,6 +58941,20 @@ var LST_WITHDRAWAL_REGISTRY = {
     }
   ],
   "56": [
+    {
+      // wBETH — Binance's UnwrapTokenV1 queue, the SAME contract address
+      // on Ethereum and BNB. Entered via `wBETH.requestWithdrawEth`;
+      // `getUserWithdrawRequests(user)` enumerates open requests, and
+      // `claimWithdraw(index)` takes the user's ARRAY POSITION (swap-and-pop,
+      // so ids shift on every claim — never cache them). `lockTime()` is
+      // 10 days today but is admin-settable down to 2, and the ETH owed is
+      // frozen at request time, so the position stops earning meanwhile.
+      lst: "0xa2e3356610840701bdf5611a53974510ae27e2e1",
+      brand: "Binance",
+      symbol: "wBETH",
+      reader: "binanceWbethQueue",
+      withdrawalContract: "0x79973d557cd9dd87eb61e250cc2572c990e20196"
+    },
     // Ankr ankrBNB — Ankr unstake queue; reader not yet implemented.
     {
       lst: "0x52f24a5e03aee338da5fd9df68d2b6fae1178827",
@@ -59321,7 +59871,7 @@ query LagoonVaults($where: VaultFilterInput!, $first: Int!, $skip: Int!) {
     }
   }
 }`;
-var PAGE_SIZE2 = 200;
+var PAGE_SIZE3 = 200;
 async function fetchLagoonApiVaults(chainId) {
   const out = [];
   let skip = 0;
@@ -59333,7 +59883,7 @@ async function fetchLagoonApiVaults(chainId) {
         query: VAULTS_QUERY,
         variables: {
           where: { chainId_eq: Number(chainId), isVisible_eq: true },
-          first: PAGE_SIZE2,
+          first: PAGE_SIZE3,
           skip
         }
       })
@@ -59351,8 +59901,8 @@ async function fetchLagoonApiVaults(chainId) {
     }
     const items = json?.data?.vaults?.items ?? [];
     out.push(...items);
-    if (items.length < PAGE_SIZE2) break;
-    skip += PAGE_SIZE2;
+    if (items.length < PAGE_SIZE3) break;
+    skip += PAGE_SIZE3;
   }
   return out;
 }
@@ -59472,7 +60022,7 @@ var Erc4626TotalAssetsAbi = [
 
 // src/vaults/aave-earn/api.ts
 var AAVE_EARN_API_URL = "https://api.v3.aave.com/graphql";
-var PAGE_SIZE3 = "FIFTY";
+var PAGE_SIZE4 = "FIFTY";
 var VAULT_FIELDS = `
   address
   shareName
@@ -59530,7 +60080,7 @@ async function fetchAaveEarnApiVaults(chainId, targets) {
     for (let page = 0; page < 20; page++) {
       const request = {
         criteria: { ownedBy: [owner] },
-        pageSize: PAGE_SIZE3
+        pageSize: PAGE_SIZE4
       };
       if (cursor) request.cursor = cursor;
       const data = await postGraphql(OWNED_VAULTS_QUERY, { request });
@@ -59789,47 +60339,6 @@ var fetchUpshiftVaults = async (chainId, prices = {}, tokenList = {}) => {
   return out;
 };
 
-// src/vaults/yearn/api.ts
-var YEARN_YDAEMON_BASE = "https://ydaemon.yearn.fi";
-var YEARN_CHAIN_IDS = /* @__PURE__ */ new Set([
-  "1",
-  // Ethereum
-  "137",
-  // Polygon
-  "8453",
-  // Base
-  "42161",
-  // Arbitrum
-  "100",
-  // Gnosis
-  "146",
-  // Sonic
-  "747474"
-  // Katana
-]);
-var hasYearnVaults = (chainId) => YEARN_CHAIN_IDS.has(String(chainId));
-var isYearnV3 = (v) => typeof v?.version === "string" && v.version.startsWith("3.");
-var PAGE_SIZE4 = 500;
-async function fetchYearnApiVaults(chainId) {
-  const out = [];
-  for (let page = 1; page <= 20; page++) {
-    const url = `${YEARN_YDAEMON_BASE}/${chainId}/vaults/all?limit=${PAGE_SIZE4}&page=${page}`;
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(
-        `Yearn yDaemon API failed: ${response.status} - ${response.statusText}`
-      );
-    }
-    const items = await response.json();
-    if (!Array.isArray(items)) break;
-    for (const v of items) {
-      if (isYearnV3(v) && v.endorsed) out.push(v);
-    }
-    if (items.length < PAGE_SIZE4) break;
-  }
-  return out;
-}
-
 // src/vaults/yearn/fetchPublic.ts
 var BRAND3 = "Yearn";
 var ZERO_ADDR = "0x0000000000000000000000000000000000000000";
@@ -59875,7 +60384,7 @@ var asBig = (v) => {
   }
 };
 var num9 = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
-var toPct = (v) => {
+var toPct2 = (v) => {
   const n = num9(v);
   return n == null ? 0 : n * 100;
 };
@@ -59911,9 +60420,9 @@ function parseVault9(v, chainId, prices, tokenList) {
   const realized = num9(v.apr?.netAPR);
   const forward = num9(v.apr?.forwardAPR?.netAPR);
   const isForwardApr = realized == null && forward != null;
-  const supplyRate = toPct(realized ?? forward);
-  const rewardsRate = toPct(v.apr?.extra?.stakingRewardsAPR);
-  const fee = toPct(v.apr?.fees?.performance);
+  const supplyRate = toPct2(realized ?? forward);
+  const rewardsRate = toPct2(v.apr?.extra?.stakingRewardsAPR);
+  const fee = toPct2(v.apr?.fees?.performance);
   const oracleKey = toOracleKey(assetMeta?.assetGroup) ?? toGenericPriceKey(assetAddr, chainId);
   const apiPrice = num9(v.tvl?.price) ?? 0;
   const priceUsd = prices[oracleKey] ?? prices[assetAddr] ?? apiPrice;
@@ -64697,11 +65206,12 @@ var llamaLendAdapter = {
           /**
            * The band count as an editable TERM, not just a curve to read.
            *
-           * `bandLtv` alone cannot drive a control: it is four sampled points,
-           * and it is missing on any market whose curve could not be computed.
-           * The domain is always known — `MIN_TICKS`/`MAX_TICKS` are 4..50 on
-           * both generations — so the control works even where the curve does
-           * not.
+           * `bandLtv` alone cannot drive a control: it is missing on any
+           * market whose geometry could not be read. The domain is always
+           * known — `MIN_TICKS`/`MAX_TICKS` are 4..50 on both generations — so
+           * the control works even where the curve does not. Where the curve
+           * IS present it spans the full domain, so a control can show the LTV
+           * for every value it offers.
            *
            * `immutableAfterOpen` is what tells the UI to render this read-only
            * on an existing loan: `_add_collateral_borrow` reuses the tick
@@ -64766,7 +65276,16 @@ var frankencoinAdapter = {
     return {
       // Not a coverage hole: the protocol has no price feed by design.
       oracle: { kind: "none" },
+      supply: {
+        // Collateral inside a position. There is no ZCHF lending deposit at
+        // all — the earn surface is the savings module, a separate provider —
+        // so this side never pays interest.
+        role: "collateral",
+        availability: { opensWith: "both-legs" },
+        counterparty: { kind: "cdp", solvency: "overcollateralized" }
+      },
       borrow: {
+        availability: { opensWith: "both-legs" },
         debtShape: "accruing",
         maturity: expiration > 0 ? {
           kind: "fixed-date",