@1delta/margin-fetcher 5.0.90 → 5.0.91

package/dist/index.js

@@ -1,4 +1,4 @@
-import { parseAbi, keccak256, encodeAbiParameters, formatEther, BaseError, erc20Abi, isAddress, stringToHex, pad, encodeFunctionData, formatUnits, getAddress, decodeFunctionResult, decodeAbiParameters, toBytes, slice, concat, AbiEncodingLengthMismatchError, concatHex, parseAbiParameters, hexToString, InvalidAddressError, boolToHex, integerRegex, numberToHex, bytesRegex, BytesSizeMismatchError, arrayRegex, UnsupportedPackedAbiType } from './chunk-JUYF2XLF.js';
+import { parseAbi, keccak256, encodeAbiParameters, formatEther, BaseError, erc20Abi, isAddress, stringToHex, pad, encodeFunctionData, decodeFunctionResult, decodeAbiParameters, formatUnits, getAddress, toBytes, slice, concat, AbiEncodingLengthMismatchError, concatHex, parseAbiParameters, hexToString, InvalidAddressError, boolToHex, integerRegex, numberToHex, bytesRegex, BytesSizeMismatchError, arrayRegex, UnsupportedPackedAbiType } from './chunk-JUYF2XLF.js';
 import './chunk-BYTNVMX7.js';
 import './chunk-PR4QN5HX.js';
 import { Lender, isExactly, isMidnight, isTerm, isTermMax, isTeller, isListaDao, isLiquityFamily, isRiver, isInverse, isCooler, isDssType, isCompoundV3Type, isFluid, isGearboxV3, isLlamaLend, isFrankencoin, isResupply, isCurvance, isFlyingTulip, isTwyne, isFraxlend, isAaveV4Type, LIQUITY_FAMILY_LENDERS, isAaveType, isCompoundV3, isCompoundV2Type, isMultiMarket, isSiloV2Type, isSiloV3Type, isDolomite, isMorphoType, isUsdd, isSky, hasCrossMarginRisk, isEulerType, isInit, isVenusType, isSumerType, AAVE_V3_LENDERS, AAVE_V2_LENDERS, isMorphoBlue, isAaveV2Type, isAaveV32Type, isAaveV3Type, isYLDR, isLista, hasSubAccounts, isTectonicType, isKineticType, isBenqiType } from '@1delta/lender-registry';
@@ -10656,6 +10656,7 @@ var brokerAbi = parseAbi([
 ]);
 var BROKER_CACHE = {};
 var FIXED_TERMS_CACHE = {};
+var brokerUserCacheKey = (chainId, account, blockNumber) => `${chainId}:${account.toLowerCase()}:${blockNumber === void 0 ? "head" : blockNumber.toString()}`;
 var BROKER_USER_CACHE = {};
 var FIXED_TERMS_INFLIGHT = {};
 function toBytes32MarketId(key3) {
@@ -10820,11 +10821,11 @@ async function fetchListaFixedTerms(chainId, marketKeys, multicallRetry) {
 function getCachedListaFixedTerms(chainId, marketKey2) {
   return FIXED_TERMS_CACHE[chainId]?.[toBytes32MarketId(marketKey2)];
 }
-async function fetchListaBrokerUserData(chainId, account, marketKeys, nowSecs = Math.floor(Date.now() / 1e3), getClient = getEvmClient) {
+async function fetchListaBrokerUserData(chainId, account, marketKeys, nowSecs = Math.floor(Date.now() / 1e3), getClient = getEvmClient, blockNumber) {
   const brokers = await resolveListaBrokers(chainId, marketKeys, getClient);
   const ids = Object.keys(brokers);
   const out = {};
-  const cacheKey7 = `${chainId}:${account.toLowerCase()}`;
+  const cacheKey7 = brokerUserCacheKey(chainId, account, blockNumber);
   BROKER_USER_CACHE[cacheKey7] = out;
   if (ids.length === 0) return out;
   try {
@@ -10858,7 +10859,11 @@ async function fetchListaBrokerUserData(chainId, account, marketKeys, nowSecs =
         }
       ];
     });
-    const results = await client.multicall({ allowFailure: true, contracts });
+    const results = await client.multicall({
+      allowFailure: true,
+      contracts,
+      ...blockNumber === void 0 ? {} : { blockNumber }
+    });
     const now = BigInt(nowSecs);
     ids.forEach((id, marketIdx) => {
       const base = marketIdx * 4;
@@ -10931,8 +10936,8 @@ async function fetchListaBrokerUserData(chainId, account, marketKeys, nowSecs =
   }
   return out;
 }
-function getCachedListaBrokerUserData(chainId, account, marketKey2) {
-  return BROKER_USER_CACHE[`${chainId}:${account.toLowerCase()}`]?.[toBytes32MarketId(marketKey2)];
+function getCachedListaBrokerUserData(chainId, account, marketKey2, blockNumber) {
+  return BROKER_USER_CACHE[brokerUserCacheKey(chainId, account, blockNumber)]?.[toBytes32MarketId(marketKey2)];
 }
 var { chunk } = lodash;
 var MORPHO_LENS = {
@@ -10996,22 +11001,17 @@ var buildMorphoUserCallWithLens = (chainId, account, lender, marketsToQuery) =>
     ]
   }));
 };
