@1delta/margin-fetcher 0.0.411 → 0.0.412

package/dist/index.js

@@ -1,12 +1,12 @@
-import { parseAbi, keccak256, encodeAbiParameters, formatEther, BaseError, stringToHex, erc20Abi, pad, encodeFunctionData, formatUnits, isAddress, getAddress, decodeFunctionResult, decodeAbiParameters, concat, AbiEncodingLengthMismatchError, concatHex, toBytes, slice, hexToString, InvalidAddressError, boolToHex, integerRegex, numberToHex, bytesRegex, BytesSizeMismatchError, arrayRegex, UnsupportedPackedAbiType } from './chunk-YILYOOYB.js';
+import { parseAbi, keccak256, encodeAbiParameters, formatEther, BaseError, erc20Abi, stringToHex, pad, encodeFunctionData, formatUnits, isAddress, getAddress, decodeFunctionResult, decodeAbiParameters, concat, AbiEncodingLengthMismatchError, concatHex, toBytes, slice, hexToString, InvalidAddressError, boolToHex, integerRegex, numberToHex, bytesRegex, BytesSizeMismatchError, arrayRegex, UnsupportedPackedAbiType } from './chunk-YILYOOYB.js';
 import './chunk-BYTNVMX7.js';
 import './chunk-PR4QN5HX.js';
-import { Lender, LIQUITY_FAMILY_LENDERS, isAaveType, isCompoundV3, isMultiMarket, isSiloV2Type, isSiloV3Type, isDolomite, isMidnight, isTerm, isExactly, isLiquityFamily, isRiver, isTeller, isInverse, isTermMax, isUsdd, isEulerType, isAaveV4Type, isInit, isMorphoType, isCompoundV2Type, isVenusType, isSumerType, AAVE_V3_LENDERS, AAVE_V2_LENDERS, isAaveV2Type, isAaveV32Type, isAaveV3Type, isFluid, isGearboxV3, isYLDR, isCompoundV3Type, isLista, isTectonicType, isKineticType, isBenqiType } from '@1delta/lender-registry';
+import { Lender, LIQUITY_FAMILY_LENDERS, isAaveType, isCompoundV3, isMultiMarket, isSiloV2Type, isSiloV3Type, isDolomite, isMidnight, isTerm, isExactly, isLiquityFamily, isRiver, isTeller, isInverse, isTermMax, isResupply, isUsdd, isFrankencoin, isLlamaLend, isEulerType, isAaveV4Type, isInit, isMorphoType, isCompoundV2Type, isVenusType, isSumerType, AAVE_V3_LENDERS, AAVE_V2_LENDERS, isAaveV2Type, isAaveV32Type, isAaveV3Type, isFluid, isGearboxV3, isYLDR, isCompoundV3Type, isLista, isTectonicType, isKineticType, isBenqiType } from '@1delta/lender-registry';
 export { isAaveType, isAaveV2Type, isAaveV32Type, isAaveV3Type, isCompoundV3, isCompoundV3Type, isInit, isMorphoType, isMultiMarket, isYLDR } from '@1delta/lender-registry';
-import { fetchTokenLists, fetchTokenList, aavePools, compoundV3Pools, initConfig, morphoPools, compoundV2Pools, eulerVaults, siloMarkets, siloV2LenderKey, siloMarketsV3, siloV3LenderKey, aaveV4Spokes, aaveV4SpokeLenderKey, fluidResolvers, gearboxResolvers, dolomiteConfigs, midnightConfig, termConfig, termMarketsByChain, exactlyConfig, liquityLendersByChain, riverLendersByChain, inverseLendersByChain, usddLendersByChain, tellerConfigByChain, tellerPoolsByChain, termMaxConfigByChain, aaveReserves, compoundV3Reserves, liquityConfigFor, liquityBranchesByChain, riverConfigFor, riverChainData, termMaxApiBaseUrl, termMaxLenderKey, inverseConfigFor, inverseChainData, usddConfigFor, usddChainData, aaveOracles, morphoTypeMarkets, resolveMidnightApiBase, resolveTermApiBase, getSiloV2MarketEntry, getSiloV3MarketEntry, dolomiteEmode, aaveTokens, morphoTypeVaults, eulerConfigs, gearboxMarketCompressor, gearboxMarketConfigurators, gearboxV3LenderKey, midnightMarketsByChain, parseAaveV4SpokeLenderKey, gearboxAccountCompressor, compoundV2Tokens, exactlyMarketsByChain, aaveOraclesConfig, compoundV2Oracles, compoundV2TokenArray, compoundV2OraclesConfig, compoundV3OraclesData, compoundV3BaseData, compoundV2Reserves, aaveV4Oracles } from '@1delta/data-sdk';
+import { fetchTokenLists, fetchTokenList, aavePools, compoundV3Pools, initConfig, morphoPools, compoundV2Pools, eulerVaults, siloMarkets, siloV2LenderKey, siloMarketsV3, siloV3LenderKey, aaveV4Spokes, aaveV4SpokeLenderKey, fluidResolvers, gearboxResolvers, dolomiteConfigs, midnightConfig, termConfig, termMarketsByChain, exactlyConfig, liquityLendersByChain, riverLendersByChain, inverseLendersByChain, llamaLendLendersByChain, usddLendersByChain, frankencoinLendersByChain, resupplyLendersByChain, tellerConfigByChain, tellerPoolsByChain, termMaxConfigByChain, aaveReserves, compoundV3Reserves, liquityConfigFor, liquityBranchesByChain, riverConfigFor, riverChainData, termMaxApiBaseUrl, termMaxLenderKey, inverseConfigFor, inverseChainData, llamaLendConfigFor, llamaLendChainData, llamaLendApiBaseUrl, resupplyConfigFor, usddConfigFor, usddChainData, frankencoinConfigFor, frankencoinChainData, aaveOracles, morphoTypeMarkets, resolveMidnightApiBase, resolveTermApiBase, llamaLendMarketByVault, getSiloV2MarketEntry, getSiloV3MarketEntry, dolomiteEmode, aaveTokens, morphoTypeVaults, eulerConfigs, gearboxMarketCompressor, gearboxMarketConfigurators, gearboxV3LenderKey, midnightMarketsByChain, parseAaveV4SpokeLenderKey, gearboxAccountCompressor, compoundV2Tokens, exactlyMarketsByChain, aaveOraclesConfig, compoundV2Oracles, compoundV2TokenArray, compoundV2OraclesConfig, compoundV3OraclesData, compoundV3BaseData, compoundV2Reserves, aaveV4Oracles } from '@1delta/data-sdk';
 import lodash from 'lodash';
 import { multicallRetryUniversal, getEvmClient, getEvmChain, getEvmClientUniversal } from '@1delta/providers';
-import { LiquityTroveManagerAbi, LiquityActivePoolAbi, LiquityStabilityPoolAbi, LiquityPriceFeedAbi, LiquitySortedTrovesAbi, RiverTroveManagerAbi, RiverStabilityPoolAbi, TellerMarketRegistryAbi, TellerV2Abi, InverseMarketAbi, InverseOracleAbi, InverseDbrAbi, Erc20Abi, MetaMorphoAbi, ExactlyPreviewerAbi, ExactlyAuditorAbi, LenderCommitmentGroupAbi, UsddVatAbi, UsddJugAbi, UsddSpotAbi, FluidLendingResolverAbi, FluidVaultResolverAbi, FluidLiquidityResolverAbi, MoolahVaultAbi, MorphoLensAbi, AaveV4SpokeAbi, AaveV4OracleAbi, AaveV4HubAbi, DolomiteMarginAbi, GearboxMarketCompressorV310Abi, MorphoBlueAbi, MidnightAbi, TermRepoTokenAbi, TermRepoServicerAbi, TermRepoCollateralManagerAbi, LiquityTroveNFTAbi, LiquityCollSurplusPoolAbi, TellerCollateralManagerAbi, TermMaxViewerAbi, InverseEscrowAbi, GearboxCreditAccountCompressorV310Abi, UsddCdpManagerAbi, UsddProxyRegistryAbi, TermPriceConsumerAbi, TermMaxOracleAggregatorV2Abi } from '@1delta/abis';
+import { LiquityTroveManagerAbi, LiquityActivePoolAbi, LiquityStabilityPoolAbi, LiquityPriceFeedAbi, LiquitySortedTrovesAbi, RiverTroveManagerAbi, RiverStabilityPoolAbi, TellerMarketRegistryAbi, TellerV2Abi, InverseMarketAbi, InverseOracleAbi, InverseDbrAbi, Erc20Abi, LlamaLendControllerAbi, LlamaLendControllerV1Abi, LlamaLendControllerV2Abi, LlamaLendVaultAbi, LlamaLendAmmAbi, MetaMorphoAbi, ExactlyPreviewerAbi, ExactlyAuditorAbi, LenderCommitmentGroupAbi, ResupplyRegistryAbi, ResupplyPairAbi, UsddVatAbi, UsddJugAbi, UsddSpotAbi, FrankencoinPositionAbi, FluidLendingResolverAbi, FluidVaultResolverAbi, FluidLiquidityResolverAbi, MoolahVaultAbi, ResupplyUtilitiesAbi, MorphoLensAbi, AaveV4SpokeAbi, AaveV4OracleAbi, AaveV4HubAbi, DolomiteMarginAbi, GearboxMarketCompressorV310Abi, MorphoBlueAbi, MidnightAbi, TermRepoTokenAbi, TermRepoServicerAbi, TermRepoCollateralManagerAbi, LiquityTroveNFTAbi, LiquityCollSurplusPoolAbi, TellerCollateralManagerAbi, TermMaxViewerAbi, InverseEscrowAbi, GearboxCreditAccountCompressorV310Abi, UsddCdpManagerAbi, UsddProxyRegistryAbi, TermPriceConsumerAbi, TermMaxOracleAggregatorV2Abi } from '@1delta/abis';
 export { MorphoLensAbi } from '@1delta/abis';
 import { prepareDebitDataMulticall, prepareLenderDebitMulticall, parseDebitDataResult, parseLenderDebitResult, getPermit2ContractAddress, getCompoundV3CometAddress as getCompoundV3CometAddress$1, getMorphoAddress, getAaveCollateralTokenAddress, getSiloHalfForUnderlying, InitMarginAddresses, getLstAcceptedInputs } from '@1delta/calldata-sdk';
 import { proxyNativeFetch } from '@1delta/proxy-fetch';
