@1delta/margin-fetcher 5.0.63 → 5.0.64

package/dist/index.js

@@ -10951,9 +10951,9 @@ function applyPositionDelta(positions, targetMarketUid, depositsDeltaUSD, debtDe
 }
 
 // src/lending/margin/base/sumer/deposit.ts
-function computeSumerDepositDelta(amount3, price2, targetMarketUid, balanceData2, positions, createNewSubAccount = false, apr, yieldParams) {
+function computeSumerDepositDelta(amount4, price2, targetMarketUid, balanceData2, positions, createNewSubAccount = false, apr, yieldParams) {
   const base = createNewSubAccount ? EMPTY_BALANCE : balanceData2;
-  const dollarAmount = amount3 * price2;
+  const dollarAmount = amount4 * price2;
   const updatedPositions = applyPositionDelta(
     positions,
     targetMarketUid,
@@ -11019,8 +11019,8 @@ function computeSumerDepositDelta(amount3, price2, targetMarketUid, balanceData2
 }
 
 // src/lending/margin/base/sumer/withdraw.ts
-function computeSumerWithdrawDelta(amount3, price2, targetMarketUid, balanceData2, positions, apr, yieldParams) {
-  const dollarAmount = amount3 * price2;
+function computeSumerWithdrawDelta(amount4, price2, targetMarketUid, balanceData2, positions, apr, yieldParams) {
+  const dollarAmount = amount4 * price2;
   const updatedPositions = applyPositionDelta(
     positions,
     targetMarketUid,
@@ -11086,8 +11086,8 @@ function computeSumerWithdrawDelta(amount3, price2, targetMarketUid, balanceData
 }
 
 // src/lending/margin/base/sumer/borrow.ts
-function computeSumerBorrowDelta(amount3, price2, targetMarketUid, balanceData2, positions, apr, yieldParams, irMode) {
-  const dollarAmount = amount3 * price2;
+function computeSumerBorrowDelta(amount4, price2, targetMarketUid, balanceData2, positions, apr, yieldParams, irMode) {
+  const dollarAmount = amount4 * price2;
   const mode = irMode ?? 2;
   const updatedPositions = applyPositionDelta(
     positions,
@@ -11157,8 +11157,8 @@ function computeSumerBorrowDelta(amount3, price2, targetMarketUid, balanceData2,
 }
 
 // src/lending/margin/base/sumer/repay.ts
-function computeSumerRepayDelta(amount3, price2, targetMarketUid, balanceData2, positions, apr, yieldParams, irMode) {
-  const dollarAmount = amount3 * price2;
+function computeSumerRepayDelta(amount4, price2, targetMarketUid, balanceData2, positions, apr, yieldParams, irMode) {
+  const dollarAmount = amount4 * price2;
   const mode = irMode ?? 2;
   const updatedPositions = applyPositionDelta(
     positions,
@@ -16661,13 +16661,13 @@ var REPAIR_BACKOFF_JITTER_MS = 60;
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
 var backoffForRound = (round) => REPAIR_BACKOFF_BASE_MS * 2 ** round + Math.random() * REPAIR_BACKOFF_JITTER_MS;
 var endpointUrl = (client, rpcId) => client?.transport?.url ?? `rpc#${rpcId}`;
-var resolveEndpoint = (chainId, getEvmClient18, startRpcId, tried, maxProbe = 12, timeoutMs) => {
+var resolveEndpoint = (chainId, getEvmClient19, startRpcId, tried, maxProbe = 12, timeoutMs) => {
   let fallback = null;
   for (let probe = 0; probe < maxProbe; probe++) {
     const rpcId = startRpcId + probe;
     let client;
     try {
-      client = getEvmClient18(chainId, rpcId, { timeoutMs });
+      client = getEvmClient19(chainId, rpcId, { timeoutMs });
     } catch {
       break;
     }
@@ -16696,7 +16696,7 @@ var recordPermanentFailures = (slots, offset, collector) => {
     if (slots[i].permanent) collector.add(offset + i);
   }
 };
-var repairFailedSlots = async (chainId, contracts, slots, getEvmClient18, nextRpcId, batchSize, logs, rounds = MULTICALL_REPAIR_ROUNDS, options) => {
+var repairFailedSlots = async (chainId, contracts, slots, getEvmClient19, nextRpcId, batchSize, logs, rounds = MULTICALL_REPAIR_ROUNDS, options) => {
   let searchFrom = nextRpcId;
   for (let round = 0; round < rounds; round++) {
     const failedIdx = [];
@@ -16706,7 +16706,7 @@ var repairFailedSlots = async (chainId, contracts, slots, getEvmClient18, nextRp
     if (failedIdx.length === 0) return slots;
     const endpoint = resolveEndpoint(
       chainId,
-      getEvmClient18,
+      getEvmClient19,
       searchFrom,
       options?.tried
     );
@@ -16758,7 +16758,7 @@ var repairFailedSlots = async (chainId, contracts, slots, getEvmClient18, nextRp
   }
   return slots;
 };
-var multicallShardedAbiArray = async (chainId, abi, calls, getEvmClient18, poolSize, retries = maxRetries, allowFailure = true, batchSize = MULTICALL_DEFAULT_BATCH_SIZE, logs = false, retryFailed = false, permanentFailures, options) => {
+var multicallShardedAbiArray = async (chainId, abi, calls, getEvmClient19, poolSize, retries = maxRetries, allowFailure = true, batchSize = MULTICALL_DEFAULT_BATCH_SIZE, logs = false, retryFailed = false, permanentFailures, options) => {
   const abiIsArray = isArray(abi[0]);
   const contracts = calls.map(({ address, name, params }, i) => ({
     abi: abiIsArray ? abi?.[i] : abi,
@@ -16832,7 +16832,7 @@ var multicallShardedAbiArray = async (chainId, abi, calls, getEvmClient18, poolS
   const attemptHedged = async (items, startRpcId, tried) => {
     const primary = resolveEndpoint(
       chainId,
-      getEvmClient18,
+      getEvmClient19,
       startRpcId,
       tried,
       12,
@@ -16856,7 +16856,7 @@ var multicallShardedAbiArray = async (chainId, abi, calls, getEvmClient18, poolS
         clearTimeout(timer);
         const alt = resolveEndpoint(
           chainId,
-          getEvmClient18,
+          getEvmClient19,
           primary.rpcId + 1,
           tried,
           12,
@@ -16908,7 +16908,7 @@ var multicallShardedAbiArray = async (chainId, abi, calls, getEvmClient18, poolS
         chainId,
         batch.items,
         slots,
-        getEvmClient18,
+        getEvmClient19,
         won.rpcId + 1,
         requestBytes,
         logs,
@@ -16930,7 +16930,7 @@ var multicallShardedAbiArray = async (chainId, abi, calls, getEvmClient18, poolS
       const tried = /* @__PURE__ */ new Set();
       const start = resolveEndpoint(
         chainId,
-        getEvmClient18,
+        getEvmClient19,
         workerId,
         void 0,
         12,
@@ -29674,8 +29674,9 @@ var LENS_FAMILY = {
    */
   RESUPPLY: 15
 };
+var V6_WITHHELD = /* @__PURE__ */ new Set([LENS_FAMILY.AAVE_V4]);
 var ALL_FAMILIES = new Set(
-  Object.values(LENS_FAMILY)
+  Object.values(LENS_FAMILY).filter((f) => !V6_WITHHELD.has(f))
 );
 var v6 = () => ({
   address: POSITION_LENS_V6,
@@ -34270,25 +34271,25 @@ var getFluidUserDataConverter = (lender, chainId, account, meta) => {
               legRaw(leg, supplyRaw).toString(),
               leg.decimals
             );
-            const amount3 = Number(amountStr);
+            const amount4 = Number(amountStr);
             const e = entryFor(leg);
             e.deposits = amountStr;
-            e.depositsUSD = amount3 * leg.displayPrice;
-            e.depositsUSDOracle = amount3 * leg.oraclePrice;
+            e.depositsUSD = amount4 * leg.displayPrice;
+            e.depositsUSDOracle = amount4 * leg.oraclePrice;
             e.collateralEnabled = supplyRaw > 0n;
-            deposits24h += amount3 * leg.priceHist;
+            deposits24h += amount4 * leg.priceHist;
           }
           for (const leg of debtLegs) {
             const amountStr = parseRawAmount(
               legRaw(leg, borrowRaw).toString(),
               leg.decimals
             );
-            const amount3 = Number(amountStr);
+            const amount4 = Number(amountStr);
             const e = entryFor(leg);
             e.debt = amountStr;
-            e.debtUSD = amount3 * leg.displayPrice;
-            e.debtUSDOracle = amount3 * leg.oraclePrice;
-            debt24h += amount3 * leg.priceHist;
+            e.debtUSD = amount4 * leg.displayPrice;
+            e.debtUSDOracle = amount4 * leg.oraclePrice;
+            debt24h += amount4 * leg.priceHist;
           }
           histData[nftId] = {
             totalDeposits24h: deposits24h,
@@ -34541,10 +34542,10 @@ var getDolomiteUserDataConverter = (lender, chainId, account, metaMap) => {
           const meta = metaMap?.[key3];
           if (!meta) return;
           const decimals = meta.asset?.decimals ?? 18;
-          const amount3 = parseRawAmount(wei.value, decimals);
+          const amount4 = parseRawAmount(wei.value, decimals);
           const isSupply = wei.sign;
-          const deposits = isSupply ? amount3 : "0";
-          const debt = isSupply ? "0" : amount3;
+          const deposits = isSupply ? amount4 : "0";
+          const debt = isSupply ? "0" : amount4;
           const debtPar = isSupply ? "0" : pars[k]?.value?.toString() ?? "0";
           const price2 = getDisplayPrice(meta);
           const oPrice = getOraclePrice(meta);
@@ -35977,11 +35978,11 @@ var big13 = (v) => {
 };
 function fraxlendToAmount(shares, totalAmount, totalShares, roundUp) {
   if (totalShares === 0n) return shares;
-  let amount3 = shares * totalAmount / totalShares;
-  if (roundUp && totalAmount > 0n && amount3 * totalShares / totalAmount < shares) {
-    amount3 = amount3 + 1n;
+  let amount4 = shares * totalAmount / totalShares;
+  if (roundUp && totalAmount > 0n && amount4 * totalShares / totalAmount < shares) {
+    amount4 = amount4 + 1n;
   }
-  return amount3;
+  return amount4;
 }
 var getFraxlendUserDataConverter = (lender, chainId, account, meta) => {
   const pairs = fraxlendPairsFor(lender, chainId);
@@ -41897,7 +41898,7 @@ function unflattenLenderData(pools) {
   }
   return result;
 }
-var getLenderUserDataResult = async (chainId, queriesRaw, getEvmClient18, allowFailure = true, batchSize = MULTICALL_DEFAULT_BATCH_SIZE, retries = 3, logs = false, concurrency = 1, permanentFailures, onEndpointFailure) => {
+var getLenderUserDataResult = async (chainId, queriesRaw, getEvmClient19, allowFailure = true, batchSize = MULTICALL_DEFAULT_BATCH_SIZE, retries = 3, logs = false, concurrency = 1, permanentFailures, onEndpointFailure) => {
   const queries = organizeUserQueries(queriesRaw);
   const builtCalls = await Promise.all(
     queries.map(async (query3) => {
@@ -41907,7 +41908,7 @@ var getLenderUserDataResult = async (chainId, queriesRaw, getEvmClient18, allowF
         query3.lender,
         query3.account,
         query3.params,
-        getEvmClient18
+        getEvmClient19
       );
       return callData.map((call) => ({ call, abi: call.abi ?? abi }));
     })
@@ -41917,7 +41918,7 @@ var getLenderUserDataResult = async (chainId, queriesRaw, getEvmClient18, allowF
     chainId,
     calls.map((call) => call.abi),
     calls.map((call) => call.call),
-    getEvmClient18,
+    getEvmClient19,
     concurrency,
     retries,
     allowFailure,
@@ -42216,29 +42217,29 @@ async function getMergedUserData(chainId, balanceQueries, permissionParams, lend
   });
   return parseMergedResult(chainId, rawResults, prepared, lenderState);
 }
-function toCompoundV2Shares(entry, amount3) {
+function toCompoundV2Shares(entry, amount4) {
   const raw = entry.params?.exchangeRateCurrent;
-  if (!raw || raw === "0x") return amount3;
+  if (!raw || raw === "0x") return amount4;
   try {
     const exRate = BigInt(raw);
-    if (exRate === 0n) return amount3;
-    return amount3 * 10n ** 18n / exRate * 1001n / 1000n;
+    if (exRate === 0n) return amount4;
+    return amount4 * 10n ** 18n / exRate * 1001n / 1000n;
   } catch {
-    return amount3;
+    return amount4;
   }
 }
-function toSiloShares(entry, amount3, chainId, lender, tokenAddress) {
+function toSiloShares(entry, amount4, chainId, lender, tokenAddress) {
   const raw = entry.params?.collateralRate;
-  if (!raw || raw === "0x") return amount3;
+  if (!raw || raw === "0x") return amount4;
   try {
     const rate = BigInt(raw);
-    if (rate === 0n) return amount3;
+    if (rate === 0n) return amount4;
     const half = getSiloHalfForUnderlying(chainId, lender, tokenAddress);
-    if (!half) return amount3;
+    if (!half) return amount4;
     const oneUnit = BigInt(10) ** BigInt(half.decimals);
-    return amount3 * oneUnit / rate * 1001n / 1000n;
+    return amount4 * oneUnit / rate * 1001n / 1000n;
   } catch {
-    return amount3;
+    return amount4;
   }
 }
 function resolveDebitDataKey(chainId, lender, tokenAddress, cToken, isProtected) {
@@ -42274,7 +42275,7 @@ function resolveDebitDataKey(chainId, lender, tokenAddress, cToken, isProtected)
   return tokenAddress.toLowerCase();
 }
 function needsLenderApproval(params) {
-  const { lender, lenderDebitData, tokenAddress, amount: amount3, chainId, cToken, isProtected } = params;
+  const { lender, lenderDebitData, tokenAddress, amount: amount4, chainId, cToken, isProtected } = params;
   if (!lenderDebitData) return true;
   if (isAaveV4Type(lender)) {
     const key4 = (params.aaveV4Spoke ?? tokenAddress).toLowerCase();
@@ -42291,33 +42292,33 @@ function needsLenderApproval(params) {
   const entry = lenderDebitData[key3];
   if (!entry || entry.amount === void 0) return true;
   if (isCompoundV2Type(lender) || isVenusType(lender)) {
-    const requiredShares = toCompoundV2Shares(entry, amount3);
+    const requiredShares = toCompoundV2Shares(entry, amount4);
     return entry.amount < requiredShares;
   }
   if (isSiloV2Type(lender) || isSiloV3Type(lender)) {
-    const requiredShares = toSiloShares(entry, amount3, chainId, lender, tokenAddress);
+    const requiredShares = toSiloShares(entry, amount4, chainId, lender, tokenAddress);
     return entry.amount < requiredShares;
   }
   if (isCompoundV3(lender)) {
     return entry.amount === 0n;
   }
-  return entry.amount < amount3;
+  return entry.amount < amount4;
 }
 function needsTokenApproval(params) {
-  const { debitData, spender, amount: amount3, chainId, usePermit2 } = params;
+  const { debitData, spender, amount: amount4, chainId, usePermit2 } = params;
   if (!debitData) return true;
   const spenderLower = spender.toLowerCase();
   if (usePermit2) {
     const p2 = debitData.permit2?.[spenderLower];
-    return !p2 || p2.amount < amount3;
+    return !p2 || p2.amount < amount4;
   }
   const permit2Address = getPermit2ContractAddress(chainId).toLowerCase();
   if (spenderLower === permit2Address) {
     const p2 = debitData.permit2?.[spenderLower];
-    if (p2 && p2.amount >= amount3) return false;
+    if (p2 && p2.amount >= amount4) return false;
   }
   const allowance = debitData.allowances?.[spenderLower] ?? 0n;
-  return allowance < amount3;
+  return allowance < amount4;
 }
 var MORPHO_USER_SUBGRAPH_URLS = {
   [Chain.SEI_NETWORK]: "https://api.goldsky.com/api/public/project_cmiergfbv4vma01vb642yaeam/subgraphs/morphoblue-sei/1.0.1/gn",
@@ -42824,10 +42825,10 @@ function fuseLenderData(userDataResult, summary) {
 }
 
 // src/lending/margin/base/standard/deposit.ts
-function computeDepositDelta(amount3, price2, balanceData2, config, modeId, createNewSubAccount = false, apr, yieldParams) {
+function computeDepositDelta(amount4, price2, balanceData2, config, modeId, createNewSubAccount = false, apr, yieldParams) {
   const { borrowCollateralFactor, collateralFactor } = getAssetConfig(config, modeId);
   const base = createNewSubAccount ? EMPTY_BALANCE : balanceData2;
-  const dollarAmount = amount3 * price2;
+  const dollarAmount = amount4 * price2;
   const postTrade = {
     ...base,
     borrowDiscountedCollateral: base.borrowDiscountedCollateral + borrowCollateralFactor * dollarAmount,
@@ -42874,13 +42875,13 @@ function computeDepositDelta(amount3, price2, balanceData2, config, modeId, crea
 }
 
 // src/lending/margin/base/deposit.ts
-function computeDepositDelta2(lender, amount3, price2, balanceData2, config, modeId, createNewSubAccount, apr, yieldParams, targetMarketUid, positions) {
+function computeDepositDelta2(lender, amount4, price2, balanceData2, config, modeId, createNewSubAccount, apr, yieldParams, targetMarketUid, positions) {
   if (isSumerType(lender)) {
     if (!positions || targetMarketUid === void 0) {
       throw new Error("Sumer operations require positions and targetMarketUid");
     }
     return computeSumerDepositDelta(
-      amount3,
+      amount4,
       price2,
       targetMarketUid,
       balanceData2,
@@ -42894,7 +42895,7 @@ function computeDepositDelta2(lender, amount3, price2, balanceData2, config, mod
     throw new Error("Standard operations require config and modeId");
   }
   return computeDepositDelta(
-    amount3,
+    amount4,
     price2,
     balanceData2,
     config,
@@ -42906,9 +42907,9 @@ function computeDepositDelta2(lender, amount3, price2, balanceData2, config, mod
 }
 
 // src/lending/margin/base/standard/withdraw.ts
-function computeWithdrawDelta(amount3, price2, balanceData2, config, modeId, apr, yieldParams) {
+function computeWithdrawDelta(amount4, price2, balanceData2, config, modeId, apr, yieldParams) {
   const { borrowCollateralFactor, collateralFactor } = getAssetConfig(config, modeId);
-  const dollarAmount = amount3 * price2;
+  const dollarAmount = amount4 * price2;
   const postTrade = {
     ...balanceData2,
     borrowDiscountedCollateral: balanceData2.borrowDiscountedCollateral - borrowCollateralFactor * dollarAmount,
@@ -42955,13 +42956,13 @@ function computeWithdrawDelta(amount3, price2, balanceData2, config, modeId, apr
 }
 
 // src/lending/margin/base/withdraw.ts
-function computeWithdrawDelta2(lender, amount3, price2, balanceData2, config, modeId, apr, yieldParams, targetMarketUid, positions) {
+function computeWithdrawDelta2(lender, amount4, price2, balanceData2, config, modeId, apr, yieldParams, targetMarketUid, positions) {
   if (isSumerType(lender)) {
     if (!positions || targetMarketUid === void 0) {
       throw new Error("Sumer operations require positions and targetMarketUid");
     }
     return computeSumerWithdrawDelta(
-      amount3,
+      amount4,
       price2,
       targetMarketUid,
       balanceData2,
@@ -42974,7 +42975,7 @@ function computeWithdrawDelta2(lender, amount3, price2, balanceData2, config, mo
     throw new Error("Standard operations require config and modeId");
   }
   return computeWithdrawDelta(
-    amount3,
+    amount4,
     price2,
     balanceData2,
     config,
@@ -42985,9 +42986,9 @@ function computeWithdrawDelta2(lender, amount3, price2, balanceData2, config, mo
 }
 
 // src/lending/margin/base/standard/borrow.ts
-function computeBorrowDelta(amount3, price2, balanceData2, config, modeId, apr, yieldParams, irMode) {
+function computeBorrowDelta(amount4, price2, balanceData2, config, modeId, apr, yieldParams, irMode) {
   const { borrowFactor } = getAssetConfig(config, modeId);
-  const dollarAmount = amount3 * price2;
+  const dollarAmount = amount4 * price2;
   const postTrade = {
     ...balanceData2,
     debt: balanceData2.debt + dollarAmount,
@@ -43036,13 +43037,13 @@ function computeBorrowDelta(amount3, price2, balanceData2, config, modeId, apr,
 }
 
 // src/lending/margin/base/borrow.ts
-function computeBorrowDelta2(lender, amount3, price2, balanceData2, config, modeId, apr, yieldParams, irMode, targetMarketUid, positions) {
+function computeBorrowDelta2(lender, amount4, price2, balanceData2, config, modeId, apr, yieldParams, irMode, targetMarketUid, positions) {
   if (isSumerType(lender)) {
     if (!positions || targetMarketUid === void 0) {
       throw new Error("Sumer operations require positions and targetMarketUid");
     }
     return computeSumerBorrowDelta(
-      amount3,
+      amount4,
       price2,
       targetMarketUid,
       balanceData2,
@@ -43056,7 +43057,7 @@ function computeBorrowDelta2(lender, amount3, price2, balanceData2, config, mode
     throw new Error("Standard operations require config and modeId");
   }
   return computeBorrowDelta(
-    amount3,
+    amount4,
     price2,
     balanceData2,
     config,
@@ -43068,9 +43069,9 @@ function computeBorrowDelta2(lender, amount3, price2, balanceData2, config, mode
 }
 
 // src/lending/margin/base/standard/repay.ts
-function computeRepayDelta(amount3, price2, balanceData2, config, modeId, apr, yieldParams, irMode) {
+function computeRepayDelta(amount4, price2, balanceData2, config, modeId, apr, yieldParams, irMode) {
   const { borrowFactor } = getAssetConfig(config, modeId);
-  const dollarAmount = amount3 * price2;
+  const dollarAmount = amount4 * price2;
   const postTrade = {
     ...balanceData2,
     debt: balanceData2.debt - dollarAmount,
@@ -43119,13 +43120,13 @@ function computeRepayDelta(amount3, price2, balanceData2, config, modeId, apr, y
 }
 
 // src/lending/margin/base/repay.ts
-function computeRepayDelta2(lender, amount3, price2, balanceData2, config, modeId, apr, yieldParams, irMode, targetMarketUid, positions) {
+function computeRepayDelta2(lender, amount4, price2, balanceData2, config, modeId, apr, yieldParams, irMode, targetMarketUid, positions) {
   if (isSumerType(lender)) {
     if (!positions || targetMarketUid === void 0) {
       throw new Error("Sumer operations require positions and targetMarketUid");
     }
     return computeSumerRepayDelta(
-      amount3,
+      amount4,
       price2,
       targetMarketUid,
       balanceData2,
@@ -43139,7 +43140,7 @@ function computeRepayDelta2(lender, amount3, price2, balanceData2, config, modeI
     throw new Error("Standard operations require config and modeId");
   }
   return computeRepayDelta(
-    amount3,
+    amount4,
     price2,
     balanceData2,
     config,
@@ -45056,6 +45057,42 @@ var wbethFetcher = {
   }
 };
 
+// src/yields/intrinsic/fetchers/treehouse.ts
+var TETH_POOL_ID = "5762f4a8-bb48-45d6-90ed-2d93d1777169";
+var TAVAX_POOL_ID = "40a1e447-058d-4c5b-b567-30543ea185c3";
+var TREEHOUSE_APY_URL = "https://api.treehouse.finance/apy";
+var TETH_KEYS = ["Treehouse ETH::TETH", "Treehouse ETH::tETH"];
+var fetchTethApr = async () => {
+  try {
+    const res = await fetch(TREEHOUSE_APY_URL, {
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(8e3)
+    });
+    if (!res.ok) throw new Error(`Treehouse HTTP ${res.status}`);
+    const json = await res.json();
+    const apr = json?.total_apr_teth;
+    if (typeof apr === "number" && Number.isFinite(apr) && apr > 0) return apr;
+    throw new Error("Treehouse: no total_apr_teth");
+  } catch {
+    return apyToAprPercent(await fetchDefiLlamaApy(TETH_POOL_ID));
+  }
+};
+var tethFetcher = {
+  label: "TETH",
+  fetch: async () => {
+    const apr = await fetchTethApr();
+    return Object.fromEntries(TETH_KEYS.map((k) => [k, apr]));
+  }
+};
+var tavaxFetcher = {
+  label: "TAVAX",
+  fetch: async () => ({
+    "Treehouse AVAX::tAVAX": apyToAprPercent(
+      await fetchDefiLlamaApy(TAVAX_POOL_ID)
+    )
+  })
+};
+
 // src/vaults/lst/registry.ts
 var LST_REGISTRY = {
   // Monad (143) — native-MON LSTs. shMON / aprMON are ERC-4626 over native
@@ -45144,6 +45181,50 @@ var LST_REGISTRY = {
     }
   ],
   "1": [
+    {
+      // Treehouse tETH — an ERC-4626 share over wstETH that runs a
+      // leveraged staking carry (wstETH collateral on Aave Core / Aave
+      // Prime / Spark, ETH borrowed against it, converted back to wstETH).
+      //
+      // THREE things the generic 4626 path gets wrong here:
+      //  1. `asset()` is NOT wstETH — it returns
+      //     `InternalAccountingUnit_Wrapped liquid staked Ether 2.0`
+      //     (`IAU_wstETH`, 0x1b6238e9…), a synthetic unit minted 1:1
+      //     against the real underlying. The underlying below is
+      //     `Vault.getUnderlying()`; never read `asset()`.
+      //  2. Entry is the `TreehouseRouter`, not the share token. It takes
+      //     native ETH (`depositETH()`) or any `Vault.isAllowableAsset`
+      //     ERC-20 (stETH / WETH / wstETH) via `deposit(asset, amount)`,
+      //     and **credits `msg.sender`** — there is no receiver argument.
+      //  3. Exit is neither of the share's own 4626 legs: `maxWithdraw`
+      //     and `maxRedeem` both read 0. It is the Fastlane (instant,
+      //     50 bps) or RedemptionV2 (queued, 5 bps) — hence
+      //     `fee-or-queued`, with `liquidity` measured by the reader off
+      //     `Fastlane.getRedeemableAmount()`.
+      address: "0xd11c452fc99cf405034ee446803b6f6c1f6d5ed8",
+      underlying: "0x7f39c581f595b53c5cb19bd0b3f8da6c935e2ca0",
+      // wstETH
+      symbol: "tETH",
+      brand: "Treehouse",
+      decimals: 18,
+      reader: "treehouseTAsset",
+      isErc4626: true,
+      isRebasing: false,
+      isMintable: true,
+      isNativeUnderlying: true,
+      mintContract: "0xefa3fa8e85d2b3cfdb250cdea156c2c6c90628f5",
+      // TreehouseRouter
+      mintInputAsset: "native",
+      withdrawalMode: "fee-or-queued",
+      // Read live by the reader (7 d today, and it is an owner dial).
+      withdrawalCooldownSeconds: 7 * 86400,
+      yieldFetcher: tethFetcher,
+      yieldKey: "Treehouse ETH::TETH",
+      readerExtras: {
+        treehouseFastlane: "0x829525417cd78cba0f99a8736426fc299506c0d6",
+        treehouseRedemption: "0xcd63a29faff07130d3af89bb4f40778938aabb85"
+      }
+    },
     {
       address: "0x7f39c581f595b53c5cb19bd0b3f8da6c935e2ca0",
       underlying: "0x0000000000000000000000000000000000000000",
@@ -45816,6 +45897,38 @@ var LST_REGISTRY = {
     }
   ],
   "43114": [
+    {
+      // Treehouse tAVAX — the tETH design on Avalanche, denominated in
+      // BENQI sAVAX. Same Router / Vault / RedemptionController stack; see
+      // the tETH entry on chain 1 for the three traps.
+      //
+      // The Avalanche Router carries NO `depositETH()` (selector-scanned
+      // against the live runtime), so native AVAX is not an entry here —
+      // the allowable set is sAVAX and WAVAX only.
+      address: "0x14a84f1a61ccd7d1be596a6cc11fe33a36bc1646",
+      underlying: "0x2b2c81e08f1af8835a78bb2a90ae924ace0ea4be",
+      // sAVAX
+      symbol: "tAVAX",
+      brand: "Treehouse",
+      decimals: 18,
+      reader: "treehouseTAsset",
+      isErc4626: true,
+      isRebasing: false,
+      isMintable: true,
+      isNativeUnderlying: false,
+      mintContract: "0x5f4d2e6c118b5e3c74f0b61de40f627ca9873d6e",
+      // TreehouseRouter
+      mintInputAsset: "0x2b2c81e08f1af8835a78bb2a90ae924ace0ea4be",
+      withdrawalMode: "fee-or-queued",
+      // 17 d live — NOT the 7 d the docs describe. Read live by the reader.
+      withdrawalCooldownSeconds: 17 * 86400,
+      yieldFetcher: tavaxFetcher,
+      yieldKey: "Treehouse AVAX::tAVAX",
+      readerExtras: {
+        treehouseFastlane: "0x3d00a639183b07e35efef044ee6cc14e8598a01c",
+        treehouseRedemption: "0x765f6dc8496ca7ef1e4a391be10185229aacf04b"
+      }
+    },
     {
       address: "0x2b2c81e08f1af8835a78bb2a90ae924ace0ea4be",
       underlying: "0x0000000000000000000000000000000000000000",
@@ -45857,6 +45970,40 @@ var LST_REGISTRY = {
     }
   ],
   "999": [
+    {
+      // Treehouse tHYPE — the tETH design on HyperEVM, denominated in
+      // Kinetiq kHYPE. Same stack; see the tETH entry on chain 1.
+      //
+      // No `depositETH()` on this Router either (selector-scanned), so the
+      // entry set is kHYPE and WHYPE (0x5555…), never native HYPE.
+      //
+      // NO yield fetcher: DefiLlama carries no `treehouse-protocol` pool
+      // for tHYPE and Treehouse's own `/apy` route serves tETH only, so the
+      // row reports a `supplyRate` of 0 rather than an invented number.
+      // The vault launched recently (share price 1.0007) — revisit with an
+      // archival `convertToAssets` delta once it has real history.
+      address: "0xb83d27f0f4133a7b0377a88089583131a903fdc7",
+      underlying: "0xfd739d4e423301ce9385c1fb8850539d657c296d",
+      // kHYPE
+      symbol: "tHYPE",
+      brand: "Treehouse",
+      decimals: 18,
+      reader: "treehouseTAsset",
+      isErc4626: true,
+      isRebasing: false,
+      isMintable: true,
+      isNativeUnderlying: false,
+      mintContract: "0x1620b7e5c9099c8bcbc326b55e0b8440eda9d30a",
+      // TreehouseRouter
+      mintInputAsset: "0xfd739d4e423301ce9385c1fb8850539d657c296d",
+      withdrawalMode: "fee-or-queued",
+      // 10 d live — again not the docs' 7 d. Read live by the reader.
+      withdrawalCooldownSeconds: 10 * 86400,
+      readerExtras: {
+        treehouseFastlane: "0x3018e0747549835faa8d06cf4809b1a2519fab31",
+        treehouseRedemption: "0xcebbb011c2f29b0ed25895c54662bd1ccad30280"
+      }
+    },
     {
       // hbHYPE Ultra — Hyperbeat's ERC-4626 staked HYPE vault.
       // TokenizedAccount impl, 4626-compliant, accepts WHYPE.
@@ -47525,6 +47672,84 @@ var strataFetcher = {
     return out;
   }
 };
+var thBill = "Theo Short Duration US Treasury Fund::THBILL";
+var THBILL_DEFILLAMA_POOL = "e17dab50-85b1-45e8-b4a5-b8ae7898c4a3";
+var thbillFetcher = {
+  label: "THBILL",
+  fetch: async () => {
+    const apy = await fetchDefiLlamaApy(THBILL_DEFILLAMA_POOL);
+    return { [thBill]: apyToAprPercent(apy) };
+  }
+};
+var STHUSD_VAULT = "0xa808bc9775cb41c52c7842f8b50427fe7a770326";
+var STHUSD_UNIT = 10n ** 6n;
+var STHUSD_WINDOW_SECONDS = 30 * 24 * 60 * 60;
+var ETH_BLOCK_TIME_SECONDS = 12;
+var STHUSD_WINDOW_BLOCKS = BigInt(
+  Math.floor(STHUSD_WINDOW_SECONDS / ETH_BLOCK_TIME_SECONDS)
+);
+var STHUSD_MAX_RPC_TRIES = 2;
+var STHUSD_DEADLINE_MS = 12e3;
+var STHUSD_KEY = "STHUSD";
+var STHUSD_GROUP_KEY = "Staked thUSD::STHUSD";
+var STHUSD_GROUP_KEY_OFT = "sthUSD::sthUSD";
+var CONVERT_TO_ASSETS_ABI4 = [
+  {
+    name: "convertToAssets",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ type: "uint256" }],
+    outputs: [{ type: "uint256" }]
+  }
+];
+var readSthUsdRateAt = (client, blockNumber) => client.readContract({
+  address: STHUSD_VAULT,
+  abi: CONVERT_TO_ASSETS_ABI4,
+  functionName: "convertToAssets",
+  args: [STHUSD_UNIT],
+  ...blockNumber !== void 0 ? { blockNumber } : {}
+});
+var computeSthUsdApr = async () => {
+  let lastErr;
+  const deadline = Date.now() + STHUSD_DEADLINE_MS;
+  for (let rpcId = 0; rpcId < STHUSD_MAX_RPC_TRIES; rpcId++) {
+    if (Date.now() > deadline) break;
+    try {
+      const client = getEvmClient("1", rpcId);
+      const head = await client.getBlockNumber();
+      const pastBlock = head > STHUSD_WINDOW_BLOCKS ? head - STHUSD_WINDOW_BLOCKS : 0n;
+      const [rateNow, rateThen, headBlock, thenBlock] = await Promise.all([
+        readSthUsdRateAt(client),
+        readSthUsdRateAt(client, pastBlock),
+        client.getBlock({ blockNumber: head }),
+        client.getBlock({ blockNumber: pastBlock })
+      ]);
+      if (rateNow < STHUSD_UNIT || rateThen < STHUSD_UNIT) {
+        throw new Error("sthUSD: share price below par \u2014 pruned or bad read");
+      }
+      if (rateNow < rateThen) {
+        throw new Error("sthUSD: share price decreased \u2014 non-archival RPC");
+      }
+      const elapsed = Number(headBlock.timestamp - thenBlock.timestamp);
+      if (elapsed <= 0) throw new Error("sthUSD: non-positive window");
+      return annualizeRateDeltaPercent(rateNow, rateThen, elapsed);
+    } catch (e) {
+      lastErr = e;
+    }
+  }
+  throw lastErr ?? new Error("sthUSD: no RPC served archive state");
+};
+var sthusdFetcher = {
+  label: "STHUSD",
+  fetch: async () => {
+    const apr = await computeSthUsdApr().catch(() => 0);
+    return {
+      [STHUSD_KEY]: apr,
+      [STHUSD_GROUP_KEY]: apr,
+      [STHUSD_GROUP_KEY_OFT]: apr
+    };
+  }
+};
 var RAY9 = 10n ** 27n;
 var YEAR_SECONDS11 = 31536e3;
 var DSR_ABI = [
@@ -50518,6 +50743,87 @@ var SINGLE_CHAIN_ENTRIES = {
       solvency: "overcollateralized",
       yieldFetcher: frankencoinSavingsFetcher,
       yieldKey: zchfSavingsKey(Chain.ETHEREUM_MAINNET)
+    },
+    {
+      // Theo **sthUSD** — the ERC-4626 staked wrapper over `thUSD`, Theo's
+      // gold-yield stablecoin. Source Sourcify-verified on chain 1
+      // (`contracts/thusd/SthUSD.sol` behind the UUPS proxy, impl
+      // `0x342487f9…`), so every claim below is read off the code rather
+      // than inferred.
+      //
+      // $24.20M held / 23.83M shares, price 1.015636 (2026-08-25). Ethereum
+      // is the ONLY vault: `0xd1db2090…` is a LayerZero OFT Adapter that
+      // LOCKS these shares and mints a bare OFT at the same address on
+      // Stable (988), Arbitrum, BNB and Mantle — and **97 % of the supply
+      // has left for Stable**, where the mirror is the largest Morpho Blue
+      // collateral on the chain. See the `'988'` row for that side.
+      //
+      // **The yield is a PUSH, not a stream, and the row must not imply
+      // otherwise.** A `yieldDistributor` calls `setYield(amount)`, which
+      // reverts while `getUnvestedAmount() > 0`, so batches cannot overlap;
+      // each vests over `vestingDuration` (10,800 s = 3 h) and then nothing
+      // accrues until the next push. Measured daily on-chain, the share
+      // price steps by at most +142e-6/day (≈ 5.10 % APR) with flat
+      // stretches of up to nine days. `sthusdFetcher` reads a 30-day
+      // trailing delta for exactly this reason — see its docstring before
+      // reaching for a shorter window.
+      //
+      // **The exit is asynchronous and the wait is not free.**
+      // `initiateRedeem(shares, owner)` is permissionless, but it BURNS the
+      // shares immediately and snapshots `assets = convertToAssets(shares)`
+      // at that block; the claim (`redeem`/`withdraw`) unlocks
+      // `lockupPeriod` later and pays that frozen figure, so the five days
+      // earn nothing and there is no cancel path. The claim additionally
+      // requires `msg.sender == owner_` (`OwnerMustCompleteRedeem`), and
+      // `initiateRedeem` books the request under the CALLER — so a
+      // third-party redeem via allowance lands the request on the caller,
+      // not the holder. Hence `request-based`, never `instant`.
+      //
+      // TRAP: **`previewRedeem` and `previewWithdraw` are hardcoded
+      // `return 0`** — the protocol deprecated them in favour of
+      // `maxWithdraw`/`maxRedeem`, which describe only a CLAIMABLE REQUEST
+      // and so read 0 for every ordinary holder, including one sitting on
+      // 23.2M shares for 27 days. Neither view can size an exit here, and
+      // both are the obvious thing to reach for. `previewDeposit` is fine.
+      //
+      // `erc4626-cooldown` with `cooldownGetter: 'lockupPeriod'`: the pin
+      // below is a snapshot of an `onlyOwner` dial with no timelock whose
+      // `MAX_LOCKUP_PERIOD` is **30 days** — six times what is configured
+      // today. Read it live, like Brix's.
+      //
+      // `nav-attested`, CURATED — the one field on this row that must not be
+      // left to the builder's default. `totalAssets()` is honest about the
+      // vault (its own thUSD balance, net of unvested yield and pending
+      // redemptions), so the SHARES are backed by the asset; the trust
+      // question sits one level down, in what backs thUSD — a gold-leasing
+      // and CME-futures-roll book run off-chain and marked by the issuer,
+      // with no on-chain solvency invariant anywhere. Absent, the builder
+      // falls back to `overcollateralized` and only whispers the doubt
+      // through `coverage.pending.counterparty`: a row that says
+      // "overcollateralized" about attested gold is wrong in the one field a
+      // reader checks before trusting the rate. Naming it also earns the
+      // consequences — `nav-drawdown` in `principal.risks`, the
+      // `nav-accrual` rate kind — which are all true here: the share price
+      // moves only when a distributor chooses to push a batch. Same call as
+      // Brix wiTRY.
+      reader: "erc4626-cooldown",
+      solvency: "nav-attested",
+      cooldownGetter: "lockupPeriod",
+      address: "0xa808bc9775cb41c52c7842f8b50427fe7a770326",
+      underlying: "0xa3fe5c7596024e6811e14f029937d5bd8ae485b3",
+      // thUSD
+      symbol: "sthUSD",
+      brand: "Theo",
+      description: "thUSD is Theo's gold-yield stablecoin \u2014 the return comes from leasing physical gold and rolling CME futures, not from lending, and the book runs off-chain with no on-chain solvency invariant. sthUSD stakes it with an appreciating share price, but a distributor PUSHES each batch, so the price steps rather than streams and can sit flat for a week. Deposits are permissionless and uncapped. Exiting is a two-step request: initiating burns the shares and fixes the payout at that block's price, and the claim unlocks 5 days later \u2014 the wait earns nothing and cannot be cancelled.",
+      decimals: 6,
+      isRebasing: false,
+      isMintable: true,
+      withdrawalMode: "request-based",
+      // `lockupPeriod()` = 432,000 s on 2026-08-25. Re-read live by the
+      // reader; this is only the fallback if that call fails.
+      withdrawalCooldownSeconds: 432e3,
+      yieldFetcher: sthusdFetcher,
+      yieldKey: STHUSD_KEY
     }
   ],
   "100": [
@@ -50743,6 +51049,70 @@ var SINGLE_CHAIN_ENTRIES = {
       yieldKey: sparkVaultV2Key("43114", "spUSDC")
     }
   ],
+  // ---------------------------------------------------------------------
+  // Stable (988) — a Tether-adjacent L1 whose whole lending surface is one
+  // Morpho Blue deployment (`0xa40103…`), and whose largest market by an
+  // order of magnitude is sthUSD/USDT0: $23.03M of collateral against
+  // $18.59M supplied / $16.81M borrowed at 86 % LLTV. The earn row and that
+  // collateral leg are the same asset, so registering it here is also what
+  // gives the pair book a non-zero carry on the chain's biggest position.
+  // ---------------------------------------------------------------------
+  "988": [
+    {
+      // Theo **sthUSD**, bridged. This address is NOT the vault — it is the
+      // LayerZero OFT minted against shares locked in the Ethereum OFT
+      // Adapter at the same address, and it is a bare ERC-20 with a
+      // blacklist and a pause: `asset()`, `totalAssets()`, `convertToAssets()`
+      // and every `max*` view revert. See the chain-1 row for the vault,
+      // its push-yield mechanism and its two-step exit.
+      //
+      // Priced by RedStone's **"RedStone Price Feed for sthUSD_FUNDAMENTAL"**
+      // `0xb81131b6…` — the same feed Morpho's own oracle for this market
+      // reads (`BASE_FEED_1` under a 1e28 `SCALE_FACTOR`), so the earn row
+      // and the lending row cannot disagree about what a share is worth. It
+      // is Chainlink-shaped and fresh, but answers in **8 decimals** (hence
+      // `priceOracleDecimals`) and pins `roundId` at 1, i.e. NO round
+      // history — an on-chain rate delta is impossible here, which is one
+      // more reason `sthusdFetcher` measures the Ethereum vault instead.
+      //
+      // `underlying` is USDT0, the chain's dollar and this market's loan
+      // asset: thUSD itself was never bridged to Stable, so there is no
+      // local asset to name. Same call as Re's rows, which point at USDC.
+      //
+      // `isMintable: false` states a plain fact rather than a permission:
+      // there is no mint function on an OFT and no vault on this chain, so
+      // the only way in is to bridge from Ethereum. And it is deliberately
+      // NOT `secondaryMarketOnly` — that flag promises a tradeable market,
+      // and there isn't one: **23,216,009 of the 23,216,028 supply
+      // (99.99997 %) sits inside Morpho Blue as collateral**, leaving ~19
+      // sthUSD of free float across the whole chain. A `via: 'swap'` route
+      // would advertise depth that does not exist.
+      reader: "nav-oracle",
+      // Same curated answer as the chain-1 row — one asset cannot have two
+      // trust stories. Here it is doubly right: this side's price IS an
+      // attestation, published by RedStone rather than derived from anything
+      // the chain holds.
+      solvency: "nav-attested",
+      address: "0xd1db209087516883ec705cfeb99e80bb6032d540",
+      underlying: "0x779ded0c9e1022225f8e0630b35a9b54be713736",
+      // USDT0
+      priceOracle: "0xb81131b6368b3f0a83af09db4e39ac23da96c2db",
+      priceOracleDecimals: 8,
+      symbol: "sthUSD",
+      brand: "Theo",
+      description: "Bridged sthUSD \u2014 Theo's staked gold-yield dollar, whose vault lives on Ethereum; this is the LayerZero token minted against shares locked there, priced by RedStone's sthUSD NAV feed. It holds 97 % of the supply and is the largest Morpho Blue collateral on Stable. There is no vault on this chain: entering and exiting both mean bridging to Ethereum, where redemption is a request that burns the shares at today's price and pays out 5 days later.",
+      decimals: 6,
+      underlyingDecimals: 6,
+      isRebasing: false,
+      isMintable: false,
+      withdrawalMode: "request-based",
+      // The Ethereum vault's `lockupPeriod`, plus a bridge hop each way that
+      // this number does not include.
+      withdrawalCooldownSeconds: 432e3,
+      yieldFetcher: sthusdFetcher,
+      yieldKey: STHUSD_KEY
+    }
+  ],
   "4663": [
     {
       // Spark Vaults V2 spUSDG on Robinhood Chain — the first V2 vault
@@ -50861,17 +51231,6 @@ var jitoSolFetcher = {
   }
 };
 
-// src/yields/intrinsic/fetchers/theo.ts
-var thBill = "Theo Short Duration US Treasury Fund::THBILL";
-var THBILL_DEFILLAMA_POOL = "e17dab50-85b1-45e8-b4a5-b8ae7898c4a3";
-var thbillFetcher = {
-  label: "THBILL",
-  fetch: async () => {
-    const apy = await fetchDefiLlamaApy(THBILL_DEFILLAMA_POOL);
-    return { [thBill]: apyToAprPercent(apy) };
-  }
-};
-
 // src/yields/intrinsic/fetchers/superreturn.ts
 var SSUPERUSD_URL = "https://www.superreturn.ai/api/trpc/cmc.getUSDCPrice,rewardBackend.getYield,rewardBackend.getTvlChange?batch=1&input=%7B%220%22%3A%7B%22json%22%3Anull%2C%22meta%22%3A%7B%22values%22%3A%5B%22undefined%22%5D%7D%7D%2C%221%22%3A%7B%22json%22%3Anull%2C%22meta%22%3A%7B%22values%22%3A%5B%22undefined%22%5D%7D%7D%2C%222%22%3A%7B%22json%22%3Anull%2C%22meta%22%3A%7B%22values%22%3A%5B%22undefined%22%5D%7D%7D%7D";
 var ssuperusd = "SuperReturn sSuperUSD::SSUPERUSD";
@@ -51586,25 +51945,14 @@ var lsethFetcher = {
   }
 };
 
-// src/yields/intrinsic/fetchers/treehouse.ts
-var TETH_POOL_ID = "5762f4a8-bb48-45d6-90ed-2d93d1777169";
-var KEYS2 = ["Treehouse ETH::tETH"];
-var tethFetcher = {
-  label: "TETH",
-  fetch: async () => {
-    const apr = apyToAprPercent(await fetchDefiLlamaApy(TETH_POOL_ID));
-    return Object.fromEntries(KEYS2.map((k) => [k, apr]));
-  }
-};
-
 // src/yields/intrinsic/fetchers/anzen.ts
 var SUSDZ_POOL_ID = "46518e93-8197-4539-9861-2340c2ac965a";
-var KEYS3 = ["Anzen Staked USDz::SUSDZ", "Anzen Staked USDz::sUSDz", "Staked USDz::sUSDz"];
+var KEYS2 = ["Anzen Staked USDz::SUSDZ", "Anzen Staked USDz::sUSDz", "Staked USDz::sUSDz"];
 var susdzFetcher = {
   label: "SUSDZ",
   fetch: async () => {
     const apr = apyToAprPercent(await fetchDefiLlamaApy(SUSDZ_POOL_ID));
-    return Object.fromEntries(KEYS3.map((k) => [k, apr]));
+    return Object.fromEntries(KEYS2.map((k) => [k, apr]));
   }
 };
 
@@ -51617,6 +51965,7 @@ var LENDING_ONLY_FETCHERS = [
   ethZeroFetcher,
   jitoSolFetcher,
   thbillFetcher,
+  sthusdFetcher,
   ssuperusdFetcher,
   hlpFetcher,
   hwhlpFetcher,
@@ -51631,7 +51980,10 @@ var LENDING_ONLY_FETCHERS = [
   // it reaches the global map via `collectVaultFetchers` (disjointness rule).
   syzusdFetcher,
   midasFetcher,
-  capFetcher,
+  // capFetcher is NOT here: the Cap stcUSD savings row vault-wires it, so it
+  // reaches the global map via `collectVaultFetchers` (disjointness rule).
+  // It was double-listed, which the registry test flags — the union dedupes
+  // by reference, so removing it here changes nothing at runtime.
   nestFetcher,
   accountableFetcher,
   upshiftFetcher,
@@ -51640,7 +51992,9 @@ var LENDING_ONLY_FETCHERS = [
   yearnFetcher,
   // DefiLlama-mapped intrinsic yields for classifier assets lacking a bespoke source
   lsethFetcher,
-  tethFetcher,
+  // tethFetcher / tavaxFetcher are NOT here: the Treehouse tAsset LST rows
+  // vault-wire them, so they reach the global map via `collectVaultFetchers`
+  // (disjointness rule).
   // strataFetcher is NOT here: the Strata tranche savings rows vault-wire
   // it, so it reaches the global map via `collectVaultFetchers`.
   susdzFetcher
@@ -53467,9 +53821,9 @@ function getTermCalls(chainId) {
     }
   }
   const results = [];
-  for (const [token, { amount: amount3, repoKeys }] of byToken) {
+  for (const [token, { amount: amount4, repoKeys }] of byToken) {
     const calls = [
-      { address: oracle, name: "usdValueOfTokens", params: [token, amount3] }
+      { address: oracle, name: "usdValueOfTokens", params: [token, amount4] }
     ];
     results.push({
       calls,
@@ -61680,6 +62034,165 @@ var readerKintsuSMon = (entry) => ({
   }
 });
 
+// src/vaults/lst/abis/treehouse.ts
+var TreehouseFastlaneAbi = [
+  {
+    name: "getRedeemableAmount",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    // Delegates to a swappable fee contract, so it is a live read even
+    // though the Fastlane itself is behind the timelock.
+    name: "redemptionFee",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "minRedeemInUnderlying",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint96" }]
+  }
+];
+var TreehouseRedemptionAbi = [
+  {
+    name: "waitingPeriod",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint32" }]
+  },
+  {
+    // The QUEUED leg charges too (5 bps). That contradicts the convention
+    // `SavingsVault.withdrawFeeBps` documents — "the queued leg pays at par"
+    // — which is exactly why the route list carries a fee PER LEG instead of
+    // one field plus an assumption.
+    name: "redemptionFee",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint32" }]
+  },
+  {
+    // The gate that decides whether the cheap leg exists for a given holder:
+    // 50 wstETH / 4,000 sAVAX / 1,000 kHYPE, checked against
+    // `previewRedeem(shares)`, i.e. in UNDERLYING units.
+    name: "minRedeemInUnderlying",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint96" }]
+  }
+];
+
+// src/vaults/lst/readers/treehouse.ts
+var asBps = (v) => v === void 0 ? void 0 : Number(v);
+var fmt = (raw, decimals) => raw === void 0 ? void 0 : Number(raw) / 10 ** decimals;
+var readerTreehouseTAsset = (entry) => {
+  const fastlane = entry.readerExtras?.treehouseFastlane;
+  const redemption = entry.readerExtras?.treehouseRedemption;
+  const fl = fastlane ?? entry.address;
+  const rd = redemption ?? entry.address;
+  const underlyingDec = entry.underlyingDecimals ?? entry.decimals;
+  return {
+    calls: [
+      { address: entry.address, name: "totalAssets", params: [] },
+      { address: entry.address, name: "totalSupply", params: [] },
+      { address: entry.address, name: "convertToAssets", params: [ONE_E1811] },
+      { address: fl, name: "getRedeemableAmount", params: [] },
+      { address: fl, name: "redemptionFee", params: [] },
+      { address: fl, name: "minRedeemInUnderlying", params: [] },
+      { address: rd, name: "waitingPeriod", params: [] },
+      { address: rd, name: "redemptionFee", params: [] },
+      { address: rd, name: "minRedeemInUnderlying", params: [] }
+    ],
+    abis: [
+      Erc4626ReadAbi,
+      TotalSupplyAbi,
+      Erc4626ReadAbi,
+      TreehouseFastlaneAbi,
+      TreehouseFastlaneAbi,
+      TreehouseFastlaneAbi,
+      TreehouseRedemptionAbi,
+      TreehouseRedemptionAbi,
+      TreehouseRedemptionAbi
+    ],
+    parse: (slice2) => {
+      const [
+        assets,
+        supply,
+        rate,
+        redeemable,
+        fastFee,
+        fastMin,
+        waiting,
+        queueFee,
+        queueMin
+      ] = slice2;
+      const totalAssets = toBigInt13(assets);
+      const totalSupply = toBigInt13(supply);
+      const exchangeRate = toBigInt13(rate);
+      if (totalAssets === void 0 || totalSupply === void 0 || exchangeRate === void 0) {
+        return void 0;
+      }
+      const liquidity = toBigInt13(redeemable) ?? 0n;
+      const wait = toBigInt13(waiting);
+      const instantFeeBps = asBps(toBigInt13(fastFee));
+      const queuedFeeBps = asBps(toBigInt13(queueFee));
+      const instantMin = toBigInt13(fastMin);
+      const queuedMin = toBigInt13(queueMin);
+      const instant = {
+        id: "instant",
+        kind: "instant",
+        label: "Fast redemption",
+        settlement: "sync",
+        feeBps: instantFeeBps,
+        waitSeconds: 0,
+        // `0` is the live value on all three chains and means "no floor" —
+        // emitted rather than dropped, because on this protocol the ABSENCE
+        // of a minimum on the expensive leg is the reason it is the only exit
+        // most holders have.
+        minAmount: instantMin?.toString(),
+        minAmountFormatted: fmt(instantMin, underlyingDec),
+        capacity: liquidity.toString(),
+        capacityFormatted: Number(liquidity) / 10 ** underlyingDec,
+        selfOnly: true,
+        description: "Burns the tAsset and pays the underlying in the same transaction, out of the vault balance not already earmarked by queued requests. Bounded by that balance \u2014 a larger redemption reverts rather than partially filling."
+      };
+      const queued = {
+        id: "queued",
+        kind: "queued",
+        label: wait !== void 0 ? `${Math.round(Number(wait) / 86400)}-day queue` : "Queued redemption",
+        settlement: "async",
+        feeBps: queuedFeeBps,
+        waitSeconds: wait !== void 0 ? Number(wait) : void 0,
+        minAmount: queuedMin?.toString(),
+        minAmountFormatted: fmt(queuedMin, underlyingDec),
+        selfOnly: true,
+        description: "Escrows the shares now and pays after the wait. Far cheaper, but it enforces a minimum size, and it settles at the WORSE of the rate at request and at claim \u2014 so the amount quoted when you file it is a ceiling, not a quote."
+      };
+      return {
+        totalAssets,
+        totalSupply,
+        exchangeRate,
+        liquidity,
+        withdrawalCooldownSeconds: wait !== void 0 ? Number(wait) : void 0,
+        withdrawFeeBps: instantFeeBps,
+        // Cheapest reachable leg first is the list's ordering rule, and here
+        // the cheap one is second on purpose: it is gated by a minimum that
+        // most holders do not clear, so the leg anyone can take leads.
+        exitRoutes: [instant, queued]
+      };
+    }
+  };
+};
+
 // src/vaults/lst/readers/index.ts
 var buildReader = (entry) => {
   switch (entry.reader) {
@@ -61741,6 +62254,8 @@ var buildReader = (entry) => {
       return readerCoreStakedRatio(entry);
     case "kintsuSMon":
       return readerKintsuSMon(entry);
+    case "treehouseTAsset":
+      return readerTreehouseTAsset(entry);
   }
 };
 
@@ -62110,6 +62625,98 @@ var getLstValidators = async (chainId, shareToken) => {
   return [];
 };
 
+// src/vaults/exitRoutes.ts
+var asyncLabel = (secs) => {
+  if (!secs || secs <= 0) return "Queued";
+  const d = secs / 86400;
+  if (d >= 1) return `${Number.isInteger(d) ? d : d.toFixed(1)}-day queue`;
+  const h = secs / 3600;
+  return h >= 1 ? `${Number.isInteger(h) ? h : h.toFixed(1)}-hour queue` : `${Math.round(secs / 60)}-minute queue`;
+};
+var instantRoute = (i, feeBps) => ({
+  id: "instant",
+  kind: "instant",
+  label: feeBps ? "Instant (fee)" : "Instant",
+  settlement: "sync",
+  feeBps,
+  waitSeconds: 0,
+  capacity: i.liquidity,
+  capacityFormatted: i.liquidityFormatted,
+  capacityUsd: i.liquidityUsd
+});
+var queuedRoute = (i) => ({
+  id: "queued",
+  kind: "queued",
+  label: asyncLabel(i.withdrawalCooldownSeconds),
+  settlement: "async",
+  waitSeconds: i.withdrawalCooldownSeconds
+});
+var deriveExitRoutes = (i) => {
+  switch (i.withdrawalMode) {
+    // The instant leg pays the fee; the queue pays at par. That is the
+    // convention `SavingsVault.withdrawFeeBps` already documents — and
+    // Treehouse is the counter-example, which is why its reader overrides
+    // this rather than being described by it.
+    case "fee-or-queued":
+      return [
+        {
+          ...instantRoute(i, i.withdrawFeeBps),
+          // The mode's whole meaning is that THIS leg costs something. Say so
+          // even when the size is unknown: an absent `feeBps` renders as
+          // "leave instantly", which reads as free — the same failure the
+          // term-sheet rules call out for `fees: []`.
+          ...i.withdrawFeeBps == null ? { feeUnknown: true, label: "Instant (fee)" } : {}
+        },
+        { ...queuedRoute(i), feeBps: 0 }
+      ];
+    // Same split with no fee on either leg — the instant leg is bounded by
+    // inventory instead.
+    case "instant-or-queued":
+      return [instantRoute(i, i.withdrawFeeBps ?? 0), queuedRoute(i)];
+    case "instant":
+      return [
+        {
+          id: "instant",
+          kind: "instant",
+          label: "Instant",
+          settlement: "sync",
+          feeBps: i.withdrawFeeBps ?? 0,
+          waitSeconds: 0
+        }
+      ];
+    case "instant-capped":
+      return [instantRoute(i, i.withdrawFeeBps ?? 0)];
+    case "fixed-cooldown":
+    case "queued":
+    case "request-based":
+      return [{ ...queuedRoute(i), feeBps: i.withdrawFeeBps }];
+    case "off-chain":
+      return [
+        {
+          id: "off-chain",
+          kind: "queued",
+          label: "Off-chain redemption",
+          settlement: "async",
+          waitSeconds: i.withdrawalCooldownSeconds,
+          description: "Redemption is handled by the issuer off-chain; there is no on-chain exit to call."
+        }
+      ];
+    case "dex-only":
+    case "market-sale":
+      return [
+        {
+          id: "market",
+          kind: "market",
+          label: "Sell on the market",
+          settlement: "market",
+          description: "There is no redemption \u2014 you leave by selling the token, at whatever price is bid and with price impact that grows with size."
+        }
+      ];
+    default:
+      return [];
+  }
+};
+
 // src/vaults/lst/fetchPublic.ts
 var ONE_E1812 = 10n ** 18n;
 var ERC20_BALANCE_ABI = parseAbi([
@@ -62237,6 +62844,7 @@ var fetchLstShareTokens = async (chainId, multicallRetry, prices = {}, tokenList
     }
     const liquidityFormatted = Number(liquidityRaw) / 10 ** underlyingDec;
     const liquidityUsd = priceUsd !== void 0 ? liquidityFormatted * priceUsd : 0;
+    const cooldownSecs = state.withdrawalCooldownSeconds ?? entry.withdrawalCooldownSeconds;
     const displayName = composeVaultDisplayName(
       entry.brand,
       entry.brand,
@@ -62274,7 +62882,22 @@ var fetchLstShareTokens = async (chainId, multicallRetry, prices = {}, tokenList
       delegation: delegationByAddress.get(addressLc),
       validators: validatorsByAddress.get(addressLc),
       withdrawalMode: entry.withdrawalMode,
-      withdrawalCooldownSeconds: entry.withdrawalCooldownSeconds,
+      // A reader-measured wait wins over the registry's static one — see
+      // `LstOnChainState.withdrawalCooldownSeconds`.
+      withdrawalCooldownSeconds: cooldownSecs,
+      withdrawFeeBps: state.withdrawFeeBps,
+      // A reader that reads its protocol's own per-leg dials publishes the
+      // list itself; everything else gets the coarse derivation, which is
+      // still strictly better than making every consumer reassemble the two
+      // legs out of `withdrawalMode` + one cooldown + one liquidity number.
+      exitRoutes: state.exitRoutes ?? deriveExitRoutes({
+        withdrawalMode: entry.withdrawalMode,
+        withdrawFeeBps: state.withdrawFeeBps,
+        withdrawalCooldownSeconds: cooldownSecs,
+        liquidity: liquidityRaw.toString(),
+        liquidityFormatted,
+        liquidityUsd
+      }),
       asset,
       priceUsd,
       totalAssetsFormatted,
@@ -62376,17 +62999,17 @@ var readerBeets = {
     const out = [];
     for (let i = 0; i < reqs.length; i++) {
       const r = reqs[i];
-      const amount3 = toBigInt14(r.assetAmount);
+      const amount4 = toBigInt14(r.assetAmount);
       const ts = toNumber(r.requestTimestamp);
       const isWithdrawn = Boolean(r.isWithdrawn);
-      if (amount3 === void 0 || ts === void 0) continue;
+      if (amount4 === void 0 || ts === void 0) continue;
       const readyAt = ts + delay;
       out.push({
         lst: entry.lst,
         brand: entry.brand,
         symbol: entry.symbol,
         requestId: String(i),
-        amountUnderlying: amount3.toString(),
+        amountUnderlying: amount4.toString(),
         status: isWithdrawn ? "claimed" : computeStatus(readyAt),
         readyAt: isWithdrawn ? void 0 : readyAt
       });
@@ -62837,8 +63460,8 @@ var readerIbera = {
       const r = stage2[k];
       if (!r) continue;
       const receiver = Array.isArray(r) ? r[2] : r.receiver;
-      const amount3 = Array.isArray(r) ? toBigInt14(r[3]) : toBigInt14(r.amount);
-      if (typeof receiver !== "string" || receiver.toLowerCase() !== target || amount3 === void 0 || amount3 === 0n) {
+      const amount4 = Array.isArray(r) ? toBigInt14(r[3]) : toBigInt14(r.amount);
+      if (typeof receiver !== "string" || receiver.toLowerCase() !== target || amount4 === void 0 || amount4 === 0n) {
         continue;
       }
       const id = BigInt(ids[k]);
@@ -62847,7 +63470,7 @@ var readerIbera = {
         brand: entry.brand,
         symbol: entry.symbol,
         requestId: String(ids[k]),
-        amountUnderlying: amount3.toString(),
+        amountUnderlying: amount4.toString(),
         status: id < frontier ? "claimable" : "pending"
       });
     }
@@ -63020,13 +63643,13 @@ var readerErc7540 = {
         ],
         abi: [Erc7540Abi]
       });
-      const amount3 = toBigInt14(stage2[0]) ?? claimable;
+      const amount4 = toBigInt14(stage2[0]) ?? claimable;
       out.push({
         lst: entry.lst,
         brand: entry.brand,
         symbol: entry.symbol,
         requestId: "0",
-        amountUnderlying: amount3.toString(),
+        amountUnderlying: amount4.toString(),
         // The 7540 claim (`redeem`) takes the share amount.
         shares: claimable.toString(),
         status: "claimable"
@@ -63075,15 +63698,15 @@ var readerEthenaCooldown = {
     });
     const cell = res[0];
     let cooldownEnd;
-    let amount3;
+    let amount4;
     if (Array.isArray(cell)) {
       cooldownEnd = toBigInt14(cell[0]);
-      amount3 = toBigInt14(cell[1]);
+      amount4 = toBigInt14(cell[1]);
     } else if (cell && typeof cell === "object") {
       cooldownEnd = toBigInt14(cell.cooldownEnd);
-      amount3 = toBigInt14(cell.underlyingAmount);
+      amount4 = toBigInt14(cell.underlyingAmount);
     }
-    if (!amount3 || amount3 === 0n) return [];
+    if (!amount4 || amount4 === 0n) return [];
     const readyAt = Number(cooldownEnd ?? 0n);
     const out = [
       {
@@ -63091,7 +63714,7 @@ var readerEthenaCooldown = {
         brand: entry.brand,
         symbol: entry.symbol,
         requestId: "0",
-        amountUnderlying: amount3.toString(),
+        amountUnderlying: amount4.toString(),
         status: computeStatus(readyAt),
         readyAt
       }
@@ -63146,7 +63769,7 @@ var readerSusd3Cooldown = {
       shares = toBigInt14(cell.shares);
     }
     if (!shares || shares === 0n) return [];
-    let amount3 = shares;
+    let amount4 = shares;
     try {
       const stage2 = await multicallRetry({
         chain: chainId,
@@ -63155,7 +63778,7 @@ var readerSusd3Cooldown = {
         ],
         abi: [Susd3CooldownStatusAbi]
       });
-      amount3 = toBigInt14(stage2[0]) ?? shares;
+      amount4 = toBigInt14(stage2[0]) ?? shares;
     } catch {
     }
     const readyAt = Number(cooldownEnd ?? 0n);
@@ -63166,7 +63789,7 @@ var readerSusd3Cooldown = {
         brand: entry.brand,
         symbol: entry.symbol,
         requestId: "0",
-        amountUnderlying: amount3.toString(),
+        amountUnderlying: amount4.toString(),
         shares: shares.toString(),
         status: computeStatus(readyAt, expiresAt),
         readyAt,
@@ -63362,14 +63985,14 @@ var readerEtherFi = {
       const isValid = Boolean(stage3[i * 3 + 2]);
       if (!req) continue;
       if (!isValid) continue;
-      const amount3 = toBigInt14(req.amountOfEEth);
-      if (amount3 === void 0) continue;
+      const amount4 = toBigInt14(req.amountOfEEth);
+      if (amount4 === void 0) continue;
       out.push({
         lst: entry.lst,
         brand: entry.brand,
         symbol: entry.symbol,
         requestId: id.toString(),
-        amountUnderlying: amount3.toString(),
+        amountUnderlying: amount4.toString(),
         status: isFinalized ? "claimable" : "pending"
       });
     }
@@ -63699,15 +64322,15 @@ var readerLista = {
       const isClaimable = Array.isArray(status) ? Boolean(status[0]) : Boolean(status._isClaimable);
       const bnbAmount = Array.isArray(status) ? toBigInt14(status[1]) : toBigInt14(status._amount);
       const snbnbAmount = Array.isArray(req) ? toBigInt14(req[1]) : toBigInt14(req?.amountInSnBnb);
-      const amount3 = bnbAmount ?? snbnbAmount;
-      if (amount3 === void 0) continue;
+      const amount4 = bnbAmount ?? snbnbAmount;
+      if (amount4 === void 0) continue;
       const uuid = Array.isArray(req) ? toBigInt14(req[0]) : toBigInt14(req?.uuid);
       out.push({
         lst: entry.lst,
         brand: entry.brand,
         symbol: entry.symbol,
         requestId: String(uuid ?? i),
-        amountUnderlying: amount3.toString(),
+        amountUnderlying: amount4.toString(),
         status: isClaimable ? "claimable" : "pending"
       });
     }
@@ -63962,7 +64585,7 @@ var readerStaderMaticX2 = {
     const out = [];
     for (let i = 0; i < arr.length; i++) {
       const r = arr[i];
-      const amount3 = toBigInt14(r.amount) ?? 0n;
+      const amount4 = toBigInt14(r.amount) ?? 0n;
       const requestEpoch = toBigInt14(r.requestEpoch);
       if (requestEpoch === void 0) continue;
       const ready = stakeManager ? currentEpoch >= requestEpoch + delay : false;
@@ -63973,7 +64596,7 @@ var readerStaderMaticX2 = {
         // Use array index as the request id (consistent with
         // `claimWithdrawal(uint256 _idx)`).
         requestId: String(i),
-        amountUnderlying: amount3.toString(),
+        amountUnderlying: amount4.toString(),
         status: ready ? "claimable" : "pending"
       });
     }
@@ -64374,7 +64997,7 @@ var readerStakeWise = {
     const out = [];
     for (let i = 0; i < requests.length; i++) {
       const r = requests[i];
-      const amount3 = toBigInt14(r.totalAssets) ?? 0n;
+      const amount4 = toBigInt14(r.totalAssets) ?? 0n;
       const onChainClaimed = claimedByIdx.get(i);
       const claimable = onChainClaimed !== void 0 || r.isClaimable;
       out.push({
@@ -64382,7 +65005,7 @@ var readerStakeWise = {
         brand: entry.brand,
         symbol: entry.symbol,
         requestId: r.positionTicket,
-        amountUnderlying: (onChainClaimed ?? amount3).toString(),
+        amountUnderlying: (onChainClaimed ?? amount4).toString(),
         status: claimable ? "claimable" : "pending"
       });
     }
@@ -64431,15 +65054,15 @@ var readerStCelo2 = {
     const timestamps = cell[1] ?? [];
     const out = [];
     for (let i = 0; i < values.length; i++) {
-      const amount3 = toBigInt14(values[i]);
+      const amount4 = toBigInt14(values[i]);
       const readyAt = toNumber(timestamps[i]);
-      if (amount3 === void 0 || readyAt === void 0) continue;
+      if (amount4 === void 0 || readyAt === void 0) continue;
       out.push({
         lst: entry.lst,
         brand: entry.brand,
         symbol: entry.symbol,
         requestId: String(i),
-        amountUnderlying: amount3.toString(),
+        amountUnderlying: amount4.toString(),
         status: computeStatus(readyAt),
         readyAt
       });
@@ -64540,15 +65163,15 @@ var readerSwell = {
       const id = ids[i];
       const r = stage3[i];
       if (!r) continue;
-      const amount3 = toBigInt14(r.amount);
-      if (amount3 === void 0) continue;
+      const amount4 = toBigInt14(r.amount);
+      if (amount4 === void 0) continue;
       const claimable = id <= lastProcessed;
       out.push({
         lst: entry.lst,
         brand: entry.brand,
         symbol: entry.symbol,
         requestId: id.toString(),
-        amountUnderlying: amount3.toString(),
+        amountUnderlying: amount4.toString(),
         status: claimable ? "claimable" : "pending"
       });
     }
@@ -64614,15 +65237,15 @@ var readerValantis = {
     for (let i = 0; i < burns.length; i++) {
       const b = burns[i];
       if (!b) continue;
-      const amount3 = Array.isArray(b) ? toBigInt14(b[0]) : toBigInt14(b.amount);
+      const amount4 = Array.isArray(b) ? toBigInt14(b[0]) : toBigInt14(b.amount);
       const completed = Array.isArray(b) ? Boolean(b[2]) : Boolean(b.completed);
-      if (amount3 === void 0 || completed) continue;
+      if (amount4 === void 0 || completed) continue;
       out.push({
         lst: entry.lst,
         brand: entry.brand,
         symbol: entry.symbol,
         requestId: String(toBigInt14(ids[i]) ?? i),
-        amountUnderlying: amount3.toString(),
+        amountUnderlying: amount4.toString(),
         status: redeemable[i] ? "claimable" : "pending"
       });
     }
@@ -64630,6 +65253,84 @@ var readerValantis = {
   }
 };
 
+// src/vaults/lst/withdrawals/abis/treehouse.ts
+var TreehouseRedemptionQueueAbi = [
+  {
+    name: "getPendingRedeems",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ type: "address", name: "user" }],
+    outputs: [
+      {
+        type: "tuple[]",
+        components: [
+          { type: "uint64", name: "startTime" },
+          { type: "uint96", name: "shares" },
+          { type: "uint128", name: "assets" },
+          { type: "uint128", name: "baseRate" }
+        ]
+      }
+    ]
+  },
+  {
+    name: "waitingPeriod",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint32" }]
+  }
+];
+
+// src/vaults/lst/withdrawals/readers/treehouse.ts
+var readerTreehouseRedemption = {
+  fetch: async (user, multicallRetry, chainId, entry) => {
+    if (!entry.withdrawalContract) return [];
+    const res = await multicallRetry({
+      chain: chainId,
+      calls: [
+        {
+          address: entry.withdrawalContract,
+          name: "getPendingRedeems",
+          params: [user]
+        },
+        {
+          address: entry.withdrawalContract,
+          name: "waitingPeriod",
+          params: []
+        }
+      ],
+      abi: [
+        TreehouseRedemptionQueueAbi,
+        TreehouseRedemptionQueueAbi
+      ]
+    });
+    const reqs = res[0];
+    const waitingPeriod = toNumber(res[1]);
+    if (!Array.isArray(reqs) || waitingPeriod === void 0) return [];
+    const out = [];
+    for (let i = 0; i < reqs.length; i++) {
+      const r = reqs[i];
+      const startTime = toNumber(r.startTime);
+      const assets = toBigInt14(r.assets);
+      const shares = toBigInt14(r.shares);
+      if (startTime === void 0 || assets === void 0) continue;
+      const readyAt = startTime + waitingPeriod;
+      out.push({
+        lst: entry.lst,
+        brand: entry.brand,
+        symbol: entry.symbol,
+        // Positional — see note 1 above.
+        requestId: String(i),
+        amountUnderlying: assets.toString(),
+        shares: shares?.toString(),
+        status: computeStatus(readyAt),
+        readyAt
+      });
+    }
+    return out;
+  }
+};
+
 // src/vaults/lst/withdrawals/abis/trufin.ts
 var TruFinVaultAbi = [
   {
@@ -64694,15 +65395,15 @@ var readerTruFin = {
       if (typeof recipient === "string" && recipient.toLowerCase() !== lcUser) {
         continue;
       }
-      const amount3 = Array.isArray(w) ? toBigInt14(w[1]) : toBigInt14(w.amount);
-      if (amount3 === void 0 || amount3 === 0n) continue;
+      const amount4 = Array.isArray(w) ? toBigInt14(w[1]) : toBigInt14(w.amount);
+      if (amount4 === void 0 || amount4 === 0n) continue;
       out.push({
         lst: entry.lst,
         brand: entry.brand,
         symbol: entry.symbol,
         // Composite id — same shape as the input.
         requestId: `${pairs[i].validator}:${pairs[i].nonce.toString()}`,
-        amountUnderlying: amount3.toString(),
+        amountUnderlying: amount4.toString(),
         status: claimable ? "claimable" : "pending"
       });
     }
@@ -64809,17 +65510,17 @@ var readerYieldNest = {
       const id = ids[i];
       const r = stage3[i];
       if (!r) continue;
-      const amount3 = toBigInt14(r.amount);
+      const amount4 = toBigInt14(r.amount);
       const created = toNumber(r.creationTimestamp);
       const processed = Boolean(r.processed);
-      if (amount3 === void 0 || created === void 0) continue;
+      if (amount4 === void 0 || created === void 0) continue;
       const readyAt = created + finalizationSeconds;
       out.push({
         lst: entry.lst,
         brand: entry.brand,
         symbol: entry.symbol,
         requestId: id.toString(),
-        amountUnderlying: amount3.toString(),
+        amountUnderlying: amount4.toString(),
         status: processed ? "claimed" : computeStatus(readyAt),
         readyAt: processed ? void 0 : readyAt
       });
@@ -64888,6 +65589,8 @@ var buildWithdrawalReader = (entry) => {
       return readerPrimeStaking;
     case "berapawRedeemQueue":
       return readerBeraPaw;
+    case "treehouseRedemptionQueue":
+      return readerTreehouseRedemption;
     case "eventsOnly":
     case "noQueue":
     case "unverified":
@@ -64898,6 +65601,18 @@ var buildWithdrawalReader = (entry) => {
 // src/vaults/lst/withdrawals/registry.ts
 var LST_WITHDRAWAL_REGISTRY = {
   "1": [
+    {
+      // Treehouse tETH — `TreehouseRedemptionV2`, the queued (5 bps / 7 d)
+      // exit. The instant Fastlane leg settles in the same transaction and
+      // so never produces a pending request. Undocumented address,
+      // recovered from `Vault.redemption()` →
+      // `RedemptionController.getRedemptionContracts()`.
+      lst: "0xd11c452fc99cf405034ee446803b6f6c1f6d5ed8",
+      brand: "Treehouse",
+      symbol: "tETH",
+      reader: "treehouseRedemptionQueue",
+      withdrawalContract: "0xcd63a29faff07130d3af89bb4f40778938aabb85"
+    },
     {
       // wBETH — Binance's UnwrapTokenV1 queue, the SAME contract address
       // on Ethereum and BNB. Entered via `wBETH.requestWithdrawEth`;
@@ -65361,6 +66076,14 @@ var LST_WITHDRAWAL_REGISTRY = {
     }
   ],
   "43114": [
+    {
+      // Treehouse tAVAX — same stack as tETH; 17-day wait here.
+      lst: "0x14a84f1a61ccd7d1be596a6cc11fe33a36bc1646",
+      brand: "Treehouse",
+      symbol: "tAVAX",
+      reader: "treehouseRedemptionQueue",
+      withdrawalContract: "0x765f6dc8496ca7ef1e4a391be10185229aacf04b"
+    },
     // Ankr ankrAVAX — Ankr unstake queue; reader not yet implemented.
     {
       lst: "0xc3344870d52688874b06d844e0c36cc39fc727f6",
@@ -65431,6 +66154,14 @@ var LST_WITHDRAWAL_REGISTRY = {
     }
   ],
   "999": [
+    {
+      // Treehouse tHYPE — same stack as tETH; 10-day wait here.
+      lst: "0xb83d27f0f4133a7b0377a88089583131a903fdc7",
+      brand: "Treehouse",
+      symbol: "tHYPE",
+      reader: "treehouseRedemptionQueue",
+      withdrawalContract: "0xcebbb011c2f29b0ed25895c54662bd1ccad30280"
+    },
     {
       // Hyperbeat hbHYPE Ultra — ERC-7540 async-redeem.
       lst: "0x96c6cbb6251ee1c257b2162ca0f39aa5fa44b1fb",
@@ -65670,6 +66401,15 @@ var Erc4626ReadAbi2 = [
     outputs: [{ type: "uint256", name: "assets" }]
   }
 ];
+var LockupPeriodAbi = [
+  {
+    name: "lockupPeriod",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  }
+];
 var CooldownDurationAbi = [
   {
     name: "cooldownDuration",
@@ -65770,14 +66510,16 @@ var readerErc46262 = (entry) => {
 var readerErc4626Cooldown = (entry) => {
   const shareUnit = 10n ** BigInt(entry.decimals);
   const underlyingUnit = 10n ** BigInt(entry.underlyingDecimals ?? entry.decimals);
+  const cooldownGetter = entry.cooldownGetter ?? "cooldownDuration";
+  const cooldownAbi = cooldownGetter === "lockupPeriod" ? LockupPeriodAbi : CooldownDurationAbi;
   return {
     calls: [
       { address: entry.address, name: "totalAssets", params: [] },
       { address: entry.address, name: "totalSupply", params: [] },
       { address: entry.address, name: "convertToAssets", params: [shareUnit] },
-      { address: entry.address, name: "cooldownDuration", params: [] }
+      { address: entry.address, name: cooldownGetter, params: [] }
     ],
-    abis: [Erc4626ReadAbi2, TotalSupplyAbi2, Erc4626ReadAbi2, CooldownDurationAbi],
+    abis: [Erc4626ReadAbi2, TotalSupplyAbi2, Erc4626ReadAbi2, cooldownAbi],
     parse: ([assets, supply, rate, cooldown]) => {
       const totalAssets = toBigInt15(assets);
       const totalSupply = toBigInt15(supply);
@@ -66255,6 +66997,8 @@ var readerHyperbeatVault = (entry) => {
 var readerNavOracle = (entry) => {
   const shareUnit = 10n ** BigInt(entry.decimals);
   const underlyingUnit = 10n ** BigInt(entry.underlyingDecimals ?? entry.decimals);
+  const oracleDecimals = entry.priceOracleDecimals ?? 18;
+  const oracleScale = 10n ** BigInt(oracleDecimals);
   return {
     calls: [
       { address: entry.address, name: "totalSupply", params: [] },
@@ -66269,8 +67013,9 @@ var readerNavOracle = (entry) => {
       const totalSupply = toBigInt15(supply);
       if (totalSupply === void 0) return void 0;
       const raw = Array.isArray(round) ? round[1] : round?.answer;
-      const exchangeRate = toBigInt15(raw);
-      if (exchangeRate === void 0 || exchangeRate <= 0n) return void 0;
+      const answer = toBigInt15(raw);
+      if (answer === void 0 || answer <= 0n) return void 0;
+      const exchangeRate = answer * ONE_E1813 / oracleScale;
       return {
         totalAssets: totalSupply * exchangeRate * underlyingUnit / (ONE_E1813 * shareUnit),
         totalSupply,
@@ -66570,6 +67315,19 @@ var fetchSavingsVaults = async (chainId, multicallRetry, prices = {}, tokenList
       instantRedeemEnabled: state.instantRedeemEnabled,
       inventoryContract: entry.inventoryContract?.toLowerCase(),
       withdrawQueue: state.withdrawQueue ?? entry.withdrawQueue?.toLowerCase(),
+      // Both legs of a two-legged exit, spelled out — see `VaultExitRoute`.
+      // Derived from the flat fields the readers already establish, so every
+      // savings row gets it without a per-provider change; the queued leg's
+      // fee is left ABSENT rather than 0 because "not published" and "free"
+      // are different claims and only some protocols make the second.
+      exitRoutes: deriveExitRoutes({
+        withdrawalMode: entry.withdrawalMode,
+        withdrawFeeBps: state.withdrawFeeBps,
+        withdrawalCooldownSeconds: state.withdrawalCooldownSeconds ?? entry.withdrawalCooldownSeconds,
+        liquidity: liquidityRaw,
+        liquidityFormatted,
+        liquidityUsd
+      }),
       depositCapacity,
       depositCapacityFormatted,
       depositCapacityUsd,
@@ -67186,6 +67944,34 @@ var fetchUpshiftVaults = async (chainId, prices = {}, tokenList = {}) => {
   return out;
 };
 
+// src/vaults/rateSanity.ts
+var NOISE_DEVIATION_BPS = 10;
+var IMPLAUSIBLE_APR_PERCENT2 = 1e3;
+var DUST_TVL_USD = 1e3;
+var impliedDeviationBps = (c) => {
+  const secs = c.expiry - c.nowSecs;
+  if (!(secs > 0)) return 0;
+  const years = secs / 31536e3;
+  return (Math.pow(1 + c.aprPercent / 100, years) - 1) * 1e4;
+};
+var isAnnualizationNoise = (c) => {
+  if (!Number.isFinite(c.aprPercent)) return false;
+  if (!(c.expiry > c.nowSecs)) return false;
+  return Math.abs(impliedDeviationBps(c)) < NOISE_DEVIATION_BPS;
+};
+var isImplausibleMagnitude = (aprPercent, totalAssetsUsd) => {
+  if (!Number.isFinite(aprPercent)) return false;
+  if (Math.abs(aprPercent) <= IMPLAUSIBLE_APR_PERCENT2) return false;
+  return (totalAssetsUsd ?? 0) < DUST_TVL_USD;
+};
+var isUnearnableRate = (args) => {
+  const { aprPercent, totalAssetsUsd, expiry } = args;
+  if (isImplausibleMagnitude(aprPercent, totalAssetsUsd)) return true;
+  if (expiry === void 0) return false;
+  const nowSecs = args.nowSecs ?? Math.floor(Date.now() / 1e3);
+  return (totalAssetsUsd ?? 0) < DUST_TVL_USD && isAnnualizationNoise({ aprPercent, expiry, nowSecs });
+};
+
 // src/vaults/yearn/fetchPublic.ts
 var BRAND3 = "Yearn";
 var ZERO_ADDR = "0x0000000000000000000000000000000000000000";
@@ -67375,7 +68161,14 @@ var fetchYearnVaults = async (chainId, multicallRetry, prices = {}, tokenList =
   const out = {};
   for (const item of items) {
     const parsed = parseVault9(item, chainId, prices, tokenList);
-    if (parsed) out[parsed.address] = parsed;
+    if (!parsed) continue;
+    if (isUnearnableRate({
+      aprPercent: parsed.supplyRate,
+      totalAssetsUsd: parsed.totalAssetsUsd
+    })) {
+      continue;
+    }
+    out[parsed.address] = parsed;
   }
   try {
     await attachYearnLiquidity(chainId, multicallRetry, out);
@@ -69137,7 +69930,16 @@ var fetchPendlePtMarkets = async (chainId, multicallRetry, prices = {}, tokenLis
       decimalsOnChain,
       nowSecs
     );
-    if (parsed) out[parsed.address] = parsed;
+    if (!parsed) continue;
+    if (isUnearnableRate({
+      aprPercent: parsed.supplyRate,
+      totalAssetsUsd: parsed.totalAssetsUsd,
+      expiry: parsed.expiry,
+      nowSecs
+    })) {
+      continue;
+    }
+    out[parsed.address] = parsed;
   }
   return out;
 };
@@ -69386,7 +70188,16 @@ var fetchSpectraPtMarkets = async (chainId, multicallRetry, prices = {}, tokenLi
       decimalsOnChain,
       nowSecs
     );
-    if (parsed) out[parsed.address] = parsed;
+    if (!parsed) continue;
+    if (isUnearnableRate({
+      aprPercent: parsed.supplyRate,
+      totalAssetsUsd: parsed.totalAssetsUsd,
+      expiry: parsed.expiry,
+      nowSecs
+    })) {
+      continue;
+    }
+    out[parsed.address] = parsed;
   }
   return out;
 };
@@ -69714,24 +70525,24 @@ function shortDate(unixSecs) {
 }
 function feePhrase(fee) {
   const magnitude = Math.abs(fee.value);
-  let amount3;
+  let amount4;
   switch (fee.unit) {
     case "bps":
-      amount3 = `${magnitude} bps`;
+      amount4 = `${magnitude} bps`;
       break;
     case "apr-percent":
-      amount3 = `${pct(magnitude)}/yr`;
+      amount4 = `${pct(magnitude)}/yr`;
       break;
     case "percent":
-      amount3 = pct(magnitude);
+      amount4 = pct(magnitude);
       break;
     default:
-      amount3 = String(magnitude);
+      amount4 = String(magnitude);
   }
   const rebate = fee.value < 0 ? " rebate" : "";
   const qualifier = fee.indicative ? " (estimated, resolved at execution)" : "";
   const bound = fee.mutable && fee.cap != null ? `, governance-set up to a maximum of ${fee.unit === "bps" ? `${fee.cap} bps` : pct(fee.cap)}` : fee.mutable ? ", governance-set" : "";
-  return `${fee.label}: ${amount3}${rebate}${bound}${qualifier}`;
+  return `${fee.label}: ${amount4}${rebate}${bound}${qualifier}`;
 }
 function maturityPhrase(m) {
   if (m.kind === "fixed-date" && m.maturity)
@@ -69817,12 +70628,40 @@ function provenance(rate) {
   }
   return ` (incl. ${pct(intrinsic)} from the asset)`;
 }
-function supplyHeadline(s) {
+function routePhrase(r, symbol) {
+  const when = r.kind === "instant" ? "instantly" : r.waitSeconds ? `after ${duration(r.waitSeconds)}` : r.kind === "market" ? "by selling it" : "after a wait";
+  const cost = r.feeBps === 0 ? " free" : r.feeBps != null ? ` for ${(r.feeBps / 100).toFixed(2)} %` : r.feeUnknown ? " for a fee" : "";
+  const floor = r.minAmountFormatted != null && r.minAmountFormatted > 0 ? ` (min ${amount(r.minAmountFormatted)}${symbol ? ` ${symbol}` : ""})` : "";
+  const cap = r.kind !== "instant" || r.capacityFormatted == null ? "" : r.capacityFormatted <= 0 ? ", though nothing is available right now" : `, up to ${amount(r.capacityFormatted)}${symbol ? ` ${symbol}` : ""} right now`;
+  return `${when}${cost}${floor}${cap}`;
+}
+function routesSentence(routes2, symbol) {
+  const legs = routes2.map((r) => routePhrase(r, symbol));
+  const body = legs.length === 1 ? legs[0] : `${legs.slice(0, -1).join(", ")}, or ${legs[legs.length - 1]}`;
+  return `You can leave ${body}.`;
+}
+function amount(v) {
+  if (v >= 1e3) return v.toLocaleString("en-US", { maximumFractionDigits: 0 });
+  if (v >= 1) return v.toFixed(2).replace(/\.?0+$/, "");
+  return v.toPrecision(3);
+}
+function headlineExitFromRoutes(routes2, symbol) {
+  if (!routes2 || routes2.length < 2) return void 0;
+  const fast = routes2.find((r) => r.kind === "instant");
+  const slow = routes2.find((r) => r.kind === "queued");
+  if (!fast || !slow) return void 0;
+  const fastPart = fast.feeBps == null ? "instant exit" : fast.feeBps === 0 ? "free instant exit" : `instant exit for ${(fast.feeBps / 100).toFixed(2)} %`;
+  const slowCost = slow.feeBps === 0 ? "free" : slow.feeBps != null ? `${(slow.feeBps / 100).toFixed(2)} %` : void 0;
+  const floor = slow.minAmountFormatted != null && slow.minAmountFormatted > 0 ? ` above ${amount(slow.minAmountFormatted)}${symbol ? ` ${symbol}` : ""}` : "";
+  const slowPart = slowCost ? `queue${floor} for ${slowCost}` : `queue${floor}`;
+  return `${fastPart}, or ${slowPart}`;
+}
+function supplyHeadline(s, sheet = {}) {
   if (s.role === "collateral") {
     return `Collateral only \xB7 ${maturityPhrase(s.maturity)}`;
   }
   const rate = `${rateLabel(s)} ${pct(s.rate.aprTotal)}${windowNote(s.rate)}${provenance(s.rate)}`;
-  const exit = exitPhrase[String(s.exit.mode)] ?? (s.exit.settlement === "sync" ? "withdraw any time" : "delayed withdrawal");
+  const exit = headlineExitFromRoutes(s.exit.routes, sheet.asset?.symbol) ?? exitPhrase[String(s.exit.mode)] ?? (s.exit.settlement === "sync" ? "withdraw any time" : "delayed withdrawal");
   const cooldown = s.exit.cooldownSecs ? ` (${duration(s.exit.cooldownSecs)})` : "";
   const mat = s.maturity.kind === "perpetual" ? "" : ` ${maturityPhrase(s.maturity)}`;
   const warmup = s.rate.warmupSecs ? ` \xB7 earns after ${duration(s.rate.warmupSecs)}` : "";
@@ -69858,7 +70697,9 @@ function supplyDescription(s, sheet = {}) {
       `You earn ${pct(s.rate.aprTotal)} (${comp.join(" + ")}), ${rateBehaviour(s.rate)}.`
     );
   }
-  if (s.exit.mode === "instant") {
+  if (s.exit.routes && s.exit.routes.length > 1) {
+    parts.push(routesSentence(s.exit.routes, sheet.asset?.symbol));
+  } else if (s.exit.mode === "instant") {
     const util = sheet.utilization?.utilization;
     parts.push(
       util != null && util >= 0.95 ? `Withdrawals are instant in principle, but utilization is ${pct(util * 100)} \u2014 there may be little or no liquidity to withdraw right now.` : "Withdrawals are instant, up to the liquidity available in the market."
@@ -70991,7 +71832,7 @@ function finalizeInfo(sheet) {
     sheet.borrow.info = { headline: "", description: "", tags: [] };
   if (sheet.supply) {
     sheet.supply.info = {
-      headline: sheet.supply.info.headline || supplyHeadline(sheet.supply),
+      headline: sheet.supply.info.headline || supplyHeadline(sheet.supply, sheet),
       description: sheet.supply.info.description || supplyDescription(sheet.supply, sheet),
       implications: sheet.supply.info.implications,
       tags: deriveSupplyTags(sheet.supply, market)
@@ -71495,6 +72336,10 @@ function resolveExitMode(input, t) {
   if (totalAssets <= 0) return "instant";
   return liquidity >= totalAssets ? "instant" : "instant-capped";
 }
+var TWO_LEGGED_MODES = /* @__PURE__ */ new Set([
+  "fee-or-queued",
+  "instant-or-queued"
+]);
 var ASYNC_MODES = /* @__PURE__ */ new Set([
   "fixed-cooldown",
   "queued",
@@ -71508,12 +72353,29 @@ function settlementFor(mode, priceRisk) {
     return "market";
   return ASYNC_MODES.has(mode) ? "async" : "sync";
 }
+function derivedRoutes(input, mode) {
+  const routes2 = deriveExitRoutes({
+    withdrawalMode: mode,
+    withdrawFeeBps: input.withdrawFeeBps,
+    withdrawalCooldownSeconds: input.withdrawalCooldownSeconds,
+    liquidity: isNum2(input.liquidity) ? String(input.liquidity) : void 0,
+    liquidityFormatted: input.liquidity,
+    liquidityUsd: input.liquidityUsd
+  });
+  return routes2.length > 0 ? routes2 : void 0;
+}
 function buildExit(input, t, fees) {
   const mode = resolveExitMode(input, t);
   const priceRisk = resolvePriceRisk(input, t);
   const ratio = input.instantLiquidityRatio ?? (isNum2(input.liquidity) && isNum2(input.totalAssets) && input.totalAssets > 0 ? clamp014(input.liquidity / input.totalAssets) : void 0);
   return {
     mode,
+    // The row's own list wins — providers that read their protocol's exit
+    // modules attach live per-leg fees and minimums. Otherwise derive the
+    // same split from the flat fields, because the alternative is a sheet
+    // that states one wait and one fee belonging to DIFFERENT legs. Only a
+    // row whose mode we cannot map at all ends up with no routes.
+    routes: input.exitRoutes ?? derivedRoutes(input, mode),
     settlement: settlementFor(mode, priceRisk),
     cooldownSecs: input.withdrawalCooldownSeconds,
     liquidity: isNum2(input.liquidity) || isNum2(input.liquidityUsd) ? {
@@ -71720,6 +72582,10 @@ function buildCoverage2(sheet, input, t) {
   else pending.counterparty = "solvency-not-curated-default-assumed";
   if (sheet.supply?.exit.liquidity) present.push("exitLiquidity");
   else pending.exitLiquidity = "provider-does-not-publish-liquidity";
+  if (sheet.supply?.exit.routes?.length) present.push("exitRoutes");
+  else if (TWO_LEGGED_MODES.has(String(sheet.supply?.exit.mode)))
+    pending.exitRoutes = "provider-does-not-publish-per-leg-terms";
+  else notApplicable.exitRoutes = "single-exit-route";
   return {
     present,
     notApplicable: Object.keys(notApplicable).length ? notApplicable : void 0,
@@ -72448,13 +73314,13 @@ function earnMarketFromVault(row, chainId, opts = {}) {
     // The vault origin reports RAW base units + a pre-formatted convenience
     // field. Carry both; fall back to formatting the raw amount ourselves so
     // `formatted` — the field consumers sort on — is never silently absent.
-    tvl: amount(
+    tvl: amount2(
       tvl.totalAssets,
       tvl.totalAssetsFormatted,
       tvl.totalAssetsUsd,
       assetDecimals
     ),
-    liquidity: liq.liquidity != null || liq.liquidityUsd != null ? amount(
+    liquidity: liq.liquidity != null || liq.liquidityUsd != null ? amount2(
       liq.liquidity,
       liq.liquidityFormatted,
       liq.liquidityUsd,
@@ -72466,7 +73332,10 @@ function earnMarketFromVault(row, chainId, opts = {}) {
       mode: exitMode,
       settlement: str6(meta.redemptionType),
       cooldownSecs: num13(meta.withdrawalCooldownSeconds),
-      feeBps: num13(meta.withdrawFeeBps)
+      feeBps: num13(meta.withdrawFeeBps),
+      // Passed through, never re-derived: the earn row and the vault row must
+      // not disagree about what the legs out are.
+      routes: Array.isArray(meta.exitRoutes) ? meta.exitRoutes : void 0
     },
     availability,
     risk: {
@@ -72567,7 +73436,7 @@ function isMatured(maturity) {
   if (!maturity?.maturity) return false;
   return maturity.maturity <= Math.floor(Date.now() / 1e3);
 }
-function amount(raw, formatted, usd, decimals) {
+function amount2(raw, formatted, usd, decimals) {
   const rawStr = raw != null ? String(raw) : void 0;
   return {
     raw: rawStr,
@@ -72595,6 +73464,13 @@ var num14 = (v) => {
 };
 var str7 = (v) => typeof v === "string" && v.trim() !== "" ? v : void 0;
 var bool2 = (v) => typeof v === "boolean" ? v : void 0;
+var routes = (v) => {
+  if (!Array.isArray(v)) return void 0;
+  const out = v.filter(
+    (r) => !!r && typeof r === "object" && typeof r.id === "string" && typeof r.kind === "string"
+  );
+  return out.length > 0 ? out : void 0;
+};
 var strArray = (v) => {
   if (!Array.isArray(v)) return void 0;
   const out = v.filter((x) => typeof x === "string" && x !== "");
@@ -72665,6 +73541,7 @@ function toVaultTermInput(vault, provider, chainId) {
     withdrawalMode: str7(row.withdrawalMode),
     withdrawalCooldownSeconds: num14(row.withdrawalCooldownSeconds),
     withdrawFeeBps: num14(row.withdrawFeeBps),
+    exitRoutes: routes(row.exitRoutes),
     fee: num14(row.fee),
     managementFee: num14(row.managementFee),
     swapFeeRate: num14(row.feeRate),
@@ -72731,6 +73608,7 @@ function vaultTermInputFromEarnMarket(m) {
     withdrawalMode: m.exit.mode,
     withdrawalCooldownSeconds: m.exit.cooldownSecs,
     withdrawFeeBps: m.exit.feeBps,
+    exitRoutes: routes(m.exit.routes),
     fee: m.rate.fee,
     managementFee: num14(meta.managementFee),
     swapFeeRate: num14(meta.feeRate),
@@ -72813,6 +73691,7 @@ function vaultTermInputFromSourceRow(row, chainId) {
     withdrawalMode: str7(meta.withdrawalMode),
     withdrawalCooldownSeconds: num14(meta.withdrawalCooldownSeconds),
     withdrawFeeBps: num14(meta.withdrawFeeBps),
+    exitRoutes: routes(meta.exitRoutes),
     fee: num14(rates.fee),
     managementFee: num14(meta.managementFee),
     swapFeeRate: num14(meta.feeRate),
@@ -76063,11 +76942,11 @@ function earnMarketFromPool(row, fallbackChainId, venueCollaterals) {
     // so `formatted` is populated and `raw` is genuinely absent. Do NOT
     // back-fill `raw` by re-scaling — the round-trip loses precision and would
     // fabricate base units the origin never sent.
-    tvl: amount2(
+    tvl: amount3(
       row.totalDeposits,
       row.totalDepositsUSD ?? row.totalDepositsUsd
     ),
-    liquidity: amount2(
+    liquidity: amount3(
       row.totalLiquidity,
       row.totalLiquidityUSD ?? row.totalLiquidityUsd
     ),
@@ -76167,7 +77046,7 @@ function sumRewardAprs(rewards) {
   }
   return seen ? total : void 0;
 }
-function amount2(formatted, usd) {
+function amount3(formatted, usd) {
   return { formatted: num13(formatted), usd: num13(usd) };
 }
 function sum2(...parts) {