-var buildMorphoTypeUserCallWithLens = (chainId, account, lender, marketsToQuery, getClient) => {
-  return lender === Lender.MORPHO_BLUE ? buildMorphoUserCallWithLens(chainId, account, lender, marketsToQuery) : buildListaUserCallWithLens(
-    chainId,
-    account,
-    lender,
-    marketsToQuery,
-    getClient
-  );
+var buildMorphoTypeUserCallWithLens = (chainId, account, lender, marketsToQuery, opts) => {
+  return lender === Lender.MORPHO_BLUE ? buildMorphoUserCallWithLens(chainId, account, lender, marketsToQuery) : buildListaUserCallWithLens(chainId, account, lender, marketsToQuery, opts);
 };
-var buildListaUserCallWithLens = async (chainId, account, lender, marketsToQuery, getClient) => {
+var buildListaUserCallWithLens = async (chainId, account, lender, marketsToQuery, opts) => {
   await fetchListaBrokerUserData(
     chainId,
     account,
     marketsToQuery,
     void 0,
-    getClient
+    opts?.getClient,
+    opts?.blockNumber
   ).catch(() => ({}));
   const marketSlices = chunk(marketsToQuery, 100);
   return marketSlices.flatMap((marketsInChunk) => ({
@@ -12018,7 +12018,7 @@ function createSumerUserState(payload, lenderData, totalDeposits24h = 0, totalDe
 }
 
 // src/lending/user-data/utils/createMultiAccountStyleUserState.ts
-function createMultiAccountTypeUserState(payload, lenderData, histData) {
+function createMultiAccountTypeUserState(payload, lenderData, histData, accountAddresses) {
   const positionKeys = Object.keys(payload.lendingPositions ?? {});
   let marketUids2 = getMarketUidsFromMeta(lenderData);
   const { chainId, account } = payload;
@@ -12094,7 +12094,10 @@ function createMultiAccountTypeUserState(payload, lenderData, histData) {
       rewardApr: safeDivide(rewardDepositAccrual + rewardBorrowAccrual, nav),
       rewardDepositApr: safeDivide(rewardDepositAccrual, deposits),
       rewardBorrowApr: safeDivide(rewardBorrowAccrual, debt),
-      intrinsicApr: safeDivide(stakingDepositAccrual - stakingBorrowAccrual, nav),
+      intrinsicApr: safeDivide(
+        stakingDepositAccrual - stakingBorrowAccrual,
+        nav
+      ),
       intrinsicDepositApr: safeDivide(stakingDepositAccrual, deposits),
       intrinsicBorrowApr: safeDivide(stakingBorrowAccrual, debt),
       rewards: {}
@@ -12117,10 +12120,14 @@ function createMultiAccountTypeUserState(payload, lenderData, histData) {
           withdrawable = String(pos.deposits);
         } else {
           const withdrawableUSD = Math.max(creditLine / bcf, 0);
-          withdrawable = String(Math.min(withdrawableUSD / price2, Number(pos.deposits)));
+          withdrawable = String(
+            Math.min(withdrawableUSD / price2, Number(pos.deposits))
+          );
         }
         if (withdrawLiquidity != null) {
-          withdrawable = String(Math.min(Number(withdrawable), withdrawLiquidity));
+          withdrawable = String(
+            Math.min(Number(withdrawable), withdrawLiquidity)
+          );
         }
         let borrowable;
         if (!flags?.borrowingEnabled || flags?.isFrozen || config?.debtDisabled) {
@@ -12134,7 +12141,9 @@ function createMultiAccountTypeUserState(payload, lenderData, histData) {
         }
         pos.withdrawable = withdrawable;
         pos.borrowable = borrowable;
-        pos.underlyingInfo = buildUnderlyingInfo(lenderData[marketUid]);
+        pos.underlyingInfo = buildUnderlyingInfo(
+          lenderData[marketUid]
+        );
       } else if ((deposits > 0 || debt > 0) && flags?.borrowingEnabled && !flags?.isFrozen && !config?.debtDisabled) {
         let borrowable = String(Math.max(creditLine / bf, 0) / price2);
         if (borrowLiquidity != null) {
@@ -12156,6 +12165,7 @@ function createMultiAccountTypeUserState(payload, lenderData, histData) {
     }
     data.push({
       accountId: posId,
+      ...accountAddresses?.[posId] ? { accountAddress: accountAddresses[posId] } : {},
       health: balanceData2.debt === 0 ? null : balanceData2.adjustedDebt > 0 ? balanceData2.borrowDiscountedCollateral / balanceData2.adjustedDebt : balanceData2.collateral / balanceData2.debt,
       borrowCapacityUSD: creditLine,
       userConfig,
@@ -12173,6 +12183,27 @@ function createMultiAccountTypeUserState(payload, lenderData, histData) {
     data
   };
 }
+
+// src/lending/user-data/utils/readContext.ts
+var blockNumberFromTag = (blockTag) => {
+  if (blockTag === void 0 || blockTag === null) return void 0;
+  if (typeof blockTag === "bigint") return blockTag;
+  if (typeof blockTag === "number")
+    return Number.isInteger(blockTag) && blockTag >= 0 ? BigInt(blockTag) : void 0;
+  const s = blockTag.trim();
+  if (!/^(0x[0-9a-fA-F]+|\d+)$/.test(s)) return void 0;
+  try {
+    return BigInt(s);
+  } catch {
+    return void 0;
+  }
+};
+var blockKey = (opts) => opts?.blockNumber === void 0 ? "head" : opts.blockNumber.toString();
+var discoveryMulticall = (params, opts) => multicallRetryUniversal({
+  ...params,
+  ...opts?.blockNumber === void 0 ? {} : { blockNumber: opts.blockNumber },
+  ...opts?.rpcOverrides === void 0 ? {} : { overrides: opts.rpcOverrides }
+});
 var isFixedTermLender = (lender) => isMidnight(lender) || isTerm(lender) || isTermMax(lender) || isTeller(lender) || isExactly(lender);
 function positionUnitKind(lenderKey, p) {
   const hasShares = p.depositShares !== void 0 || p.debtShares !== void 0;
@@ -30471,6 +30502,166 @@ var getLenderPublicDataAll = async (chainId, lenders, prices, additionalYields,
   }
   return { ...onChainRes, ...apiRes };
 };
+var marketKeysOf = (params) => Array.isArray(params) ? params : void 0;
+var subAccountsOf = (params) => params === void 0 || Array.isArray(params) ? void 0 : params;
+function organizeUserQueries(queries) {
+  const morphos = queries.filter((q) => isMorphoType(q.lender));
+  const gearbox = queries.filter((q) => isGearboxV3(q.lender));
+  const midnight = queries.filter((q) => isMidnight(q.lender));
+  const term = queries.filter((q) => isTerm(q.lender));
+  const exactly = queries.filter((q) => isExactly(q.lender));
+  const liquity = queries.filter((q) => isLiquityFamily(q.lender));
+  const river = queries.filter((q) => isRiver(q.lender));
+  const teller = queries.filter((q) => isTeller(q.lender));
+  const termMax = queries.filter((q) => isTermMax(q.lender));
+  const usdd = queries.filter((q) => isUsdd(q.lender));
+  const sky = queries.filter((q) => isSky(q.lender));
+  const llamaLend = queries.filter((q) => isLlamaLend(q.lender));
+  const siloV2 = queries.filter((q) => isSiloV2Type(q.lender));
+  const siloV3 = queries.filter((q) => isSiloV3Type(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 && sky.length === 0 && frankencoin.length === 0 && llamaLend.length === 0 && siloV2.length === 0 && siloV3.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) && !isDssType(q.lender) && !isFrankencoin(q.lender) && !isLlamaLend(q.lender) && !isSiloV2Type(q.lender) && !isSiloV3Type(q.lender)
+  );
+  const morphoBlue = morphos.filter((q) => q.lender.startsWith("MORPHO_BLUE"));
+  const moolah = morphos.filter((q) => q.lender.startsWith("LISTA_DAO"));
+  const result = [...others];
+  if (morphoBlue.length > 0) {
+    result.push({
+      lender: Lender.MORPHO_BLUE,
+      account: morphoBlue[0].account,
+      params: morphoBlue.map((p) => p.lender),
+      assets: void 0
+    });
+  }
+  if (moolah.length > 0) {
+    result.push({
+      lender: Lender.LISTA_DAO,
+      account: moolah[0].account,
+      params: moolah.map((p) => p.lender),
+      assets: void 0
+    });
+  }
+  if (gearbox.length > 0) {
+    result.push({
+      lender: Lender.GEARBOX_V3,
+      account: gearbox[0].account,
+      params: gearbox.map((p) => p.lender),
+      assets: void 0
+    });
+  }
+  if (midnight.length > 0) {
+    result.push({
+      lender: Lender.MORPHO_MIDNIGHT,
+      account: midnight[0].account,
+      params: midnight.map((p) => p.lender),
+      assets: void 0
+    });
+  }
+  if (term.length > 0) {
+    result.push({
+      lender: Lender.TERM_FINANCE,
+      account: term[0].account,
+      params: term.map((p) => p.lender),
+      assets: void 0
+    });
+  }
+  if (exactly.length > 0) {
+    result.push({
+      lender: Lender.EXACTLY,
+      account: exactly[0].account,
+      params: exactly.map((p) => p.lender),
+      assets: void 0
+    });
+  }
+  if (river.length > 0) {
+    result.push({
+      lender: Lender.RIVER,
+      account: river[0].account,
+      params: river.map((p) => p.lender),
+      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,
+      account: usdd[0].account,
+      params: usdd.map((p) => p.lender),
+      assets: void 0
+    });
+  }
+  if (sky.length > 0) {
+    result.push({
+      lender: Lender.SKY,
+      account: sky[0].account,
+      params: sky.map((p) => p.lender),
+      assets: void 0
+    });
+  }
+  if (siloV2.length > 0) {
+    result.push({
+      lender: "SILO_V2",
+      account: siloV2[0].account,
+      params: siloV2.map((p) => p.lender),
+      assets: void 0
+    });
+  }
+  if (siloV3.length > 0) {
+    result.push({
+      lender: "SILO_V3",
+      account: siloV3[0].account,
+      params: siloV3.map((p) => p.lender),
+      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,
+      account: teller[0].account,
+      params: teller.map((p) => p.lender),
+      assets: void 0
+    });
+  }
+  if (termMax.length > 0) {
+    result.push({
+      lender: Lender.TERMMAX,
+      account: termMax[0].account,
+      params: termMax.map((p) => p.lender),
+      assets: void 0
+    });
+  }
+  if (liquity.length > 0) {
+    for (const base of LIQUITY_FAMILY_LENDERS) {
+      const members = liquity.filter((q) => q.lender.startsWith(base));
+      if (members.length === 0) continue;
+      result.push({
+        lender: base,
+        account: members[0].account,
+        params: members.map((p) => p.lender),
+        assets: void 0
+      });
+    }
+  }
+  return result;
+}
 
 // src/lending/user-data/aave-v2-type/userCallBuild.ts
 var getBaseAaveV2Calls = (chainId, account, lender, assetsToQuery) => {
@@ -31840,7 +32031,7 @@ var buildExactlyUserCall = (chainId, _lender, account) => {
 var OWNER_INDEX_PROBE_COUNT = 8;
 var CACHE_TTL_MS = 5 * 6e4;
 var discoveryCache = /* @__PURE__ */ new Map();
-async function discoverViaLens(chainId, branches, zappers, account) {
+async function discoverViaLens(chainId, branches, zappers, account, opts) {
   const lens = getPositionLensFor(chainId, LENS_FAMILY.LIQUITY);
   if (!lens) return void 0;
   const payload = encodeAbiParameters(
@@ -31866,18 +32057,21 @@ async function discoverViaLens(chainId, branches, zappers, account) {
   );
   let blobs;
   try {
-    const res = await multicallRetryUniversal({
-      chain: chainId,
-      calls: [
-        {
-          address: lens,
-          name: "getUserData",
-          params: [[{ family: LENS_FAMILY.LIQUITY, payload }], account]
-        }
-      ],
-      abi: PositionLensAbi,
-      allowFailure: true
-    });
+    const res = await discoveryMulticall(
+      {
+        chain: chainId,
+        calls: [
+          {
+            address: lens,
+            name: "getUserData",
+            params: [[{ family: LENS_FAMILY.LIQUITY, payload }], account]
+          }
+        ],
+        abi: PositionLensAbi,
+        allowFailure: true
+      },
+      opts
+    );
     blobs = res?.[0];
   } catch {
     return void 0;
@@ -31899,9 +32093,11 @@ async function discoverViaLens(chainId, branches, zappers, account) {
   }
   return perBranch;
 }
-var cacheKey = (chainId, lender, account) => `${chainId}:${lender}:${account.toLowerCase()}`;
-var getCachedLiquityTroves = (chainId, lender, account) => {
-  const hit = discoveryCache.get(cacheKey(chainId, lender, account));
+var cacheKey = (chainId, lender, account, block = "head") => `${chainId}:${lender}:${account.toLowerCase()}:${block}`;
+var getCachedLiquityTroves = (chainId, lender, account, opts) => {
+  const hit = discoveryCache.get(
+    cacheKey(chainId, lender, account, blockKey(opts))
+  );
   if (!hit || Date.now() - hit.at > CACHE_TTL_MS) return void 0;
   return hit;
 };
@@ -31946,38 +32142,53 @@ function liquityCandidateTroveIds(account, zappers) {
   return ids;
 }
 var liquityBranchCallCount = (branch, troveCount) => troveCount * 2 + 4 + (branch.collSurplusPool ? 1 : 0);
-var buildLiquityUserCall = async (chainId, lender, account) => {
+var buildLiquityUserCall = async (chainId, lender, account, opts) => {
   const cfg = liquityConfigFor(lender, chainId);
   const branches = liquityBranchesByChain(lender, chainId);
   if (!cfg || branches.length === 0) return [];
   const zappers = cfg.zappers ?? [];
-  let perBranch = await discoverViaLens(chainId, branches, zappers, account);
+  let perBranch = await discoverViaLens(
+    chainId,
+    branches,
+    zappers,
+    account,
+    opts
+  );
   if (!perBranch) {
-    perBranch = await discoverByProbing(chainId, branches, zappers, account);
+    perBranch = await discoverByProbing(
+      chainId,
+      branches,
+      zappers,
+      account,
+      opts
+    );
     if (!perBranch) return [];
   }
-  discoveryCache.set(cacheKey(chainId, lender, account), {
+  discoveryCache.set(cacheKey(chainId, lender, account, blockKey(opts)), {
     perBranch,
     at: Date.now()
   });
   return buildDataPhaseCalls(branches, perBranch, account);
 };
-async function discoverByProbing(chainId, branches, zappers, account) {
+async function discoverByProbing(chainId, branches, zappers, account, opts) {
   const candidates = liquityCandidateTroveIds(account, zappers);
   let statuses = [];
   try {
-    statuses = await multicallRetryUniversal({
-      chain: chainId,
-      calls: branches.flatMap(
-        (b) => candidates.map((id) => ({
-          address: b.troveManager,
-          name: "getTroveStatus",
-          params: [id]
-        }))
-      ),
-      abi: LiquityTroveManagerAbi,
-      allowFailure: true
-    });
+    statuses = await discoveryMulticall(
+      {
+        chain: chainId,
+        calls: branches.flatMap(
+          (b) => candidates.map((id) => ({
+            address: b.troveManager,
+            name: "getTroveStatus",
+            params: [id]
+          }))
+        ),
+        abi: LiquityTroveManagerAbi,
+        allowFailure: true
+      },
+      opts
+    );
   } catch {
     return void 0;
   }
@@ -32289,19 +32500,22 @@ var DISCOVERY_TTL_MS = 6e4;
 var SNAPSHOT_CHUNK = 12;
 var rosterCache3 = /* @__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, allowlist2) => {
-  const cached = rosterCache3.get(rosterKey(chainId, lender));
+var rosterKey = (chainId, lender, block = "head") => `${chainId}:${lender}:${block}`;
+var discoveryKey = (chainId, lender, account, block = "head") => `${chainId}:${lender}:${account.toLowerCase()}:${block}`;
+var getCachedResupplyDiscovery = (chainId, lender, account, opts) => discoveryCache2.get(discoveryKey(chainId, lender, account, blockKey(opts)));
+var fetchRoster = async (chainId, lender, registry, allowlist2, opts) => {
+  const cached = rosterCache3.get(rosterKey(chainId, lender, blockKey(opts)));
   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
-  });
+  const [raw] = await discoveryMulticall(
+    {
+      chain: chainId,
+      calls: [{ address: registry, name: "getAllPairAddresses", params: [] }],
+      abi: ResupplyRegistryAbi,
+      allowFailure: true
+    },
+    opts
+  );
   if (Array.isArray(raw)) {
     addresses = raw.filter(
       (a) => typeof a === "string" && a.startsWith("0x")
@@ -32313,42 +32527,48 @@ var fetchRoster = async (chainId, lender, registry, allowlist2) => {
   }
   if (addresses.length === 0) {
     const empty = { pairs: [], at: Date.now() };
-    rosterCache3.set(rosterKey(chainId, lender), empty);
+    rosterCache3.set(rosterKey(chainId, lender, blockKey(opts)), 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 cols = await discoveryMulticall(
+    {
+      chain: chainId,
+      calls: addresses.map((pair) => ({
+        address: pair,
+        name: "collateral",
+        params: []
+      })),
+      abi: addresses.map(() => ResupplyPairAbi),
+      allowFailure: true
+    },
+    opts
+  );
   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() };
-  rosterCache3.set(rosterKey(chainId, lender), roster);
+  rosterCache3.set(rosterKey(chainId, lender, blockKey(opts)), roster);
   return roster;
 };
-var discoverPositions = async (chainId, pairs, account) => {
+var discoverPositions = async (chainId, pairs, account, opts) => {
   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
-      });
+      res = await discoveryMulticall(
+        {
+          chain: chainId,
+          calls: slice2.map((p) => ({
+            address: p.pair,
+            name: "getUserSnapshot",
+            params: [account]
+          })),
+          abi: slice2.map(() => ResupplyPairAbi),
+          allowFailure: true
+        },
+        opts
+      );
     } catch {
       continue;
     }
@@ -32363,9 +32583,9 @@ var discoverPositions = async (chainId, pairs, account) => {
   }
   return active;
 };
-var buildResupplyUserCall = async (chainId, lender, account) => {
+var buildResupplyUserCall = async (chainId, lender, account, opts) => {
   const cfg = resupplyConfigFor(lender, chainId);
-  const key3 = discoveryKey(chainId, lender, account);
+  const key3 = discoveryKey(chainId, lender, account, blockKey(opts));
   const stash = (positions2) => discoveryCache2.set(key3, { positions: positions2, at: Date.now() });
   if (!cfg?.registry) {
     stash([]);
@@ -32373,7 +32593,13 @@ var buildResupplyUserCall = async (chainId, lender, account) => {
   }
   let roster;
   try {
-    roster = await fetchRoster(chainId, lender, cfg.registry, cfg.pairAllowlist);
+    roster = await fetchRoster(
+      chainId,
+      lender,
+      cfg.registry,
+      cfg.pairAllowlist,
+      opts
+    );
   } catch {
     return [];
   }
@@ -32382,7 +32608,7 @@ var buildResupplyUserCall = async (chainId, lender, account) => {
     return [];
   }
   const cachedDiscovery = discoveryCache2.get(key3);
-  const positions = cachedDiscovery && Date.now() - cachedDiscovery.at < DISCOVERY_TTL_MS ? cachedDiscovery.positions : await discoverPositions(chainId, roster.pairs, account);
+  const positions = cachedDiscovery && Date.now() - cachedDiscovery.at < DISCOVERY_TTL_MS ? cachedDiscovery.positions : await discoverPositions(chainId, roster.pairs, account, opts);
   stash(positions);
   if (positions.length === 0) return [];
   return positions.flatMap(({ pair, collateral }) => [
@@ -32470,19 +32696,22 @@ var CURVANCE_MARKET_READS = 2;
 var CURVANCE_READS_PER_TOKEN = 4;
 var rosterCache4 = /* @__PURE__ */ new Map();
 var discoveryCache3 = /* @__PURE__ */ new Map();
-var rosterKey2 = (chainId, lender) => `${chainId}:${lender}`;
-var discoveryKey2 = (chainId, lender, account) => `${chainId}:${lender}:${account.toLowerCase()}`;
-var getCachedCurvanceDiscovery = (chainId, lender, account) => discoveryCache3.get(discoveryKey2(chainId, lender, account));
-var fetchRoster2 = async (chainId, lender, centralRegistry, allowlist2) => {
-  const cached = rosterCache4.get(rosterKey2(chainId, lender));
+var rosterKey2 = (chainId, lender, block = "head") => `${chainId}:${lender}:${block}`;
+var discoveryKey2 = (chainId, lender, account, block = "head") => `${chainId}:${lender}:${account.toLowerCase()}:${block}`;
+var getCachedCurvanceDiscovery = (chainId, lender, account, opts) => discoveryCache3.get(discoveryKey2(chainId, lender, account, blockKey(opts)));
+var fetchRoster2 = async (chainId, lender, centralRegistry, allowlist2, opts) => {
+  const cached = rosterCache4.get(rosterKey2(chainId, lender, blockKey(opts)));
   if (cached && Date.now() - cached.at < ROSTER_TTL_MS2) return cached;
   let managers = [];
-  const [raw] = await multicallRetryUniversal({
-    chain: chainId,
-    calls: [{ address: centralRegistry, name: "marketManagers", params: [] }],
-    abi: CurvanceCentralRegistryAbi,
-    allowFailure: true
-  });
+  const [raw] = await discoveryMulticall(
+    {
+      chain: chainId,
+      calls: [{ address: centralRegistry, name: "marketManagers", params: [] }],
+      abi: CurvanceCentralRegistryAbi,
+      allowFailure: true
+    },
+    opts
+  );
   if (Array.isArray(raw)) {
     managers = raw.filter(
       (a) => typeof a === "string" && a.startsWith("0x")
@@ -32494,19 +32723,22 @@ var fetchRoster2 = async (chainId, lender, centralRegistry, allowlist2) => {
   }
   if (managers.length === 0) {
     const empty = { markets: [], at: Date.now() };
-    rosterCache4.set(rosterKey2(chainId, lender), empty);
+    rosterCache4.set(rosterKey2(chainId, lender, blockKey(opts)), empty);
     return empty;
   }
-  const listed = await multicallRetryUniversal({
-    chain: chainId,
-    calls: managers.map((mm) => ({
-      address: mm,
-      name: "queryTokensListed",
-      params: []
-    })),
-    abi: managers.map(() => CurvanceMarketManagerAbi),
-    allowFailure: true
-  });
+  const listed = await discoveryMulticall(
+    {
+      chain: chainId,
+      calls: managers.map((mm) => ({
+        address: mm,
+        name: "queryTokensListed",
+        params: []
+      })),
+      abi: managers.map(() => CurvanceMarketManagerAbi),
+      allowFailure: true
+    },
+    opts
+  );
   const withTokens = managers.map((marketManager, i) => ({
     marketManager,
     addresses: Array.isArray(listed[i]) ? listed[i].filter(
@@ -32518,16 +32750,19 @@ var fetchRoster2 = async (chainId, lender, centralRegistry, allowlist2) => {
   );
   let assets = [];
   try {
-    assets = await multicallRetryUniversal({
-      chain: chainId,
-      calls: flat.map((f) => ({
-        address: f.cToken,
-        name: "asset",
-        params: []
-      })),
-      abi: flat.map(() => CurvanceCTokenAbi),
-      allowFailure: true
-    });
+    assets = await discoveryMulticall(
+      {
+        chain: chainId,
+        calls: flat.map((f) => ({
+          address: f.cToken,
+          name: "asset",
+          params: []
+        })),
+        abi: flat.map(() => CurvanceCTokenAbi),
+        allowFailure: true
+      },
+      opts
+    );
   } catch {
     assets = [];
   }
@@ -32546,26 +32781,29 @@ var fetchRoster2 = async (chainId, lender, centralRegistry, allowlist2) => {
     })).filter((t) => t.asset !== "")
   })).filter((m) => m.cTokens.length > 0);
   const roster = { markets, at: Date.now() };
-  rosterCache4.set(rosterKey2(chainId, lender), roster);
+  rosterCache4.set(rosterKey2(chainId, lender, blockKey(opts)), roster);
   return roster;
 };
-var discoverPositions2 = async (chainId, markets, account) => {
+var discoverPositions2 = async (chainId, markets, account, opts) => {
   const CHUNK = 15;
   const active = [];
   for (let i = 0; i < markets.length; i += CHUNK) {
     const slice2 = markets.slice(i, i + CHUNK);
     let res = [];
     try {
-      res = await multicallRetryUniversal({
-        chain: chainId,
-        calls: slice2.map((m) => ({
-          address: m.marketManager,
-          name: "assetsOf",
-          params: [account]
-        })),
-        abi: slice2.map(() => CurvanceMarketManagerAbi),
-        allowFailure: true
-      });
+      res = await discoveryMulticall(
+        {
+          chain: chainId,
+          calls: slice2.map((m) => ({
+            address: m.marketManager,
+            name: "assetsOf",
+            params: [account]
+          })),
+          abi: slice2.map(() => CurvanceMarketManagerAbi),
+          allowFailure: true
+        },
+        opts
+      );
     } catch {
       continue;
     }
@@ -32584,9 +32822,9 @@ var discoverPositions2 = async (chainId, markets, account) => {
   }
   return active;
 };
-var buildCurvanceUserCall = async (chainId, lender, account) => {
+var buildCurvanceUserCall = async (chainId, lender, account, opts) => {
   const cfg = curvanceConfigFor(lender, chainId);
-  const key3 = discoveryKey2(chainId, lender, account);
+  const key3 = discoveryKey2(chainId, lender, account, blockKey(opts));
   const stash = (positions2) => discoveryCache3.set(key3, { positions: positions2, at: Date.now() });
   if (!cfg?.centralRegistry) {
     stash([]);
@@ -32598,7 +32836,8 @@ var buildCurvanceUserCall = async (chainId, lender, account) => {
       chainId,
       lender,
       cfg.centralRegistry,
-      cfg.marketAllowlist
+      cfg.marketAllowlist,
+      opts
     );
   } catch {
     return [];
@@ -32608,7 +32847,7 @@ var buildCurvanceUserCall = async (chainId, lender, account) => {
     return [];
   }
   const cached = discoveryCache3.get(key3);
-  const positions = cached && Date.now() - cached.at < DISCOVERY_TTL_MS2 ? cached.positions : await discoverPositions2(chainId, roster.markets, account);
+  const positions = cached && Date.now() - cached.at < DISCOVERY_TTL_MS2 ? cached.positions : await discoverPositions2(chainId, roster.markets, account, opts);
   stash(positions);
   if (positions.length === 0) return [];
   return positions.flatMap((p) => [
@@ -32634,46 +32873,54 @@ var buildCurvanceUserCall = async (chainId, lender, account) => {
 var DISCOVERY_TTL_MS3 = 6e4;
 var TWYNE_READS_PER_VAULT = 7;
 var discoveryCache4 = /* @__PURE__ */ new Map();
-var discoveryKey3 = (chainId, lender, account) => `${chainId}:${lender}:${account.toLowerCase()}`;
-function getCachedTwyneDiscovery(chainId, lender, account) {
-  return discoveryCache4.get(discoveryKey3(chainId, lender, account));
+var discoveryKey3 = (chainId, lender, account, block = "head") => `${chainId}:${lender}:${account.toLowerCase()}:${block}`;
+function getCachedTwyneDiscovery(chainId, lender, account, opts) {
+  return discoveryCache4.get(
+    discoveryKey3(chainId, lender, account, blockKey(opts))
+  );
 }
 var lower2 = (a) => String(a).toLowerCase();
 var isAddress4 = (v) => typeof v === "string" && /^0x[0-9a-fA-F]{40}$/.test(v);
-async function discover(chainId, lender, account) {
-  const key3 = discoveryKey3(chainId, lender, account);
+async function discover(chainId, lender, account, opts) {
+  const key3 = discoveryKey3(chainId, lender, account, blockKey(opts));
   const cached = discoveryCache4.get(key3);
   if (cached && Date.now() - cached.at < DISCOVERY_TTL_MS3) return cached;
   const cfg = twyneConfigFor(lender, chainId);
   const empty = { vaults: [], at: Date.now() };
   if (!cfg?.collateralVaultFactory) return empty;
-  const [listRaw] = await multicallRetryUniversal({
-    chain: chainId,
-    calls: [
-      {
-        address: cfg.collateralVaultFactory,
-        name: "getCollateralVaults",
-        args: [account]
-      }
-    ],
-    abi: TwyneCollateralVaultFactoryAbi,
-    allowFailure: true
-  });
+  const [listRaw] = await discoveryMulticall(
+    {
+      chain: chainId,
+      calls: [
+        {
+          address: cfg.collateralVaultFactory,
+          name: "getCollateralVaults",
+          args: [account]
+        }
+      ],
+      abi: TwyneCollateralVaultFactoryAbi,
+      allowFailure: true
+    },
+    opts
+  );
   const created = Array.isArray(listRaw) ? listRaw.filter(isAddress4).map(lower2) : [];
   if (created.length === 0) {
     discoveryCache4.set(key3, empty);
     return empty;
   }
-  const refs = await multicallRetryUniversal({
-    chain: chainId,
-    calls: created.flatMap((v) => [
-      { address: v, name: "intermediateVault", args: [] },
-      { address: v, name: "targetAsset", args: [] },
-      { address: v, name: "borrower", args: [] }
-    ]),
-    abi: TwyneCollateralVaultAbi,
-    allowFailure: true
-  });
+  const refs = await discoveryMulticall(
+    {
+      chain: chainId,
+      calls: created.flatMap((v) => [
+        { address: v, name: "intermediateVault", args: [] },
+        { address: v, name: "targetAsset", args: [] },
+        { address: v, name: "borrower", args: [] }
+      ]),
+      abi: TwyneCollateralVaultAbi,
+      allowFailure: true
+    },
+    opts
+  );
   const queried = twyneKeyParts(lender);
   const known = new Map(
     (twyneChainData(lender, chainId)?.markets ?? []).filter(
@@ -32702,19 +32949,24 @@ async function discover(chainId, lender, account) {
     });
   });
   const receipts = [
-    ...new Set(vaults.map((v) => v.collateralAsset).filter((a) => !!a))
+    ...new Set(
+      vaults.map((v) => v.collateralAsset).filter((a) => !!a)
+    )
   ];
   if (receipts.length > 0) {
-    const scales = await multicallRetryUniversal({
-      chain: chainId,
-      calls: receipts.map((address) => ({
-        address,
-        name: "convertToAssets",
-        args: [10n ** 18n]
-      })),
-      abi: TwyneATokenWrapperAbi,
-      allowFailure: true
-    });
+    const scales = await discoveryMulticall(
+      {
+        chain: chainId,
+        calls: receipts.map((address) => ({
+          address,
+          name: "convertToAssets",
+          args: [10n ** 18n]
+        })),
+        abi: TwyneATokenWrapperAbi,
+        allowFailure: true
+      },
+      opts
+    );
     const byReceipt = /* @__PURE__ */ new Map();
     receipts.forEach((address, i) => {
       const v = scales[i];
@@ -32730,8 +32982,8 @@ async function discover(chainId, lender, account) {
   discoveryCache4.set(key3, result);
   return result;
 }
-async function buildTwyneUserCall(chainId, lender, account) {
-  const { vaults } = await discover(chainId, lender, account);
+async function buildTwyneUserCall(chainId, lender, account, opts) {
+  const { vaults } = await discover(chainId, lender, account, opts);
   if (vaults.length === 0) return [];
   return vaults.flatMap(({ vault }) => [
     { address: vault, name: "totalAssetsDepositedOrReserved", args: [] },
@@ -32747,9 +32999,11 @@ var DSS_CALLS_PER_CDP = 1;
 var MAX_CDP_WALK = 64;
 var CACHE_TTL_MS2 = 5 * 6e4;
 var discoveryCache5 = /* @__PURE__ */ new Map();
-var cacheKey2 = (lender, chainId, account) => `${lender}:${chainId}:${account.toLowerCase()}`;
-var getCachedDssCdps = (lender, chainId, account) => {
-  const hit = discoveryCache5.get(cacheKey2(lender, chainId, account));
+var cacheKey2 = (lender, chainId, account, block = "head") => `${lender}:${chainId}:${account.toLowerCase()}:${block}`;
+var getCachedDssCdps = (lender, chainId, account, opts) => {
+  const hit = discoveryCache5.get(
+    cacheKey2(lender, chainId, account, blockKey(opts))
+  );
   if (!hit || Date.now() - hit.at > CACHE_TTL_MS2) return void 0;
   return hit;
 };
@@ -32762,10 +33016,10 @@ var big7 = (v) => {
   return 0n;
 };
 var field6 = (res, name, idx) => res?.[name] ?? res?.[idx];
-var buildDssUserCall = async (chainId, lender, account) => {
+var buildDssUserCall = async (chainId, lender, account, opts) => {
   const cfg = dssConfigFor(lender, chainId);
   const markets = dssChainData(lender, chainId)?.markets ?? [];
-  const stash = (d) => discoveryCache5.set(cacheKey2(lender, chainId, account), d);
+  const stash = (d) => discoveryCache5.set(cacheKey2(lender, chainId, account, blockKey(opts)), d);
   if (!cfg || markets.length === 0) {
     stash({ cdps: [], ilks: [], at: Date.now() });
     return [];
@@ -32774,28 +33028,34 @@ var buildDssUserCall = async (chainId, lender, account) => {
   const zero2 = "0x0000000000000000000000000000000000000000";
   const owners = [];
   try {
-    const [rawCount, rawFirst, rawProxy] = await multicallRetryUniversal({
-      chain: chainId,
-      abi: [...UsddCdpManagerAbi, ...UsddProxyRegistryAbi],
-      calls: [
-        { address: cfg.cdpManager, name: "count", params: [account] },
-        { address: cfg.cdpManager, name: "first", params: [account] },
-        { address: cfg.proxyRegistry, name: "proxies", params: [account] }
-      ],
-      allowFailure: false
-    });
-    owners.push({ owner: account, count: big7(rawCount), cursor: big7(rawFirst) });
-    const proxy = String(rawProxy ?? zero2);
-    if (proxy.toLowerCase() !== zero2) {
-      const [pCount, pFirst] = await multicallRetryUniversal({
+    const [rawCount, rawFirst, rawProxy] = await discoveryMulticall(
+      {
         chain: chainId,
-        abi: UsddCdpManagerAbi,
+        abi: [...UsddCdpManagerAbi, ...UsddProxyRegistryAbi],
         calls: [
-          { address: cfg.cdpManager, name: "count", params: [proxy] },
-          { address: cfg.cdpManager, name: "first", params: [proxy] }
+          { address: cfg.cdpManager, name: "count", params: [account] },
+          { address: cfg.cdpManager, name: "first", params: [account] },
+          { address: cfg.proxyRegistry, name: "proxies", params: [account] }
         ],
         allowFailure: false
-      });
+      },
+      opts
+    );
+    owners.push({ owner: account, count: big7(rawCount), cursor: big7(rawFirst) });
+    const proxy = String(rawProxy ?? zero2);
+    if (proxy.toLowerCase() !== zero2) {
+      const [pCount, pFirst] = await discoveryMulticall(
+        {
+          chain: chainId,
+          abi: UsddCdpManagerAbi,
+          calls: [
+            { address: cfg.cdpManager, name: "count", params: [proxy] },
+            { address: cfg.cdpManager, name: "first", params: [proxy] }
+          ],
+          allowFailure: false
+        },
+        opts
+      );
       owners.push({ owner: proxy, count: big7(pCount), cursor: big7(pFirst) });
     }
   } catch {
@@ -32819,16 +33079,19 @@ var buildDssUserCall = async (chainId, lender, account) => {
         );
       }
       for (let i = 0; i < steps && cursor !== 0n; i++) {
-        const [urn, ilk32, link] = await multicallRetryUniversal({
-          chain: chainId,
-          abi: UsddCdpManagerAbi,
-          calls: [
-            { address: cfg.cdpManager, name: "urns", params: [cursor] },
-            { address: cfg.cdpManager, name: "ilks", params: [cursor] },
-            { address: cfg.cdpManager, name: "list", params: [cursor] }
-          ],
-          allowFailure: false
-        });
+        const [urn, ilk32, link] = await discoveryMulticall(
+          {
+            chain: chainId,
+            abi: UsddCdpManagerAbi,
+            calls: [
+              { address: cfg.cdpManager, name: "urns", params: [cursor] },
+              { address: cfg.cdpManager, name: "ilks", params: [cursor] },
+              { address: cfg.cdpManager, name: "list", params: [cursor] }
+            ],
+            allowFailure: false
+          },
+          opts
+        );
         let ilk = "";
         try {
           ilk = hexToString(ilk32, { size: 32 }).replace(/[\s\0]+$/g, "");
@@ -32931,9 +33194,11 @@ var buildFrankencoinUserCall = async (chainId, lender, account) => {
   }
   return calls;
 };
+
+// src/lending/user-data/teller/lens.ts
 var ROW_BYTES2 = 117;
 var usesTellerLens = (chainId) => getPositionLensFor(chainId, LENS_FAMILY.TELLER) !== void 0;
-async function discoverTellerBidsViaLens(chainId, tellerV2, account) {
+async function discoverTellerBidsViaLens(chainId, tellerV2, account, opts) {
   const lens = getPositionLensFor(chainId, LENS_FAMILY.TELLER);
   if (!lens || !tellerV2) return void 0;
   const payload = encodeAbiParameters(parseAbiParameters("address, uint256"), [
@@ -32942,18 +33207,21 @@ async function discoverTellerBidsViaLens(chainId, tellerV2, account) {
   ]);
   let blob;
   try {
-    const res = await multicallRetryUniversal({
-      chain: chainId,
-      calls: [
-        {
-          address: lens,
-          name: "getUserData",
-          params: [[{ family: LENS_FAMILY.TELLER, payload }], account]
-        }
-      ],
-      abi: PositionLensAbi,
-      allowFailure: true
-    });
+    const res = await discoveryMulticall(
+      {
+        chain: chainId,
+        calls: [
+          {
+            address: lens,
+            name: "getUserData",
+            params: [[{ family: LENS_FAMILY.TELLER, payload }], account]
+          }
+        ],
+        abi: PositionLensAbi,
+        allowFailure: true
+      },
+      opts
+    );
     const blobs = res?.[0];
     if (!Array.isArray(blobs) || blobs.length !== 1) return void 0;
     blob = blobs[0];
@@ -32981,9 +33249,9 @@ async function discoverTellerBidsViaLens(chainId, tellerV2, account) {
 var TELLER_CALLS_PER_BID = 4;
 var CACHE_TTL_MS3 = 5 * 6e4;
 var discoveryCache7 = /* @__PURE__ */ new Map();
-var cacheKey4 = (chainId, account) => `${chainId}:${account.toLowerCase()}`;
-var getCachedTellerBids = (chainId, account) => {
-  const hit = discoveryCache7.get(cacheKey4(chainId, account));
+var cacheKey4 = (chainId, account, block = "head") => `${chainId}:${account.toLowerCase()}:${block}`;
+var getCachedTellerBids = (chainId, account, opts) => {
+  const hit = discoveryCache7.get(cacheKey4(chainId, account, blockKey(opts)));
   if (!hit || Date.now() - hit.at > CACHE_TTL_MS3) return void 0;
   return hit;
 };
@@ -32999,7 +33267,7 @@ var toBigints = (arr) => {
   }
   return out;
 };
-var buildTellerUserCall = async (chainId, _lender, account) => {
+var buildTellerUserCall = async (chainId, _lender, account, opts) => {
   const proto = tellerConfigByChain(chainId);
   const pools = tellerPoolsByChain(chainId);
   if (!proto?.tellerV2 || !proto?.collateralManager || pools.length === 0) {
@@ -33011,7 +33279,8 @@ var buildTellerUserCall = async (chainId, _lender, account) => {
     const viaLens = await discoverTellerBidsViaLens(
       chainId,
       proto.tellerV2,
-      account
+      account,
+      opts
     );
     if (viaLens) {
       const keptLens = [];
@@ -33019,7 +33288,7 @@ var buildTellerUserCall = async (chainId, _lender, account) => {
         const pool = poolByAddrEarly.get(b.lender.toLowerCase());
         if (pool) keptLens.push({ bidId: b.bidId, pool });
       }
-      discoveryCache7.set(cacheKey4(chainId, account), {
+      discoveryCache7.set(cacheKey4(chainId, account, blockKey(opts)), {
         bids: keptLens,
         at: Date.now()
       });
@@ -33028,40 +33297,49 @@ var buildTellerUserCall = async (chainId, _lender, account) => {
   }
   let ids = [];
   try {
-    const res = await multicallRetryUniversal({
-      chain: chainId,
-      calls: [
-        {
-          address: proto.tellerV2,
-          name: "getBorrowerActiveLoanIds",
-          params: [account]
-        }
-      ],
-      abi: TellerV2Abi,
-      allowFailure: true
-    });
+    const res = await discoveryMulticall(
+      {
+        chain: chainId,
+        calls: [
+          {
+            address: proto.tellerV2,
+            name: "getBorrowerActiveLoanIds",
+            params: [account]
+          }
+        ],
+        abi: TellerV2Abi,
+        allowFailure: true
+      },
+      opts
+    );
     ids = toBigints(res?.[0]);
   } catch {
     return [];
   }
   if (ids.length === 0) {
-    discoveryCache7.set(cacheKey4(chainId, account), { bids: [], at: Date.now() });
+    discoveryCache7.set(cacheKey4(chainId, account, blockKey(opts)), {
+      bids: [],
+      at: Date.now()
+    });
     return [];
   }
   const poolByAddr = /* @__PURE__ */ new Map();
   for (const p of pools) poolByAddr.set(p.pool.toLowerCase(), p);
   let lenders = [];
   try {
-    lenders = await multicallRetryUniversal({
-      chain: chainId,
-      calls: ids.map((id) => ({
-        address: proto.tellerV2,
-        name: "getLoanLender",
-        params: [id]
-      })),
-      abi: TellerV2Abi,
-      allowFailure: true
-    });
+    lenders = await discoveryMulticall(
+      {
+        chain: chainId,
+        calls: ids.map((id) => ({
+          address: proto.tellerV2,
+          name: "getLoanLender",
+          params: [id]
+        })),
+        abi: TellerV2Abi,
+        allowFailure: true
+      },
+      opts
+    );
   } catch {
     return [];
   }
@@ -33072,7 +33350,10 @@ var buildTellerUserCall = async (chainId, _lender, account) => {
     const pool = poolByAddr.get(lenderAddr);
     if (pool) kept.push({ bidId: id, pool });
   });
-  discoveryCache7.set(cacheKey4(chainId, account), { bids: kept, at: Date.now() });
+  discoveryCache7.set(cacheKey4(chainId, account, blockKey(opts)), {
+    bids: kept,
+    at: Date.now()
+  });
   return buildTellerDataPhase(proto, kept);
 };
 function buildTellerDataPhase(proto, kept, _account) {
@@ -33164,7 +33445,7 @@ var buildTermMaxUserCall = async (chainId, _lender, account) => {
 };
 
 // src/lending/user-data/fetch-balances/prepare.ts
-async function buildUserCall(chainId, lender, account, params, getClient) {
+async function buildUserCall(chainId, lender, account, params, opts) {
   if (isAaveV4Type(lender)) return buildAaveV4UserCall(chainId, lender, account);
   if (isAaveV2Type(lender)) return buildAaveV2UserCall(chainId, lender, account);
   if (isAaveV3Type(lender)) return buildAaveV3UserCall(chainId, lender, account);
@@ -33174,16 +33455,17 @@ async function buildUserCall(chainId, lender, account, params, getClient) {
       chainId,
       account,
       lender,
-      params,
-      getClient
+      marketKeysOf(params) ?? [],
+      opts
     );
   if (isMidnight(lender)) return buildMidnightUserCall(chainId, lender, account);
   if (isTerm(lender)) return buildTermUserCall(chainId, lender, account);
   if (isExactly(lender)) return buildExactlyUserCall(chainId, lender, account);
   if (isLiquityFamily(lender))
-    return buildLiquityUserCall(chainId, lender, account);
+    return buildLiquityUserCall(chainId, lender, account, opts);
   if (isRiver(lender)) return buildRiverUserCall(chainId, lender, account);
-  if (isTeller(lender)) return buildTellerUserCall(chainId, lender, account);
+  if (isTeller(lender))
+    return buildTellerUserCall(chainId, lender, account, opts);
   if (isTermMax(lender)) return buildTermMaxUserCall(chainId, lender, account);
   if (isInverse(lender)) return buildInverseUserCall(chainId, lender, account);
   if (isCooler(lender)) return buildCoolerUserCall(chainId, lender, account);
@@ -33191,11 +33473,13 @@ async function buildUserCall(chainId, lender, account, params, getClient) {
     return buildFlyingTulipUserCall(chainId, lender, account);
   if (isLlamaLend(lender))
     return buildLlamaLendUserCall(chainId, lender, account);
-  if (isResupply(lender)) return buildResupplyUserCall(chainId, lender, account);
+  if (isResupply(lender))
+    return buildResupplyUserCall(chainId, lender, account, opts);
   if (isFraxlend(lender)) return buildFraxlendUserCall(chainId, lender, account);
-  if (isCurvance(lender)) return buildCurvanceUserCall(chainId, lender, account);
-  if (isTwyne(lender)) return buildTwyneUserCall(chainId, lender, account);
-  if (isDssType(lender)) return buildDssUserCall(chainId, lender, account);
+  if (isCurvance(lender))
+    return buildCurvanceUserCall(chainId, lender, account, opts);
+  if (isTwyne(lender)) return buildTwyneUserCall(chainId, lender, account, opts);
+  if (isDssType(lender)) return buildDssUserCall(chainId, lender, account, opts);
   if (isFrankencoin(lender))
     return buildFrankencoinUserCall(chainId, lender, account);
   if (isCompoundV3Type(lender))
@@ -33205,12 +33489,12 @@ async function buildUserCall(chainId, lender, account, params, getClient) {
       chainId,
       lender,
       account,
-      params?.subAccountIndexes
+      subAccountsOf(params)?.subAccountIndexes
     );
   if (isSiloV2Type(lender))
-    return buildSiloV2UserCall(chainId, lender, account, params);
+    return buildSiloV2UserCall(chainId, lender, account, marketKeysOf(params));
   if (isSiloV3Type(lender))
-    return buildSiloV3UserCall(chainId, lender, account, params);
+    return buildSiloV3UserCall(chainId, lender, account, marketKeysOf(params));
   if (isCompoundV2Type(lender))
     return buildCompoundV2UserCall(chainId, lender, account);
   if (isFluid(lender)) return buildFluidUserCall(chainId, lender, account);
@@ -33221,168 +33505,10 @@ async function buildUserCall(chainId, lender, account, params, getClient) {
       chainId,
       lender,
       account,
-      params?.accountNumbers
+      subAccountsOf(params)?.accountNumbers
     );
   return [];
 }
-function organizeUserQueries(queries) {
-  const morphos = queries.filter((q) => isMorphoType(q.lender));
-  const gearbox = queries.filter((q) => isGearboxV3(q.lender));
-  const midnight = queries.filter((q) => isMidnight(q.lender));
-  const term = queries.filter((q) => isTerm(q.lender));
-  const exactly = queries.filter((q) => isExactly(q.lender));
-  const liquity = queries.filter((q) => isLiquityFamily(q.lender));
-  const river = queries.filter((q) => isRiver(q.lender));
-  const teller = queries.filter((q) => isTeller(q.lender));
-  const termMax = queries.filter((q) => isTermMax(q.lender));
-  const usdd = queries.filter((q) => isUsdd(q.lender));
-  const sky = queries.filter((q) => isSky(q.lender));
-  const llamaLend = queries.filter((q) => isLlamaLend(q.lender));
-  const siloV2 = queries.filter((q) => isSiloV2Type(q.lender));
-  const siloV3 = queries.filter((q) => isSiloV3Type(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 && sky.length === 0 && frankencoin.length === 0 && llamaLend.length === 0 && siloV2.length === 0 && siloV3.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) && !isDssType(q.lender) && !isFrankencoin(q.lender) && !isLlamaLend(q.lender) && !isSiloV2Type(q.lender) && !isSiloV3Type(q.lender)
-  );
-  const morphoBlue = morphos.filter((q) => q.lender.startsWith("MORPHO_BLUE"));
-  const moolah = morphos.filter((q) => q.lender.startsWith("LISTA_DAO"));
-  const result = [...others];
-  if (morphoBlue.length > 0) {
-    result.push({
-      lender: Lender.MORPHO_BLUE,
-      account: morphoBlue[0].account,
-      params: morphoBlue.map((p) => p.lender),
-      assets: void 0
-    });
-  }
-  if (moolah.length > 0) {
-    result.push({
-      lender: Lender.LISTA_DAO,
-      account: moolah[0].account,
-      params: moolah.map((p) => p.lender),
-      assets: void 0
-    });
-  }
-  if (gearbox.length > 0) {
-    result.push({
-      lender: Lender.GEARBOX_V3,
-      account: gearbox[0].account,
-      params: gearbox.map((p) => p.lender),
-      assets: void 0
-    });
-  }
-  if (midnight.length > 0) {
-    result.push({
-      lender: Lender.MORPHO_MIDNIGHT,
-      account: midnight[0].account,
-      params: midnight.map((p) => p.lender),
-      assets: void 0
-    });
-  }
-  if (term.length > 0) {
-    result.push({
-      lender: Lender.TERM_FINANCE,
-      account: term[0].account,
-      params: term.map((p) => p.lender),
-      assets: void 0
-    });
-  }
-  if (exactly.length > 0) {
-    result.push({
-      lender: Lender.EXACTLY,
-      account: exactly[0].account,
-      params: exactly.map((p) => p.lender),
-      assets: void 0
-    });
-  }
-  if (river.length > 0) {
-    result.push({
-      lender: Lender.RIVER,
-      account: river[0].account,
-      params: river.map((p) => p.lender),
-      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,
-      account: usdd[0].account,
-      params: usdd.map((p) => p.lender),
-      assets: void 0
-    });
-  }
-  if (sky.length > 0) {
-    result.push({
-      lender: Lender.SKY,
-      account: sky[0].account,
-      params: sky.map((p) => p.lender),
-      assets: void 0
-    });
-  }
-  if (siloV2.length > 0) {
-    result.push({
-      lender: "SILO_V2",
-      account: siloV2[0].account,
-      params: siloV2.map((p) => p.lender),
-      assets: void 0
-    });
-  }
-  if (siloV3.length > 0) {
-    result.push({
-      lender: "SILO_V3",
-      account: siloV3[0].account,
-      params: siloV3.map((p) => p.lender),
-      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,
-      account: teller[0].account,
-      params: teller.map((p) => p.lender),
-      assets: void 0
-    });
-  }
-  if (termMax.length > 0) {
-    result.push({
-      lender: Lender.TERMMAX,
-      account: termMax[0].account,
-      params: termMax.map((p) => p.lender),
-      assets: void 0
-    });
-  }
-  if (liquity.length > 0) {
-    for (const base of LIQUITY_FAMILY_LENDERS) {
-      const members = liquity.filter((q) => q.lender.startsWith(base));
-      if (members.length === 0) continue;
-      result.push({
-        lender: base,
-        account: members[0].account,
-        params: members.map((p) => p.lender),
-        assets: void 0
-      });
-    }
-  }
-  return result;
-}
 
 // src/lending/user-data/aave-v2-type/userCallParse.ts
 var getAaveV2UserDataConverter = (lender, chainId, account, metaMap) => {
@@ -34052,7 +34178,7 @@ var userDataEmpty = (account, chainId, notWhitelisted = false) => {
     ]
   };
 };
-var getMorphoTypeUserDataConverterWithlens = (lender, chainId, account, markets, metaMap) => {
+var getMorphoTypeUserDataConverterWithlens = (lender, chainId, account, markets, metaMap, opts) => {
   return !isLista(lender) ? getMorphoUserDataConverterWithlens(
     lender,
     chainId,
@@ -34064,7 +34190,8 @@ var getMorphoTypeUserDataConverterWithlens = (lender, chainId, account, markets,
     chainId,
     account,
     markets,
-    metaMap
+    metaMap,
+    opts
   );
 };
 var getMorphoUserDataConverterWithlens = (lender, chainId, account, markets, metaMap) => {
@@ -34118,7 +34245,7 @@ var getMorphoUserDataConverterWithlens = (lender, chainId, account, markets, met
     expectedNumberOfCalls
   ];
 };
-var getListaUserDataConverterWithlens = (lender, chainId, account, markets, metaMap) => {
+var getListaUserDataConverterWithlens = (lender, chainId, account, markets, metaMap, opts) => {
   const expectedNumberOfCalls = Math.ceil(markets.length / CHUNK_SIZE);
   return [
     (data) => {
@@ -34151,7 +34278,8 @@ var getListaUserDataConverterWithlens = (lender, chainId, account, markets, meta
           const brokerData = getCachedListaBrokerUserData(
             chainId,
             account,
-            marketId
+            marketId,
+            opts?.blockNumber
           );
           const { dataForMarket, addedDebt, addedDeposits } = createMorphoEntryFromMarketWithLens(
             balanceData2,
@@ -34357,6 +34485,13 @@ function createMorphoEntryFromMarketWithLens(balanceInfo, metaMap, chainId, lend
 }
 
 // src/lending/user-data/utils/createEulerMultiAccountTypeUserState.ts
+function subAccountAddressOf(owner, index) {
+  const i = Number(index);
+  if (!Number.isInteger(i) || i < 0 || i > 255) return void 0;
+  if (!/^0x[0-9a-fA-F]{40}$/.test(owner)) return void 0;
+  const last = parseInt(owner.slice(40), 16);
+  return (owner.slice(0, 40) + ((last ^ i) & 255).toString(16).padStart(2, "0")).toLowerCase();
+}
 function createEulerMultiAccountTypeUserState(payload, lenderData, histData) {
   const subAccountIndexes = Object.keys(payload.lendingPositions ?? {});
   const marketUids2 = getMarketUidsFromMeta(lenderData);
@@ -34513,6 +34648,11 @@ function createEulerMultiAccountTypeUserState(payload, lenderData, histData) {
     }
     data.push({
       accountId: subAccountIndex,
+      // owner ^ index, offline (see `euler/userCallBuild.ts`). Index 0 IS the
+      // owner, so it carries no separate address.
+      ...subAccountIndex === "0" ? {} : {
+        accountAddress: subAccountAddressOf(account, subAccountIndex)
+      },
       health: balanceData2.debt === 0 ? null : balanceData2.adjustedDebt > 0 ? balanceData2.collateral / balanceData2.adjustedDebt : balanceData2.collateral / balanceData2.debt,
       borrowCapacityUSD: creditLine,
       userConfig,
@@ -35571,7 +35711,16 @@ var getDolomiteUserDataConverter = (lender, chainId, account, metaMap) => {
         modes,
         account
       };
-      return createMultiAccountTypeUserState(payload, metaMap, histData);
+      const accountAddresses = {};
+      for (const sa of subAccounts)
+        if (sa.owner && sa.owner.toLowerCase() !== account.toLowerCase())
+          accountAddresses[sa.id] = sa.owner.toLowerCase();
+      return createMultiAccountTypeUserState(
+        payload,
+        metaMap,
+        histData,
+        accountAddresses
+      );
     },
     expectedNumberOfCalls
   ];
@@ -36052,10 +36201,10 @@ var big8 = (v) => {
   return 0n;
 };
 var field7 = (res, name, idx) => big8(res?.[name] ?? res?.[idx]);
-var getLiquityUserDataConverter = (lender, chainId, account, meta) => {
+var getLiquityUserDataConverter = (lender, chainId, account, meta, opts) => {
   const cfg = liquityConfigFor(lender, chainId);
   const branches = liquityBranchesByChain(lender, chainId);
-  const discovery = getCachedLiquityTroves(chainId, lender, account);
+  const discovery = getCachedLiquityTroves(chainId, lender, account, opts);
   const expected = cfg && discovery ? branches.reduce(
     (acc, b, i) => acc + liquityBranchCallCount(b, discovery.perBranch[i]?.length ?? 0),
     0
@@ -36976,9 +37125,9 @@ function sharesToAmount(shares, totalAmount, totalShares) {
   const q = shares * totalAmount / totalShares;
   return q * totalShares < shares * totalAmount ? q + 1n : q;
 }
-var getResupplyUserDataConverter = (lender, chainId, account, meta) => {
+var getResupplyUserDataConverter = (lender, chainId, account, meta, opts) => {
   const cfg = resupplyConfigFor(lender, chainId);
-  const discovery = getCachedResupplyDiscovery(chainId, lender, account);
+  const discovery = getCachedResupplyDiscovery(chainId, lender, account, opts);
   const positions = discovery?.positions ?? [];
   const expected = cfg && positions.length > 0 ? positions.length * RESUPPLY_CALLS_PER_PAIR : 0;
   return [
@@ -37263,9 +37412,9 @@ var big16 = (v) => {
 };
 var tupleAt2 = (v, i) => Array.isArray(v) ? big16(v[i]) : 0n;
 var HOLD_PERIOD_SECONDS = 1200n;
-var getCurvanceUserDataConverter = (lender, chainId, account, meta) => {
+var getCurvanceUserDataConverter = (lender, chainId, account, meta, opts) => {
   const cfg = curvanceConfigFor(lender, chainId);
-  const discovery = getCachedCurvanceDiscovery(chainId, lender, account);
+  const discovery = getCachedCurvanceDiscovery(chainId, lender, account, opts);
   const positions = discovery?.positions ?? [];
   const expected = cfg && positions.length > 0 ? positions.reduce(
     (acc, p) => acc + CURVANCE_MARKET_READS + p.activeTokens.length * CURVANCE_READS_PER_TOKEN,
@@ -37377,8 +37526,8 @@ var big17 = (v) => {
   }
   return 0n;
 };
-var getTwyneUserDataConverter = (lender, chainId, account, meta) => {
-  const discovery = getCachedTwyneDiscovery(chainId, lender, account);
+var getTwyneUserDataConverter = (lender, chainId, account, meta, opts) => {
+  const discovery = getCachedTwyneDiscovery(chainId, lender, account, opts);
   const vaults = discovery?.vaults ?? [];
   const expected = vaults.length * TWYNE_READS_PER_VAULT;
   const markets = twyneChainData(lender, chainId)?.markets ?? [];
@@ -37405,7 +37554,12 @@ var getTwyneUserDataConverter = (lender, chainId, account, meta) => {
           (m) => m.intermediateVault.toLowerCase() === ref.intermediateVault && m.targetAsset.toLowerCase() === ref.targetAsset
         );
         if (!market) return;
-        const lenderKey = twyneLenderKey(lender, chainId, ref.intermediateVault, ref.targetAsset);
+        const lenderKey = twyneLenderKey(
+          lender,
+          chainId,
+          ref.intermediateVault,
+          ref.targetAsset
+        );
         if (!byMarket.has(lenderKey)) {
           byMarket.set(lenderKey, {
             collAddr: market.underlyingAsset.toLowerCase(),
@@ -37522,10 +37676,10 @@ var big18 = (v) => {
   return 0n;
 };
 var field9 = (res, name, idx) => big18(res?.[name] ?? res?.[idx]);
-var getDssUserDataConverter = (lender, chainId, account, meta) => {
+var getDssUserDataConverter = (lender, chainId, account, meta, opts) => {
   const cfg = dssConfigFor(lender, chainId);
   const markets = dssChainData(lender, chainId)?.markets ?? [];
-  const discovery = getCachedDssCdps(lender, chainId, account);
+  const discovery = getCachedDssCdps(lender, chainId, account, opts);
   const cdps = discovery?.cdps ?? [];
   const ilks = discovery?.ilks ?? [];
   const expected = cfg && markets.length > 0 && cdps.length > 0 ? cdps.length * DSS_CALLS_PER_CDP + ilks.length : 0;
@@ -37780,8 +37934,8 @@ var big20 = (v) => {
   return 0n;
 };
 var field10 = (res, name, idx) => res?.[name] ?? res?.[idx];
-var getTellerUserDataConverter = (_lender, chainId, account, meta) => {
-  const discovery = getCachedTellerBids(chainId, account);
+var getTellerUserDataConverter = (_lender, chainId, account, meta, opts) => {
+  const discovery = getCachedTellerBids(chainId, account, opts);
   const kept = discovery?.bids ?? [];
   const expected = kept.length * TELLER_CALLS_PER_BID;
   return [
@@ -38184,7 +38338,7 @@ function validateUserData(userData, hadFailedReads) {
 }
 
 // src/lending/user-data/fetch-balances/parse.ts
-function getUserDataConverter(lender, chainId, account, params, meta) {
+function getUserDataConverter(lender, chainId, account, params, meta, opts) {
   if (isAaveV4Type(lender))
     return getAaveV4UserDataConverter(lender, chainId, account, meta?.[lender]);
   if (isYLDR(lender))
@@ -38201,7 +38355,8 @@ function getUserDataConverter(lender, chainId, account, params, meta) {
       chainId,
       account,
       params,
-      meta
+      meta,
+      opts
     );
   if (isMidnight(lender))
     return getMidnightUserDataConverter(lender, chainId, account, meta);
@@ -38210,11 +38365,11 @@ function getUserDataConverter(lender, chainId, account, params, meta) {
   if (isExactly(lender))
     return getExactlyUserDataConverter(lender, chainId, account, meta);
   if (isLiquityFamily(lender))
-    return getLiquityUserDataConverter(lender, chainId, account, meta);
+    return getLiquityUserDataConverter(lender, chainId, account, meta, opts);
   if (isRiver(lender))
     return getRiverUserDataConverter(lender, chainId, account, meta);
   if (isTeller(lender))
-    return getTellerUserDataConverter(lender, chainId, account, meta);
+    return getTellerUserDataConverter(lender, chainId, account, meta, opts);
   if (isTermMax(lender))
     return getTermMaxUserDataConverter(lender, chainId, account, meta);
   if (isInverse(lender))
@@ -38231,15 +38386,15 @@ function getUserDataConverter(lender, chainId, account, params, meta) {
   if (isLlamaLend(lender))
     return getLlamaLendUserDataConverter(lender, chainId, account, meta);
   if (isResupply(lender))
-    return getResupplyUserDataConverter(lender, chainId, account, meta);
+    return getResupplyUserDataConverter(lender, chainId, account, meta, opts);
   if (isFraxlend(lender))
     return getFraxlendUserDataConverter(lender, chainId, account, meta);
   if (isCurvance(lender))
-    return getCurvanceUserDataConverter(lender, chainId, account, meta);
+    return getCurvanceUserDataConverter(lender, chainId, account, meta, opts);
   if (isTwyne(lender))
-    return getTwyneUserDataConverter(lender, chainId, account, meta);
+    return getTwyneUserDataConverter(lender, chainId, account, meta, opts);
   if (isDssType(lender))
-    return getDssUserDataConverter(lender, chainId, account, meta);
+    return getDssUserDataConverter(lender, chainId, account, meta, opts);
   if (isFrankencoin(lender))
     return getFrankencoinUserDataConverter(lender, chainId, account, meta);
   if (isCompoundV3Type(lender))
@@ -38295,6 +38450,7 @@ var filterEmptyUserData = (userData, keepActiveControllerMode = false) => {
 var getReadFailurePolicy = (lender) => isMultiMarket(lender) && !hasCrossMarginRisk(lender) ? "lenient" : "strict";
 var convertLenderUserDataResult = (chainId, queriesRaw, rawResults, lenderState, options) => {
   const queries = organizeUserQueries(queriesRaw);
+  const readOpts = options?.blockNumber === void 0 ? void 0 : { blockNumber: options.blockNumber };
   const lenderData = {};
   let currentSlice = 0;
   for (const query3 of queries) {
@@ -38303,7 +38459,8 @@ var convertLenderUserDataResult = (chainId, queriesRaw, rawResults, lenderState,
       chainId,
       query3.account,
       query3.params,
-      lenderState
+      lenderState,
+      readOpts
     );
     const data = rawResults.slice(currentSlice, currentSlice + sliceLength);
     let failedCalls = 0;
@@ -43041,7 +43198,7 @@ var getLenderUserDataResult = async (chainId, queriesRaw, getEvmClient21, allowF
         query3.lender,
         query3.account,
         query3.params,
-        getEvmClient21
+        { getClient: getEvmClient21 }
       );
       return callData.map((call) => ({ call, abi: call.abi ?? abi }));
     })
@@ -43065,9 +43222,13 @@ var getLenderUserDataResult = async (chainId, queriesRaw, getEvmClient21, allowF
     onEndpointFailure ? { onEndpointFailure } : void 0
   );
 };
-var prepareLenderUserDataRpcCalls = async (chainId, queriesRaw, batchSize = MULTICALL_DEFAULT_BATCH_SIZE, blockTag = "latest", allowFailure = true) => {
+var prepareLenderUserDataRpcCalls = async (chainId, queriesRaw, batchSize = MULTICALL_DEFAULT_BATCH_SIZE, blockTag = "latest", allowFailure = true, opts) => {
   const multicallAddress = getEvmChain(chainId).contracts?.multicall3?.address;
   const queries = organizeUserQueries(queriesRaw);
+  const readOpts = {
+    ...opts,
+    blockNumber: opts?.blockNumber ?? blockNumberFromTag(blockTag)
+  };
   const builtCalls = await Promise.all(
     queries.map(async (query3) => {
       const abi = getAbi2(query3.lender);
@@ -43075,7 +43236,8 @@ var prepareLenderUserDataRpcCalls = async (chainId, queriesRaw, batchSize = MULT
         chainId,
         query3.lender,
         query3.account,
-        query3.params
+        query3.params,
+        readOpts
       );
       return callData.map((call) => ({ call, abi: call.abi ?? abi }));
     })
@@ -43991,6 +44153,248 @@ function fuseLenderData(userDataResult, summary) {
   return entries;
 }
 
+// src/lending/user-data/read/select.ts
+var PREFIX_LENDERS = /* @__PURE__ */ new Set([
+  "MORPHO_BLUE",
+  "LISTA_DAO",
+  "COMPOUND_V3",
+  "CURVANCE"
+]);
+var parseLenderKey = (raw) => raw.trim().toUpperCase().replaceAll("-", "_");
+function filterLenderMeta(meta, filter) {
+  const lenders = filter?.lenders;
+  if (!lenders?.length) return meta;
+  const exact = /* @__PURE__ */ new Set();
+  const prefixes = [];
+  for (const l of lenders) {
+    if (PREFIX_LENDERS.has(l)) prefixes.push(l);
+    else exact.add(l);
+  }
+  const markets = filter?.markets?.length ? new Set(filter.markets.map((m) => m.toLowerCase().replace(/^0x/, ""))) : void 0;
+  const out = {};
+  for (const key3 of Object.keys(meta)) {
+    if (exact.has(key3)) {
+      out[key3] = meta[key3];
+      continue;
+    }
+    const p = prefixes.find((x) => key3.startsWith(`${x}_`));
+    if (!p) continue;
+    if (markets) {
+      const id = key3.slice(p.length + 1).toLowerCase().replace(/^0x/, "");
+      if (!markets.has(id)) continue;
+    }
+    out[key3] = meta[key3];
+  }
+  return out;
+}
+var buildQueriesFromMeta = (meta, account, selection) => Object.keys(meta).map((lender) => {
+  if (selection?.subAccountIndexes?.length && isEulerType(lender))
+    return {
+      lender,
+      account,
+      params: { subAccountIndexes: selection.subAccountIndexes }
+    };
+  const dolomiteIds = selection?.accountNumbers ?? selection?.subAccountIndexes?.map((i) => String(i));
+  if (dolomiteIds?.length && isDolomite(lender))
+    return { lender, account, params: { accountNumbers: dolomiteIds } };
+  return { lender, account };
+});
+var injectLenderInfoIntoEntries = (entries, infoByChain) => {
+  if (!infoByChain) return;
+  for (const entry of entries) {
+    const hit = infoByChain[entry.chainId]?.[entry.lender];
+    if (hit) entry.lenderInfo = hit;
+  }
+};
+
+// src/utils/rpcParse.ts
+function parseRawRpcResponses(responses, callMetadata, allowFailure = true) {
+  const sortedResponses = [...responses].sort((a, b) => a.id - b.id);
+  return sortedResponses.map((response, idx) => {
+    const metadata = callMetadata[idx];
+    if (response.error || !response.result) {
+      if (!allowFailure) {
+        throw new Error(
+          `RPC call failed for ${metadata.functionName}: ${response.error?.message || "No result"}`
+        );
+      }
+      return "0x";
+    }
+    try {
+      const decoded = decodeFunctionResult({
+        abi: metadata.abi,
+        functionName: metadata.functionName,
+        data: response.result
+      });
+      return decoded;
+    } catch (error) {
+      if (!allowFailure) {
+        throw new Error(
+          `Failed to decode result for ${metadata.functionName}: ${error}`
+        );
+      }
+      return "0x";
+    }
+  });
+}
+function parseRawRpcBatchResponses(batches, batchResponses, allowFailure = true) {
+  const allResults = [];
+  batches.forEach((batch, batchIdx) => {
+    const responses = batchResponses[batchIdx];
+    const parsed = parseRawRpcResponses(
+      responses,
+      batch.callMetadata,
+      allowFailure
+    );
+    allResults.push(...parsed);
+  });
+  return allResults;
+}
+function parseMulticallRpcResponses(responses, batches, allowFailure = true, permanentFailures) {
+  const allResults = [];
+  const sortedResponses = [...responses].sort((a, b) => a.id - b.id);
+  sortedResponses.forEach((response, batchIdx) => {
+    const batch = batches[batchIdx];
+    if (response.error || !response.result) {
+      if (!allowFailure) {
+        throw new Error(
+          `Multicall RPC failed: ${response.error?.message || "No result"}`
+        );
+      }
+      batch.callMetadata.forEach(() => allResults.push("0x"));
+      return;
+    }
+    try {
+      const decoded = decodeAbiParameters(
+        [
+          {
+            type: "tuple[]",
+            components: [
+              { name: "success", type: "bool" },
+              { name: "returnData", type: "bytes" }
+            ]
+          }
+        ],
+        response.result
+      )[0];
+      decoded.forEach((result, idx) => {
+        const metadata = batch.callMetadata[idx];
+        if (!result.success || result.returnData === "0x") {
+          if (!allowFailure) {
+            throw new Error(`Call failed for ${metadata.functionName}`);
+          }
+          permanentFailures?.add(allResults.length);
+          allResults.push("0x");
+          return;
+        }
+        try {
+          const decodedResult = decodeFunctionResult({
+            abi: metadata.abi,
+            functionName: metadata.functionName,
+            data: result.returnData
+          });
+          allResults.push(decodedResult);
+        } catch (error) {
+          if (!allowFailure) {
+            throw new Error(
+              `Failed to decode result for ${metadata.functionName}: ${error}`
+            );
+          }
+          permanentFailures?.add(allResults.length);
+          allResults.push("0x");
+        }
+      });
+    } catch (error) {
+      if (!allowFailure) {
+        throw new Error(`Failed to decode multicall response: ${error}`);
+      }
+      batch.callMetadata.forEach(() => allResults.push("0x"));
+    }
+  });
+  return allResults;
+}
+
+// src/lending/user-data/read/readUserPositions.ts
+async function readUserPositions(params) {
+  const t0 = Date.now();
+  const {
+    chainId,
+    account,
+    meta,
+    transport,
+    batchSize = MULTICALL_DEFAULT_BATCH_SIZE
+  } = params;
+  const blockNumber = params.blockNumber === void 0 ? void 0 : BigInt(params.blockNumber);
+  const asOfBlock = blockNumber === void 0 ? null : Number(blockNumber);
+  const selected = filterLenderMeta(meta, {
+    lenders: params.lenders,
+    markets: params.markets
+  });
+  const queries = buildQueriesFromMeta(selected, account, {
+    subAccountIndexes: params.subAccountIndexes,
+    accountNumbers: params.accountNumbers
+  });
+  if (queries.length === 0)
+    return {
+      items: [],
+      asOfBlock,
+      partial: false,
+      incompleteLenders: [],
+      stats: { lenders: 0, calls: 0, batches: 0, ms: Date.now() - t0 }
+    };
+  const prepared = await prepareLenderUserDataRpcCalls(
+    chainId,
+    queries,
+    batchSize,
+    blockNumber === void 0 ? "latest" : `0x${blockNumber.toString(16)}`,
+    true,
+    { ...params.readContext, blockNumber }
+  );
+  const responses = await transport(prepared.rpcCalls);
+  const permanentFailures = /* @__PURE__ */ new Set();
+  const decoded = parseMulticallRpcResponses(
+    responses,
+    prepared.batches,
+    true,
+    permanentFailures
+  );
+  const incompleteLenders = [];
+  const converted = convertLenderUserDataResult(
+    chainId,
+    prepared.queries,
+    decoded,
+    selected,
+    {
+      permanentFailures,
+      // The build phase cached its discoveries under this block; the parse
+      // phase has to look them up under the same one.
+      blockNumber,
+      onIncomplete: (info) => {
+        incompleteLenders.push(`${chainId}:${info.lender}`);
+        params.onIncomplete?.(info);
+      }
+    }
+  );
+  const userData = { [chainId]: converted };
+  const items = fuseLenderData(userData, buildSummaries(userData));
+  injectLenderInfoIntoEntries(
+    items,
+    params.lenderInfo ? { [chainId]: params.lenderInfo } : void 0
+  );
+  return {
+    items,
+    asOfBlock,
+    partial: incompleteLenders.length > 0,
+    incompleteLenders,
+    stats: {
+      lenders: queries.length,
+      calls: prepared.batches.reduce((n, b) => n + b.callMetadata.length, 0),
+      batches: prepared.batches.length,
+      ms: Date.now() - t0
+    }
+  };
+}
+
 // src/yields/intrinsic/fetchers/lido.ts
 var WSTETH_URL = "https://eth-api.lido.fi/v1/protocol/steth/apr/sma";
 var DEFILLAMA_LIDO_URL = "https://yields.llama.fi/chart/747c1d2a-c668-4682-b9f9-296708a3dd90";
@@ -79218,113 +79622,6 @@ function computeEModeAnalysis(subAccount, lenderMeta, eModes) {
     };
   });
 }
-
-// src/utils/rpcParse.ts
-function parseRawRpcResponses(responses, callMetadata, allowFailure = true) {
-  const sortedResponses = [...responses].sort((a, b) => a.id - b.id);
-  return sortedResponses.map((response, idx) => {
-    const metadata = callMetadata[idx];
-    if (response.error || !response.result) {
-      if (!allowFailure) {
-        throw new Error(
-          `RPC call failed for ${metadata.functionName}: ${response.error?.message || "No result"}`
-        );
-      }
-      return "0x";
-    }
-    try {
-      const decoded = decodeFunctionResult({
-        abi: metadata.abi,
-        functionName: metadata.functionName,
-        data: response.result
-      });
-      return decoded;
-    } catch (error) {
-      if (!allowFailure) {
-        throw new Error(
-          `Failed to decode result for ${metadata.functionName}: ${error}`
-        );
-      }
-      return "0x";
-    }
-  });
-}
-function parseRawRpcBatchResponses(batches, batchResponses, allowFailure = true) {
-  const allResults = [];
-  batches.forEach((batch, batchIdx) => {
-    const responses = batchResponses[batchIdx];
-    const parsed = parseRawRpcResponses(
-      responses,
-      batch.callMetadata,
-      allowFailure
-    );
-    allResults.push(...parsed);
-  });
-  return allResults;
-}
-function parseMulticallRpcResponses(responses, batches, allowFailure = true, permanentFailures) {
-  const allResults = [];
-  const sortedResponses = [...responses].sort((a, b) => a.id - b.id);
-  sortedResponses.forEach((response, batchIdx) => {
-    const batch = batches[batchIdx];
-    if (response.error || !response.result) {
-      if (!allowFailure) {
-        throw new Error(
-          `Multicall RPC failed: ${response.error?.message || "No result"}`
-        );
-      }
-      batch.callMetadata.forEach(() => allResults.push("0x"));
-      return;
-    }
-    try {
-      const decoded = decodeAbiParameters(
-        [
-          {
-            type: "tuple[]",
-            components: [
-              { name: "success", type: "bool" },
-              { name: "returnData", type: "bytes" }
-            ]
-          }
-        ],
-        response.result
-      )[0];
-      decoded.forEach((result, idx) => {
-        const metadata = batch.callMetadata[idx];
-        if (!result.success || result.returnData === "0x") {
-          if (!allowFailure) {
-            throw new Error(`Call failed for ${metadata.functionName}`);
-          }
-          permanentFailures?.add(allResults.length);
-          allResults.push("0x");
-          return;
-        }
-        try {
-          const decodedResult = decodeFunctionResult({
-            abi: metadata.abi,
-            functionName: metadata.functionName,
-            data: result.returnData
-          });
-          allResults.push(decodedResult);
-        } catch (error) {
-          if (!allowFailure) {
-            throw new Error(
-              `Failed to decode result for ${metadata.functionName}: ${error}`
-            );
-          }
-          permanentFailures?.add(allResults.length);
-          allResults.push("0x");
-        }
-      });
-    } catch (error) {
-      if (!allowFailure) {
-        throw new Error(`Failed to decode multicall response: ${error}`);
-      }
-      batch.callMetadata.forEach(() => allResults.push("0x"));
-    }
-  });
-  return allResults;
-}
 var ERC20_STRING_ABI = [
   {
     inputs: [],
@@ -82759,6 +83056,6 @@ function earnPositionTotals(items) {
   };
 }
 
-export { ApiBookSource, DEFAULT_MIDNIGHT_API, DEFAULT_OUTLIER_GUARD, DEFAULT_PROFILE_ID, DEFAULT_STALE_REJECT_SECONDS, DEFAULT_TERMMAX_API, DEFAULT_TERM_ORDER_STORE, DOLOMITE_ISO_ID_PREFIX, EARN_DESCRIPTIONS, EARN_LABELS, EARN_RATE_SOURCE_BY_PROVIDER, EMPTY_BALANCE, EXACTLY_LENDER_KEY, FLYING_TULIP_LENDER_KEY, FRACTION_RATE_PROVIDERS, 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, MULTICALL_FAILURE, MaxParamThresholds, PASSTHROUGH_RATE_EPSILON, PENDLE_ASSETS_URL, PENDLE_CHAIN_IDS, PENDLE_MARKETS_URL, SDK_FRACTION_RATE_PROVIDERS, SPECTRA_NETWORKS, SPECTRA_RATE_MAX_PERCENT, SPECTRA_RATE_MIN_PERCENT, STABLECOIN_SYMBOLS, STCELO_MANAGER_ADDRESS, TELLER_CALLS_PER_BID, DECIMAL_BASE as TERMMAX_DECIMAL_BASE, TERMMAX_LIQUIDATION_PENALTY, TERMMAX_LIQUIDATION_WINDOW_SECS, TERMMAX_LIQUIDATOR_BONUS, TERMMAX_MARKETS_PER_CALL, TERMMAX_PARTIAL_CLOSE_FACTOR, TERMMAX_PARTIAL_LIQUIDATION_THRESHOLD_USD, TERM_ADAPTERS, TERM_PROFILES, TERM_SHEET_SCHEMA_VERSION, TermMaxApiSource, TermSubgraphSource, UPSHIFT_CHAIN_IDS, UPSHIFT_VAULTS_URL, VAULT_PROVIDERS, VAULT_PROVIDER_PROFILE, VAULT_PROVIDER_TRAITS, VAULT_SHARE_PRICE_PROBE, VAULT_VENUE_PREFIX, VOLATILE_VAULT_OVERRIDES, YEARN_CHAIN_IDS, YEARN_YDAEMON_BASE, __resetResupplyUserCaches, accountDepositListKey, accountWithdrawalListKey, appendSnapshot, applyEarnSanity, applyPositionDelta, attachImplications, attachPricesToFlashLiquidity, borrowDescription, borrowFindings, borrowHeadline, buildExposures2 as buildExposures, buildFluidFTokensCall, buildLendingPositionUid, buildLiquityUserCall, buildLoopResult, buildMorphoTypeCall, buildMorphoTypeUserCallWithLens, buildPortfolioTotals, buildSumerAccumulators, buildSummaries, buildTellerUserCall, buildTermMaxUserCall, buildTermSheet, buildTermSheetsForGroup, buildVaultEarnUid, buildVaultLookup, buildVaultTermSheet, calculateLeverage, calculateNetApr, calculateOverallNetApr, calculateWeightedAverage, classifyFreshness, classifyReliability, classifyVault, clearPendleMarketsCache, clearSpectraMarketsCache, collateralSymbolsByVenue, 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, convertCoolerMarketsToResponse, convertDssMarketsToResponse, convertExactlyMarketsToResponse, convertFlyingTulipMarketsToResponse, convertFrankencoinMarketsToResponse, convertFraxlendPairsToResponse, convertInverseMarketsToResponse, convertLenderUserDataResult, convertLiquityMarketsToResponse, convertLlamaLendMarketsToResponse, convertResupplyMarketsToResponse, convertRiverMarketsToResponse, convertTellerMarketsToResponse, convertTermMarketsToResponse, convertTermMaxMarketsToResponse, convertUsddMarketsToResponse, createMarketUid, createMidnightBookSource, createMulticallRpcCall, createRawRpcCalls, createTermBookSource, createTermMaxDataSource, decodeListaMarkets, decodeMarkets, decodePackedListaUserDataset, decodePackedMorphoUserDataset, deriveBorrowTags, deriveSupplyTags, detectInterfaceKinds, dexResolverFor, disambiguateEarnNames, dolomiteVaultAddress, dssIlkBytes32, dssKeyParts, dssLenderKey, duration, earnDescription, earnLabel, earnMarketFromPool, earnMarketFromVault, earnMarketLabel, earnPositionFromLenderEntry, earnPositionFromVaultBalance, earnPositionTotals, earnRateAtMaturity, earnRowSubtitle, earnUidFromMarketUid, earnVaultTerms, earnVenueKind, emitterCoverage, encodeBalanceFetcherCalldata, enrichTermSheet, enrichmentIndexFromRows, enumerateEmitters, exactlyPairLtv, exactlyPenaltyRateToAprPercent, exactlyWadRateToPercent, feePhrase, feedKeyOf, feedStatKey, fetchCoolerMarkets, fetchDolomiteAccountNumbers, fetchDolomiteSubAccounts, fetchDssMarkets, fetchEulerEarnVaults, fetchEulerEarnVaultsFromSubgraph, fetchEulerSubAccountIndexes, fetchExactlyMarkets, fetchFlashLiquidityForChain, fetchFluidDexState, fetchFluidFTokens, fetchFlyingTulipMarkets, fetchFrankencoinMarkets, fetchFraxlendPairs, fetchGeneralYields, fetchGeneralYieldsByMarketUid, fetchGmxExecutionFees, fetchGmxTickerPrices, fetchGmxVaults, fetchHypercoreVaults, fetchInverseMarkets, fetchLagoonApiVaults, fetchLagoonVaults, fetchLiquityMarkets, fetchListaVaultsFromChain, fetchLlamaLendMarkets, fetchMorphoUserBalances, fetchMorphoUserPositionMarkets, fetchMorphoVaults, fetchMorphoVaultsFromApi, fetchMorphoVaultsFromChain, fetchOraclePrices, fetchPendleApiAssets, fetchPendleApiMarkets, fetchPendlePrices, fetchPendlePtMarkets, fetchResupplyMarkets, fetchRiverMarkets, fetchSiloVaults, fetchSpectraApiMarkets, fetchSpectraPtMarkets, fetchTellerMarkets, fetchTermMarkets, fetchTermMaxMarkets, fetchTermStoreOrders, fetchTokenBalances, fetchTokenMetadata, fetchUpshiftApiVaults, fetchUpshiftVaults, fetchUsddMarkets, fetchYearnApiVaults, fetchYearnVaults, fillableRemaining, filterActiveLenders, filterLendersByProtocol, finalizeInfo, findingsFor, formatRaw, frankencoinKeyParts, frankencoinLenderKey, fraxlendAssetPerCollateral, fraxlendKeyParts, fraxlendLenderKey, fuseLenderData, generateLendingPools, getAavesForChain, getAssetConfig, getBalanceForMarketUid, getBorrowCapacity, getCachedFluidDexState, 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, getReadFailurePolicy, getResolvedDolomiteAccountNumbers, getResolvedDolomiteSubAccounts, getStCeloValidatorGroups, getSubAccountAddress, getSubAccountIndex, getTermProfile, getVaultPublicDataAll, getVaultWithdrawalRequests, hasCritical, hasEulerEarnVaultSubgraph, hasLagoonVaults, hasMorphoPositionIndex, hasMorphoUserApi, hasMorphoUserSubgraph, hasPendleMarkets, hasSpectraMarkets, hasUpshiftVaults, hasYearnVaults, ilkToKeySegment, implausibleRatePercent, inverseKeyParts, inverseLenderKey, isBoundNeed, isFailedCall, isIlliquid, isLendingPosition, isLiveMarket as isLivePendleMarket, isLiveSpectraMarket, isMaturedTerm, isSecondaryMarketOnly, isStablecoinSymbol, isUnearnableEarnRate, isUnrealizableEarnRate, isVaultPosition, isVaultVenue, isYearnV3, keySegmentToIlk, keysFromMaps, lenderApiOnly, lenderFamily, liquityCandidateTroveIds, liquityKeyParts, liquityLenderKey, llamaLendKeyParts, llamaLendLenderKey, meetsLiquidityFloor, mergeDeep, multicall3Abi2 as multicall3Abi, nanTo, needsLenderApproval, needsTokenApproval, noOpResult, normalizeToBytes, organizeUserQueries, parseBalanceFetcherResult, parseDolomiteSubAccountId, parseEarnUid, parseMergedResult, parseMulticallRpcResponses, parseExpirySeconds as parsePendleExpirySeconds, parseRawRpcBatchResponses, parseRawRpcResponses, parseCurveFee as parseSpectraCurveFee, parsePtRate as parseSpectraPtRate, parseTermMaxLtv, parseTokenBalanceResult, pct, assetKey as pendleAssetKey, pickPool as pickSpectraPool, positivePart2 as positivePart, predictInverseEscrow, prepareLenderUserDataRpcCalls, prepareMergedMulticallParams, prepareMergedRpcCalls, prepareMulticallInputs, prepareTokenBalanceRpcCalls, priceGlvVaults, priceGmMarkets, probeAaveFeedTimestamps, pruneFeedStats, rankFindings, ratePercent, readVaultSharePrices, rejectOutliers as rejectPriceOutliers, repairImpossibleTvl, resolveAdapter, resolveDerivation, resolveDolomiteRowIdentity, resolveEarnIdentity, resolveModeConfig, resolveStCeloDepositGroup, resolveVaultProfileId, resupplyKeyParts, resupplyLenderKey, resupplyMarketLabel, riverKeyParts, riverLenderKey, sanePercent as saneSpectraPercent, savingsAddresses, savingsBalanceKind, secondaryMarketVault, selectAssetGroupPrices, setMysticApiKey, shortDate, spectraAddress, spectraNetwork, spectraPoolsUrl, splitChainScopedAddress as splitPendleChainScopedAddress, stampCapabilities, stampEarnSubtitles, stampVaultClassification, stampVaultTermSheets, stripLeadingBrand, supplyDescription, supplyFindings, supplyHeadline, swapRoutedProvidersArePriceConsistent, tellerBpsToPercent, tellerImpliedLtv, tellerLenderKey, tellerPoolFromLenderKey, termApiBaseUrl, 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, termOfferRateToAprPct, termOrderStoreBaseUrl, tickToAprNumber, tickToPrice, toDigest, toDolomiteSubAccountId, toTermFillNow, toTermSheetInput, toVaultTermInput, trancheFromCounterparty, tryParseEarnUid, unflattenLenderData, updateFeedStats, usdValue, usddIlkBytes32, usddKeyParts, usddLenderKey, validateTermSheet, validateTermSheets, validateUserData, vaultSharesToAssets, vaultTermInputFromEarnMarket, vaultTermInputFromSourceRow, vaultTraits, vaultVenue, venueBrand, venueBrandKey, withMaturityLabel, withTrancheLabel };
+export { ApiBookSource, DEFAULT_MIDNIGHT_API, DEFAULT_OUTLIER_GUARD, DEFAULT_PROFILE_ID, DEFAULT_STALE_REJECT_SECONDS, DEFAULT_TERMMAX_API, DEFAULT_TERM_ORDER_STORE, DOLOMITE_ISO_ID_PREFIX, EARN_DESCRIPTIONS, EARN_LABELS, EARN_RATE_SOURCE_BY_PROVIDER, EMPTY_BALANCE, EXACTLY_LENDER_KEY, FLYING_TULIP_LENDER_KEY, FRACTION_RATE_PROVIDERS, 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, MULTICALL_FAILURE, MaxParamThresholds, PASSTHROUGH_RATE_EPSILON, PENDLE_ASSETS_URL, PENDLE_CHAIN_IDS, PENDLE_MARKETS_URL, PREFIX_LENDERS, SDK_FRACTION_RATE_PROVIDERS, SPECTRA_NETWORKS, SPECTRA_RATE_MAX_PERCENT, SPECTRA_RATE_MIN_PERCENT, STABLECOIN_SYMBOLS, STCELO_MANAGER_ADDRESS, TELLER_CALLS_PER_BID, DECIMAL_BASE as TERMMAX_DECIMAL_BASE, TERMMAX_LIQUIDATION_PENALTY, TERMMAX_LIQUIDATION_WINDOW_SECS, TERMMAX_LIQUIDATOR_BONUS, TERMMAX_MARKETS_PER_CALL, TERMMAX_PARTIAL_CLOSE_FACTOR, TERMMAX_PARTIAL_LIQUIDATION_THRESHOLD_USD, TERM_ADAPTERS, TERM_PROFILES, TERM_SHEET_SCHEMA_VERSION, TermMaxApiSource, TermSubgraphSource, UPSHIFT_CHAIN_IDS, UPSHIFT_VAULTS_URL, VAULT_PROVIDERS, VAULT_PROVIDER_PROFILE, VAULT_PROVIDER_TRAITS, VAULT_SHARE_PRICE_PROBE, VAULT_VENUE_PREFIX, VOLATILE_VAULT_OVERRIDES, YEARN_CHAIN_IDS, YEARN_YDAEMON_BASE, __resetResupplyUserCaches, accountDepositListKey, accountWithdrawalListKey, appendSnapshot, applyEarnSanity, applyPositionDelta, attachImplications, attachPricesToFlashLiquidity, blockNumberFromTag, borrowDescription, borrowFindings, borrowHeadline, buildExposures2 as buildExposures, buildFluidFTokensCall, buildLendingPositionUid, buildLiquityUserCall, buildLoopResult, buildMorphoTypeCall, buildMorphoTypeUserCallWithLens, buildPortfolioTotals, buildQueriesFromMeta, buildSumerAccumulators, buildSummaries, buildTellerUserCall, buildTermMaxUserCall, buildTermSheet, buildTermSheetsForGroup, buildVaultEarnUid, buildVaultLookup, buildVaultTermSheet, calculateLeverage, calculateNetApr, calculateOverallNetApr, calculateWeightedAverage, classifyFreshness, classifyReliability, classifyVault, clearPendleMarketsCache, clearSpectraMarketsCache, collateralSymbolsByVenue, 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, convertCoolerMarketsToResponse, convertDssMarketsToResponse, convertExactlyMarketsToResponse, convertFlyingTulipMarketsToResponse, convertFrankencoinMarketsToResponse, convertFraxlendPairsToResponse, convertInverseMarketsToResponse, convertLenderUserDataResult, convertLiquityMarketsToResponse, convertLlamaLendMarketsToResponse, convertResupplyMarketsToResponse, convertRiverMarketsToResponse, convertTellerMarketsToResponse, convertTermMarketsToResponse, convertTermMaxMarketsToResponse, convertUsddMarketsToResponse, createMarketUid, createMidnightBookSource, createMulticallRpcCall, createRawRpcCalls, createTermBookSource, createTermMaxDataSource, decodeListaMarkets, decodeMarkets, decodePackedListaUserDataset, decodePackedMorphoUserDataset, deriveBorrowTags, deriveSupplyTags, detectInterfaceKinds, dexResolverFor, disambiguateEarnNames, dolomiteVaultAddress, dssIlkBytes32, dssKeyParts, dssLenderKey, duration, earnDescription, earnLabel, earnMarketFromPool, earnMarketFromVault, earnMarketLabel, earnPositionFromLenderEntry, earnPositionFromVaultBalance, earnPositionTotals, earnRateAtMaturity, earnRowSubtitle, earnUidFromMarketUid, earnVaultTerms, earnVenueKind, emitterCoverage, encodeBalanceFetcherCalldata, enrichTermSheet, enrichmentIndexFromRows, enumerateEmitters, exactlyPairLtv, exactlyPenaltyRateToAprPercent, exactlyWadRateToPercent, feePhrase, feedKeyOf, feedStatKey, fetchCoolerMarkets, fetchDolomiteAccountNumbers, fetchDolomiteSubAccounts, fetchDssMarkets, fetchEulerEarnVaults, fetchEulerEarnVaultsFromSubgraph, fetchEulerSubAccountIndexes, fetchExactlyMarkets, fetchFlashLiquidityForChain, fetchFluidDexState, fetchFluidFTokens, fetchFlyingTulipMarkets, fetchFrankencoinMarkets, fetchFraxlendPairs, fetchGeneralYields, fetchGeneralYieldsByMarketUid, fetchGmxExecutionFees, fetchGmxTickerPrices, fetchGmxVaults, fetchHypercoreVaults, fetchInverseMarkets, fetchLagoonApiVaults, fetchLagoonVaults, fetchLiquityMarkets, fetchListaVaultsFromChain, fetchLlamaLendMarkets, fetchMorphoUserBalances, fetchMorphoUserPositionMarkets, fetchMorphoVaults, fetchMorphoVaultsFromApi, fetchMorphoVaultsFromChain, fetchOraclePrices, fetchPendleApiAssets, fetchPendleApiMarkets, fetchPendlePrices, fetchPendlePtMarkets, fetchResupplyMarkets, fetchRiverMarkets, fetchSiloVaults, fetchSpectraApiMarkets, fetchSpectraPtMarkets, fetchTellerMarkets, fetchTermMarkets, fetchTermMaxMarkets, fetchTermStoreOrders, fetchTokenBalances, fetchTokenMetadata, fetchUpshiftApiVaults, fetchUpshiftVaults, fetchUsddMarkets, fetchYearnApiVaults, fetchYearnVaults, fillableRemaining, filterActiveLenders, filterLenderMeta, filterLendersByProtocol, finalizeInfo, findingsFor, formatRaw, frankencoinKeyParts, frankencoinLenderKey, fraxlendAssetPerCollateral, fraxlendKeyParts, fraxlendLenderKey, fuseLenderData, generateLendingPools, getAavesForChain, getAssetConfig, getBalanceForMarketUid, getBorrowCapacity, getCachedFluidDexState, 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, getReadFailurePolicy, getResolvedDolomiteAccountNumbers, getResolvedDolomiteSubAccounts, getStCeloValidatorGroups, getSubAccountAddress, getSubAccountIndex, getTermProfile, getVaultPublicDataAll, getVaultWithdrawalRequests, hasCritical, hasEulerEarnVaultSubgraph, hasLagoonVaults, hasMorphoPositionIndex, hasMorphoUserApi, hasMorphoUserSubgraph, hasPendleMarkets, hasSpectraMarkets, hasUpshiftVaults, hasYearnVaults, ilkToKeySegment, implausibleRatePercent, injectLenderInfoIntoEntries, inverseKeyParts, inverseLenderKey, isBoundNeed, isFailedCall, isIlliquid, isLendingPosition, isLiveMarket as isLivePendleMarket, isLiveSpectraMarket, isMaturedTerm, isSecondaryMarketOnly, isStablecoinSymbol, isUnearnableEarnRate, isUnrealizableEarnRate, isVaultPosition, isVaultVenue, isYearnV3, keySegmentToIlk, keysFromMaps, lenderApiOnly, lenderFamily, liquityCandidateTroveIds, liquityKeyParts, liquityLenderKey, llamaLendKeyParts, llamaLendLenderKey, marketKeysOf, meetsLiquidityFloor, mergeDeep, multicall3Abi2 as multicall3Abi, nanTo, needsLenderApproval, needsTokenApproval, noOpResult, normalizeToBytes, organizeUserQueries, parseBalanceFetcherResult, parseDolomiteSubAccountId, parseEarnUid, parseLenderKey, parseMergedResult, parseMulticallRpcResponses, parseExpirySeconds as parsePendleExpirySeconds, parseRawRpcBatchResponses, parseRawRpcResponses, parseCurveFee as parseSpectraCurveFee, parsePtRate as parseSpectraPtRate, parseTermMaxLtv, parseTokenBalanceResult, pct, assetKey as pendleAssetKey, pickPool as pickSpectraPool, positivePart2 as positivePart, predictInverseEscrow, prepareLenderUserDataRpcCalls, prepareMergedMulticallParams, prepareMergedRpcCalls, prepareMulticallInputs, prepareTokenBalanceRpcCalls, priceGlvVaults, priceGmMarkets, probeAaveFeedTimestamps, pruneFeedStats, rankFindings, ratePercent, readUserPositions, readVaultSharePrices, rejectOutliers as rejectPriceOutliers, repairImpossibleTvl, resolveAdapter, resolveDerivation, resolveDolomiteRowIdentity, resolveEarnIdentity, resolveModeConfig, resolveStCeloDepositGroup, resolveVaultProfileId, resupplyKeyParts, resupplyLenderKey, resupplyMarketLabel, riverKeyParts, riverLenderKey, sanePercent as saneSpectraPercent, savingsAddresses, savingsBalanceKind, secondaryMarketVault, selectAssetGroupPrices, setMysticApiKey, shortDate, spectraAddress, spectraNetwork, spectraPoolsUrl, splitChainScopedAddress as splitPendleChainScopedAddress, stampCapabilities, stampEarnSubtitles, stampVaultClassification, stampVaultTermSheets, stripLeadingBrand, subAccountsOf, supplyDescription, supplyFindings, supplyHeadline, swapRoutedProvidersArePriceConsistent, tellerBpsToPercent, tellerImpliedLtv, tellerLenderKey, tellerPoolFromLenderKey, termApiBaseUrl, 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, termOfferRateToAprPct, termOrderStoreBaseUrl, tickToAprNumber, tickToPrice, toDigest, toDolomiteSubAccountId, toTermFillNow, toTermSheetInput, toVaultTermInput, trancheFromCounterparty, tryParseEarnUid, unflattenLenderData, updateFeedStats, usdValue, usddIlkBytes32, usddKeyParts, usddLenderKey, validateTermSheet, validateTermSheets, validateUserData, vaultSharesToAssets, vaultTermInputFromEarnMarket, vaultTermInputFromSourceRow, vaultTraits, vaultVenue, venueBrand, venueBrandKey, withMaturityLabel, withTrancheLabel };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map