@@ -7519,9 +7519,18 @@ var getLendersForChain = (c) => {
   for (const l of inverseLendersByChain(c)) {
     lenders.push(l);
   }
+  for (const l of llamaLendLendersByChain(c)) {
+    lenders.push(l);
+  }
   for (const l of usddLendersByChain(c)) {
     lenders.push(l);
   }
+  for (const l of frankencoinLendersByChain(c)) {
+    lenders.push(l);
+  }
+  for (const l of resupplyLendersByChain(c)) {
+    lenders.push(l);
+  }
   if (tellerConfigByChain(c)?.tellerV2 && tellerPoolsByChain(c).length > 0) {
     lenders.push(Lender.TELLER);
   }
@@ -7543,7 +7552,7 @@ var filterLendersByProtocol = (allLenders, protocolList) => {
     (b) => protocolList.includes(b)
   );
   return allLenders.filter(
-    (lender) => protocolList.includes(lender) || hasMorpho && lender?.startsWith("MORPHO_BLUE") || hasMoolah && lender?.startsWith("LISTA_DAO") || hasFluid && lender?.startsWith("FLUID") || hasGearboxV3 && lender?.startsWith("GEARBOX_V3") || hasDolomite && lender?.startsWith("DOLOMITE") || liquityBases.some((b) => lender?.startsWith(b)) || protocolList.includes(Lender.RIVER) && lender?.startsWith("RIVER") || protocolList.includes(Lender.TELLER) && lender?.startsWith("TELLER") || protocolList.includes(Lender.USDD) && lender?.startsWith("USDD")
+    (lender) => protocolList.includes(lender) || hasMorpho && lender?.startsWith("MORPHO_BLUE") || hasMoolah && lender?.startsWith("LISTA_DAO") || hasFluid && lender?.startsWith("FLUID") || hasGearboxV3 && lender?.startsWith("GEARBOX_V3") || hasDolomite && lender?.startsWith("DOLOMITE") || liquityBases.some((b) => lender?.startsWith(b)) || protocolList.includes(Lender.RIVER) && lender?.startsWith("RIVER") || protocolList.includes(Lender.TELLER) && lender?.startsWith("TELLER") || protocolList.includes(Lender.USDD) && lender?.startsWith("USDD") || protocolList.includes(Lender.FRANKENCOIN) && lender?.startsWith("FRANKENCOIN")
   );
 };
 var getAavesForChain = () => {
@@ -11208,8 +11217,8 @@ async function fetchListaBrokerUserData(chainId, account, marketKeys, nowSecs =
   const brokers = await resolveListaBrokers(chainId, marketKeys, getClient);
   const ids = Object.keys(brokers);
   const out = {};
-  const cacheKey6 = `${chainId}:${account.toLowerCase()}`;
-  BROKER_USER_CACHE[cacheKey6] = out;
+  const cacheKey7 = `${chainId}:${account.toLowerCase()}`;
+  BROKER_USER_CACHE[cacheKey7] = out;
   if (ids.length === 0) return out;
   try {
     const client = getClient(chainId);
@@ -22882,7 +22891,7 @@ async function fetchTellerMarkets(chainId) {
   } catch {
     return { chainId, pools: [] };
   }
-  const big9 = (i) => {
+  const big13 = (i) => {
     const r = results[i];
     if (typeof r === "bigint") return r;
     if (typeof r === "number") return BigInt(r);
@@ -22895,21 +22904,21 @@ async function fetchTellerMarkets(chainId) {
     }
     return null;
   };
-  const num9 = (i) => {
-    const b = big9(i);
+  const num10 = (i) => {
+    const b = big13(i);
     return b === null ? null : Number(b);
   };
   const pool0 = pools.map((config, i) => {
     const base = i * READS_PER_POOL;
     return {
       config,
-      available: big9(base),
-      committed: big9(base + 1),
-      minRateBps: num9(base + 2),
-      collateralPerPrincipal: big9(base + 3),
-      maxLoanDuration: num9(base + 4),
-      marketId: big9(base + 5),
-      totalAssets: big9(base + 6)
+      available: big13(base),
+      committed: big13(base + 1),
+      minRateBps: num10(base + 2),
+      collateralPerPrincipal: big13(base + 3),
+      maxLoanDuration: num10(base + 4),
+      marketId: big13(base + 5),
+      totalAssets: big13(base + 6)
     };
   });
   const attByMarket = /* @__PURE__ */ new Map();
@@ -23827,7 +23836,7 @@ var INVERSE_PUBLIC_READ_ABI = [
   ...InverseDbrAbi,
   ...Erc20Abi
 ];
-var READS_PER_MARKET2 = 4;
+var READS_PER_MARKET2 = 5;
 var fetchJson = async (url, timeoutMs = 6e3) => {
   const res = await fetch(url, {
     headers: { accept: "application/json" },
@@ -23870,15 +23879,24 @@ async function fetchInverseMarkets(lender, chainId) {
     if (Object.keys(byAddr).length > 0) {
       const rows = markets.map((market) => {
         const m = byAddr[market.address.toLowerCase()];
-        const num9 = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+        const num10 = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
         return {
           market,
-          totalDebt: num9(m?.totalDebt),
-          dolaLiquidity: num9(m?.dolaLiquidity),
-          leftToBorrow: num9(m?.leftToBorrow),
-          price: num9(m?.price),
+          totalDebt: num10(m?.totalDebt),
+          dolaLiquidity: num10(m?.dolaLiquidity),
+          leftToBorrow: num10(m?.leftToBorrow),
+          price: num10(m?.price),
           borrowPaused: typeof m?.borrowPaused === "boolean" ? m.borrowPaused : null,
-          dailyBorrows: num9(m?.dailyBorrows)
+          dailyBorrows: num10(m?.dailyBorrows),
+          // The API serves it as a DECIMAL (`replenishmentIncentive: 0.1`),
+          // unlike the on-chain bps — normalize here, and fall back to the
+          // curated metadata value when the field is missing.
+          replenishmentIncentiveBps: (() => {
+            const dec = num10(m?.replenishmentIncentive);
+            if (dec !== null) return Math.round(dec * 1e4);
+            const meta = Number(market.replenishmentIncentiveBps);
+            return Number.isFinite(meta) ? meta : null;
+          })()
         };
       });
       return {
@@ -23903,7 +23921,8 @@ async function fetchInverseMarkets(lender, chainId) {
         address: config.oracle,
         name: "viewPrice",
         params: [m.collToken, BigInt(m.collateralFactorBps)]
-      }
+      },
+      { address: m.address, name: "replenishmentIncentiveBps", params: [] }
     ])
   ];
   try {
@@ -23926,6 +23945,7 @@ async function fetchInverseMarkets(lender, chainId) {
       const paused = results[base + 1];
       const liq = bigAt(base + 2);
       const price2 = bigAt(base + 3);
+      const replenishIncentive = bigAt(base + 4);
       return {
         market,
         totalDebt: totalDebt !== null ? Number(totalDebt) / 10 ** debtDecimals : null,
@@ -23937,7 +23957,11 @@ async function fetchInverseMarkets(lender, chainId) {
         // 10^(36 − collDecimals) per unit — normalize to USD per token.
         price: price2 !== null ? Number(price2) / 10 ** (36 - market.collDecimals) : null,
         borrowPaused: typeof paused === "boolean" ? paused : null,
-        dailyBorrows: null
+        dailyBorrows: null,
+        replenishmentIncentiveBps: replenishIncentive !== null ? Number(replenishIncentive) : (() => {
+          const meta = Number(market.replenishmentIncentiveBps);
+          return Number.isFinite(meta) ? meta : null;
+        })()
       };
     });
     return {
@@ -23957,6 +23981,454 @@ function num(api, key) {
   const v = api?.[key];
   return typeof v === "number" && Number.isFinite(v) ? v : null;
 }
+var BANDS_ENDPOINTS = [4, 10, 20, 50];
+var DEFAULT_BANDS = 10;
+var LLAMALEND_READ_ABI = [
+  ...LlamaLendControllerAbi,
+  ...LlamaLendControllerV1Abi,
+  ...LlamaLendControllerV2Abi,
+  ...LlamaLendVaultAbi,
+  ...LlamaLendAmmAbi,
+  ...Erc20Abi
+];
+var ZERO = "0x0000000000000000000000000000000000000000";
+var fetchJson2 = async (url, timeoutMs = 8e3) => {
+  const res = await fetch(url, {
+    headers: { accept: "application/json" },
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  return res.json();
+};
+var num2 = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+var toBig5 = (v) => {
+  if (typeof v === "bigint") return v;
+  if (typeof v === "number" && Number.isFinite(v)) return BigInt(Math.trunc(v));
+  return null;
+};
+var human = (v, decimals) => v === null ? null : Number(v) / 10 ** decimals;
+var bandsFor = (m) => m.defaultBands && m.defaultBands >= 4 && m.defaultBands <= 50 ? m.defaultBands : DEFAULT_BANDS;
+var bandGrid = (m) => {
+  const set = /* @__PURE__ */ new Set([...BANDS_ENDPOINTS, bandsFor(m)]);
+  return [...set].sort((a, b) => a - b);
+};
+var maxBorrowableCall = (m, oneUnit, n) => m.version === 1 ? {
+  address: m.controller,
+  name: "max_borrowable",
+  params: [oneUnit, BigInt(n), 0n, ZERO]
+} : {
+  address: m.controller,
+  name: "max_borrowable",
+  params: [oneUnit, BigInt(n), ZERO]
+};
+var buildBandLtv = (perBand, borrowedDecimals, collateralPrice) => {
+  if (!collateralPrice || collateralPrice <= 0) return null;
+  const out = {};
+  for (const { n, maxBorrowable } of perBand) {
+    const borrowable = human(maxBorrowable, borrowedDecimals);
+    if (borrowable === null || borrowable <= 0) continue;
+    const ltv = borrowable / collateralPrice;
+    if (ltv > 0 && ltv <= 1) out[String(n)] = ltv;
+  }
+  return Object.keys(out).length > 0 ? out : null;
+};
+async function fetchChainExtras(chainId, markets) {
+  const perMarketCalls = markets.map((m) => {
+    const grid = bandGrid(m);
+    const oneUnit = 10n ** BigInt(m.collateralDecimals);
+    const calls = [
+      { address: m.amm, name: "price_oracle", params: [] },
+      { address: m.amm, name: "active_band", params: [] },
+      { address: m.controller, name: "n_loans", params: [] },
+      { address: m.vault, name: "maxDeposit", params: [ZERO] },
+      // v1 controllers have no `borrow_cap`; allowFailure turns that into a
+      // null rather than sinking the whole batch.
+      { address: m.controller, name: "borrow_cap", params: [] },
+      ...grid.map((n) => maxBorrowableCall(m, oneUnit, n))
+    ];
+    return { market: m, grid, calls };
+  });
+  const flat = perMarketCalls.flatMap((x) => x.calls);
+  if (flat.length === 0) return {};
+  let results;
+  try {
+    results = await multicallRetryUniversal({
+      chain: chainId,
+      calls: flat,
+      abi: LLAMALEND_READ_ABI,
+      allowFailure: true
+    });
+  } catch {
+    return {};
+  }
+  const out = {};
+  let cursor = 0;
+  for (const { market, grid } of perMarketCalls) {
+    const priceRaw = toBig5(results[cursor]);
+    const activeBandRaw = toBig5(results[cursor + 1]);
+    const nLoansRaw = toBig5(results[cursor + 2]);
+    const maxDepositRaw = toBig5(results[cursor + 3]);
+    const borrowCapRaw = toBig5(results[cursor + 4]);
+    const perBand = grid.map((n, i) => ({
+      n,
+      maxBorrowable: toBig5(results[cursor + 5 + i])
+    }));
+    cursor += 5 + grid.length;
+    const collateralPrice = priceRaw === null ? null : Number(priceRaw) / 1e18;
+    const bandLtv = buildBandLtv(
+      perBand,
+      market.borrowedDecimals,
+      collateralPrice
+    );
+    const defaultN = String(bandsFor(market));
+    out[market.controller.toLowerCase()] = {
+      collateralPrice,
+      bandLtv,
+      collateralFactor: bandLtv?.[defaultN] ?? null,
+      borrowCap: human(borrowCapRaw, market.borrowedDecimals),
+      maxDeposit: human(maxDepositRaw, market.borrowedDecimals),
+      nLoans: nLoansRaw === null ? null : Number(nLoansRaw),
+      activeBand: activeBandRaw === null ? null : Number(activeBandRaw)
+    };
+  }
+  return out;
+}
+var isBorrowingEnabled = (version, availableToBorrow, borrowCap, totalDebt) => {
+  const liquid = (availableToBorrow ?? 0) > 0;
+  if (version === 1) return liquid;
+  if (borrowCap === null) return liquid;
+  if (borrowCap <= 0) return false;
+  return liquid && (totalDebt ?? 0) < borrowCap;
+};
+async function fetchLlamaLendMarkets(lender, chainId) {
+  const config = llamaLendConfigFor(lender, chainId);
+  const chainData = llamaLendChainData(lender, chainId);
+  const markets = chainData?.markets ?? [];
+  const empty = {
+    lender,
+    config,
+    chainData,
+    markets: [],
+    source: "none"
+  };
+  if (!config || markets.length === 0) return empty;
+  const extrasPromise = fetchChainExtras(chainId, markets);
+  try {
+    const base = llamaLendApiBaseUrl(lender, chainId);
+    const api = await fetchJson2(`${base}/v1/getLendingVaults/all`);
+    const byController = {};
+    for (const row of api?.data?.lendingVaultData ?? []) {
+      const c = row?.controllerAddress;
+      if (c) byController[String(c).toLowerCase()] = row;
+    }
+    if (Object.keys(byController).length > 0) {
+      const extras = await extrasPromise;
+      const rows = markets.map((market) => {
+        const r = byController[market.controller.toLowerCase()];
+        const ex = extras[market.controller.toLowerCase()];
+        const totalDebt = num2(r?.borrowed?.total);
+        const availableToBorrow = num2(r?.availableToBorrow?.total);
+        return {
+          market,
+          totalDebt,
+          totalSupplied: num2(r?.totalSupplied?.total),
+          availableToBorrow,
+          // `borrowApr`/`lendApr` are the NOMINAL rates and match
+          // `Vault.borrow_apr()`/`lend_apr()`. The sibling `borrowApy` /
+          // `lendApy` fields are compounded — mixing them in would make this
+          // lender look systematically more expensive than its peers.
+          borrowApr: num2(r?.rates?.borrowApr),
+          lendApr: num2(r?.rates?.lendApr),
+          collateralPrice: ex?.collateralPrice ?? null,
+          collateralPriceUsd: num2(r?.assets?.collateral?.usdPrice),
+          borrowedPriceUsd: num2(r?.assets?.borrowed?.usdPrice),
+          collateralFactor: ex?.collateralFactor ?? null,
+          bandLtv: ex?.bandLtv ?? null,
+          borrowCap: ex?.borrowCap ?? null,
+          borrowingEnabled: isBorrowingEnabled(
+            market.version,
+            availableToBorrow,
+            ex?.borrowCap ?? null,
+            totalDebt
+          ),
+          maxDeposit: ex?.maxDeposit ?? null,
+          nLoans: ex?.nLoans ?? null,
+          activeBand: ex?.activeBand ?? null
+        };
+      });
+      return { lender, config, chainData, markets: rows, source: "api" };
+    }
+  } catch {
+  }
+  const READS_PER_MARKET4 = 5;
+  const calls = markets.flatMap((m) => [
+    { address: m.controller, name: "total_debt", params: [] },
+    { address: m.vault, name: "totalAssets", params: [] },
+    { address: m.vault, name: "borrow_apr", params: [] },
+    { address: m.vault, name: "lend_apr", params: [] },
+    // v2 tracks its own lent-out accounting; v1 has no such getter, so the
+    // controller's token balance IS the borrowable liquidity there.
+    m.version === 2 ? { address: m.controller, name: "available_balance", params: [] } : { address: m.borrowedToken, name: "balanceOf", params: [m.controller] }
+  ]);
+  try {
+    const results = await multicallRetryUniversal({
+      chain: chainId,
+      calls,
+      abi: LLAMALEND_READ_ABI,
+      allowFailure: true
+    });
+    const extras = await extrasPromise;
+    const rows = markets.map((market, i) => {
+      const b = i * READS_PER_MARKET4;
+      const ex = extras[market.controller.toLowerCase()];
+      const totalDebt = human(toBig5(results[b]), market.borrowedDecimals);
+      const availableToBorrow = human(
+        toBig5(results[b + 4]),
+        market.borrowedDecimals
+      );
+      const borrowAprRaw = toBig5(results[b + 2]);
+      const lendAprRaw = toBig5(results[b + 3]);
+      const collateralPrice = ex?.collateralPrice ?? null;
+      return {
+        market,
+        totalDebt,
+        totalSupplied: human(toBig5(results[b + 1]), market.borrowedDecimals),
+        availableToBorrow,
+        // Both getters are already annualised nominal rates, WAD-scaled.
+        borrowApr: borrowAprRaw === null ? null : Number(borrowAprRaw) / 1e18,
+        lendApr: lendAprRaw === null ? null : Number(lendAprRaw) / 1e18,
+        collateralPrice,
+        // No USD leg on-chain — the oracle prices collateral in the borrowed
+        // token only. The converter falls back to the global price oracle.
+        collateralPriceUsd: null,
+        borrowedPriceUsd: null,
+        collateralFactor: ex?.collateralFactor ?? null,
+        bandLtv: ex?.bandLtv ?? null,
+        borrowCap: ex?.borrowCap ?? null,
+        borrowingEnabled: isBorrowingEnabled(
+          market.version,
+          availableToBorrow,
+          ex?.borrowCap ?? null,
+          totalDebt
+        ),
+        maxDeposit: ex?.maxDeposit ?? null,
+        nLoans: ex?.nLoans ?? null,
+        activeBand: ex?.activeBand ?? null
+      };
+    });
+    return { lender, config, chainData, markets: rows, source: "chain" };
+  } catch {
+    return empty;
+  }
+}
+var VAULT_PRICE_ABI = [
+  {
+    name: "convertToAssets",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "shares", type: "uint256" }],
+    outputs: [{ type: "uint256" }]
+  }
+];
+var IDENTITY_READS = 3;
+var STATE_READS = 12;
+var ONE = 10n ** 18n;
+var identityCache = /* @__PURE__ */ new Map();
+var identityKey = (chainId, pair) => `${chainId}:${pair.toLowerCase()}`;
+var big = (v) => {
+  if (typeof v === "bigint") return v;
+  if (typeof v === "number") return BigInt(v);
+  return null;
+};
+async function fetchResupplyMarkets(lender, chainId) {
+  const config = resupplyConfigFor(lender, chainId);
+  if (!config?.registry) return { lender, config, pairs: [] };
+  let discovered = [];
+  try {
+    const [addresses] = await multicallRetryUniversal({
+      chain: chainId,
+      calls: [
+        { address: config.registry, name: "getAllPairAddresses", params: [] }
+      ],
+      abi: ResupplyRegistryAbi,
+      allowFailure: true
+    });
+    if (Array.isArray(addresses)) {
+      discovered = addresses.filter(
+        (a) => typeof a === "string" && a.startsWith("0x")
+      );
+    }
+  } catch {
+    return { lender, config, pairs: [] };
+  }
+  if (discovered.length === 0) return { lender, config, pairs: [] };
+  if (config.pairAllowlist && config.pairAllowlist.length > 0) {
+    const allow = new Set(config.pairAllowlist.map((p) => p.toLowerCase()));
+    discovered = discovered.filter((p) => allow.has(p.toLowerCase()));
+    if (discovered.length === 0) return { lender, config, pairs: [] };
+  }
+  const unknown = discovered.filter(
+    (p) => !identityCache.has(identityKey(chainId, p))
+  );
+  if (unknown.length > 0) {
+    const calls2 = unknown.flatMap((pair) => [
+      { address: pair, name: "name", params: [] },
+      { address: pair, name: "collateral", params: [] },
+      { address: pair, name: "underlying", params: [] }
+    ]);
+    let res = [];
+    try {
+      res = await multicallRetryUniversal({
+        chain: chainId,
+        calls: calls2,
+        abi: unknown.flatMap(() => [
+          ResupplyPairAbi,
+          ResupplyPairAbi,
+          ResupplyPairAbi
+        ]),
+        allowFailure: true
+      });
+    } catch {
+      return { lender, config, pairs: [] };
+    }
+    const pending = [];
+    unknown.forEach((pair, i) => {
+      const base = i * IDENTITY_READS;
+      const name = res[base];
+      const collateral = res[base + 1];
+      const underlying = res[base + 2];
+      if (typeof collateral !== "string" || !collateral.startsWith("0x") || typeof underlying !== "string" || !underlying.startsWith("0x")) {
+        return;
+      }
+      pending.push({
+        pair,
+        name: typeof name === "string" ? name : pair,
+        collateral,
+        underlying
+      });
+    });
+    if (pending.length > 0) {
+      let dec = [];
+      try {
+        dec = await multicallRetryUniversal({
+          chain: chainId,
+          calls: pending.flatMap((p) => [
+            { address: p.collateral, name: "decimals", params: [] },
+            { address: p.underlying, name: "decimals", params: [] }
+          ]),
+          abi: pending.flatMap(() => [erc20Abi, erc20Abi]),
+          allowFailure: true
+        });
+      } catch {
+        dec = [];
+      }
+      pending.forEach((p, i) => {
+        const cd = Number(dec[i * 2]);
+        const ud = Number(dec[i * 2 + 1]);
+        identityCache.set(identityKey(chainId, p.pair), {
+          pair: p.pair,
+          name: p.name,
+          collateral: p.collateral,
+          underlying: p.underlying,
+          collateralDecimals: Number.isFinite(cd) && cd > 0 ? cd : 18,
+          underlyingDecimals: Number.isFinite(ud) && ud > 0 ? ud : 18
+        });
+      });
+    }
+  }
+  const identities = discovered.map((p) => identityCache.get(identityKey(chainId, p))).filter((x) => !!x);
+  if (identities.length === 0) return { lender, config, pairs: [] };
+  const utilities = config.utilities;
+  const calls = [];
+  const abis = [];
+  for (const id of identities) {
+    calls.push(
+      { address: id.pair, name: "maxLTV", params: [] },
+      { address: id.pair, name: "borrowLimit", params: [] },
+      { address: id.pair, name: "liquidationFee", params: [] },
+      { address: id.pair, name: "mintFee", params: [] },
+      { address: id.pair, name: "minimumBorrowAmount", params: [] },
+      { address: id.pair, name: "getPairAccounting", params: [] },
+      { address: id.pair, name: "currentRateInfo", params: [] },
+      { address: id.pair, name: "exchangeRateInfo", params: [] },
+      // The collateral vault's own share price — the exact input Resupply's
+      // `BasicVaultOracle` uses. Read LIVE rather than inverting the pair's
+      // cached `exchangeRate`, which only moves when someone writes.
+      { address: id.collateral, name: "convertToAssets", params: [ONE] }
+    );
+    abis.push(
+      ResupplyPairAbi,
+      ResupplyPairAbi,
+      ResupplyPairAbi,
+      ResupplyPairAbi,
+      ResupplyPairAbi,
+      ResupplyPairAbi,
+      ResupplyPairAbi,
+      ResupplyPairAbi,
+      VAULT_PRICE_ABI
+    );
+    if (utilities) {
+      calls.push(
+        { address: utilities, name: "getPairInterestRate", params: [id.pair] },
+        {
+          address: utilities,
+          name: "getUnderlyingSupplyRate",
+          params: [id.pair]
+        },
+        { address: id.pair, name: "totalDebtAvailable", params: [] }
+      );
+      abis.push(ResupplyUtilitiesAbi, ResupplyUtilitiesAbi, ResupplyPairAbi);
+    } else {
+      calls.push(
+        { address: id.pair, name: "totalDebtAvailable", params: [] },
+        { address: id.pair, name: "totalDebtAvailable", params: [] },
+        { address: id.pair, name: "totalDebtAvailable", params: [] }
+      );
+      abis.push(ResupplyPairAbi, ResupplyPairAbi, ResupplyPairAbi);
+    }
+  }
+  const PAIRS_PER_BATCH = 6;
+  const results = [];
+  for (let i = 0; i < identities.length; i += PAIRS_PER_BATCH) {
+    const from = i * STATE_READS;
+    const to = Math.min(i + PAIRS_PER_BATCH, identities.length) * STATE_READS;
+    try {
+      const chunk7 = await multicallRetryUniversal({
+        chain: chainId,
+        calls: calls.slice(from, to),
+        abi: abis.slice(from, to),
+        allowFailure: true
+      });
+      results.push(...chunk7);
+    } catch {
+      results.push(...new Array(to - from).fill("0x"));
+    }
+  }
+  const pairs = identities.map((identity, i) => {
+    const base = i * STATE_READS;
+    const accounting = results[base + 5];
+    const rateInfo = results[base + 6];
+    const exchangeInfo = results[base + 7];
+    const tuple = (v, idx) => Array.isArray(v) ? big(v[idx]) : null;
+    return {
+      identity,
+      maxLTV: big(results[base]),
+      borrowLimit: big(results[base + 1]),
+      liquidationFee: big(results[base + 2]),
+      mintFee: big(results[base + 3]),
+      minimumBorrowAmount: big(results[base + 4]),
+      totalBorrowAmount: tuple(accounting, 1),
+      totalBorrowShares: tuple(accounting, 2),
+      totalCollateral: tuple(accounting, 3),
+      ratePerSec: tuple(rateInfo, 1),
+      exchangeRate: tuple(exchangeInfo, 2),
+      collateralPrice: big(results[base + 8]),
+      liveRatePerSec: utilities ? big(results[base + 9]) : null,
+      underlyingSupplyRatePerSec: utilities ? big(results[base + 10]) : null
+    };
+  });
+  return { lender, config, pairs };
+}
 
 // src/lending/public-data/inverse/convertPublic.ts
 function inverseLenderKey(lender, market) {
@@ -24124,8 +24596,13 @@ function convertInverseMarketsToResponse(raw, chainId, prices = {}, _additionalY
           liquidationFactorBps: market.liquidationFactorBps,
           /** Fixed borrow APR as a DECIMAL (DBR price in DOLA). */
           dbrPriceDola: raw.dbrPriceDola !== null ? String(raw.dbrPriceDola) : void 0,
-          /** Force-replenish penalty (5475 = 54.75% APR on missed DBR). */
+          /** Force-replenish penalty (5475 = 54.75% APR on missed DBR):
+           *  the DOLA debt added per 1 DBR minted back to the borrower. */
           replenishmentPriceBps: raw.replenishmentPriceBps !== null ? String(raw.replenishmentPriceBps) : void 0,
+          /** Replenisher bot's cut (1000 = 10%) — carved OUT of the cost
+           *  above and paid from market liquidity, NOT charged on top of
+           *  the borrower's debt. Bot-side economics (liquidation dashboard). */
+          replenishmentIncentiveBps: m.replenishmentIncentiveBps !== null ? String(m.replenishmentIncentiveBps) : void 0,
           borrowPaused: paused,
           addresses: {
             market: market.address,
@@ -24142,6 +24619,500 @@ function convertInverseMarketsToResponse(raw, chainId, prices = {}, _additionalY
   }
   return out;
 }
+
+// src/lending/public-data/llamalend/convertPublic.ts
+function llamaLendLenderKey(lender, controller) {
+  return `${lender}_${controller.replace(/^0x/i, "").toUpperCase()}`;
+}
+function llamaLendKeyParts(key) {
+  if (!key.startsWith("LLAMALEND_")) return void 0;
+  const suffix = key.slice("LLAMALEND_".length);
+  if (!/^[0-9A-F]{40}$/.test(suffix)) return void 0;
+  return { lender: "LLAMALEND", controller: "0x" + suffix.toLowerCase() };
+}
+function currencyFor9(address, decimals, symbol, tokens) {
+  const lower3 = address.toLowerCase();
+  return tokens[lower3] ?? { address: lower3, symbol, name: symbol, decimals };
+}
+function convertLlamaLendMarketsToResponse(raw, chainId, prices = {}, additionalYields = {
+  intrinsicYields: {},
+  lenderRewards: {},
+  loaded: true
+}, tokens = {}) {
+  const out = {};
+  const cfg = raw?.config;
+  if (!cfg) return out;
+  for (const m of raw.markets ?? []) {
+    const market = m.market;
+    const lenderKey = llamaLendLenderKey(raw.lender, market.controller);
+    const collAddr = market.collateralToken.toLowerCase();
+    const loanAddr = market.borrowedToken.toLowerCase();
+    const collDecimals = market.collateralDecimals;
+    const loanDecimals = market.borrowedDecimals;
+    const collToken = tokens[collAddr];
+    const loanToken = tokens[loanAddr];
+    const collSymbol = collToken?.symbol ?? market.collateralSymbol ?? "COLL";
+    const loanSymbol = loanToken?.symbol ?? market.borrowedSymbol ?? "LOAN";
+    const marketName = market.name ?? `${loanSymbol} / ${collSymbol}`;
+    const collPriceKey = toOracleKey(collToken?.assetGroup) || toGenericPriceKey(collAddr, chainId);
+    const loanPriceKey = toOracleKey(loanToken?.assetGroup) || toGenericPriceKey(loanAddr, chainId);
+    prices[collPriceKey] || m.collateralPriceUsd || 0;
+    const loanPrice = prices[loanPriceKey] || m.borrowedPriceUsd || 0;
+    const totalDebt = m.totalDebt ?? 0;
+    const totalDeposits = m.totalSupplied ?? 0;
+    const borrowLiquidity = m.borrowingEnabled ? m.availableToBorrow ?? 0 : 0;
+    const withdrawLiquidity = m.availableToBorrow ?? 0;
+    const reserves = totalDebt + (m.availableToBorrow ?? 0);
+    const utilization = reserves > 0 ? totalDebt / reserves : 0;
+    const borrowRatePct = (m.borrowApr ?? 0) * 100;
+    const depositRatePct = (m.lendApr ?? 0) * 100;
+    const ltv = m.collateralFactor ?? 0;
+    const liqPenalty = Number(market.liquidationDiscount) / 1e18 || 0;
+    const closeFactor = 1;
+    const depositsEnabled = (m.maxDeposit ?? 0) > 0;
+    const entry = { data: {} };
+    const collUid = createMarketUid(chainId, lenderKey, collAddr);
+    entry.data[collUid] = {
+      marketUid: collUid,
+      name: "Collateral " + collSymbol,
+      poolId: market.controller.toLowerCase(),
+      underlying: collAddr,
+      asset: currencyFor9(collAddr, collDecimals, collSymbol, tokens),
+      // Collateral lives inside the LLAMMA spread over bands; there is no
+      // single market-level balance worth reporting, and the number the UI
+      // needs is the borrowed side anyway.
+      totalDeposits: 0,
+      totalDebtStable: 0,
+      totalDebt: 0,
+      totalLiquidity: 0,
+      borrowLiquidity: 0,
+      totalLiquidityUSD: 0,
+      borrowLiquidityUSD: 0,
+      totalDepositsUSD: 0,
+      totalDebtStableUSD: 0,
+      totalDebtUSD: 0,
+      utilization: 0,
+      depositRate: 0,
+      variableBorrowRate: 0,
+      stableBorrowRate: 0,
+      intrinsicYield: additionalYields?.intrinsicYields?.[collToken?.assetGroup] ?? 0,
+      rewards: void 0,
+      decimals: collDecimals,
+      config: {
+        0: {
+          category: 0,
+          borrowCollateralFactor: ltv,
+          collateralFactor: ltv,
+          borrowFactor: 1,
+          liquidationPenalty: liqPenalty,
+          closeFactor,
+          collateralDisabled: false,
+          debtDisabled: true
+        }
+      },
+      closeFactor,
+      collateralActive: true,
+      borrowingEnabled: false,
+      depositsEnabled: m.borrowingEnabled,
+      hasStable: false,
+      isActive: true,
+      isFrozen: false
+    };
+    const loanUid = createMarketUid(chainId, lenderKey, loanAddr);
+    entry.data[loanUid] = {
+      marketUid: loanUid,
+      name: loanSymbol,
+      poolId: market.controller.toLowerCase(),
+      underlying: loanAddr,
+      asset: currencyFor9(loanAddr, loanDecimals, loanSymbol, tokens),
+      totalDeposits,
+      totalDebtStable: 0,
+      totalDebt,
+      totalLiquidity: withdrawLiquidity,
+      borrowLiquidity,
+      totalLiquidityUSD: withdrawLiquidity * loanPrice,
+      borrowLiquidityUSD: borrowLiquidity * loanPrice,
+      totalDepositsUSD: totalDeposits * loanPrice,
+      totalDebtStableUSD: 0,
+      totalDebtUSD: totalDebt * loanPrice,
+      utilization,
+      depositRate: depositRatePct,
+      variableBorrowRate: borrowRatePct,
+      stableBorrowRate: 0,
+      // Which curve the depth layer should use. Both are closed-form and both
+      // policies also expose an exact on-chain `future_rate`, so rate-at-depth
+      // never has to be modelled here.
+      rateModel: market.rateModel ?? (market.version === 1 ? "semilog" : "hyperbolic"),
+      intrinsicYield: additionalYields?.intrinsicYields?.[loanToken?.assetGroup] ?? 0,
+      rewards: additionalYields?.lenderRewards?.[lenderKey] ?? void 0,
+      decimals: loanDecimals,
+      config: {
+        0: {
+          category: 0,
+          borrowCollateralFactor: 0,
+          collateralFactor: 0,
+          borrowFactor: 1,
+          liquidationPenalty: liqPenalty,
+          closeFactor,
+          collateralDisabled: true,
+          debtDisabled: !m.borrowingEnabled
+        }
+      },
+      closeFactor,
+      collateralActive: false,
+      borrowingEnabled: m.borrowingEnabled,
+      depositsEnabled,
+      hasStable: false,
+      variableBorrowDisabled: !m.borrowingEnabled,
+      isActive: true,
+      isFrozen: false
+    };
+    entry.params = {
+      market: {
+        lender: lenderKey,
+        name: marketName,
+        loanDecimals,
+        collateralDecimals: collDecimals,
+        // The Controller doubles as the market id.
+        id: market.controller.toLowerCase(),
+        lltv: String(ltv),
+        oracle: market.priceOracle ?? market.amm,
+        irm: market.monetaryPolicy ?? zeroAddress,
+        collateralAddress: collAddr,
+        loanAddress: loanAddr,
+        // --- LlamaLend descriptor (consumed by the calldata builders,
+        // the leverage sizer and worker-api resolvers) ---
+        llamalend: {
+          /** 1 = `oneway` (v1), 2 = `oneway-v2`. Branch every encoder on this. */
+          version: market.version,
+          /** FAIL CLOSED — an unknown market is not delegatable. */
+          supportsDelegation: market.supportsDelegation === true,
+          /**
+           * The market's index in its factory — also the `controller_id` that
+           * Curve's leverage zap requires in `callback_args`. Without it no
+           * leveraged transaction can be encoded.
+           */
+          factoryIndex: market.factoryIndex,
+          /**
+           * Whether Curve's deployed v1 zap accepts this market. A WIDER gate
+           * than `supportsDelegation` — leverage is EOA-direct and needs no
+           * grant — so never conflate the two.
+           */
+          supportsLeverage: market.supportsLeverage === true,
+          /**
+           * Band count the reported `collateralFactor` was computed at. A
+           * consumer quoting a different `N` MUST re-read `bandLtv`.
+           */
+          defaultBands: market.defaultBands ?? 10,
+          /** `{ [N]: ltv }` — the collateral-factor curve across band counts. */
+          bandLtv: m.bandLtv ?? void 0,
+          /** AMM band-geometry parameter. */
+          ammA: market.ammA,
+          loanDiscount: market.loanDiscount,
+          /** HARD-liquidation bonus only; soft liquidation carries no penalty. */
+          liquidationDiscount: market.liquidationDiscount,
+          /**
+           * Positions soft-liquidate over a band RANGE rather than at a single
+           * price. `activeBand` says whether the market is currently
+           * converting anyone; the per-user range comes from `user_prices`.
+           */
+          activeBand: m.activeBand ?? void 0,
+          nLoans: m.nLoans ?? void 0,
+          /** Collateral price in BORROWED-token terms (the AMM's EMA oracle). */
+          collateralPrice: m.collateralPrice !== null ? String(m.collateralPrice) : void 0,
+          /** v2 only; `0` means borrowing is switched off. */
+          borrowCap: m.borrowCap !== null ? String(m.borrowCap) : void 0,
+          addresses: {
+            controller: market.controller,
+            vault: market.vault,
+            /**
+             * MUST be excluded from any leverage swap route — the Controller
+             * asserts this AMM's band state is unchanged across a callback,
+             * so a route through it reverts with no usable reason string.
+             */
+            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
+             * than deploying a callbacker: their router is an immutable with
+             * no allowlist, so arbitrary aggregator calldata is permitted.
+             *
+             * A quote MUST be checked against the matching `*Router` before
+             * encoding — the zap forwards mismatched calldata to its own
+             * router rather than rejecting it.
+             */
+            leverageZapOdos: cfg.leverageZapOdos,
+            leverageZapOdosRouter: cfg.leverageZapOdosRouter,
+            leverageZap1inch: cfg.leverageZap1inch,
+            leverageZap1inchRouter: cfg.leverageZap1inchRouter,
+            oneWayFactory: cfg.oneWayFactory,
+            lendFactory: cfg.lendFactory
+          }
+        }
+      }
+    };
+    entry.chainId = chainId;
+    out[lenderKey] = entry;
+  }
+  return out;
+}
+var llamaLendKey = (controller) => `LLAMALEND_${controller.replace(/^0x/i, "").toUpperCase()}`;
+function resolveWrappedMarket(chainId, collateralVault, pairName) {
+  const market = llamaLendMarketByVault("LLAMALEND", chainId, collateralVault);
+  if (market) {
+    return {
+      provider: "llamalend",
+      vault: collateralVault,
+      lender: llamaLendKey(market.controller),
+      controller: market.controller,
+      amm: market.amm,
+      version: market.version,
+      collateralSymbol: market.collateralSymbol
+    };
+  }
+  const isFraxlend = /fraxlend/i.test(pairName);
+  return {
+    provider: isFraxlend ? "fraxlend" : "unknown",
+    vault: collateralVault
+  };
+}
+function resupplyLenderKey(lender, chainId, pair) {
+  return `${lender}_${chainId}_${pair.replace(/^0x/i, "").toUpperCase()}`;
+}
+function resupplyKeyParts(key) {
+  if (!key.startsWith("RESUPPLY_")) return void 0;
+  const suffix = key.slice("RESUPPLY_".length);
+  const m = suffix.match(/^(\d+)_([0-9A-Fa-f]{40})$/);
+  if (!m) return void 0;
+  return {
+    lender: "RESUPPLY",
+    chainId: m[1],
+    pair: `0x${m[2].toLowerCase()}`
+  };
+}
+var SECONDS_PER_YEAR9 = 31536e3;
+var LTV_PRECISION = 1e5;
+var ONE2 = 10n ** 18n;
+function currencyFor10(address, decimals, symbol, tokens) {
+  const lower3 = address.toLowerCase();
+  return tokens[lower3] ?? { address: lower3, symbol, name: symbol, decimals };
+}
+function ratePerSecToApr(rate) {
+  if (rate === null) return 0;
+  return Number(rate) / 1e18 * SECONDS_PER_YEAR9 * 100;
+}
+function convertResupplyMarketsToResponse(raw, chainId, prices = {}, _additionalYields = {
+  intrinsicYields: {},
+  lenderRewards: {},
+  loaded: true
+}, tokens = {}) {
+  const out = {};
+  const cfg = raw?.config;
+  if (!cfg) return out;
+  const debtAddr = cfg.reusd.toLowerCase();
+  const debtDecimals = cfg.debtDecimals ?? 18;
+  const debtToken = tokens[debtAddr];
+  const debtSymbol = debtToken?.symbol ?? "reUSD";
+  const debtPriceKey = toOracleKey(debtToken?.assetGroup) || toGenericPriceKey(debtAddr, chainId);
+  const debtPrice = prices[debtPriceKey] || 1;
+  for (const p of raw.pairs ?? []) {
+    const id = p.identity;
+    if (p.maxLTV === null || p.borrowLimit === null) continue;
+    if (p.totalBorrowAmount === null || p.totalCollateral === null) continue;
+    if (p.collateralPrice === null || p.collateralPrice === 0n) continue;
+    const lenderKey = resupplyLenderKey(raw.lender, chainId, id.pair);
+    const collAddr = id.underlying.toLowerCase();
+    const collDecimals = id.underlyingDecimals;
+    const collToken = tokens[collAddr];
+    const collSymbol = collToken?.symbol ?? "COLL";
+    const collPriceKey = toOracleKey(collToken?.assetGroup) || toGenericPriceKey(collAddr, chainId);
+    const collPrice = prices[collPriceKey] || 1;
+    const shares = p.totalCollateral ?? 0n;
+    const sharePrice = p.collateralPrice ?? 0n;
+    const collUnderlyingRaw = sharePrice > 0n ? shares * sharePrice / ONE2 : 0n;
+    const totalColl = Number(collUnderlyingRaw) / 10 ** collDecimals;
+    const totalDebt = p.totalBorrowAmount !== null ? Number(p.totalBorrowAmount) / 10 ** debtDecimals : 0;
+    const borrowLimit = p.borrowLimit !== null ? Number(p.borrowLimit) / 10 ** debtDecimals : 0;
+    const borrowLiquidity = Math.max(borrowLimit - totalDebt, 0);
+    const halted = (p.borrowLimit ?? 0n) === 0n;
+    const wrappedMarket = resolveWrappedMarket(chainId, id.collateral, id.name);
+    const maxLtv = p.maxLTV !== null ? Number(p.maxLTV) / LTV_PRECISION : 0;
+    const liquidationPenalty = p.liquidationFee !== null ? Number(p.liquidationFee) / LTV_PRECISION : 0;
+    const mintFeePct = p.mintFee !== null ? Number(p.mintFee) / LTV_PRECISION * 100 : 0;
+    const borrowApr = ratePerSecToApr(p.liveRatePerSec ?? p.ratePerSec);
+    const collateralIntrinsicApr = ratePerSecToApr(p.underlyingSupplyRatePerSec);
+    const entry = { data: {} };
+    const collUid = createMarketUid(chainId, lenderKey, collAddr);
+    entry.data[collUid] = {
+      marketUid: collUid,
+      name: "Collateral " + collSymbol,
+      poolId: id.pair.toLowerCase(),
+      underlying: collAddr,
+      asset: currencyFor10(collAddr, collDecimals, collSymbol, tokens),
+      totalDeposits: totalColl,
+      totalDebtStable: 0,
+      totalDebt: 0,
+      totalLiquidity: totalColl,
+      borrowLiquidity: 0,
+      totalLiquidityUSD: totalColl * collPrice,
+      borrowLiquidityUSD: 0,
+      totalDepositsUSD: totalColl * collPrice,
+      totalDebtStableUSD: 0,
+      totalDebtUSD: 0,
+      utilization: 0,
+      depositRate: 0,
+      variableBorrowRate: 0,
+      stableBorrowRate: 0,
+      // The wrapped Curve Lend / Fraxlend supply rate — this collateral is a
+      // lending position and earns while it sits here.
+      intrinsicYield: collateralIntrinsicApr,
+      rewards: void 0,
+      decimals: collDecimals,
+      config: {
+        0: {
+          category: 0,
+          borrowCollateralFactor: maxLtv,
+          collateralFactor: maxLtv,
+          borrowFactor: 1,
+          liquidationPenalty,
+          // Liquidation takes the WHOLE position (`liquidate(borrower)` repays
+          // all of it) — there is no partial close.
+          closeFactor: 1,
+          collateralDisabled: false,
+          debtDisabled: true
+        }
+      },
+      closeFactor: 1,
+      collateralActive: true,
+      borrowingEnabled: false,
+      // Deposits stay open on a paused pair so positions can be topped up to
+      // avoid liquidation; only borrowing is stopped.
+      depositsEnabled: true,
+      hasStable: false,
+      isActive: !halted,
+      isFrozen: halted
+    };
+    const loanUid = createMarketUid(chainId, lenderKey, debtAddr);
+    entry.data[loanUid] = {
+      marketUid: loanUid,
+      name: debtSymbol,
+      poolId: id.pair.toLowerCase(),
+      underlying: debtAddr,
+      asset: currencyFor10(debtAddr, debtDecimals, debtSymbol, tokens),
+      totalDeposits: 0,
+      totalDebtStable: 0,
+      totalDebt,
+      totalLiquidity: borrowLiquidity,
+      borrowLiquidity,
+      totalLiquidityUSD: borrowLiquidity * debtPrice,
+      borrowLiquidityUSD: borrowLiquidity * debtPrice,
+      totalDepositsUSD: 0,
+      totalDebtStableUSD: 0,
+      totalDebtUSD: totalDebt * debtPrice,
+      // Against the governance-set debt ceiling, not a deposit base — there is
+      // no supply side to be utilized.
+      utilization: borrowLimit > 0 ? Math.min(totalDebt / borrowLimit, 1) : 0,
+      depositRate: 0,
+      variableBorrowRate: borrowApr,
+      stableBorrowRate: 0,
+      // Pinned to ~half the greater of {wrapped supply rate, sfrxUSD risk-free
+      // rate, floor}, then scaled by the reUSD off-peg weight. No utilization
+      // curve anywhere in the protocol.
+      rateModel: "protocolSet",
+      // `mintFee` is added to the debt at borrow time. Zero on every live pair,
+      // but it is governance-settable.
+      originationFee: mintFeePct,
+      intrinsicYield: 0,
+      rewards: void 0,
+      decimals: debtDecimals,
+      config: {
+        0: {
+          category: 0,
+          borrowCollateralFactor: 0,
+          collateralFactor: 0,
+          borrowFactor: 1,
+          liquidationPenalty,
+          closeFactor: 1,
+          collateralDisabled: true,
+          debtDisabled: halted
+        }
+      },
+      closeFactor: 1,
+      collateralActive: false,
+      borrowingEnabled: !halted,
+      depositsEnabled: false,
+      hasStable: false,
+      variableBorrowDisabled: halted,
+      isActive: !halted,
+      isFrozen: halted
+    };
+    entry.params = {
+      market: {
+        lender: lenderKey,
+        name: id.name,
+        loanDecimals: debtDecimals,
+        collateralDecimals: collDecimals,
+        id: id.pair.toLowerCase(),
+        lltv: p.maxLTV !== null ? p.maxLTV.toString() : "0",
+        // The oracle is the collateral vault's own `convertToAssets`; there is
+        // no external price feed contract to name.
+        oracle: zeroAddress,
+        irm: zeroAddress,
+        collateralAddress: collAddr,
+        loanAddress: debtAddr,
+        // --- Resupply descriptor (consumed by the calldata builders, the
+        // worker-api resolvers and the loop quoter) ---
+        resupply: {
+          pair: id.pair,
+          /** The ERC-4626 share the pair actually books as collateral. */
+          collateralVault: id.collateral,
+          collateralVaultDecimals: id.collateralDecimals,
+          /** What the user deposits/withdraws (crvUSD or frxUSD). */
+          underlying: id.underlying,
+          /**
+           * The EXTERNAL lending market this pair wraps. A Resupply position
+           * inherits that market's risk (bad debt there is bad debt here), so
+           * the link is first-class rather than a footnote. Resolved against
+           * our own LlamaLend roster by vault address where possible.
+           */
+          wrappedMarket,
+          /** `convertToAssets(1e18)` — UNDERLYING per 1e18 shares. ~1e15 for
+           *  Curve Lend vaults. Required to size any share-denominated arg. */
+          collateralPrice: (p.collateralPrice ?? 0n).toString(),
+          /** The pair's cached `1e36 / collateralPrice` (stale between writes). */
+          exchangeRate: (p.exchangeRate ?? 0n).toString(),
+          maxLTV: (p.maxLTV ?? 0n).toString(),
+          borrowLimit: (p.borrowLimit ?? 0n).toString(),
+          /** Hard floor per position — a smaller borrow, or a repay leaving
+           *  less than this, reverts. */
+          minimumBorrowAmount: (p.minimumBorrowAmount ?? 0n).toString(),
+          liquidationFee: (p.liquidationFee ?? 0n).toString(),
+          mintFee: (p.mintFee ?? 0n).toString(),
+          totalBorrowShares: (p.totalBorrowShares ?? 0n).toString(),
+          totalBorrowAmount: (p.totalBorrowAmount ?? 0n).toString(),
+          totalCollateralShares: (p.totalCollateral ?? 0n).toString(),
+          borrowRatePerSecond: (p.liveRatePerSec ?? p.ratePerSec ?? 0n).toString(),
+          underlyingSupplyRatePerSecond: (p.underlyingSupplyRatePerSec ?? 0n).toString(),
+          /** Zero borrow limit = paused by governance (no `isPaused` exists). */
+          paused: halted,
+          addresses: {
+            registry: cfg.registry,
+            reusd: cfg.reusd,
+            utilities: cfg.utilities ?? void 0,
+            curveSwapper: cfg.curveSwapper ?? void 0,
+            ensoSwapper: cfg.ensoSwapper ?? void 0,
+            lifiSwapper: cfg.lifiSwapper ?? void 0
+          }
+        }
+      }
+    };
+    entry.chainId = chainId;
+    out[lenderKey] = entry;
+  }
+  return out;
+}
 var READS_PER_ILK = 4;
 var USDD_ABI_PER_READ = [UsddVatAbi, UsddJugAbi, UsddSpotAbi, erc20Abi];
 var usddIlkBytes32 = (ilk) => stringToHex(ilk, { size: 32 });
@@ -24172,12 +25143,12 @@ async function fetchUsddMarkets(lender, chainId) {
   } catch {
     return { lender, config, chainData, markets: [] };
   }
-  const big9 = (v) => {
+  const big13 = (v) => {
     if (typeof v === "bigint") return v;
     if (typeof v === "number") return BigInt(v);
     return null;
   };
-  const field12 = (res, name, idx) => big9(res?.[name] ?? res?.[idx]);
+  const field12 = (res, name, idx) => big13(res?.[name] ?? res?.[idx]);
   const out = markets.map((market, i) => {
     const base = i * READS_PER_ILK;
     const vatIlk = results[base];
@@ -24192,7 +25163,7 @@ async function fetchUsddMarkets(lender, chainId) {
       dust: field12(vatIlk, "dust", 4),
       duty: field12(jugIlk, "duty", 0),
       mat: field12(spotIlk, "mat", 1),
-      joinBalance: big9(results[base + 3])
+      joinBalance: big13(results[base + 3])
     };
   });
   return { lender, config, chainData, markets: out };
@@ -24216,7 +25187,7 @@ var YEAR_SECONDS2 = 31536e3;
 function toHuman4(raw, decimals) {
   return Number(raw) / 10 ** decimals;
 }
-function currencyFor9(address, decimals, symbol, tokens) {
+function currencyFor11(address, decimals, symbol, tokens) {
   const lower3 = address.toLowerCase();
   return tokens[lower3] ?? { address: lower3, symbol, name: symbol, decimals };
 }
@@ -24264,7 +25235,7 @@ function convertUsddMarketsToResponse(raw, chainId, prices = {}, _additionalYiel
       name: "Collateral " + collSymbol,
       poolId: market.gemJoin.toLowerCase(),
       underlying: collAddr,
-      asset: currencyFor9(collAddr, collDecimals, collSymbol, tokens),
+      asset: currencyFor11(collAddr, collDecimals, collSymbol, tokens),
       totalDeposits: totalColl,
       totalDebtStable: 0,
       totalDebt: 0,
@@ -24308,7 +25279,7 @@ function convertUsddMarketsToResponse(raw, chainId, prices = {}, _additionalYiel
       name: debtSymbol,
       poolId: cfg.vat.toLowerCase(),
       underlying: debtAddr,
-      asset: currencyFor9(debtAddr, debtDecimals, debtSymbol, tokens),
+      asset: currencyFor11(debtAddr, debtDecimals, debtSymbol, tokens),
       totalDeposits: 0,
       totalDebtStable: 0,
       totalDebt,
@@ -24400,6 +25371,304 @@ function convertUsddMarketsToResponse(raw, chainId, prices = {}, _additionalYiel
   }
   return out;
 }
+var READS_PER_MARKET3 = 10;
+var FRANKENCOIN_ABI_PER_READ = [
+  FrankencoinPositionAbi,
+  FrankencoinPositionAbi,
+  FrankencoinPositionAbi,
+  FrankencoinPositionAbi,
+  FrankencoinPositionAbi,
+  FrankencoinPositionAbi,
+  FrankencoinPositionAbi,
+  FrankencoinPositionAbi,
+  FrankencoinPositionAbi,
+  erc20Abi
+];
+async function fetchFrankencoinMarkets(lender, chainId) {
+  const config = frankencoinConfigFor(lender, chainId);
+  const chainData = frankencoinChainData(lender, chainId);
+  const markets = chainData?.markets ?? [];
+  if (!config || markets.length === 0) {
+    return { lender, config, chainData, markets: [] };
+  }
+  const calls = markets.flatMap((m) => [
+    { address: m.position, name: "price", params: [] },
+    { address: m.position, name: "minted", params: [] },
+    { address: m.position, name: "availableForClones", params: [] },
+    { address: m.position, name: "annualInterestPPM", params: [] },
+    { address: m.position, name: "calculateCurrentFee", params: [] },
+    { address: m.position, name: "reserveContribution", params: [] },
+    { address: m.position, name: "challengedAmount", params: [] },
+    { address: m.position, name: "expiration", params: [] },
+    // Read LIVE rather than trusting the generator's snapshot: a position
+    // can close between metadata runs (and dropping below
+    // `minimumCollateral` closes one permanently), and publishing a dead
+    // market as borrowable is the worst failure mode here.
+    { address: m.position, name: "isClosed", params: [] },
+    { address: m.collToken, name: "balanceOf", params: [m.position] }
+  ]);
+  let results = [];
+  try {
+    results = await multicallRetryUniversal({
+      chain: chainId,
+      calls,
+      abi: markets.flatMap(() => FRANKENCOIN_ABI_PER_READ),
+      allowFailure: true
+    });
+  } catch {
+    return { lender, config, chainData, markets: [] };
+  }
+  const big13 = (v) => {
+    if (typeof v === "bigint") return v;
+    if (typeof v === "number") return BigInt(v);
+    return null;
+  };
+  const out = markets.map((market, i) => {
+    const base = i * READS_PER_MARKET3;
+    const expiration = big13(results[base + 7]);
+    return {
+      market,
+      price: big13(results[base]),
+      minted: big13(results[base + 1]),
+      availableForClones: big13(results[base + 2]),
+      annualInterestPPM: big13(results[base + 3]),
+      currentFeePPM: big13(results[base + 4]),
+      reserveContribution: big13(results[base + 5]),
+      challengedAmount: big13(results[base + 6]),
+      expiration,
+      isClosed: typeof results[base + 8] === "boolean" ? results[base + 8] : null,
+      collateralBalance: big13(results[base + 9])
+    };
+  });
+  return { lender, config, chainData, markets: out };
+}
+
+// src/lending/public-data/frankencoin/convertPublic.ts
+function frankencoinLenderKey(lender, chainId, position) {
+  return `${lender}_${chainId}_${position.replace(/^0x/i, "").toUpperCase()}`;
+}
+function frankencoinKeyParts(key) {
+  if (!key.startsWith("FRANKENCOIN_")) return void 0;
+  const suffix = key.slice("FRANKENCOIN_".length);
+  const m = suffix.match(/^(\d+)_([0-9A-Fa-f]{40})$/);
+  if (!m) return void 0;
+  return {
+    lender: "FRANKENCOIN",
+    chainId: m[1],
+    position: `0x${m[2].toLowerCase()}`
+  };
+}
+var PPM = 1e6;
+function currencyFor12(address, decimals, symbol, tokens) {
+  const lower3 = address.toLowerCase();
+  return tokens[lower3] ?? { address: lower3, symbol, name: symbol, decimals };
+}
+function convertFrankencoinMarketsToResponse(raw, chainId, prices = {}, _additionalYields = {
+  intrinsicYields: {},
+  lenderRewards: {},
+  loaded: true
+}, tokens = {}) {
+  const out = {};
+  const cfg = raw?.config;
+  const chainData = raw?.chainData;
+  if (!cfg || !chainData) return out;
+  const debtAddr = cfg.zchf.toLowerCase();
+  const debtDecimals = cfg.debtDecimals ?? 18;
+  const debtToken = tokens[debtAddr];
+  const debtSymbol = debtToken?.symbol ?? "ZCHF";
+  const debtPriceKey = toOracleKey(debtToken?.assetGroup) || toGenericPriceKey(debtAddr, chainId);
+  const debtPrice = prices[debtPriceKey] ?? 0;
+  const nowSec9 = Math.floor(Date.now() / 1e3);
+  for (const m of raw.markets ?? []) {
+    const market = m.market;
+    const lenderKey = frankencoinLenderKey(raw.lender, chainId, market.position);
+    const collAddr = market.collToken.toLowerCase();
+    const collDecimals = market.collDecimals;
+    const collToken = tokens[collAddr];
+    const collSymbol = collToken?.symbol ?? market.collSymbol ?? "COLL";
+    const marketName = market.name ?? `${debtSymbol} / ${collSymbol}`;
+    const collPriceKey = toOracleKey(collToken?.assetGroup) || toGenericPriceKey(collAddr, chainId);
+    const collPrice = prices[collPriceKey] ?? 0;
+    const declaredPrice = m.price !== null ? Number(m.price) / 10 ** (36 - collDecimals) : Number(market.price) / 10 ** (36 - collDecimals);
+    const totalColl = m.collateralBalance !== null ? Number(m.collateralBalance) / 10 ** collDecimals : 0;
+    const totalDebt = m.minted !== null ? Number(m.minted) / 10 ** debtDecimals : 0;
+    const borrowLiquidity = m.availableForClones !== null ? Number(m.availableForClones) / 10 ** debtDecimals : 0;
+    const expiration = m.expiration !== null ? Number(m.expiration) : Number(market.expiration);
+    const expired = expiration > 0 && expiration <= nowSec9;
+    const challenged = (m.challengedAmount ?? 0n) > 0n;
+    const closed = m.isClosed === true;
+    const halted = expired || closed;
+    const borrowApr = m.annualInterestPPM !== null ? Number(m.annualInterestPPM) / PPM * 100 : 0;
+    const upfrontFeePct = m.currentFeePPM !== null ? Number(m.currentFeePPM) / PPM * 100 : 0;
+    const reserveContributionPpm = m.reserveContribution !== null ? Number(m.reserveContribution) : Number(market.reserveContribution);
+    const ltvVsMarket = collPrice > 0 ? Math.min(declaredPrice / collPrice, 1) : 0;
+    const declaredVsMarket = collPrice > 0 ? declaredPrice / collPrice : void 0;
+    const entry = { data: {} };
+    const collUid = createMarketUid(chainId, lenderKey, collAddr);
+    entry.data[collUid] = {
+      marketUid: collUid,
+      name: "Collateral " + collSymbol,
+      poolId: market.position.toLowerCase(),
+      underlying: collAddr,
+      asset: currencyFor12(collAddr, collDecimals, collSymbol, tokens),
+      totalDeposits: totalColl,
+      totalDebtStable: 0,
+      totalDebt: 0,
+      totalLiquidity: totalColl,
+      borrowLiquidity: 0,
+      totalLiquidityUSD: totalColl * collPrice,
+      borrowLiquidityUSD: 0,
+      totalDepositsUSD: totalColl * collPrice,
+      totalDebtStableUSD: 0,
+      totalDebtUSD: 0,
+      utilization: 0,
+      depositRate: 0,
+      variableBorrowRate: 0,
+      stableBorrowRate: 0,
+      intrinsicYield: 0,
+      rewards: void 0,
+      decimals: collDecimals,
+      config: {
+        0: {
+          category: 0,
+          borrowCollateralFactor: ltvVsMarket,
+          collateralFactor: ltvVsMarket,
+          borrowFactor: 1,
+          // Liquidation is a Dutch auction against the declared price, not a
+          // fixed penalty; the challenger reward (2 %) is the closest
+          // bounded cost and is carried in the descriptor.
+          liquidationPenalty: 0,
+          closeFactor: 1,
+          collateralDisabled: false,
+          debtDisabled: true
+        }
+      },
+      closeFactor: 1,
+      collateralActive: true,
+      borrowingEnabled: false,
+      depositsEnabled: !halted,
+      hasStable: false,
+      isActive: !halted,
+      isFrozen: halted
+    };
+    const loanUid = createMarketUid(chainId, lenderKey, debtAddr);
+    entry.data[loanUid] = {
+      marketUid: loanUid,
+      name: debtSymbol,
+      poolId: cfg.mintingHub.toLowerCase(),
+      underlying: debtAddr,
+      asset: currencyFor12(debtAddr, debtDecimals, debtSymbol, tokens),
+      totalDeposits: 0,
+      totalDebtStable: 0,
+      totalDebt,
+      totalLiquidity: borrowLiquidity,
+      borrowLiquidity,
+      totalLiquidityUSD: borrowLiquidity * debtPrice,
+      borrowLiquidityUSD: borrowLiquidity * debtPrice,
+      totalDepositsUSD: 0,
+      totalDebtStableUSD: 0,
+      totalDebtUSD: totalDebt * debtPrice,
+      utilization: 0,
+      // The earn side is the savings module (savings provider), not a
+      // lending deposit.
+      depositRate: 0,
+      variableBorrowRate: borrowApr,
+      stableBorrowRate: 0,
+      // Per-position fixed rate (hub lead rate + risk premium) — no
+      // utilization curve anywhere in the protocol.
+      rateModel: "protocolSet",
+      // One-off, pro-rata to expiry, charged at mint out of the proceeds.
+      originationFee: upfrontFeePct,
+      intrinsicYield: 0,
+      rewards: void 0,
+      decimals: debtDecimals,
+      config: {
+        0: {
+          category: 0,
+          borrowCollateralFactor: 0,
+          collateralFactor: 0,
+          borrowFactor: 1,
+          liquidationPenalty: 0,
+          closeFactor: 1,
+          collateralDisabled: true,
+          debtDisabled: halted
+        }
+      },
+      closeFactor: 1,
+      collateralActive: false,
+      borrowingEnabled: !halted && !challenged,
+      depositsEnabled: false,
+      hasStable: false,
+      variableBorrowDisabled: halted || challenged,
+      isActive: !halted,
+      isFrozen: halted
+    };
+    entry.params = {
+      market: {
+        lender: lenderKey,
+        name: marketName,
+        loanDecimals: debtDecimals,
+        collateralDecimals: collDecimals,
+        // The original position doubles as the market id.
+        id: market.position.toLowerCase(),
+        lltv: m.price !== null ? m.price.toString() : market.price,
+        // There is no oracle contract — deliberately zero, with the
+        // declared price carried below.
+        oracle: zeroAddress,
+        irm: zeroAddress,
+        collateralAddress: collAddr,
+        loanAddress: debtAddr,
+        // --- Frankencoin descriptor (consumed by the calldata builders,
+        // worker-api resolvers and any quote layer) ---
+        frankencoin: {
+          position: market.position,
+          /** Owner-DECLARED liquidation price (raw, 36-dec scaled). */
+          declaredPrice: m.price !== null ? m.price.toString() : market.price,
+          /** Same, as ZCHF per whole collateral unit. */
+          declaredPriceHuman: declaredPrice,
+          /** `declaredPrice / marketPrice`, UNCLAMPED — the liquidation
+           *  signal. `>= 1` means the collateral can no longer be sold at
+           *  the declared price, so a challenge would succeed. `undefined`
+           *  when we have no market price for the collateral. This is NOT
+           *  the health factor: our HF is `mintingCapacity / minted` (the
+           *  protocol's own `minted <= coll * price` invariant), which
+           *  answers "can I borrow more", not "am I liquidatable". */
+          declaredVsMarket,
+          /** True when the declared price has been reached or passed and a
+           *  challenge would therefore clear. Undefined without a market
+           *  price. */
+          challengeable: declaredVsMarket === void 0 ? void 0 : declaredVsMarket >= 1,
+          /** ppm withheld into the FPS equity reserve at mint. */
+          reserveContributionPPM: String(reserveContributionPpm),
+          /** ppm one-off upfront interest for minting now. */
+          upfrontFeePPM: m.currentFeePPM !== null ? m.currentFeePPM.toString() : void 0,
+          annualInterestPPM: m.annualInterestPPM !== null ? m.annualInterestPPM.toString() : void 0,
+          riskPremiumPPM: market.riskPremiumPPM,
+          minimumCollateral: market.minimumCollateral,
+          expiration: String(expiration),
+          expired,
+          closed,
+          challengePeriod: market.challengePeriod,
+          challengedAmount: m.challengedAmount !== null ? m.challengedAmount.toString() : void 0,
+          isChallenged: challenged,
+          /** ppm reward paid to a successful challenger (hub constant). */
+          challengerRewardPPM: "20000",
+          version: market.version ?? 2,
+          addresses: {
+            mintingHub: cfg.mintingHub,
+            zchf: cfg.zchf,
+            equity: cfg.equity,
+            roller: cfg.roller,
+            chfUsdFeed: cfg.chfUsdFeed
+          }
+        }
+      }
+    };
+    entry.chainId = chainId;
+    out[lenderKey] = entry;
+  }
+  return out;
+}
 
 // src/lending/public-data/silo-v2/fetchPublic.ts
 var BASE_URL2 = "https://api-v3.silo.finance";
@@ -25009,8 +26278,12 @@ async function getLenderDataFromApi(lender, chainId, prices, additionalYields, i
   if (isRiver(lender)) return await fetchRiverMarkets(lender, chainId);
   if (isTeller(lender)) return await fetchTellerMarkets(chainId);
   if (isInverse(lender)) return await fetchInverseMarkets(lender, chainId);
+  if (isLlamaLend(lender)) return await fetchLlamaLendMarkets(lender, chainId);
+  if (isResupply(lender)) return await fetchResupplyMarkets(lender, chainId);
   if (isTermMax(lender)) return await fetchTermMaxMarkets(chainId);
   if (isUsdd(lender)) return await fetchUsddMarkets(lender, chainId);
+  if (isFrankencoin(lender))
+    return await fetchFrankencoinMarkets(lender, chainId);
   return {};
 }
 function convertLenderDataFromApi(lender, chainId, data, prices, additionalYields, list = {}) {
@@ -25072,6 +26345,30 @@ function convertLenderDataFromApi(lender, chainId, data, prices, additionalYield
       additionalYields,
       list
     );
+  if (isLlamaLend(lender))
+    return convertLlamaLendMarketsToResponse(
+      data,
+      chainId,
+      prices,
+      additionalYields,
+      list
+    );
+  if (isResupply(lender))
+    return convertResupplyMarketsToResponse(
+      data,
+      chainId,
+      prices,
+      additionalYields,
+      list
+    );
+  if (isFrankencoin(lender))
+    return convertFrankencoinMarketsToResponse(
+      data,
+      chainId,
+      prices,
+      additionalYields,
+      list
+    );
   if (isUsdd(lender))
     return convertUsddMarketsToResponse(
       data,
@@ -25289,7 +26586,10 @@ function lenderApiOnly(lender, chainId) {
   if (isTeller(lender)) return true;
   if (isInverse(lender)) return true;
   if (isTermMax(lender)) return true;
+  if (isResupply(lender)) return true;
   if (isUsdd(lender)) return true;
+  if (isFrankencoin(lender)) return true;
+  if (isLlamaLend(lender)) return true;
   return false;
 }
 function lenderApiWithOnChainFallback(lender, chainId) {
@@ -26441,8 +27741,22 @@ var buildRiverUserCall = (chainId, lender, account) => {
   });
   return calls;
 };
+var LLAMALEND_CALLS_PER_MARKET = 5;
+var buildLlamaLendUserCall = (chainId, lender, account, spender) => {
+  const cfg = llamaLendConfigFor(lender, chainId);
+  const markets = llamaLendChainData(lender, chainId)?.markets ?? [];
+  if (!cfg || markets.length === 0) return [];
+  const delegate = account;
+  return markets.flatMap((m) => [
+    { address: m.controller, name: "user_state", params: [account] },
+    { address: m.controller, name: "health", params: [account, true] },
+    { address: m.controller, name: "user_prices", params: [account] },
+    { address: m.amm, name: "read_user_tick_numbers", params: [account] },
+    { address: m.controller, name: "approval", params: [account, delegate] }
+  ]);
+};
 var INVERSE_CALLS_PER_MARKET = 4;
-var INVERSE_TAIL_CALLS = 3;
+var INVERSE_TAIL_CALLS = 4;
 var proxyInitCode = (impl) => concat([
   "0x3d602d80600a3d3981f3363d3d373d3d3d363d73",
   impl,
@@ -26477,21 +27791,136 @@ var buildInverseUserCall = (chainId, lender, account) => {
   calls.push(
     { address: cfg.dbr, name: "balanceOf", params: [account] },
     { address: cfg.dbr, name: "deficitOf", params: [account] },
-    { address: cfg.dbr, name: "signedBalanceOf", params: [account] }
+    { address: cfg.dbr, name: "signedBalanceOf", params: [account] },
+    { address: cfg.dbr, name: "debts", params: [account] }
   );
   return calls;
 };
+var RESUPPLY_CALLS_PER_PAIR = 2;
+var ONE3 = 10n ** 18n;
+var ROSTER_TTL_MS = 5 * 6e4;
+var DISCOVERY_TTL_MS = 6e4;
+var SNAPSHOT_CHUNK = 12;
+var rosterCache = /* @__PURE__ */ new Map();
+var discoveryCache2 = /* @__PURE__ */ new Map();
+var rosterKey = (chainId, lender) => `${chainId}:${lender}`;
+var discoveryKey = (chainId, lender, account) => `${chainId}:${lender}:${account.toLowerCase()}`;
+var getCachedResupplyDiscovery = (chainId, lender, account) => discoveryCache2.get(discoveryKey(chainId, lender, account));
+var fetchRoster = async (chainId, lender, registry, allowlist) => {
+  const cached = rosterCache.get(rosterKey(chainId, lender));
+  if (cached && Date.now() - cached.at < ROSTER_TTL_MS) return cached;
+  let addresses = [];
+  const [raw] = await multicallRetryUniversal({
+    chain: chainId,
+    calls: [{ address: registry, name: "getAllPairAddresses", params: [] }],
+    abi: ResupplyRegistryAbi,
+    allowFailure: true
+  });
+  if (Array.isArray(raw)) {
+    addresses = raw.filter(
+      (a) => typeof a === "string" && a.startsWith("0x")
+    );
+  }
+  if (allowlist && allowlist.length > 0) {
+    const allow = new Set(allowlist.map((p) => p.toLowerCase()));
+    addresses = addresses.filter((p) => allow.has(p.toLowerCase()));
+  }
+  if (addresses.length === 0) {
+    const empty = { pairs: [], at: Date.now() };
+    rosterCache.set(rosterKey(chainId, lender), empty);
+    return empty;
+  }
+  const cols = await multicallRetryUniversal({
+    chain: chainId,
+    calls: addresses.map((pair) => ({
+      address: pair,
+      name: "collateral",
+      params: []
+    })),
+    abi: addresses.map(() => ResupplyPairAbi),
+    allowFailure: true
+  });
+  const pairs = addresses.map((pair, i) => ({ pair, collateral: cols[i] })).filter(
+    (p) => typeof p.collateral === "string" && p.collateral.startsWith("0x")
+  );
+  const roster = { pairs, at: Date.now() };
+  rosterCache.set(rosterKey(chainId, lender), roster);
+  return roster;
+};
+var discoverPositions = async (chainId, pairs, account) => {
+  const active = [];
+  for (let i = 0; i < pairs.length; i += SNAPSHOT_CHUNK) {
+    const slice2 = pairs.slice(i, i + SNAPSHOT_CHUNK);
+    let res = [];
+    try {
+      res = await multicallRetryUniversal({
+        chain: chainId,
+        calls: slice2.map((p) => ({
+          address: p.pair,
+          name: "getUserSnapshot",
+          params: [account]
+        })),
+        abi: slice2.map(() => ResupplyPairAbi),
+        allowFailure: true
+      });
+    } catch {
+      continue;
+    }
+    slice2.forEach((p, j) => {
+      const snap = res[j];
+      if (!Array.isArray(snap)) return;
+      const borrowShares = typeof snap[0] === "bigint" ? snap[0] : 0n;
+      const collateralShares = typeof snap[1] === "bigint" ? snap[1] : 0n;
+      if (borrowShares === 0n && collateralShares === 0n) return;
+      active.push({ ...p, borrowShares, collateralShares });
+    });
+  }
+  return active;
+};
+var buildResupplyUserCall = async (chainId, lender, account) => {
+  const cfg = resupplyConfigFor(lender, chainId);
+  const key = discoveryKey(chainId, lender, account);
+  const stash = (positions2) => discoveryCache2.set(key, { positions: positions2, at: Date.now() });
+  if (!cfg?.registry) {
+    stash([]);
+    return [];
+  }
+  let roster;
+  try {
+    roster = await fetchRoster(chainId, lender, cfg.registry, cfg.pairAllowlist);
+  } catch {
+    return [];
+  }
+  if (roster.pairs.length === 0) {
+    stash([]);
+    return [];
+  }
+  const cachedDiscovery = discoveryCache2.get(key);
+  const positions = cachedDiscovery && Date.now() - cachedDiscovery.at < DISCOVERY_TTL_MS ? cachedDiscovery.positions : await discoverPositions(chainId, roster.pairs, account);
+  stash(positions);
+  if (positions.length === 0) return [];
+  return positions.flatMap(({ pair, collateral }) => [
+    // Totals with interest previewed — the denominator for the share→amount
+    // conversion the parser does locally.
+    { address: pair, name: "getPairAccounting", params: [] },
+    { address: collateral, name: "convertToAssets", params: [ONE3] }
+  ]);
+};
+function __resetResupplyUserCaches() {
+  rosterCache.clear();
+  discoveryCache2.clear();
+}
 var USDD_CALLS_PER_CDP = 1;
 var MAX_CDP_WALK = 64;
 var CACHE_TTL_MS2 = 5 * 6e4;
-var discoveryCache2 = /* @__PURE__ */ new Map();
+var discoveryCache3 = /* @__PURE__ */ new Map();
 var cacheKey2 = (chainId, account) => `${chainId}:${account.toLowerCase()}`;
 var getCachedUsddCdps = (chainId, account) => {
-  const hit = discoveryCache2.get(cacheKey2(chainId, account));
+  const hit = discoveryCache3.get(cacheKey2(chainId, account));
   if (!hit || Date.now() - hit.at > CACHE_TTL_MS2) return void 0;
   return hit;
 };
-var big = (v) => {
+var big2 = (v) => {
   try {
     if (typeof v === "bigint") return v;
     if (typeof v === "number" || typeof v === "string") return BigInt(v);
@@ -26503,7 +27932,7 @@ var field6 = (res, name, idx) => res?.[name] ?? res?.[idx];
 var buildUsddUserCall = async (chainId, lender, account) => {
   const cfg = usddConfigFor(lender, chainId);
   const markets = usddChainData(lender, chainId)?.markets ?? [];
-  const stash = (d) => discoveryCache2.set(cacheKey2(chainId, account), d);
+  const stash = (d) => discoveryCache3.set(cacheKey2(chainId, account), d);
   if (!cfg || markets.length === 0) {
     stash({ cdps: [], ilks: [], at: Date.now() });
     return [];
@@ -26522,7 +27951,7 @@ var buildUsddUserCall = async (chainId, lender, account) => {
       ],
       allowFailure: false
     });
-    owners.push({ owner: account, count: big(rawCount), cursor: big(rawFirst) });
+    owners.push({ owner: account, count: big2(rawCount), cursor: big2(rawFirst) });
     const proxy = String(rawProxy ?? zero);
     if (proxy.toLowerCase() !== zero) {
       const [pCount, pFirst] = await multicallRetryUniversal({
@@ -26534,7 +27963,7 @@ var buildUsddUserCall = async (chainId, lender, account) => {
         ],
         allowFailure: false
       });
-      owners.push({ owner: proxy, count: big(pCount), cursor: big(pFirst) });
+      owners.push({ owner: proxy, count: big2(pCount), cursor: big2(pFirst) });
     }
   } catch {
     return [];
@@ -26575,7 +28004,7 @@ var buildUsddUserCall = async (chainId, lender, account) => {
         if (curated.has(ilk)) {
           cdps.push({ cdpId: cursor.toString(), urn: String(urn), ilk });
         }
-        cursor = big(field6(link, "next", 1));
+        cursor = big2(field6(link, "next", 1));
       }
     }
   } catch {
@@ -26598,12 +28027,83 @@ var buildUsddUserCall = async (chainId, lender, account) => {
   }
   return calls;
 };
+var FRANKENCOIN_CALLS_PER_POSITION = 6;
+var BOOK_TTL_MS = 5 * 6e4;
+var DISCOVERY_TTL_MS2 = 5 * 6e4;
+var API_BASE = "https://api.frankencoin.com";
+var bookCache;
+var fetchBook = async () => {
+  if (bookCache && Date.now() - bookCache.at < BOOK_TTL_MS) {
+    return bookCache.entries;
+  }
+  const res = await fetch(`${API_BASE}/positions/open`, {
+    headers: { Accept: "application/json" }
+  });
+  if (!res.ok) throw new Error(`frankencoin book: ${res.status}`);
+  const data = await res.json();
+  const entries = Object.values(data?.map ?? {}).map((p) => ({
+    position: String(p.position).toLowerCase(),
+    owner: String(p.owner).toLowerCase(),
+    // An original is its own parent.
+    original: String(p.original ?? p.position).toLowerCase(),
+    version: Number(p.version),
+    closed: !!p.closed,
+    denied: !!p.denied
+  }));
+  bookCache = { at: Date.now(), entries };
+  return entries;
+};
+var discoveryCache4 = /* @__PURE__ */ new Map();
+var cacheKey3 = (chainId, account) => `${chainId}:${account.toLowerCase()}`;
+var getCachedFrankencoinPositions = (chainId, account) => {
+  const hit = discoveryCache4.get(cacheKey3(chainId, account));
+  if (!hit || Date.now() - hit.at > DISCOVERY_TTL_MS2) return void 0;
+  return hit;
+};
+var buildFrankencoinUserCall = async (chainId, lender, account) => {
+  const cfg = frankencoinConfigFor(lender, chainId);
+  const markets = frankencoinChainData(lender, chainId)?.markets ?? [];
+  const stash = (d) => discoveryCache4.set(cacheKey3(chainId, account), d);
+  if (!cfg || markets.length === 0) {
+    stash({ positions: [], at: Date.now() });
+    return [];
+  }
+  const curated = new Set(markets.map((m) => m.position.toLowerCase()));
+  const lower3 = account.toLowerCase();
+  let book = [];
+  try {
+    book = await fetchBook();
+  } catch {
+    return [];
+  }
+  const positions = book.filter(
+    (e) => e.owner === lower3 && e.version === 2 && !e.closed && !e.denied && curated.has(e.original)
+  ).map((e) => ({ position: e.position, original: e.original }));
+  stash({ positions, at: Date.now() });
+  if (positions.length === 0) return [];
+  const collByOriginal = new Map(
+    markets.map((m) => [m.position.toLowerCase(), m.collToken])
+  );
+  const calls = [];
+  for (const p of positions) {
+    const coll = collByOriginal.get(p.original);
+    calls.push(
+      { address: p.position, name: "owner", params: [] },
+      { address: p.position, name: "minted", params: [] },
+      { address: p.position, name: "price", params: [] },
+      { address: p.position, name: "expiration", params: [] },
+      { address: p.position, name: "challengedAmount", params: [] },
+      { address: coll, name: "balanceOf", params: [p.position] }
+    );
+  }
+  return calls;
+};
 var TELLER_CALLS_PER_BID = 4;
 var CACHE_TTL_MS3 = 5 * 6e4;
-var discoveryCache3 = /* @__PURE__ */ new Map();
-var cacheKey3 = (chainId, account) => `${chainId}:${account.toLowerCase()}`;
+var discoveryCache5 = /* @__PURE__ */ new Map();
+var cacheKey4 = (chainId, account) => `${chainId}:${account.toLowerCase()}`;
 var getCachedTellerBids = (chainId, account) => {
-  const hit = discoveryCache3.get(cacheKey3(chainId, account));
+  const hit = discoveryCache5.get(cacheKey4(chainId, account));
   if (!hit || Date.now() - hit.at > CACHE_TTL_MS3) return void 0;
   return hit;
 };
@@ -26644,7 +28144,7 @@ var buildTellerUserCall = async (chainId, _lender, account) => {
     return [];
   }
   if (ids.length === 0) {
-    discoveryCache3.set(cacheKey3(chainId, account), { bids: [], at: Date.now() });
+    discoveryCache5.set(cacheKey4(chainId, account), { bids: [], at: Date.now() });
     return [];
   }
   const poolByAddr = /* @__PURE__ */ new Map();
@@ -26671,7 +28171,7 @@ var buildTellerUserCall = async (chainId, _lender, account) => {
     const pool = poolByAddr.get(lenderAddr);
     if (pool) kept.push({ bidId: id, pool });
   });
-  discoveryCache3.set(cacheKey3(chainId, account), { bids: kept, at: Date.now() });
+  discoveryCache5.set(cacheKey4(chainId, account), { bids: kept, at: Date.now() });
   if (kept.length === 0) return [];
   const ts = nowSec5();
   const calls = [];
@@ -26697,10 +28197,10 @@ var buildTellerUserCall = async (chainId, _lender, account) => {
 };
 var TERMMAX_CALLS_PER_ACCOUNT = 1;
 var CACHE_TTL_MS4 = 5 * 6e4;
-var discoveryCache4 = /* @__PURE__ */ new Map();
-var cacheKey4 = (chainId, account) => `${chainId}:${account.toLowerCase()}`;
+var discoveryCache6 = /* @__PURE__ */ new Map();
+var cacheKey5 = (chainId, account) => `${chainId}:${account.toLowerCase()}`;
 var getCachedTermMaxDiscovery = (chainId, account) => {
-  const hit = discoveryCache4.get(cacheKey4(chainId, account));
+  const hit = discoveryCache6.get(cacheKey5(chainId, account));
   if (!hit || Date.now() - hit.at > CACHE_TTL_MS4) return void 0;
   return hit;
 };
@@ -26716,11 +28216,11 @@ var buildTermMaxUserCall = async (chainId, _lender, account) => {
     }
   }
   if (markets.length === 0) {
-    discoveryCache4.set(cacheKey4(chainId, account), { markets: [], at: Date.now() });
+    discoveryCache6.set(cacheKey5(chainId, account), { markets: [], at: Date.now() });
     return [];
   }
   markets = [...markets].sort((a, b) => a.market.localeCompare(b.market));
-  discoveryCache4.set(cacheKey4(chainId, account), { markets, at: Date.now() });
+  discoveryCache6.set(cacheKey5(chainId, account), { markets, at: Date.now() });
   return [
     {
       address: proto.viewer,
@@ -26753,7 +28253,12 @@ async function buildUserCall(chainId, lender, account, params, getClient) {
   if (isTeller(lender)) return buildTellerUserCall(chainId, lender, account);
   if (isTermMax(lender)) return buildTermMaxUserCall(chainId, lender, account);
   if (isInverse(lender)) return buildInverseUserCall(chainId, lender, account);
+  if (isLlamaLend(lender))
+    return buildLlamaLendUserCall(chainId, lender, account);
+  if (isResupply(lender)) return buildResupplyUserCall(chainId, lender, account);
   if (isUsdd(lender)) return buildUsddUserCall(chainId, lender, account);
+  if (isFrankencoin(lender))
+    return buildFrankencoinUserCall(chainId, lender, account);
   if (isCompoundV3Type(lender))
     return buildCompoundV3UserCall(chainId, lender, account);
   if (isEulerType(lender))
@@ -26790,10 +28295,12 @@ function organizeUserQueries(queries) {
   const teller = queries.filter((q) => isTeller(q.lender));
   const termMax = queries.filter((q) => isTermMax(q.lender));
   const usdd = queries.filter((q) => isUsdd(q.lender));
-  if (morphos.length === 0 && gearbox.length === 0 && midnight.length === 0 && term.length === 0 && exactly.length === 0 && liquity.length === 0 && river.length === 0 && teller.length === 0 && termMax.length === 0 && usdd.length === 0)
+  const llamaLend = queries.filter((q) => isLlamaLend(q.lender));
+  const frankencoin = queries.filter((q) => isFrankencoin(q.lender));
+  if (morphos.length === 0 && gearbox.length === 0 && midnight.length === 0 && term.length === 0 && exactly.length === 0 && liquity.length === 0 && river.length === 0 && teller.length === 0 && termMax.length === 0 && usdd.length === 0 && frankencoin.length === 0 && llamaLend.length === 0)
     return queries;
   const others = queries.filter(
-    (q) => !isMorphoType(q.lender) && !isGearboxV3(q.lender) && !isMidnight(q.lender) && !isTerm(q.lender) && !isExactly(q.lender) && !isLiquityFamily(q.lender) && !isRiver(q.lender) && !isTeller(q.lender) && !isTermMax(q.lender) && !isUsdd(q.lender)
+    (q) => !isMorphoType(q.lender) && !isGearboxV3(q.lender) && !isMidnight(q.lender) && !isTerm(q.lender) && !isExactly(q.lender) && !isLiquityFamily(q.lender) && !isRiver(q.lender) && !isTeller(q.lender) && !isTermMax(q.lender) && !isUsdd(q.lender) && !isFrankencoin(q.lender) && !isLlamaLend(q.lender)
   );
   const morphoBlue = morphos.filter((q) => q.lender.startsWith("MORPHO_BLUE"));
   const moolah = morphos.filter((q) => q.lender.startsWith("LISTA_DAO"));
@@ -26854,6 +28361,14 @@ function organizeUserQueries(queries) {
       assets: void 0
     });
   }
+  if (frankencoin.length > 0) {
+    result.push({
+      lender: Lender.FRANKENCOIN,
+      account: frankencoin[0].account,
+      params: frankencoin.map((p) => p.lender),
+      assets: void 0
+    });
+  }
   if (usdd.length > 0) {
     result.push({
       lender: Lender.USDD,
@@ -26862,6 +28377,14 @@ function organizeUserQueries(queries) {
       assets: void 0
     });
   }
+  if (llamaLend.length > 0) {
+    result.push({
+      lender: Lender.LLAMALEND,
+      account: llamaLend[0].account,
+      params: llamaLend.map((p) => p.lender),
+      assets: void 0
+    });
+  }
   if (teller.length > 0) {
     result.push({
       lender: Lender.TELLER,
@@ -29530,7 +31053,7 @@ var getExactlyUserDataConverter = (_lender, chainId, account, meta) => {
     expected
   ];
 };
-var big2 = (v) => {
+var big3 = (v) => {
   try {
     if (typeof v === "bigint") return v;
     if (typeof v === "number" || typeof v === "string") return BigInt(v);
@@ -29538,7 +31061,7 @@ var big2 = (v) => {
   }
   return 0n;
 };
-var field7 = (res, name, idx) => big2(res?.[name] ?? res?.[idx]);
+var field7 = (res, name, idx) => big3(res?.[name] ?? res?.[idx]);
 var getLiquityUserDataConverter = (lender, chainId, account, meta) => {
   const cfg = liquityConfigFor(lender, chainId);
   const branches = liquityBranchesByChain(lender, chainId);
@@ -29659,11 +31182,11 @@ var getLiquityUserDataConverter = (lender, chainId, account, meta) => {
           };
         });
         const spBase = troves.length * 2;
-        const spDeposit = big2(slice2[spBase]);
-        const spYield = big2(slice2[spBase + 1]);
-        const spCollGain = big2(slice2[spBase + 2]);
-        const spStashed = big2(slice2[spBase + 3]);
-        const collSurplus = branch.collSurplusPool ? big2(slice2[spBase + 4]) : 0n;
+        const spDeposit = big3(slice2[spBase]);
+        const spYield = big3(slice2[spBase + 1]);
+        const spCollGain = big3(slice2[spBase + 2]);
+        const spStashed = big3(slice2[spBase + 3]);
+        const collSurplus = branch.collSurplusPool ? big3(slice2[spBase + 4]) : 0n;
         const spStable = spDeposit + spYield;
         const spColl = spCollGain + spStashed + collSurplus;
         if (spStable > 0n || spColl > 0n) {
@@ -29742,7 +31265,7 @@ var getLiquityUserDataConverter = (lender, chainId, account, meta) => {
     expected
   ];
 };
-var big3 = (v) => {
+var big4 = (v) => {
   try {
     if (typeof v === "bigint") return v;
     if (typeof v === "number" || typeof v === "string") return BigInt(v);
@@ -29750,7 +31273,7 @@ var big3 = (v) => {
   }
   return 0n;
 };
-var field8 = (res, name, idx) => big3(res?.[name] ?? res?.[idx]);
+var field8 = (res, name, idx) => big4(res?.[name] ?? res?.[idx]);
 var getRiverUserDataConverter = (lender, chainId, account, meta) => {
   const cfg = riverConfigFor(lender, chainId);
   const markets = riverChainData(lender, chainId)?.markets ?? [];
@@ -29762,13 +31285,13 @@ var getRiverUserDataConverter = (lender, chainId, account, meta) => {
       const debtAddr = cfg.debtToken.toLowerCase();
       const debtDecimals = cfg.debtDecimals ?? 18;
       const out = {};
-      const spDeposit = big3(data[markets.length * RIVER_CALLS_PER_MARKET]);
+      const spDeposit = big4(data[markets.length * RIVER_CALLS_PER_MARKET]);
       markets.forEach((market, i) => {
         const base = i * RIVER_CALLS_PER_MARKET;
         const entire = data[base];
         if (isFailedCall(entire) || isFailedCall(data[base + 1])) return;
-        const status = Number(big3(data[base + 1]));
-        const surplus = big3(data[base + 2]);
+        const status = Number(big4(data[base + 1]));
+        const surplus = big4(data[base + 2]);
         const lenderKey = riverLenderKey(lender, chainId, market.index);
         const metaMap = meta?.[lenderKey];
         if (!metaMap) return;
@@ -29876,7 +31399,7 @@ var getRiverUserDataConverter = (lender, chainId, account, meta) => {
     expected
   ];
 };
-var big4 = (v) => {
+var big5 = (v) => {
   try {
     if (typeof v === "bigint") return v;
     if (typeof v === "number" || typeof v === "string") return BigInt(v);
@@ -29895,20 +31418,24 @@ var getInverseUserDataConverter = (lender, chainId, account, meta) => {
       const dolaAddr = cfg.dola.toLowerCase();
       const debtDecimals = cfg.debtDecimals ?? 18;
       const tailBase = markets.length * INVERSE_CALLS_PER_MARKET;
-      const dbrBalance = big4(data[tailBase]);
-      const dbrDeficit = big4(data[tailBase + 1]);
+      const dbrBalance = big5(data[tailBase]);
+      const dbrDeficit = big5(data[tailBase + 1]);
       const dbrSignedRaw = data[tailBase + 2];
-      const dbrSigned = isFailedCall(dbrSignedRaw) ? 0n : big4(dbrSignedRaw);
+      const dbrSigned = isFailedCall(dbrSignedRaw) ? 0n : big5(dbrSignedRaw);
+      const dbrTotalDebtRaw = data[tailBase + 3];
+      const dbrTotalDebt = isFailedCall(dbrTotalDebtRaw) ? 0n : big5(dbrTotalDebtRaw);
+      const dbrRunway = dbrTotalDebt > 0n ? dbrBalance * 31536000n / dbrTotalDebt : 0n;
+      const nowSec9 = BigInt(Math.floor(Date.now() / 1e3));
       const out = {};
       markets.forEach((market, i) => {
         const base = i * INVERSE_CALLS_PER_MARKET;
-        const escrowBal = isFailedCall(data[base]) ? 0n : big4(data[base]);
+        const escrowBal = isFailedCall(data[base]) ? 0n : big5(data[base]);
         const debtRaw = data[base + 1];
         if (isFailedCall(debtRaw)) return;
-        const debt = big4(debtRaw);
+        const debt = big5(debtRaw);
         if (escrowBal === 0n && debt === 0n) return;
-        const creditLimit = isFailedCall(data[base + 2]) ? 0n : big4(data[base + 2]);
-        const withdrawalLimit = isFailedCall(data[base + 3]) ? 0n : big4(data[base + 3]);
+        const creditLimit = isFailedCall(data[base + 2]) ? 0n : big5(data[base + 2]);
+        const withdrawalLimit = isFailedCall(data[base + 3]) ? 0n : big5(data[base + 3]);
         const lenderKey = inverseLenderKey(lender, market.address);
         const metaMap = meta?.[lenderKey];
         if (!metaMap) return;
@@ -29929,7 +31456,10 @@ var getInverseUserDataConverter = (lender, chainId, account, meta) => {
           withdrawalLimit: withdrawalLimit.toString(),
           dbrBalance: dbrBalance.toString(),
           dbrDeficit: dbrDeficit.toString(),
-          dbrSignedBalance: dbrSigned.toString()
+          dbrSignedBalance: dbrSigned.toString(),
+          dbrTotalDebt: dbrTotalDebt.toString(),
+          dbrRunwaySeconds: dbrRunway.toString(),
+          dbrDepletionTimestamp: dbrTotalDebt > 0n ? String(nowSec9 + dbrRunway) : void 0
         };
         const collStr = parseRawAmount(escrowBal.toString(), collDecimals);
         const collNum = Number(collStr);
@@ -29991,8 +31521,273 @@ var getInverseUserDataConverter = (lender, chainId, account, meta) => {
     expected
   ];
 };
+var big6 = (v) => {
+  try {
+    if (typeof v === "bigint") return v;
+    if (typeof v === "number" || typeof v === "string") return BigInt(v);
+  } catch {
+  }
+  return 0n;
+};
+var arrAt = (v, i) => {
+  if (isFailedCall(v) || !Array.isArray(v)) return 0n;
+  return big6(v[i]);
+};
+var getLlamaLendUserDataConverter = (lender, chainId, account, meta) => {
+  const cfg = llamaLendConfigFor(lender, chainId);
+  const markets = llamaLendChainData(lender, chainId)?.markets ?? [];
+  const expected = cfg && markets.length > 0 ? markets.length * LLAMALEND_CALLS_PER_MARKET : 0;
+  return [
+    (data) => {
+      if (!cfg || expected === 0) return void 0;
+      if (!data || data.length < expected) return void 0;
+      const out = {};
+      markets.forEach((market, i) => {
+        const base = i * LLAMALEND_CALLS_PER_MARKET;
+        const stateRaw = data[base];
+        if (isFailedCall(stateRaw) || !Array.isArray(stateRaw)) return;
+        const collateral = big6(stateRaw[0]);
+        const bandBorrowed = big6(stateRaw[1]);
+        const debt = big6(stateRaw[2]);
+        const bandCount = Number(big6(stateRaw[3]));
+        if (collateral === 0n && debt === 0n && bandBorrowed === 0n) return;
+        const healthRaw = data[base + 1];
+        const health = isFailedCall(healthRaw) ? 0n : big6(healthRaw);
+        const pricesRaw = data[base + 2];
+        const priceUpper = arrAt(pricesRaw, 0);
+        const priceLower = arrAt(pricesRaw, 1);
+        const ticksRaw = data[base + 3];
+        const bands = isFailedCall(ticksRaw) || !Array.isArray(ticksRaw) ? void 0 : [Number(big6(ticksRaw[0])), Number(big6(ticksRaw[1]))];
+        const approvalRaw = data[base + 4];
+        const delegated = isFailedCall(approvalRaw) ? false : approvalRaw === true;
+        const lenderKey = llamaLendLenderKey(lender, market.controller);
+        const metaMap = meta?.[lenderKey];
+        if (!metaMap) return;
+        const collAddr = market.collateralToken.toLowerCase();
+        const loanAddr = market.borrowedToken.toLowerCase();
+        const collUid = createMarketUid(chainId, lenderKey, collAddr);
+        const loanUid = createMarketUid(chainId, lenderKey, loanAddr);
+        const collMeta = metaMap[collUid];
+        const loanMeta = metaMap[loanUid];
+        const collDecimals = collMeta?.asset?.decimals ?? market.collateralDecimals;
+        const loanDecimals = loanMeta?.asset?.decimals ?? market.borrowedDecimals;
+        const collDisplay = collMeta ? getDisplayPrice(collMeta) : 0;
+        const collOracle = collMeta ? getOraclePrice(collMeta) : 0;
+        const collHist = collMeta?.price?.priceUsd24h ?? collDisplay;
+        const loanDisplay = loanMeta ? getDisplayPrice(loanMeta) : 0;
+        const loanOracle = loanMeta ? getOraclePrice(loanMeta) : 0;
+        const loanHist = loanMeta?.price?.priceUsd24h ?? loanDisplay;
+        const llamalendInfo = {
+          health: health.toString(),
+          priceUpper: priceUpper.toString(),
+          priceLower: priceLower.toString(),
+          bands,
+          bandCount,
+          bandCollateralInBorrowed: bandBorrowed.toString(),
+          softLiquidating: bandBorrowed > 0n,
+          delegated,
+          supportsDelegation: market.supportsDelegation === true,
+          version: market.version
+        };
+        const collStr = parseRawAmount(collateral.toString(), collDecimals);
+        const collNum = Number(collStr);
+        const debtStr = parseRawAmount(debt.toString(), loanDecimals);
+        const debtNum = Number(debtStr);
+        const bandBorrowedStr = parseRawAmount(
+          bandBorrowed.toString(),
+          loanDecimals
+        );
+        const bandBorrowedNum = Number(bandBorrowedStr);
+        const lendingPositions = {
+          "0": {
+            [collUid]: {
+              marketUid: collUid,
+              underlying: collAddr,
+              deposits: collStr,
+              debt: "0",
+              debtStable: "0",
+              depositsUSD: collNum * collDisplay,
+              debtUSD: 0,
+              debtStableUSD: 0,
+              depositsUSDOracle: collNum * collOracle,
+              debtUSDOracle: 0,
+              debtStableUSDOracle: 0,
+              stableBorrowRate: "0",
+              collateralEnabled: true,
+              claimableRewards: 0
+            },
+            [loanUid]: {
+              marketUid: loanUid,
+              underlying: loanAddr,
+              deposits: bandBorrowedStr,
+              debt: debtStr,
+              debtStable: "0",
+              depositsUSD: bandBorrowedNum * loanDisplay,
+              debtUSD: debtNum * loanDisplay,
+              debtStableUSD: 0,
+              depositsUSDOracle: bandBorrowedNum * loanOracle,
+              debtUSDOracle: debtNum * loanOracle,
+              debtStableUSDOracle: 0,
+              stableBorrowRate: "0",
+              collateralEnabled: false,
+              claimableRewards: 0,
+              llamalendInfo
+            }
+          }
+        };
+        const modes = { "0": 0 };
+        const hist = {
+          "0": {
+            totalDeposits24h: collNum * collHist + bandBorrowedNum * loanHist,
+            totalDebt24h: debtNum * loanHist
+          }
+        };
+        const userData = createMultiAccountTypeUserState(
+          { chainId, account, lendingPositions, modes },
+          metaMap,
+          hist
+        );
+        if (userData && userData.data.length > 0) out[lenderKey] = userData;
+      });
+      return Object.keys(out).length > 0 ? out : void 0;
+    },
+    expected
+  ];
+};
+var big7 = (v) => {
+  try {
+    if (typeof v === "bigint") return v;
+    if (typeof v === "number" || typeof v === "string") return BigInt(v);
+  } catch {
+  }
+  return 0n;
+};
+var tupleAt = (v, i) => Array.isArray(v) ? big7(v[i]) : 0n;
+var ONE4 = 10n ** 18n;
+function sharesToAmount(shares, totalAmount, totalShares) {
+  if (totalShares === 0n || shares === 0n) return 0n;
+  const q = shares * totalAmount / totalShares;
+  return q * totalShares < shares * totalAmount ? q + 1n : q;
+}
+var getResupplyUserDataConverter = (lender, chainId, account, meta) => {
+  const cfg = resupplyConfigFor(lender, chainId);
+  const discovery = getCachedResupplyDiscovery(chainId, lender, account);
+  const positions = discovery?.positions ?? [];
+  const expected = cfg && positions.length > 0 ? positions.length * RESUPPLY_CALLS_PER_PAIR : 0;
+  return [
+    (data) => {
+      if (!cfg || expected === 0) return void 0;
+      if (!data || data.length < expected) return void 0;
+      const debtAddr = cfg.reusd.toLowerCase();
+      const debtDecimals = cfg.debtDecimals ?? 18;
+      const out = {};
+      positions.forEach(
+        ({ pair, collateral, borrowShares, collateralShares }, i) => {
+          const base = i * RESUPPLY_CALLS_PER_PAIR;
+          const accounting = data[base];
+          if (isFailedCall(accounting) || !Array.isArray(accounting)) return;
+          const totalBorrowAmount = tupleAt(accounting, 1);
+          const totalBorrowShares = tupleAt(accounting, 2);
+          const sharePrice = isFailedCall(data[base + 1]) ? 0n : big7(data[base + 1]);
+          const lenderKey = resupplyLenderKey(lender, chainId, pair);
+          const metaMap = meta?.[lenderKey];
+          if (!metaMap) return;
+          const debt = sharesToAmount(
+            borrowShares,
+            totalBorrowAmount,
+            totalBorrowShares
+          );
+          const collUnderlying = sharePrice > 0n ? collateralShares * sharePrice / ONE4 : 0n;
+          const collAddrEntry = Object.values(metaMap).find(
+            (m) => m?.underlying && m.underlying.toLowerCase() !== debtAddr
+          );
+          const collAddr = collAddrEntry?.underlying?.toLowerCase();
+          if (!collAddr) return;
+          const collUid = createMarketUid(chainId, lenderKey, collAddr);
+          const loanUid = createMarketUid(chainId, lenderKey, debtAddr);
+          const collMeta = metaMap[collUid];
+          const loanMeta = metaMap[loanUid];
+          const collDecimals = collMeta?.asset?.decimals ?? 18;
+          const collDisplay = collMeta ? getDisplayPrice(collMeta) : 0;
+          const collOracle = collMeta ? getOraclePrice(collMeta) : 0;
+          const collHist = collMeta?.price?.priceUsd24h ?? collDisplay;
+          const loanDisplay = loanMeta ? getDisplayPrice(loanMeta) : 0;
+          const loanOracle = loanMeta ? getOraclePrice(loanMeta) : 0;
+          const loanHist = loanMeta?.price?.priceUsd24h ?? loanDisplay;
+          const resupplyInfo = {
+            borrowShares: borrowShares.toString(),
+            collateralShares: collateralShares.toString(),
+            collateralSharePrice: sharePrice.toString(),
+            pair,
+            collateralVault: collateral
+          };
+          const collStr = parseRawAmount(
+            collUnderlying.toString(),
+            collDecimals
+          );
+          const collNum = Number(collStr);
+          const debtStr = parseRawAmount(debt.toString(), debtDecimals);
+          const debtNum = Number(debtStr);
+          const lendingPositions = {
+            "0": {
+              [collUid]: {
+                marketUid: collUid,
+                underlying: collAddr,
+                deposits: collStr,
+                debt: "0",
+                debtStable: "0",
+                depositsUSD: collNum * collDisplay,
+                debtUSD: 0,
+                debtStableUSD: 0,
+                depositsUSDOracle: collNum * collOracle,
+                debtUSDOracle: 0,
+                debtStableUSDOracle: 0,
+                stableBorrowRate: "0",
+                collateralEnabled: true,
+                claimableRewards: 0,
+                resupplyInfo
+              },
+              [loanUid]: {
+                marketUid: loanUid,
+                underlying: debtAddr,
+                deposits: "0",
+                debt: debtStr,
+                debtStable: "0",
+                depositsUSD: 0,
+                debtUSD: debtNum * loanDisplay,
+                debtStableUSD: 0,
+                depositsUSDOracle: 0,
+                debtUSDOracle: debtNum * loanOracle,
+                debtStableUSDOracle: 0,
+                stableBorrowRate: "0",
+                collateralEnabled: false,
+                claimableRewards: 0,
+                resupplyInfo
+              }
+            }
+          };
+          const modes = { "0": 0 };
+          const hist = {
+            "0": {
+              totalDeposits24h: collNum * collHist,
+              totalDebt24h: debtNum * loanHist
+            }
+          };
+          const userData = createMultiAccountTypeUserState(
+            { chainId, account, lendingPositions, modes },
+            metaMap,
+            hist
+          );
+          if (userData && userData.data.length > 0) out[lenderKey] = userData;
+        }
+      );
+      return Object.keys(out).length > 0 ? out : void 0;
+    },
+    expected
+  ];
+};
 var RAY4 = 10n ** 27n;
-var big5 = (v) => {
+var big8 = (v) => {
   try {
     if (typeof v === "bigint") return v;
     if (typeof v === "number" || typeof v === "string") return BigInt(v);
@@ -30000,7 +31795,7 @@ var big5 = (v) => {
   }
   return 0n;
 };
-var field9 = (res, name, idx) => big5(res?.[name] ?? res?.[idx]);
+var field9 = (res, name, idx) => big8(res?.[name] ?? res?.[idx]);
 var getUsddUserDataConverter = (lender, chainId, account, meta) => {
   const cfg = usddConfigFor(lender, chainId);
   const markets = usddChainData(lender, chainId)?.markets ?? [];
@@ -30113,10 +31908,142 @@ var getUsddUserDataConverter = (lender, chainId, account, meta) => {
     expected
   ];
 };
+var big9 = (v) => {
+  try {
+    if (typeof v === "bigint") return v;
+    if (typeof v === "number" || typeof v === "string") return BigInt(v);
+  } catch {
+  }
+  return 0n;
+};
+var getFrankencoinUserDataConverter = (lender, chainId, account, meta) => {
+  const cfg = frankencoinConfigFor(lender, chainId);
+  const markets = frankencoinChainData(lender, chainId)?.markets ?? [];
+  const discovery = getCachedFrankencoinPositions(chainId, account);
+  const positions = discovery?.positions ?? [];
+  const expected = cfg && markets.length > 0 && positions.length > 0 ? positions.length * FRANKENCOIN_CALLS_PER_POSITION : 0;
+  return [
+    (data) => {
+      if (!cfg || expected === 0) return void 0;
+      if (!data || data.length < expected) return void 0;
+      const debtAddr = cfg.zchf.toLowerCase();
+      const debtDecimals = cfg.debtDecimals ?? 18;
+      const marketByOriginal = new Map(
+        markets.map((m) => [m.position.toLowerCase(), m])
+      );
+      const lowerAccount = account.toLowerCase();
+      const perMarket = /* @__PURE__ */ new Map();
+      positions.forEach((p, i) => {
+        const base = i * FRANKENCOIN_CALLS_PER_POSITION;
+        const ownerRes = data[base];
+        if (isFailedCall(ownerRes)) return;
+        if (String(ownerRes).toLowerCase() !== lowerAccount) return;
+        const minted = big9(data[base + 1]);
+        const price2 = big9(data[base + 2]);
+        const expiration = big9(data[base + 3]);
+        const challenged = big9(data[base + 4]);
+        const coll = big9(data[base + 5]);
+        if (minted === 0n && coll === 0n) return;
+        const market = marketByOriginal.get(p.original);
+        if (!market) return;
+        const key = frankencoinLenderKey(lender, chainId, market.position);
+        if (!perMarket.has(key)) perMarket.set(key, { market, rows: [] });
+        perMarket.get(key).rows.push({
+          info: {
+            position: p.position,
+            original: p.original,
+            declaredPrice: price2.toString(),
+            expiration: expiration.toString(),
+            challengedAmount: challenged.toString(),
+            reserveContributionPPM: String(market.reserveContribution)
+          },
+          coll,
+          debt: minted
+        });
+      });
+      const out = {};
+      for (const [lenderKey, { market, rows }] of perMarket) {
+        const metaMap = meta?.[lenderKey];
+        if (!metaMap) continue;
+        const collAddr = market.collToken.toLowerCase();
+        const collUid = createMarketUid(chainId, lenderKey, collAddr);
+        const loanUid = createMarketUid(chainId, lenderKey, debtAddr);
+        const collMeta = metaMap[collUid];
+        const loanMeta = metaMap[loanUid];
+        const collDecimals = collMeta?.asset?.decimals ?? market.collDecimals;
+        const collDisplay = collMeta ? getDisplayPrice(collMeta) : 0;
+        const collOracle = collMeta ? getOraclePrice(collMeta) : 0;
+        const collHist = collMeta?.price?.priceUsd24h ?? collDisplay;
+        const loanDisplay = loanMeta ? getDisplayPrice(loanMeta) : 0;
+        const loanOracle = loanMeta ? getOraclePrice(loanMeta) : 0;
+        const loanHist = loanMeta?.price?.priceUsd24h ?? loanDisplay;
+        const lendingPositions = {};
+        const modes = {};
+        const hist = {};
+        for (const row of rows) {
+          const id = row.info.position;
+          const collStr = parseRawAmount(row.coll.toString(), collDecimals);
+          const collNum = Number(collStr);
+          const debtStr = parseRawAmount(row.debt.toString(), debtDecimals);
+          const debtNum = Number(debtStr);
+          lendingPositions[id] = {
+            [collUid]: {
+              marketUid: collUid,
+              underlying: collAddr,
+              deposits: collStr,
+              debt: "0",
+              debtStable: "0",
+              depositsUSD: collNum * collDisplay,
+              debtUSD: 0,
+              debtStableUSD: 0,
+              depositsUSDOracle: collNum * collOracle,
+              debtUSDOracle: 0,
+              debtStableUSDOracle: 0,
+              stableBorrowRate: "0",
+              collateralEnabled: true,
+              claimableRewards: 0
+            },
+            [loanUid]: {
+              marketUid: loanUid,
+              underlying: debtAddr,
+              deposits: "0",
+              debt: debtStr,
+              debtStable: "0",
+              depositsUSD: 0,
+              debtUSD: debtNum * loanDisplay,
+              debtStableUSD: 0,
+              depositsUSDOracle: 0,
+              debtUSDOracle: debtNum * loanOracle,
+              debtStableUSDOracle: 0,
+              stableBorrowRate: "0",
+              collateralEnabled: false,
+              claimableRewards: 0,
+              frankencoinInfo: row.info
+            }
+          };
+          modes[id] = 0;
+          hist[id] = {
+            totalDeposits24h: collNum * collHist,
+            totalDebt24h: debtNum * loanHist
+          };
+        }
+        if (Object.keys(lendingPositions).length === 0) continue;
+        const userData = createMultiAccountTypeUserState(
+          { chainId, account, lendingPositions, modes },
+          metaMap,
+          hist
+        );
+        if (userData && userData.data.length > 0) out[lenderKey] = userData;
+      }
+      return Object.keys(out).length > 0 ? out : void 0;
+    },
+    expected
+  ];
+};
 
 // src/lending/user-data/teller/userCallParse.ts
 var nowSec7 = () => Math.floor(Date.now() / 1e3);
-var big6 = (v) => {
+var big10 = (v) => {
   try {
     if (typeof v === "bigint") return v;
     if (typeof v === "number" || typeof v === "string") return BigInt(v);
@@ -30138,7 +32065,7 @@ var getTellerUserDataConverter = (_lender, chainId, account, meta) => {
         const base = i * TELLER_CALLS_PER_BID;
         const bidRes = data[base];
         const owed = data[base + 1];
-        const collAmount = big6(data[base + 2]);
+        const collAmount = big10(data[base + 2]);
         const defaulted = !!data[base + 3];
         if (isFailedCall(bidRes) || isFailedCall(owed) || !bidRes) return;
         const pool = b.pool;
@@ -30159,17 +32086,17 @@ var getTellerUserDataConverter = (_lender, chainId, account, meta) => {
         const collDisplay = collMeta ? getDisplayPrice(collMeta) : 0;
         const collOracle = collMeta ? getOraclePrice(collMeta) : 0;
         const collHist = collMeta?.price?.priceUsd24h ?? collDisplay;
-        const owedPrincipal = big6(field10(owed, "principal", 0));
-        const owedInterest = big6(field10(owed, "interest", 1));
+        const owedPrincipal = big10(field10(owed, "principal", 0));
+        const owedInterest = big10(field10(owed, "interest", 1));
         const owedTotal = owedPrincipal + owedInterest;
         if (owedTotal === 0n && collAmount === 0n) return;
         const loanDetails = field10(bidRes, "loanDetails", 5);
         const terms = field10(bidRes, "terms", 6);
         const acceptedTs = Number(
-          big6(field10(loanDetails, "acceptedTimestamp", 4))
+          big10(field10(loanDetails, "acceptedTimestamp", 4))
         );
-        const loanDuration = Number(big6(field10(loanDetails, "loanDuration", 6)));
-        const aprBps = Number(big6(field10(terms, "APR", 2)));
+        const loanDuration = Number(big10(field10(loanDetails, "loanDuration", 6)));
+        const aprBps = Number(big10(field10(terms, "APR", 2)));
         const maturity = acceptedTs > 0 ? acceptedTs + loanDuration : void 0;
         const isMatured = defaulted || maturity !== void 0 && maturity < now;
         const collStr = parseRawAmount(collAmount.toString(), collDecimals);
@@ -30467,8 +32394,14 @@ function getUserDataConverter(lender, chainId, account, params, meta) {
     return getTermMaxUserDataConverter(lender, chainId, account, meta);
   if (isInverse(lender))
     return getInverseUserDataConverter(lender, chainId, account, meta);
+  if (isLlamaLend(lender))
+    return getLlamaLendUserDataConverter(lender, chainId, account, meta);
+  if (isResupply(lender))
+    return getResupplyUserDataConverter(lender, chainId, account, meta);
   if (isUsdd(lender))
     return getUsddUserDataConverter(lender, chainId, account, meta);
+  if (isFrankencoin(lender))
+    return getFrankencoinUserDataConverter(lender, chainId, account, meta);
   if (isCompoundV3Type(lender))
     return getCompoundV3UserDataConverter(
       lender,
@@ -35024,6 +36957,15 @@ var accountLensAbi = [
     stateMutability: "view"
   }
 ];
+var VAULT_CONVERT_ABI = [
+  {
+    name: "convertToAssets",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "shares", type: "uint256" }],
+    outputs: [{ type: "uint256" }]
+  }
+];
 var getAbi2 = (lender) => {
   if (isAaveV4Type(lender)) return [...AaveV4SpokeAbi];
   if (isAaveV2Type(lender))
@@ -35069,7 +37011,13 @@ var getAbi2 = (lender) => {
   if (isTermMax(lender)) return [...TermMaxViewerAbi];
   if (isInverse(lender))
     return [...InverseMarketAbi, ...InverseEscrowAbi, ...InverseDbrAbi];
+  if (isLlamaLend(lender))
+    return [...LlamaLendControllerAbi, ...LlamaLendAmmAbi];
   if (isUsdd(lender)) return [...UsddVatAbi];
+  if (isFrankencoin(lender))
+    return [...FrankencoinPositionAbi, ...erc20Abi];
+  if (isResupply(lender))
+    return [...ResupplyPairAbi, ...VAULT_CONVERT_ABI];
   if (isInit(lender)) return InitLensAbi;
   if (isEulerType(lender)) return accountLensAbi;
   if (isCompoundV2Type(lender))
@@ -35681,11 +37629,11 @@ async function fetchJsonWithProxyFallback(url, body, proxyConfig) {
 }
 var inflight = /* @__PURE__ */ new Map();
 var resolved = /* @__PURE__ */ new Map();
-function cacheKey5(chainId, account) {
+function cacheKey6(chainId, account) {
   return `${chainId}:${account.toLowerCase()}`;
 }
 async function dedupedFetch(chainId, account, loader) {
-  const key = cacheKey5(chainId, account);
+  const key = cacheKey6(chainId, account);
   const now = Date.now();
   const cached = resolved.get(key);
   if (cached && cached.expiresAt > now) {
@@ -40171,7 +42119,7 @@ var DOLA_STAKING_URL = "https://www.inverse.finance/api/dola-staking";
 var JDOLA_STAKING_URL = "https://www.inverse.finance/api/junior/jdola-staking";
 var SDOLA_KEY = "SDOLA";
 var SDOLA_GROUP_KEY = "sDOLA::SDOLA";
-var fetchJson2 = async (url) => {
+var fetchJson3 = async (url) => {
   const res = await fetch(url, {
     headers: { accept: "application/json" },
     signal: AbortSignal.timeout(8e3)
@@ -40181,12 +42129,12 @@ var fetchJson2 = async (url) => {
 };
 var fetchSdolaApyPercent = async () => {
   try {
-    const d = await fetchJson2(DOLA_STAKING_URL);
+    const d = await fetchJson3(DOLA_STAKING_URL);
     const apy = Number(d?.calculatedApy);
     if (Number.isFinite(apy) && apy > 0) return apy;
     throw new Error("calculatedApy missing");
   } catch {
-    const d = await fetchJson2(JDOLA_STAKING_URL);
+    const d = await fetchJson3(JDOLA_STAKING_URL);
     const apy = Number(d?.sDolaApy);
     if (Number.isFinite(apy) && apy > 0) return apy;
     throw new Error("sDolaApy missing");
@@ -40618,6 +42566,72 @@ var usddFetcher = {
     return out;
   }
 };
+var FRANKENCOIN_SAVINGS_MODULE = "0x27d9ad987bde08a0d083ef7e0e4043c857a17b38";
+var SAVINGS_INFO_URL = "https://api.frankencoin.com/savings/core/info";
+var RATE_ABI2 = [
+  {
+    name: "currentRatePPM",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint24" }]
+  }
+];
+var ZCHF_SAVINGS_KEY = "ZCHF_SAVINGS";
+var aprFromRatePPM = (ppm) => Number(ppm) / 1e4;
+var fetchRateOnChain = async () => {
+  const [ppm] = await multicallRetryUniversal({
+    chain: Chain.ETHEREUM_MAINNET,
+    abi: RATE_ABI2,
+    calls: [
+      {
+        address: FRANKENCOIN_SAVINGS_MODULE,
+        name: "currentRatePPM",
+        params: []
+      }
+    ],
+    allowFailure: false
+  });
+  if (ppm === void 0 || ppm === null) {
+    throw new Error("Frankencoin: unreadable currentRatePPM()");
+  }
+  return aprFromRatePPM(ppm);
+};
+var fetchRateFromApi = async () => {
+  const res = await fetch(SAVINGS_INFO_URL, {
+    headers: { accept: "application/json" },
+    signal: AbortSignal.timeout(8e3)
+  });
+  if (!res.ok) throw new Error(`Frankencoin: savings info HTTP ${res.status}`);
+  const body = await res.json();
+  const rate = body?.status?.[String(Chain.ETHEREUM_MAINNET)]?.[FRANKENCOIN_SAVINGS_MODULE]?.rate;
+  if (typeof rate !== "number" || !Number.isFinite(rate)) {
+    throw new Error("Frankencoin: savings info carried no rate for the module");
+  }
+  return aprFromRatePPM(rate);
+};
+var frankencoinSavingsFetcher = {
+  label: "FRANKENCOIN_SAVINGS",
+  fetch: async () => {
+    const legs = await Promise.allSettled([
+      fetchRateOnChain(),
+      fetchRateFromApi()
+    ]);
+    const onChain = legs[0];
+    if (onChain.status === "fulfilled") {
+      return { [ZCHF_SAVINGS_KEY]: onChain.value };
+    }
+    const api = legs[1];
+    if (api.status === "fulfilled") {
+      return { [ZCHF_SAVINGS_KEY]: api.value };
+    }
+    throw new Error(
+      `Frankencoin: both rate legs failed (chain: ${String(
+        onChain.reason
+      )}; api: ${String(api.reason)})`
+    );
+  }
+};
 
 // src/yields/intrinsic/fetchers/nativeCreditPool.ts
 var nativeCreditPoolYieldKey = (chainId, underlying) => `${chainId}:${underlying.toLowerCase()}`;
@@ -42726,6 +44740,50 @@ var SINGLE_CHAIN_ENTRIES = {
       withdrawalCooldownSeconds: 90 * 86400,
       yieldFetcher: reProtocolFetcher,
       yieldKey: REUSDE_KEY
+    },
+    {
+      // Frankencoin savings module — a Swiss-franc savings account, not
+      // a vault. There is NO share token: `save(amount)` books ZCHF into
+      // an internal `savings(address)` account and `withdraw(target,
+      // amount)` pays it back out, so the position is a balance that
+      // grows in place (`isRebasing: true`, `exchangeRate` pinned at
+      // par) and the module's own ZCHF balance is the whole book. Hence
+      // the bespoke `frankencoin-savings` reader.
+      //
+      // TRAP — the published address config is stale. `@frankencoin/zchf`
+      // exports `savingsV2 = 0x3BF301B0…`, which now runs at 1 % and
+      // holds 17k ZCHF; the live module is the `savingsReferral`
+      // deployment below, at 3.5 % holding 12.17M (verified on-chain
+      // 2026-08-04, `currentRatePPM() = 35000`). Both answer
+      // `currentRatePPM()`, so only the balance distinguishes them.
+      //
+      // `symbol: 'ZCHF'` is deliberate. `fetchPublic` composes
+      // `displayName` from the *underlying's* token-list symbol
+      // (→ "Frankencoin ZCHF"), so `symbol` only drives `name` and the
+      // ticker a vault list renders — and the honest ticker for a
+      // position denominated 1:1 in ZCHF is ZCHF. Inventing `sZCHF`
+      // would name a token that does not exist, and `svZCHF` is already
+      // taken by an unrelated third-party ERC-4626 wrapper
+      // (0x637f00cA…, ~1 ZCHF of TVL) that would then be conflated with
+      // this row.
+      //
+      // Exit is instant and never short (withdrawals are paid from the
+      // module's own balance), but the YIELD is not instant:
+      // `INTEREST_DELAY` is 3 days and a top-up re-weights the account's
+      // tick counter, so exiting early can realise ~0 %.
+      reader: "frankencoin-savings",
+      address: "0x27d9ad987bde08a0d083ef7e0e4043c857a17b38",
+      underlying: "0xb58e61c3098d85632df34eecfb899a1ed80921cb",
+      // ZCHF
+      symbol: "ZCHF",
+      brand: "Frankencoin",
+      description: "ZCHF is Frankencoin's decentralised Swiss-franc stablecoin, minted against collateral in permissionless, auction-policed positions. The savings module pays a governance-set rate funded by borrower interest: deposits are never lent on (they sit segregated inside the module) and interest is minted by the protocol into your balance, so there are no shares and no share price. Withdrawals are instant and uncapped, but interest only starts accruing after 3 days and a top-up restarts that clock pro-rata, so a short stay can earn nothing.",
+      decimals: 18,
+      isRebasing: true,
+      isMintable: true,
+      withdrawalMode: "instant",
+      yieldFetcher: frankencoinSavingsFetcher,
+      yieldKey: ZCHF_SAVINGS_KEY
     }
   ],
   "42161": [
@@ -50036,7 +52094,7 @@ query EvkByAssets($assets: [Bytes!]!) {
   }
 }
 `;
-var ZERO = 0n;
+var ZERO2 = 0n;
 var RAY_TO_PERCENT3 = 1e25;
 function readAddress2(field12) {
   if (!field12) return void 0;
@@ -50051,28 +52109,28 @@ function parseVaultFee(v) {
   return n;
 }
 function safeBigInt(v) {
-  if (v == null || v === "") return ZERO;
+  if (v == null || v === "") return ZERO2;
   try {
     return BigInt(v);
   } catch {
-    return ZERO;
+    return ZERO2;
   }
 }
 function computeWeightedSupplyApy(strategies, totalAssetsRaw, feePercent, evkIndex) {
   if (!strategies?.length) return 0;
   const totalAssets = safeBigInt(totalAssetsRaw);
-  if (totalAssets === ZERO) return 0;
-  let weightedRay = ZERO;
+  if (totalAssets === ZERO2) return 0;
+  let weightedRay = ZERO2;
   for (const s of strategies) {
     const evk = s.strategy?.toLowerCase();
     if (!evk) continue;
     const apyRay = evkIndex.bySupplyApyRay.get(evk);
     if (apyRay == null) continue;
     const allocated = safeBigInt(s.allocatedAssets);
-    if (allocated === ZERO) continue;
+    if (allocated === ZERO2) continue;
     weightedRay += allocated * apyRay;
   }
-  if (weightedRay === ZERO) return 0;
+  if (weightedRay === ZERO2) return 0;
   const apyRayPerAsset = weightedRay / totalAssets;
   const grossPercent = apyToAprPercent(Number(apyRayPerAsset) / RAY_TO_PERCENT3);
   const netPercent = grossPercent * (1 - feePercent / 100);
@@ -50080,24 +52138,24 @@ function computeWeightedSupplyApy(strategies, totalAssetsRaw, feePercent, evkInd
 }
 function computeRealLiquidity(strategies, totalAssetsRaw, evkIndex) {
   const totalAssets = safeBigInt(totalAssetsRaw);
-  if (totalAssets === ZERO) return ZERO;
+  if (totalAssets === ZERO2) return ZERO2;
   if (evkIndex.byCash.size === 0 && evkIndex.bySupplyApyRay.size === 0) {
     return totalAssets;
   }
   if (!strategies?.length) {
     return totalAssets;
   }
-  let allocSum = ZERO;
-  let withdrawable = ZERO;
+  let allocSum = ZERO2;
+  let withdrawable = ZERO2;
   for (const s of strategies) {
     const alloc = safeBigInt(s.allocatedAssets);
-    if (alloc === ZERO) continue;
+    if (alloc === ZERO2) continue;
     allocSum += alloc;
     const evk = s.strategy?.toLowerCase();
     const cash = evk ? evkIndex.byCash.get(evk) : void 0;
     withdrawable += cash == null ? alloc : alloc < cash ? alloc : cash;
   }
-  const idle = totalAssets > allocSum ? totalAssets - allocSum : ZERO;
+  const idle = totalAssets > allocSum ? totalAssets - allocSum : ZERO2;
   const result = idle + withdrawable;
   return result > totalAssets ? totalAssets : result;
 }
@@ -50401,11 +52459,11 @@ var fetchEulerEarnVaults = async (chainId, prices = {}, tokenList = {}, multical
 };
 var warn6 = (...args) => {
 };
-var num2 = (v) => {
+var num3 = (v) => {
   const n = Number(v);
   return Number.isFinite(n) ? n : 0;
 };
-var big7 = (v) => {
+var big11 = (v) => {
   try {
     if (v === void 0 || v === null || v === "") return "0";
     const s = String(v);
@@ -50436,21 +52494,21 @@ async function fetchTermMaxVaultsFromApi(chainId, prices = {}, tokenList = {}, f
     const underlying = lower2(r?.asset?.contractAddress);
     if (!address || !underlying) continue;
     if (r.isEnabled === false) continue;
-    const assetDecimals = num2(r?.asset?.decimals) || 18;
+    const assetDecimals = num3(r?.asset?.decimals) || 18;
     const scale = 10 ** assetDecimals;
     const assetEntry = tokenList[underlying];
     const priceKey = toOracleKey(assetEntry?.assetGroup) || toGenericPriceKey(underlying, chainId);
     const priceUsd = prices[priceKey];
-    const totalAssets = big7(r.totalAssets);
-    const totalSupply = big7(r.totalSupplyAmt);
+    const totalAssets = big11(r.totalAssets);
+    const totalSupply = big11(r.totalSupplyAmt);
     const totalAssetsFormatted = Number(totalAssets) / scale;
-    const supplyRate = num2(r.apr) * 100;
-    const rewardsRate = num2(r?.incentiveData?.TMX_APR) * 100;
-    const rawLiquidity = BigInt(big7(r.redeemableAmt ?? r.idleFunds ?? "0"));
+    const supplyRate = num3(r.apr) * 100;
+    const rewardsRate = num3(r?.incentiveData?.TMX_APR) * 100;
+    const rawLiquidity = BigInt(big11(r.redeemableAmt ?? r.idleFunds ?? "0"));
     const totalAssetsBig = BigInt(totalAssets);
     const liquidity = (rawLiquidity > totalAssetsBig ? totalAssetsBig : rawLiquidity).toString();
     const liquidityFormatted = Number(liquidity) / scale;
-    const totalSupplyValue = num2(r.totalSupplyValue);
+    const totalSupplyValue = num3(r.totalSupplyValue);
     out[address] = {
       address,
       underlying,
@@ -50467,8 +52525,8 @@ async function fetchTermMaxVaultsFromApi(chainId, prices = {}, tokenList = {}, f
       rewardsRate,
       depositRate: supplyRate + rewardsRate,
       // 1e8-scaled upstream (10000000 = 10%).
-      fee: num2(r.performanceFeeRate) / 1e6,
-      timelock: num2(r.timeLockSeconds) || void 0,
+      fee: num3(r.performanceFeeRate) / 1e6,
+      timelock: num3(r.timeLockSeconds) || void 0,
       curator: r?.curator?.curatorAddress ? lower2(r.curator.curatorAddress) : void 0,
       // The API is the ONLY source for this — do not derive it from `name`.
       curatorName: r?.curator?.name || void 0,
@@ -50482,7 +52540,7 @@ async function fetchTermMaxVaultsFromApi(chainId, prices = {}, tokenList = {}, f
       liquidityUsd: priceUsd ? liquidityFormatted * priceUsd : 0,
       version: r.version,
       isPaused: r.isPaused === true || void 0,
-      supplyCap: r.capacity ? big7(r.capacity) : void 0,
+      supplyCap: r.capacity ? big11(r.capacity) : void 0,
       basePool: r.poolAddress ? lower2(r.poolAddress) : void 0
     };
   }
@@ -50538,7 +52596,7 @@ var Erc20DecimalsBalanceAbi = [
 
 // src/vaults/termmax/fetchFromChain.ts
 var DECIMAL_BASE2 = 100000000n;
-var big8 = (v) => {
+var big12 = (v) => {
   if (v === void 0 || v === null || v === "0x") return 0n;
   try {
     return typeof v === "bigint" ? v : BigInt(v);
@@ -50546,7 +52604,7 @@ var big8 = (v) => {
     return 0n;
   }
 };
-var num3 = (v) => {
+var num4 = (v) => {
   const n = Number(v);
   return Number.isFinite(n) ? n : void 0;
 };
@@ -50602,23 +52660,23 @@ var fetchTermMaxVaultsFromChain = async (chainId, multicallRetry, prices = {}, t
   vaults.forEach((address, i) => {
     const at = (k) => res[i * READS_PER_VAULT + VAULT_READS.indexOf(k)];
     const asset = addr(at("asset"));
-    const totalAssets = big8(at("totalAssets"));
+    const totalAssets = big12(at("totalAssets"));
     if (!asset || totalAssets === 0n) return;
     rows.push({
       address,
       name: str(at("name")),
       symbol: str(at("symbol")),
-      decimals: num3(at("decimals")) ?? 18,
+      decimals: num4(at("decimals")) ?? 18,
       asset,
       totalAssets,
-      totalSupply: big8(at("totalSupply")),
-      annualizedInterest: big8(at("annualizedInterest")),
-      accretingPrincipal: big8(at("accretingPrincipal")),
-      performanceFeeRate: big8(at("performanceFeeRate")),
-      aprRaw: at("apr") != null ? big8(at("apr")) : void 0,
+      totalSupply: big12(at("totalSupply")),
+      annualizedInterest: big12(at("annualizedInterest")),
+      accretingPrincipal: big12(at("accretingPrincipal")),
+      performanceFeeRate: big12(at("performanceFeeRate")),
+      aprRaw: at("apr") != null ? big12(at("apr")) : void 0,
       curator: addr(at("curator")),
       guardian: addr(at("guardian")),
-      timelock: num3(at("timelock")),
+      timelock: num4(at("timelock")),
       version: str(at("getVersion"))
     });
   });
@@ -50635,8 +52693,8 @@ var fetchTermMaxVaultsFromChain = async (chainId, multicallRetry, prices = {}, t
   });
   const out = {};
   rows.forEach((r, i) => {
-    const assetDecimals = num3(res2[i * 2]) ?? r.decimals;
-    const idle = big8(res2[i * 2 + 1]);
+    const assetDecimals = num4(res2[i * 2]) ?? r.decimals;
+    const idle = big12(res2[i * 2 + 1]);
     const assetEntry = tokenList[r.asset];
     const priceKey = toOracleKey(assetEntry?.assetGroup) || toGenericPriceKey(r.asset, chainId);
     const priceUsd = prices[priceKey];
@@ -56039,6 +58097,20 @@ var NativeWithdrawQueueReadAbi = [
   }
 ];
 
+// src/vaults/savings/abis/frankencoin.ts
+var FrankencoinSavingsReadAbi = [
+  {
+    /** Savings rate in parts per million — `35000` = 3.5 % nominal APR.
+     *  `0` means the module is disabled (`save` reverts with
+     *  `ModuleDisabled`); existing balances stay withdrawable. */
+    name: "currentRatePPM",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint24" }]
+  }
+];
+
 // src/vaults/savings/abis/yearnStrategy.ts
 var AvailableWithdrawLimitAbi = [
   {
@@ -56138,6 +58210,29 @@ var readerErc4626WithdrawLimit = (entry) => {
   };
 };
 
+// src/vaults/savings/readers/frankencoinSavings.ts
+var readerFrankencoinSavings = (entry) => ({
+  calls: [
+    { address: entry.underlying, name: "balanceOf", params: [entry.address] },
+    { address: entry.address, name: "currentRatePPM", params: [] }
+  ],
+  abis: [BalanceOfAbi, FrankencoinSavingsReadAbi],
+  parse: ([balance, ratePPM]) => {
+    const deposits = toBigInt15(balance);
+    if (deposits === void 0) return void 0;
+    if (toBigInt15(ratePPM) === void 0) return void 0;
+    return {
+      totalAssets: deposits,
+      // No shares exist; the "supply" IS the deposited principal, and
+      // the rate is fixed at par. Both are load-bearing downstream:
+      // `fetchPublic` derives `convertToAssets` / `convertToShares` from
+      // `exchangeRate`, and 1e18 makes them the identity.
+      totalSupply: deposits,
+      exchangeRate: ONE_E1811
+    };
+  }
+});
+
 // src/vaults/savings/readers/navOracle.ts
 var readerNavOracle = (entry) => {
   const shareUnit = 10n ** BigInt(entry.decimals);
@@ -56231,6 +58326,8 @@ var buildReader2 = (entry) => {
       return readerNativeWnlp(entry);
     case "nav-oracle":
       return readerNavOracle(entry);
+    case "frankencoin-savings":
+      return readerFrankencoinSavings(entry);
     case "erc4626-idle":
       return readerErc4626Idle(entry);
     case "erc4626-withdraw-limit":
@@ -56473,7 +58570,7 @@ var pickApr = (apr) => {
   if (apr.inception != null) return { rate: apr.inception, window: "inception" };
   return { rate: 0, window: "none" };
 };
-var num4 = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+var num5 = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
 function parseVault7(v, chainId, prices, tokenList) {
   const address = (v?.address ?? "").toLowerCase();
   const assetAddr = (v?.asset?.address ?? "").toLowerCase();
@@ -56489,14 +58586,14 @@ function parseVault7(v, chainId, prices, tokenList) {
     parseRawAmount(totalAssetsRaw, assetDecimals)
   );
   const apr = {
-    weekly: num4(state.weeklyApr?.twrrNetApr),
-    monthly: num4(state.monthlyApr?.twrrNetApr),
-    yearly: num4(state.yearlyApr?.twrrNetApr),
-    inception: num4(state.inceptionApr?.twrrNetApr)
+    weekly: num5(state.weeklyApr?.twrrNetApr),
+    monthly: num5(state.monthlyApr?.twrrNetApr),
+    yearly: num5(state.yearlyApr?.twrrNetApr),
+    inception: num5(state.inceptionApr?.twrrNetApr)
   };
   const { rate: supplyRate, window: aprWindow } = pickApr(apr);
   const oracleKey = toOracleKey(assetMeta?.assetGroup) ?? toGenericPriceKey(assetAddr, chainId);
-  const apiTotalAssetsUsd = num4(state.totalAssetsUsd) ?? 0;
+  const apiTotalAssetsUsd = num5(state.totalAssetsUsd) ?? 0;
   const impliedPriceUsd = totalAssetsFormatted > 0 ? apiTotalAssetsUsd / totalAssetsFormatted : 0;
   const priceUsd = prices[oracleKey] ?? prices[assetAddr] ?? impliedPriceUsd;
   const totalAssetsUsd = apiTotalAssetsUsd || totalAssetsFormatted * priceUsd;
@@ -56516,7 +58613,7 @@ function parseVault7(v, chainId, prices, tokenList) {
     totalAssets: totalAssetsRaw,
     totalSupply: totalSupplyRaw,
     pricePerShare: state.pricePerShare?.toString() ?? "0",
-    pricePerShareUsd: num4(state.pricePerShareUsd) ?? void 0,
+    pricePerShareUsd: num5(state.pricePerShareUsd) ?? void 0,
     supplyRate,
     rewardsRate: 0,
     depositRate: supplyRate,
@@ -56713,7 +58810,7 @@ var toBigInt16 = (v) => {
   }
   return void 0;
 };
-var num5 = (v) => {
+var num6 = (v) => {
   const n = Number(v);
   return Number.isFinite(n) ? n : 0;
 };
@@ -56770,12 +58867,12 @@ var fetchAaveEarnVaults = async (chainId, multicallRetry, prices = {}, tokenList
     const totalAssets = toBigInt16(slice2[0]) ?? totalSupply * convertToAssets / shareUnit;
     const totalAssetsFormatted = Number(totalAssets) / 10 ** assetDecimals;
     const asset = tokenList[underlyingLc];
-    const priceUsd = prices[underlyingLc] ?? (v.balance?.usdPerToken != null ? num5(v.balance.usdPerToken) : void 0);
+    const priceUsd = prices[underlyingLc] ?? (v.balance?.usdPerToken != null ? num6(v.balance.usdPerToken) : void 0);
     const totalAssetsUsd = priceUsd !== void 0 ? totalAssetsFormatted * priceUsd : 0;
-    const supplyRate = num5(v.vaultApr?.formatted);
+    const supplyRate = num6(v.vaultApr?.formatted);
     const rewardsRate = 0;
     const depositRate = supplyRate + rewardsRate;
-    const fee = num5(v.fee?.value);
+    const fee = num6(v.fee?.value);
     const symbol = (v.shareSymbol ?? "").trim();
     const shareName = (v.shareName ?? "").trim();
     const name = shareName || symbol;
@@ -56812,7 +58909,7 @@ var fetchAaveEarnVaults = async (chainId, multicallRetry, prices = {}, tokenList
 };
 
 // src/vaults/upshift/fetchPublic.ts
-var num6 = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+var num7 = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
 var isEvmAddress = (a) => /^0x[0-9a-fA-F]{40}$/.test(a);
 var derivePricePerShare = (totalAssetsRaw, totalSupplyRaw, shareDecimals) => {
   try {
@@ -56839,12 +58936,12 @@ function parseVault8(v, chainId, prices, tokenList) {
   const totalAssetsFormatted = Number(
     parseRawAmount(totalAssetsRaw, assetDecimals)
   );
-  const base = num6(v.apy?.apy) ?? 0;
-  const campaign = num6(v.apy?.campaignApy);
+  const base = num7(v.apy?.apy) ?? 0;
+  const campaign = num7(v.apy?.campaignApy);
   const supplyRate = apyToAprPercent(base);
   const rewardsRate = campaign != null ? apyToAprPercent(campaign) : 0;
   const oracleKey = toOracleKey(assetMeta?.assetGroup) ?? toGenericPriceKey(assetAddr, chainId);
-  const apiTvlUsd = num6(v.latest_reported_tvl) ?? 0;
+  const apiTvlUsd = num7(v.latest_reported_tvl) ?? 0;
   const impliedPriceUsd = totalAssetsFormatted > 0 ? apiTvlUsd / totalAssetsFormatted : 0;
   const priceUsd = prices[oracleKey] ?? prices[assetAddr] ?? impliedPriceUsd;
   const totalAssetsUsd = apiTvlUsd || totalAssetsFormatted * priceUsd;
@@ -56869,10 +58966,10 @@ function parseVault8(v, chainId, prices, tokenList) {
     rewardsRate,
     depositRate: supplyRate + rewardsRate,
     apy: {
-      base: num6(v.apy?.apy),
+      base: num7(v.apy?.apy),
       campaign,
-      points: num6(v.apy?.pointsApy),
-      underlying: num6(v.apy?.underlyingApy)
+      points: num7(v.apy?.pointsApy),
+      underlying: num7(v.apy?.underlyingApy)
     },
     isDepositPaused: v.isDepositPaused ?? false,
     isWithdrawalPaused: v.isWithdrawalPaused ?? false,
@@ -56981,9 +59078,9 @@ var asBig = (v) => {
     return null;
   }
 };
-var num7 = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+var num8 = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
 var toPct = (v) => {
-  const n = num7(v);
+  const n = num8(v);
   return n == null ? 0 : n * 100;
 };
 var deriveTotalSupply = (totalAssetsRaw, pricePerShareRaw, decimals) => {
@@ -57015,16 +59112,16 @@ function parseVault9(v, chainId, prices, tokenList) {
   const totalAssetsFormatted = Number(
     parseRawAmount(totalAssetsRaw, assetDecimals)
   );
-  const realized = num7(v.apr?.netAPR);
-  const forward = num7(v.apr?.forwardAPR?.netAPR);
+  const realized = num8(v.apr?.netAPR);
+  const forward = num8(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 oracleKey = toOracleKey(assetMeta?.assetGroup) ?? toGenericPriceKey(assetAddr, chainId);
-  const apiPrice = num7(v.tvl?.price) ?? 0;
+  const apiPrice = num8(v.tvl?.price) ?? 0;
   const priceUsd = prices[oracleKey] ?? prices[assetAddr] ?? apiPrice;
-  const apiTvlUsd = num7(v.tvl?.tvl) ?? 0;
+  const apiTvlUsd = num8(v.tvl?.tvl) ?? 0;
   const totalAssetsUsd = apiTvlUsd || totalAssetsFormatted * priceUsd;
   const name = (v.name ?? "").trim();
   const symbol = (v.symbol ?? "").trim();
@@ -58012,23 +60109,23 @@ var priceGmMarkets = async (chainId, multicallRetry, markets, prices) => {
     const indexMax = price(prices, m.indexToken)?.max;
     if (Array.isArray(dsRes) && longMax != null && shortMax != null) {
       const base = i * SLOTS;
-      const big9 = (j) => typeof dsRes[base + j] === "bigint" ? dsRes[base + j] : 0n;
+      const big13 = (j) => typeof dsRes[base + j] === "bigint" ? dsRes[base + j] : 0n;
       const cap = computeDepositCapacityUsd(
-        [info?.longTokenAmount, longMax, big9(0), big9(2)],
-        [info?.shortTokenAmount, shortMax, big9(1), big9(3)]
+        [info?.longTokenAmount, longMax, big13(0), big13(2)],
+        [info?.shortTokenAmount, shortMax, big13(1), big13(3)]
       );
       if (cap != null) value.depositCapacityUsd = cap;
       if (indexMax != null) {
         const divisor = m.longToken.toLowerCase() === m.shortToken.toLowerCase() ? 2n : 1n;
-        const reservedUsdLong = (big9(4) + big9(5)) / divisor * indexMax;
-        const reservedUsdShort = (big9(6) + big9(7)) / divisor;
+        const reservedUsdLong = (big13(4) + big13(5)) / divisor * indexMax;
+        const reservedUsdShort = (big13(6) + big13(7)) / divisor;
         const liq = computeLiquidityUsd(
           info?.longTokenUsd,
           info?.shortTokenUsd,
           reservedUsdLong,
           reservedUsdShort,
-          big9(8),
-          big9(9)
+          big13(8),
+          big13(9)
         );
         if (liq != null)
           value.liquidityUsd = Math.max(0, Math.min(liq, value.tvlUsd));
@@ -58227,27 +60324,27 @@ var fetchGmxExecutionFees = async (chainId, multicallRetry, gasPriceWei) => {
   } catch {
     return void 0;
   }
-  const big9 = (i) => typeof res[i] === "bigint" ? res[i] : 0n;
-  const base = big9(0);
-  const mult = big9(1);
+  const big13 = (i) => typeof res[i] === "bigint" ? res[i] : 0n;
+  const base = big13(0);
+  const mult = big13(1);
   if (base === 0n && mult === 0n) return void 0;
   const PRECISION = 10n ** 30n;
   const adjusted = (opGas) => base + opGas * mult / PRECISION;
   const fee = (opGas) => (adjusted(opGas) * gasPriceWei).toString();
-  const glvExtra = big9(6) * GLV_NOMINAL_MARKET_COUNT;
+  const glvExtra = big13(6) * GLV_NOMINAL_MARKET_COUNT;
   return {
     chainId,
     gasPriceWei: gasPriceWei.toString(),
-    deposit: fee(big9(2)),
-    withdrawal: fee(big9(3)),
-    glvDeposit: fee(big9(4) + glvExtra),
-    glvWithdrawal: fee(big9(5) + glvExtra)
+    deposit: fee(big13(2)),
+    withdrawal: fee(big13(3)),
+    glvDeposit: fee(big13(4) + glvExtra),
+    glvWithdrawal: fee(big13(5) + glvExtra)
   };
 };
 
 // src/vaults/gmx/fetchPublic.ts
 var GMX_TOKEN_DECIMALS = 18;
-var num8 = (n) => typeof n === "number" && Number.isFinite(n) ? n : 0;
+var num9 = (n) => typeof n === "number" && Number.isFinite(n) ? n : 0;
 var minDefined = (a, b) => a == null ? b : b == null ? a : Math.min(a, b);
 var glvMarketRoomUsd = (cap, priceUsd) => {
   const currentUsd = Number(cap.balanceAmount) / 1e18 * priceUsd;
@@ -58281,9 +60378,9 @@ var fetchGmxVaults = async (chainId, multicallRetry, options) => {
       indexToken: indexToken ? indexToken.toLowerCase() : void 0,
       longSymbol,
       shortSymbol,
-      apy: num8(entry?.apy),
-      baseApy: num8(entry?.baseApy),
-      bonusApr: num8(entry?.bonusApr),
+      apy: num9(entry?.apy),
+      baseApy: num9(entry?.baseApy),
+      bonusApr: num9(entry?.bonusApr),
       yieldProfile: "volatile",
       denomination: denominationFor(longSymbol, shortSymbol)
     };
@@ -59460,6 +61557,6 @@ async function fetchTokenBalances(chainId, account, tokens, options = {}) {
   return parseTokenBalanceResult(rawResult, prepared.query);
 }
 
-export { ApiBookSource, DEFAULT_MIDNIGHT_API, DEFAULT_OUTLIER_GUARD, DEFAULT_STALE_REJECT_SECONDS, DEFAULT_TERMMAX_API, EMPTY_BALANCE, EXACTLY_LENDER_KEY, GMX_API_HOSTS, GMX_READ_CONTRACTS, GMX_SUPPORTED_CHAINS, HYPERCORE_VAULT_REGISTRY, IDLE_MARKET_ID, INTERFACE_IDS, LAGOON_API_URL, LAGOON_CHAIN_IDS, MORPHO_LENS, MaxParamThresholds, STABLECOIN_SYMBOLS, STCELO_MANAGER_ADDRESS, TELLER_CALLS_PER_BID, TERMMAX_CALLS_PER_ACCOUNT, DECIMAL_BASE as TERMMAX_DECIMAL_BASE, TERMMAX_LIQUIDATION_PENALTY, TERMMAX_LIQUIDATION_WINDOW_SECS, TERMMAX_LIQUIDATOR_BONUS, TERMMAX_PARTIAL_CLOSE_FACTOR, TERMMAX_PARTIAL_LIQUIDATION_THRESHOLD_USD, TermMaxApiSource, TermSubgraphSource, UPSHIFT_CHAIN_IDS, UPSHIFT_VAULTS_URL, VAULT_SHARE_PRICE_PROBE, VOLATILE_VAULT_OVERRIDES, YEARN_CHAIN_IDS, YEARN_YDAEMON_BASE, accountDepositListKey, accountWithdrawalListKey, appendSnapshot, applyPositionDelta, attachPricesToFlashLiquidity, buildFluidFTokensCall, buildLiquityUserCall, buildLoopResult, buildMorphoTypeCall, buildMorphoTypeUserCallWithLens, buildPortfolioTotals, buildSumerAccumulators, buildSummaries, buildTellerUserCall, buildTermMaxUserCall, buildVaultLookup, calculateLeverage, calculateNetApr, calculateOverallNetApr, calculateWeightedAverage, classifyFreshness, classifyReliability, classifyVault, collectFeedObservations, computeBorrowDelta2 as computeBorrowDelta, computeCloseTradeDeltas, computeCollateralSwapDeltas, computeDebtSwapDeltas, computeDepositDelta2 as computeDepositDelta, computeEModeAnalysis, computeOpenTradeDeltas, computePostTradeMetrics, computeRepayDelta2 as computeRepayDelta, computeSumerBorrowDelta, computeSumerDepositDelta, computeSumerRepayDelta, computeSumerWaterfall, computeSumerWithdrawDelta, computeVaultApr, computeWithdrawDelta2 as computeWithdrawDelta, computeZapTradeDeltas, consensusReference, convertExactlyMarketsToResponse, convertInverseMarketsToResponse, convertLenderUserDataResult, convertLiquityMarketsToResponse, convertRiverMarketsToResponse, convertTellerMarketsToResponse, convertTermMarketsToResponse, convertTermMaxMarketsToResponse, convertUsddMarketsToResponse, createMarketUid, createMidnightBookSource, createMulticallRpcCall, createRawRpcCalls, createTermBookSource, createTermMaxDataSource, decodeListaMarkets, decodeMarkets, decodePackedListaUserDataset, decodePackedMorphoUserDataset, detectInterfaceKinds, encodeBalanceFetcherCalldata, exactlyPairLtv, exactlyPenaltyRateToAprPercent, exactlyWadRateToPercent, feedKeyOf, feedStatKey, fetchDolomiteAccountNumbers, fetchEulerEarnVaults, fetchEulerEarnVaultsFromSubgraph, fetchEulerSubAccountIndexes, fetchExactlyMarkets, fetchFlashLiquidityForChain, fetchFluidFTokens, fetchGeneralYields, fetchGeneralYieldsByMarketUid, fetchGmxExecutionFees, fetchGmxTickerPrices, fetchGmxVaults, fetchHypercoreVaults, fetchInverseMarkets, fetchLagoonApiVaults, fetchLagoonVaults, fetchLiquityMarkets, fetchListaVaultsFromChain, fetchMorphoUserBalances, fetchMorphoUserPositionMarkets, fetchMorphoVaults, fetchMorphoVaultsFromApi, fetchMorphoVaultsFromChain, fetchOraclePrices, fetchPendlePrices, fetchRiverMarkets, fetchSiloVaults, fetchTellerMarkets, fetchTermMarkets, fetchTermMaxMarkets, fetchTokenBalances, fetchTokenMetadata, fetchUpshiftApiVaults, fetchUpshiftVaults, fetchUsddMarkets, fetchYearnApiVaults, fetchYearnVaults, filterActiveLenders, filterLendersByProtocol, fuseLenderData, generateLendingPools, getAavesForChain, getAssetConfig, getBalanceForMarketUid, getBorrowCapacity, getCachedLiquityTroves, getCachedTellerBids, getCachedTermMaxDiscovery, getCachedTermMaxMarket, getCachedTermMaxMarkets, getCoreValidators, getFluidFTokensConverter, getGmxApiHost, getGmxReadContracts, getGmxUserPositions, getHealthFactor, getHypercoreUserPositions, getHypercoreVaultRegistry, getLenderAssets, getLenderPublicData, getLenderPublicDataAll, getLenderPublicDataViaApi, getLenderUserDataMulti, getLenderUserDataResult, getLendersForChain, getLstDelegation, getLstValidators, getLstWithdrawalRegistry, getLstWithdrawalRequests, getMaxAmountClose, getMaxAmountCollateralSwap, getMaxAmountDebtSwap, getMaxAmountOpen, getMergedUserData, getMorphoTypeMarketConverter, getResolvedDolomiteAccountNumbers, getStCeloValidatorGroups, getSubAccountAddress, getSubAccountIndex, getVaultPublicDataAll, getVaultWithdrawalRequests, hasEulerEarnVaultSubgraph, hasLagoonVaults, hasMorphoPositionIndex, hasMorphoUserApi, hasMorphoUserSubgraph, hasUpshiftVaults, hasYearnVaults, inverseKeyParts, inverseLenderKey, isStablecoinSymbol, isYearnV3, keysFromMaps, lenderApiOnly, lenderFamily, liquityCandidateTroveIds, liquityKeyParts, liquityLenderKey, multicall3Abi2 as multicall3Abi, nanTo, needsLenderApproval, needsTokenApproval, noOpResult, normalizeToBytes, parseBalanceFetcherResult, parseMergedResult, parseMulticallRpcResponses, parseRawRpcBatchResponses, parseRawRpcResponses, parseTermMaxLtv, parseTokenBalanceResult, positivePart2 as positivePart, predictInverseEscrow, prepareLenderUserDataRpcCalls, prepareMergedMulticallParams, prepareMergedRpcCalls, prepareMulticallInputs, prepareTokenBalanceRpcCalls, priceGlvVaults, priceGmMarkets, probeAaveFeedTimestamps, pruneFeedStats, readVaultSharePrices, rejectOutliers as rejectPriceOutliers, resolveDerivation, resolveStCeloDepositGroup, riverKeyParts, riverLenderKey, selectAssetGroupPrices, stampVaultClassification, tellerBpsToPercent, tellerImpliedLtv, tellerLenderKey, tellerPoolFromLenderKey, termLenderKey, termMaxApiBase, borrowNif as termMaxBorrowNif, curveApr as termMaxCurveApr, curveAprNumber as termMaxCurveAprNumber, daysToMaturity as termMaxDaysToMaturity, lendNif as termMaxLendNif, mintGtFeeRatio as termMaxMintGtFeeRatio, ratioToNumber as termMaxRatioToNumber, ratioToPercent as termMaxRatioToPercent, tickToAprNumber, tickToPrice, unflattenLenderData, updateFeedStats, usddIlkBytes32, usddKeyParts, usddLenderKey };
+export { ApiBookSource, DEFAULT_MIDNIGHT_API, DEFAULT_OUTLIER_GUARD, DEFAULT_STALE_REJECT_SECONDS, DEFAULT_TERMMAX_API, EMPTY_BALANCE, EXACTLY_LENDER_KEY, GMX_API_HOSTS, GMX_READ_CONTRACTS, GMX_SUPPORTED_CHAINS, HYPERCORE_VAULT_REGISTRY, IDLE_MARKET_ID, INTERFACE_IDS, LAGOON_API_URL, LAGOON_CHAIN_IDS, MORPHO_LENS, MaxParamThresholds, STABLECOIN_SYMBOLS, STCELO_MANAGER_ADDRESS, TELLER_CALLS_PER_BID, TERMMAX_CALLS_PER_ACCOUNT, DECIMAL_BASE as TERMMAX_DECIMAL_BASE, TERMMAX_LIQUIDATION_PENALTY, TERMMAX_LIQUIDATION_WINDOW_SECS, TERMMAX_LIQUIDATOR_BONUS, TERMMAX_PARTIAL_CLOSE_FACTOR, TERMMAX_PARTIAL_LIQUIDATION_THRESHOLD_USD, TermMaxApiSource, TermSubgraphSource, UPSHIFT_CHAIN_IDS, UPSHIFT_VAULTS_URL, VAULT_SHARE_PRICE_PROBE, VOLATILE_VAULT_OVERRIDES, YEARN_CHAIN_IDS, YEARN_YDAEMON_BASE, __resetResupplyUserCaches, accountDepositListKey, accountWithdrawalListKey, appendSnapshot, applyPositionDelta, attachPricesToFlashLiquidity, buildFluidFTokensCall, buildLiquityUserCall, buildLoopResult, buildMorphoTypeCall, buildMorphoTypeUserCallWithLens, buildPortfolioTotals, buildSumerAccumulators, buildSummaries, buildTellerUserCall, buildTermMaxUserCall, buildVaultLookup, calculateLeverage, calculateNetApr, calculateOverallNetApr, calculateWeightedAverage, classifyFreshness, classifyReliability, classifyVault, collectFeedObservations, computeBorrowDelta2 as computeBorrowDelta, computeCloseTradeDeltas, computeCollateralSwapDeltas, computeDebtSwapDeltas, computeDepositDelta2 as computeDepositDelta, computeEModeAnalysis, computeOpenTradeDeltas, computePostTradeMetrics, computeRepayDelta2 as computeRepayDelta, computeSumerBorrowDelta, computeSumerDepositDelta, computeSumerRepayDelta, computeSumerWaterfall, computeSumerWithdrawDelta, computeVaultApr, computeWithdrawDelta2 as computeWithdrawDelta, computeZapTradeDeltas, consensusReference, convertExactlyMarketsToResponse, convertFrankencoinMarketsToResponse, convertInverseMarketsToResponse, convertLenderUserDataResult, convertLiquityMarketsToResponse, convertLlamaLendMarketsToResponse, convertResupplyMarketsToResponse, convertRiverMarketsToResponse, convertTellerMarketsToResponse, convertTermMarketsToResponse, convertTermMaxMarketsToResponse, convertUsddMarketsToResponse, createMarketUid, createMidnightBookSource, createMulticallRpcCall, createRawRpcCalls, createTermBookSource, createTermMaxDataSource, decodeListaMarkets, decodeMarkets, decodePackedListaUserDataset, decodePackedMorphoUserDataset, detectInterfaceKinds, encodeBalanceFetcherCalldata, exactlyPairLtv, exactlyPenaltyRateToAprPercent, exactlyWadRateToPercent, feedKeyOf, feedStatKey, fetchDolomiteAccountNumbers, fetchEulerEarnVaults, fetchEulerEarnVaultsFromSubgraph, fetchEulerSubAccountIndexes, fetchExactlyMarkets, fetchFlashLiquidityForChain, fetchFluidFTokens, fetchFrankencoinMarkets, fetchGeneralYields, fetchGeneralYieldsByMarketUid, fetchGmxExecutionFees, fetchGmxTickerPrices, fetchGmxVaults, fetchHypercoreVaults, fetchInverseMarkets, fetchLagoonApiVaults, fetchLagoonVaults, fetchLiquityMarkets, fetchListaVaultsFromChain, fetchLlamaLendMarkets, fetchMorphoUserBalances, fetchMorphoUserPositionMarkets, fetchMorphoVaults, fetchMorphoVaultsFromApi, fetchMorphoVaultsFromChain, fetchOraclePrices, fetchPendlePrices, fetchResupplyMarkets, fetchRiverMarkets, fetchSiloVaults, fetchTellerMarkets, fetchTermMarkets, fetchTermMaxMarkets, fetchTokenBalances, fetchTokenMetadata, fetchUpshiftApiVaults, fetchUpshiftVaults, fetchUsddMarkets, fetchYearnApiVaults, fetchYearnVaults, filterActiveLenders, filterLendersByProtocol, frankencoinKeyParts, frankencoinLenderKey, fuseLenderData, generateLendingPools, getAavesForChain, getAssetConfig, getBalanceForMarketUid, getBorrowCapacity, getCachedLiquityTroves, getCachedTellerBids, getCachedTermMaxDiscovery, getCachedTermMaxMarket, getCachedTermMaxMarkets, getCoreValidators, getFluidFTokensConverter, getGmxApiHost, getGmxReadContracts, getGmxUserPositions, getHealthFactor, getHypercoreUserPositions, getHypercoreVaultRegistry, getLenderAssets, getLenderPublicData, getLenderPublicDataAll, getLenderPublicDataViaApi, getLenderUserDataMulti, getLenderUserDataResult, getLendersForChain, getLstDelegation, getLstValidators, getLstWithdrawalRegistry, getLstWithdrawalRequests, getMaxAmountClose, getMaxAmountCollateralSwap, getMaxAmountDebtSwap, getMaxAmountOpen, getMergedUserData, getMorphoTypeMarketConverter, getResolvedDolomiteAccountNumbers, getStCeloValidatorGroups, getSubAccountAddress, getSubAccountIndex, getVaultPublicDataAll, getVaultWithdrawalRequests, hasEulerEarnVaultSubgraph, hasLagoonVaults, hasMorphoPositionIndex, hasMorphoUserApi, hasMorphoUserSubgraph, hasUpshiftVaults, hasYearnVaults, inverseKeyParts, inverseLenderKey, isStablecoinSymbol, isYearnV3, keysFromMaps, lenderApiOnly, lenderFamily, liquityCandidateTroveIds, liquityKeyParts, liquityLenderKey, llamaLendKeyParts, llamaLendLenderKey, multicall3Abi2 as multicall3Abi, nanTo, needsLenderApproval, needsTokenApproval, noOpResult, normalizeToBytes, parseBalanceFetcherResult, parseMergedResult, parseMulticallRpcResponses, parseRawRpcBatchResponses, parseRawRpcResponses, parseTermMaxLtv, parseTokenBalanceResult, positivePart2 as positivePart, predictInverseEscrow, prepareLenderUserDataRpcCalls, prepareMergedMulticallParams, prepareMergedRpcCalls, prepareMulticallInputs, prepareTokenBalanceRpcCalls, priceGlvVaults, priceGmMarkets, probeAaveFeedTimestamps, pruneFeedStats, readVaultSharePrices, rejectOutliers as rejectPriceOutliers, resolveDerivation, resolveStCeloDepositGroup, resupplyKeyParts, resupplyLenderKey, riverKeyParts, riverLenderKey, selectAssetGroupPrices, stampVaultClassification, tellerBpsToPercent, tellerImpliedLtv, tellerLenderKey, tellerPoolFromLenderKey, termLenderKey, termMaxApiBase, borrowNif as termMaxBorrowNif, curveApr as termMaxCurveApr, curveAprNumber as termMaxCurveAprNumber, daysToMaturity as termMaxDaysToMaturity, lendNif as termMaxLendNif, mintGtFeeRatio as termMaxMintGtFeeRatio, ratioToNumber as termMaxRatioToNumber, ratioToPercent as termMaxRatioToPercent, tickToAprNumber, tickToPrice, unflattenLenderData, updateFeedStats, usddIlkBytes32, usddKeyParts, usddLenderKey };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map