@defisaver/positions-sdk 2.1.166 → 2.1.168

package/src/aaveV4/index.ts

@@ -1,7 +1,7 @@
 import { Client } from 'viem';
 import Dec from 'decimal.js';
 import { assetAmountInEth, assetAmountInWei, getAssetInfoByAddress } from '@defisaver/tokens';
-import { getViemProvider } from '../services/viem';
+import { getViemProvider, setViemBlockNumber } from '../services/viem';
 import {
   AaveV4AccountData,
   AaveV4HubAssetOnChainData,
@@ -275,6 +275,11 @@ export async function _getAaveV4AccountData(provider: Client, network: NetworkNu
   };
 }
 
+/** Shared raw read; no spoke metadata or market enrichment. */
+export const _getAaveV4LoanBalances = (provider: Client, network: NetworkNumber, block: Blockish, address: EthAddress, spoke: EthAddress) => (
+  AaveV4ViewContractViem(provider, network, block).read.getLoanData([spoke, address], setViemBlockNumber(block))
+);
+
 /**
  * Lightweight existence check for Loan Shifter / UI discovery.
  * Reads only `getLoanData(spoke, user)` and returns whether any reserve has

package/src/compoundV2/index.ts

@@ -116,7 +116,7 @@ const getAllMarketAddresses = async (provider: Client, network: NetworkNumber, b
 };
 
 
-export const _getCompoundV2AccountBalances = async (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress): Promise<PositionBalances> => {
+export const _getCompoundV2AccountBalances = async (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, tokens?: EthAddress[]): Promise<PositionBalances> => {
   let balances: PositionBalances = {
     collateral: {},
     debt: {},
@@ -126,7 +126,7 @@ export const _getCompoundV2AccountBalances = async (provider: Client, network: N
     return balances;
   }
 
-  const assets = await getAllMarketAddresses(provider, network, block);
+  const assets = tokens || await getAllMarketAddresses(provider, network, block);
   const assetInfo = assets.map(a => getAssetInfoByAddress(a, network));
   const loanInfoContract = CompoundLoanInfoContractViem(provider, network, block);
   const loanInfo = await loanInfoContract.read.getTokenBalances([address, assets], setViemBlockNumber(block));

package/src/curveUsd/index.ts

@@ -128,7 +128,7 @@ const getStatusForUser = (bandRange: string[], activeBand: string, crvUSDSupplie
   return CrvUSDStatus.Nonexistant;
 };
 
-export const _getCrvUsdAccountBalances = async (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, controllerAddress: EthAddress): Promise<PositionBalances> => {
+export const _getCrvUsdAccountBalances = async (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, controllerAddress: EthAddress, includeDeposited = false): Promise<PositionBalances> => {
   let balances: PositionBalances = {
     collateral: {},
     debt: {},
@@ -152,6 +152,11 @@ export const _getCrvUsdAccountBalances = async (provider: Client, network: Netwo
     },
   };
 
+  if (includeDeposited) {
+    balances.deposited = {
+      [addressMapping ? getAssetInfo(wethToEth(selectedMarket.baseAsset), network).address.toLowerCase() : wethToEth(selectedMarket.baseAsset)]: data.curveUsdCollateralAmount.toString(),
+    };
+  }
   return balances;
 };
 

package/src/fluid/index.ts

@@ -3,6 +3,7 @@ import {
   assetAmountInEth, AssetData, getAssetInfo, getAssetInfoByAddress,
 } from '@defisaver/tokens';
 import { Client, PublicClient } from 'viem';
+import { fluidTokenAmount } from '../helpers/fluidBalances';
 import {
   EthAddress, EthereumProvider, IncentiveKind, NetworkNumber,
 } from '../types/common';
@@ -1178,8 +1179,8 @@ const parseT1UserData = (userPositionData: FluidUserPositionStructOutputStruct,
   const debtAsset = getAssetInfo(marketData.debtAsset0);
 
   // for T2 and T4 - this is the number of shares
-  const supplied = getEthAmountForDecimals(userPositionData.supply.toString(), collAsset.decimals);
-  const borrowed = getEthAmountForDecimals(userPositionData.borrow.toString(), debtAsset.decimals);
+  const supplied = fluidTokenAmount(userPositionData.supply, collAsset.decimals);
+  const borrowed = fluidTokenAmount(userPositionData.borrow, debtAsset.decimals);
 
   const collUsedAsset: FluidUsedAsset = {
     ...EMPTY_USED_ASSET,
@@ -1234,10 +1235,10 @@ const parseT2UserData = (userPositionData: FluidUserPositionStructOutputStruct,
   const debtAsset = getAssetInfo(marketData.debtAsset0);
 
   const supplyShares = getEthAmountForDecimals(userPositionData.supply.toString(), 18); // this is supplied in coll shares
-  const borrowed = getEthAmountForDecimals(userPositionData.borrow.toString(), debtAsset.decimals); // this is actual token borrow
+  const borrowed = fluidTokenAmount(userPositionData.borrow, debtAsset.decimals); // this is actual token borrow
 
-  const supplied0 = new Dec(supplyShares).mul(assetsData[collAsset0.symbol].tokenPerSupplyShare!).toString();
-  const supplied1 = new Dec(supplyShares).mul(assetsData[collAsset1.symbol].tokenPerSupplyShare!).toString();
+  const supplied0 = fluidTokenAmount(userPositionData.supply, collAsset0.decimals, assetsData[collAsset0.symbol].tokenPerSupplyShare!);
+  const supplied1 = fluidTokenAmount(userPositionData.supply, collAsset1.decimals, assetsData[collAsset1.symbol].tokenPerSupplyShare!);
 
   const collUsedAsset0: Partial<FluidUsedAsset> = {
     symbol: collAsset0.symbol,
@@ -1302,11 +1303,11 @@ const parseT3UserData = (userPositionData: FluidUserPositionStructOutputStruct,
   const debtAsset0 = getAssetInfo(marketData.debtAsset0);
   const debtAsset1 = getAssetInfo(marketData.debtAsset1);
 
-  const supplied = getEthAmountForDecimals(userPositionData.supply.toString(), collAsset.decimals); // this is actual token supply
+  const supplied = fluidTokenAmount(userPositionData.supply, collAsset.decimals); // this is actual token supply
   const borrowShares = getEthAmountForDecimals(userPositionData.borrow.toString(), 18); // this is actual token borrow
 
-  const borrowed0 = new Dec(borrowShares).mul(assetsData[debtAsset0.symbol].tokenPerBorrowShare!).toString();
-  const borrowed1 = new Dec(borrowShares).mul(assetsData[debtAsset1.symbol].tokenPerBorrowShare!).toString();
+  const borrowed0 = fluidTokenAmount(userPositionData.borrow, debtAsset0.decimals, assetsData[debtAsset0.symbol].tokenPerBorrowShare!);
+  const borrowed1 = fluidTokenAmount(userPositionData.borrow, debtAsset1.decimals, assetsData[debtAsset1.symbol].tokenPerBorrowShare!);
 
   const collUsedAsset: Partial<FluidUsedAsset> = {
     symbol: collAsset.symbol,
@@ -1374,11 +1375,11 @@ const parseT4UserData = (userPositionData: FluidUserPositionStructOutputStruct,
   const supplyShares = getEthAmountForDecimals(userPositionData.supply.toString(), 18); // this is actual token supply
   const borrowShares = getEthAmountForDecimals(userPositionData.borrow.toString(), 18); // this is actual token borrow
 
-  const supplied0 = new Dec(supplyShares).mul(assetsData[collAsset0.symbol].tokenPerSupplyShare!).toString();
-  const supplied1 = new Dec(supplyShares).mul(assetsData[collAsset1.symbol].tokenPerSupplyShare!).toString();
+  const supplied0 = fluidTokenAmount(userPositionData.supply, collAsset0.decimals, assetsData[collAsset0.symbol].tokenPerSupplyShare!);
+  const supplied1 = fluidTokenAmount(userPositionData.supply, collAsset1.decimals, assetsData[collAsset1.symbol].tokenPerSupplyShare!);
 
-  const borrowed0 = new Dec(borrowShares).mul(assetsData[debtAsset0.symbol].tokenPerBorrowShare!).toString();
-  const borrowed1 = new Dec(borrowShares).mul(assetsData[debtAsset1.symbol].tokenPerBorrowShare!).toString();
+  const borrowed0 = fluidTokenAmount(userPositionData.borrow, debtAsset0.decimals, assetsData[debtAsset0.symbol].tokenPerBorrowShare!);
+  const borrowed1 = fluidTokenAmount(userPositionData.borrow, debtAsset1.decimals, assetsData[debtAsset1.symbol].tokenPerBorrowShare!);
 
   const collUsedAsset0: Partial<FluidUsedAsset> = {
     symbol: collAsset0.symbol,

package/src/helpers/aaveBalances.ts

@@ -0,0 +1,41 @@
+import Dec from 'decimal.js';
+import { getAssetInfoByAddress } from '@defisaver/tokens';
+import { Client } from 'viem';
+import { AaveMarketInfo, SparkMarketData } from '../types';
+import {
+  Blockish, EthAddress, NetworkNumber, PositionBalances,
+} from '../types/common';
+import { createViemContractFromConfigFunc } from '../contracts';
+import { setViemBlockNumber } from '../services/viem';
+import { wethToEth, wethToEthByAddress } from '../services/utils';
+
+/** Raw token balances shared by Aave/Spark getters and lending previews. */
+export async function getAaveLikeBalances(
+  client: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean,
+  address: EthAddress, market: Pick<AaveMarketInfo | SparkMarketData, 'providerAddress' | 'protocolData' | 'protocolDataAddress'>,
+  view: 'AaveLoanInfoV2' | 'AaveV3View' | 'SparkView', tokens?: EthAddress[],
+): Promise<PositionBalances> {
+  const balances: PositionBalances = { collateral: {}, debt: {} };
+  if (!address) return balances;
+  let reserves: { tokenAddress: EthAddress; symbol: string }[];
+  if (tokens) reserves = tokens.map(tokenAddress => ({ tokenAddress, symbol: getAssetInfoByAddress(tokenAddress, network).symbol }));
+  else {
+    if (!market.protocolData) throw new Error('Missing protocol data provider');
+    reserves = [...await createViemContractFromConfigFunc(market.protocolData, market.protocolDataAddress as EthAddress)(client, network)
+      .read.getAllReservesTokens(setViemBlockNumber(block))];
+  }
+  const addresses = reserves.map(token => token.tokenAddress);
+  const contract = createViemContractFromConfigFunc(view)(client, network, block);
+  const middle = tokens ? Math.ceil(addresses.length / 2) : Math.floor(addresses.length / 2);
+  // Preserve legacy V2 single-call and V3/Spark two-call behavior.
+  const parts = !tokens && view === 'AaveLoanInfoV2' ? [addresses] : [addresses.slice(0, middle), addresses.slice(middle)];
+  const data = (await Promise.all((tokens ? parts.filter(part => part.length) : parts)
+    .map(part => contract.read.getTokenBalances([market.providerAddress, address, part], setViemBlockNumber(block))))).flat();
+  data.forEach((token, i) => {
+    // The views leave token.token unset; input order identifies the reserve.
+    const key = addressMapping ? wethToEthByAddress(reserves[i].tokenAddress, network).toLowerCase() : wethToEth(reserves[i].symbol);
+    balances.collateral![key] = token.balance.toString();
+    balances.debt![key] = new Dec(token.borrowsStable.toString()).add(token.borrowsVariable.toString()).toString();
+  });
+  return balances;
+}

package/src/helpers/fluidBalances.ts

@@ -0,0 +1,34 @@
+import Dec from 'decimal.js';
+import { getAssetInfoByAddress } from '@defisaver/tokens';
+import { FluidUserPositionStructOutputStruct, FluidVaultDataStructOutputStruct } from '../types';
+import { NetworkNumber, PositionBalances } from '../types/common';
+
+/** Convert raw tokens, or raw 18-decimal shares with a human-readable token/share ratio. */
+export const fluidTokenAmount = (amount: bigint, decimals: number, perShare?: string): string => (
+  new Dec(amount.toString()).div(new Dec(10).pow(perShare === undefined ? decimals : 18)).mul(perShare ?? 1).toString()
+);
+
+/** The same token/share conversion used by the full Fluid user parsers, without prices or yield. */
+export function parseFluidBalances(position: FluidUserPositionStructOutputStruct, vault: FluidVaultDataStructOutputStruct, network: NetworkNumber): PositionBalances {
+  const type = Number(vault.vaultType);
+  if (![10000, 20000, 30000, 40000].includes(type)) throw new Error('Unsupported Fluid vault');
+  const side = (amount: bigint, tokens: string[], ratios: bigint[] | undefined) => {
+    const balances: Record<string, string> = {};
+    tokens.forEach((address, i) => {
+      const token = getAssetInfoByAddress(address, network);
+      if (!Number.isFinite(token.decimals) || !token.symbol) throw new Error('Fluid token metadata unavailable');
+      const perShare = ratios ? fluidTokenAmount(ratios[i], token.decimals) : undefined;
+      const value = fluidTokenAmount(amount, token.decimals, perShare);
+      balances[token.symbol] = new Dec(balances[token.symbol] || 0).add(value).toString();
+    });
+    return balances;
+  };
+  const smartSupply = type === 20000 || type === 40000;
+  const smartDebt = type === 30000 || type === 40000;
+  return {
+    collateral: side(position.supply, smartSupply ? [vault.supplyToken0, vault.supplyToken1] : [vault.supplyToken0],
+      smartSupply ? [vault.dexSupplyData.token0PerSupplyShare, vault.dexSupplyData.token1PerSupplyShare] : undefined),
+    debt: side(position.borrow, smartDebt ? [vault.borrowToken0, vault.borrowToken1] : [vault.borrowToken0],
+      smartDebt ? [vault.dexBorrowData.token0PerBorrowShare, vault.dexBorrowData.token1PerBorrowShare] : undefined),
+  };
+}

package/src/liquityV2/index.ts

@@ -152,7 +152,7 @@ const getUserTroves = async (
   return getUserTroves(provider, network, isLegacy, account, marketAddress, newStartIndex, newStartIndex + 100, existingTroves);
 };
 
-const nftContractCreationBlockMapping = {
+export const nftContractCreationBlockMapping = {
   [LiquityV2Versions.LiquityV2Eth]: 22516079,
   [LiquityV2Versions.LiquityV2WstEth]: 22516099,
   [LiquityV2Versions.LiquityV2REth]: 22516118,

package/src/llamaLend/index.ts

@@ -168,7 +168,7 @@ const getStatusForUser = (bandRange: string[], activeBand: string, debtSupplied:
   return LlamaLendStatus.Nonexistant;
 };
 
-export const _getLlamaLendAccountBalances = async (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, controllerAddress: EthAddress): Promise<PositionBalances> => {
+export const _getLlamaLendAccountBalances = async (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, controllerAddress: EthAddress, includeDeposited = false): Promise<PositionBalances> => {
   let balances: PositionBalances = {
     collateral: {},
     debt: {},
@@ -192,6 +192,11 @@ export const _getLlamaLendAccountBalances = async (provider: Client, network: Ne
     },
   };
 
+  if (includeDeposited) {
+    balances.deposited = {
+      [addressMapping ? getAssetInfo(wethToEth(selectedMarket.baseAsset), network).address.toLowerCase() : wethToEth(selectedMarket.baseAsset)]: data.debtTokenCollateralAmount.toString(),
+    };
+  }
   return balances;
 };
 

package/src/markets/morphoBlue/index.ts

@@ -712,21 +712,6 @@ export const MORPHO_BLUE_SWBTC_WBTC_945 = (networkId: NetworkNumber = NetworkNum
   marketId: '0x514efda728a646dcafe4fdc9afe4ea214709e110ac1b2b78185ae00c1782cc82',
   protocolName: 'morpho-blue',
 });
-export const MORPHO_BLUE_OSETH_ETH_860 = (networkId: NetworkNumber = NetworkNumber.Eth): MorphoBlueMarketData => ({
-  chainIds: [NetworkNumber.Eth],
-  label: 'Morpho Blue',
-  shortLabel: 'osETH/ETH',
-  value: MorphoBlueVersions.MorphoBlueOsEthEth_860,
-  url: 'osethweth-d5211d0e',
-  loanToken: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
-  collateralToken: '0xf1C9acDc66974dFB6dEcB12aA385b9cD01190E38',
-  oracle: '0x224F2F1333b45E34fFCfC3bD01cE43C73A914498',
-  oracleType: MorphoBlueOracleType.MARKET_RATE,
-  irm: '0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC',
-  lltv: 0.86,
-  marketId: '0xd5211d0e3f4a30d5c98653d988585792bb7812221f04801be73a44ceecb11e89',
-  protocolName: 'morpho-blue',
-});
 export const MORPHO_BLUE_WOETH_ETH_860 = (networkId: NetworkNumber = NetworkNumber.Eth): MorphoBlueMarketData => ({
   chainIds: [NetworkNumber.Eth],
   label: 'Morpho Blue',
@@ -1878,7 +1863,6 @@ export const MorphoBlueMarkets = (networkId: NetworkNumber) => ({
   [MorphoBlueVersions.MorphoBlueRsEthEth_945]: MORPHO_BLUE_RSETH_ETH_945(networkId),
   [MorphoBlueVersions.MorphoBlueRswEthEth_945]: MORPHO_BLUE_RSWETH_ETH_945(networkId),
   [MorphoBlueVersions.MorphoBlueWeEthEth_860]: MORPHO_BLUE_WEETH_ETH_860(networkId),
-  [MorphoBlueVersions.MorphoBlueOsEthEth_860]: MORPHO_BLUE_OSETH_ETH_860(networkId),
   [MorphoBlueVersions.MorphoBlueWoEthEth_860]: MORPHO_BLUE_WOETH_ETH_860(networkId),
   [MorphoBlueVersions.MorphoBluePTweETHUSDA_860]: MORPHO_BLUE_PTWEETH_USDA_860(networkId),
   [MorphoBlueVersions.MorphoBlueSwBTCWBTC_945]: MORPHO_BLUE_SWBTC_WBTC_945(networkId),

package/src/morphoMidnight/index.ts

@@ -222,7 +222,7 @@ export async function getMorphoMidnightAccountData(provider: EthereumProvider, n
   return _getMorphoMidnightAccountData(getViemProvider(provider, network), network, account, selectedMarket, marketInfo);
 }
 
-export const _getMorphoMidnightAccountBalances = async (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, selectedMarket: MorphoMidnightMarketData): Promise<PositionBalances> => {
+export const _getMorphoMidnightAccountBalances = async (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, selectedMarket: MorphoMidnightMarketData, includeCredit = false): Promise<PositionBalances> => {
   const balances: PositionBalances = { collateral: {}, debt: {} };
   if (!address) return balances;
 
@@ -244,6 +244,11 @@ export const _getMorphoMidnightAccountBalances = async (provider: Client, networ
   });
   balances.collateral = collateral;
 
+  if (includeCredit) {
+    balances.deposited = {
+      [addressMapping ? loanTokenInfo.address.toLowerCase() : wethToEth(loanTokenInfo.symbol)]: assetAmountInEth(positionInfo.credit.toString(), wethToEth(loanTokenInfo.symbol)),
+    };
+  }
   return balances;
 };
 

package/src/portfolio/index.ts

@@ -849,3 +849,5 @@ export async function getShifterPortfolioData(provider: EthereumProvider, networ
 }
 
 export * from './discovery';
+
+export { getWalletLendingSummaries } from './lendingSummaries';

package/src/portfolio/lendingSummaries.ts

@@ -0,0 +1,216 @@
+/* global BigInt */
+import Dec from 'decimal.js';
+import { getAssetInfo, getAssetInfoByAddress } from '@defisaver/tokens';
+import {
+  Abi, custom, parseAbi, parseAbiItem,
+} from 'viem';
+import {
+  AaveMarkets, AaveV4Spokes, CompoundMarkets, compoundV2CollateralAssets, CrvUsdMarkets,
+  LiquityV2Markets, LlamaLendMarkets, MorphoBlueMarkets, MorphoMidnightMarkets, SparkMarkets,
+} from '../markets';
+import { AaveVersions, CompoundVersions } from '../types';
+import {
+  EthAddress, EthereumProvider, NetworkNumber, PositionBalances, Amount,
+} from '../types/common';
+import { LendingSummaryOptions, WalletLendingSummaries, WalletLendingSummary } from '../types/lendingSummary';
+import { ConfigKey, getConfigContractAbi, getConfigContractAddress } from '../contracts';
+import { getViemProvider } from '../services/viem';
+import { getWrappedNativeAssetFromUnwrapped } from '../services/utils';
+import { getAaveLikeBalances } from '../helpers/aaveBalances';
+import { parseFluidBalances } from '../helpers/fluidBalances';
+import { _getAaveV4LoanBalances } from '../aaveV4';
+import { _getCompoundV2AccountBalances } from '../compoundV2';
+import { _getCompoundV3AccountBalances } from '../compoundV3';
+import { _getCrvUsdAccountBalances } from '../curveUsd';
+import { _getLlamaLendAccountBalances } from '../llamaLend';
+import { _getMorphoBlueAccountBalances } from '../morphoBlue';
+import { _getMorphoMidnightAccountBalances } from '../morphoMidnight';
+import { _getLiquityAccountBalances } from '../liquity';
+import { _getUserCdps } from '../maker';
+import { nftContractCreationBlockMapping } from '../liquityV2';
+import { lendingSummaryTransport } from './lendingSummaryTransport';
+
+const nftAbi = parseAbi([
+  'function troveNFT() view returns (address)', 'function balanceOf(address) view returns (uint256)',
+  'function ownerOf(uint256) view returns (address)',
+]);
+const transfer = parseAbiItem('event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)');
+const units = (value: unknown, decimals = 18) => new Dec(String(value)).div(new Dec(10).pow(decimals)).toString();
+const positive = (value: unknown) => new Dec(String(value)).gt(0);
+const supported = <T extends { chainIds: NetworkNumber[] }>(list: Record<string, T>, network: NetworkNumber) => Object.values(list).filter(m => m.chainIds.includes(network));
+
+/** Lending-only balances at one snapshot, valued with caller-supplied market prices.
+ * One shared client/limiter covers every wallet. Failed reads remain partial; cancellation
+ * discards results. Morpho Blue earn deposits, rewards and savings are excluded.
+ */
+export async function getWalletLendingSummaries(
+  provider: EthereumProvider, network: NetworkNumber, walletAddresses: EthAddress[], options: LendingSummaryOptions,
+): Promise<WalletLendingSummaries> {
+  const addresses = [...new Set(walletAddresses.map(address => {
+    if (!/^0x[0-9a-f]{40}$/i.test(address)) throw new Error('Invalid wallet address');
+    return address.toLowerCase() as EthAddress;
+  }))];
+  const summaries: Record<string, WalletLendingSummary> = Object.fromEntries(addresses.map(address => [address, {
+    status: 'complete', positions: [], protocols: [], suppliedUsd: '0', valuationComplete: true, errors: [],
+  }]));
+  if (!addresses.length || options.signal?.aborted) return { summaries: {}, rateLimited: false };
+  const maxCalldataBytes = options.isSim ? 2_000 : 32_000;
+  const transport = lendingSummaryTransport(provider, options.signal, options.blockNumber, maxCalldataBytes);
+  const client = getViemProvider(transport.provider, network, {
+    transport: custom(transport.provider, { retryCount: 0 }), batch: { multicall: { batchSize: maxCalldataBytes } },
+  });
+  let snapshot: bigint;
+  try {
+    snapshot = options.blockNumber ?? await client.getBlockNumber();
+    transport.pinBlock(snapshot);
+  } catch (error) {
+    if (options.signal?.aborted) return { summaries: {}, rateLimited: transport.isRateLimited() };
+    for (const summary of Object.values(summaries)) { summary.status = 'failed'; summary.errors.push(String(error)); }
+    return { summaries, rateLimited: transport.isRateLimited() };
+  }
+  const block = Number(snapshot);
+  // Dynamic ABI boundary for user-scoped CDP/NFT reads; money markets use their existing readers.
+  const read = (name: ConfigKey, functionName: string, args: readonly unknown[] = []): Promise<any> => client.readContract({
+    address: getConfigContractAddress(name, network, block), abi: getConfigContractAbi(name, network, block) as Abi, functionName, args,
+  });
+  const nftRead = (address: EthAddress, functionName: 'troveNFT' | 'balanceOf' | 'ownerOf', args: readonly any[] = []): Promise<any> => client.readContract({
+    address, abi: nftAbi as Abi, functionName, args,
+  });
+  const cache = new Map<string, Promise<any>>();
+  const shared = <T>(key: string, fetch: () => Promise<T>): Promise<T> => {
+    if (!cache.has(key)) cache.set(key, fetch());
+    return cache.get(key)!;
+  };
+  const tasks: Promise<void>[] = [];
+  const tokens = new Set<EthAddress>();
+  const valuations: (() => void)[] = [];
+  let prices: Record<string, string> = {};
+  const run = async (address: string, protocol: string, key: string, work: () => Promise<void>) => {
+    try { if (!options.signal?.aborted) await work(); } catch (error) {
+      summaries[address].errors.push(`${protocol}:${key}: ${String(error).split('\n')[0]}`);
+    }
+  };
+  const add = async (address: string, protocol: string, key: string, balances: PositionBalances, human = false) => {
+    const supply = Object.entries(balances.collateral || {}).concat(Object.entries(balances.deposited || {}));
+    const debt = Object.entries(balances.debt || {});
+    if (![...supply, ...debt].some(([, amount]) => positive(amount))) return;
+    const entry = {
+      id: `${protocol}:${key}`,
+      protocol,
+      suppliedUsd: (supply.some(([, amount]) => positive(amount)) ? null : '0') as string | null,
+      debtUsd: (debt.some(([, amount]) => positive(amount)) ? null : '0') as string | null,
+    };
+    summaries[address].positions.push(entry);
+    const normalize = (amounts: [string, Amount][]) => {
+      const result: Record<string, Dec> = {};
+      amounts.filter(([, amount]) => positive(amount)).forEach(([symbol, amount]) => {
+        const token = symbol.startsWith('0x') ? getAssetInfoByAddress(symbol, network) : getAssetInfo(getWrappedNativeAssetFromUnwrapped(symbol), network);
+        if (!token.address || !Number.isFinite(token.decimals)) throw new Error(`Token metadata unavailable: ${symbol}`);
+        const id = token.address.toLowerCase() as EthAddress;
+        tokens.add(id);
+        result[id] = (result[id] || new Dec(0)).add(human ? amount : units(amount, token.decimals));
+      });
+      return result;
+    };
+    const amounts = [normalize(supply), normalize(debt)];
+    valuations.push(() => {
+      (['suppliedUsd', 'debtUsd'] as const).forEach((field, i) => {
+        try {
+          entry[field] = Object.entries(amounts[i]).reduce((total, [token, amount]) => {
+            const price = new Dec(prices[token] || 0);
+            if (!price.isFinite() || !price.gt(0)) throw new Error(`Price unavailable: ${token}`);
+            return total.add(amount.mul(price));
+          }, new Dec(0)).toString();
+        } catch (error) { summaries[address].errors.push(`${entry.id}: ${String(error)}`); }
+      });
+    });
+  };
+  const balanceTask = (address: string, protocol: string, key: string, fetch: () => Promise<PositionBalances>, human = false) => tasks.push(run(address, protocol, key, async () => add(address, protocol, key, await fetch(), human)));
+
+  for (const address of addresses) {
+    const aaveMarkets = supported(AaveMarkets(network), network).filter(m => [AaveVersions.AaveV2, AaveVersions.AaveV3, AaveVersions.AaveV3Lido, AaveVersions.AaveV3Etherfi].includes(m.value));
+    for (const market of [...aaveMarkets, ...supported(SparkMarkets(network), network)]) {
+      const v2 = market.value === AaveVersions.AaveV2;
+      const spark = !aaveMarkets.some(m => m.value === market.value);
+      balanceTask(address, spark ? 'spark' : v2 ? 'aaveV2' : 'aaveV3', market.value, () => getAaveLikeBalances(client, network, block, false, address, market,
+        spark ? 'SparkView' : v2 ? 'AaveLoanInfoV2' : 'AaveV3View', market.assets.map(asset => getAssetInfo(getWrappedNativeAssetFromUnwrapped(asset), network).address as EthAddress)));
+    }
+    for (const spoke of supported(AaveV4Spokes(network), network)) {
+      balanceTask(address, 'aaveV4', spoke.value, async () => {
+        const { reserves } = await _getAaveV4LoanBalances(client, network, block, address, spoke.address);
+        const balances: PositionBalances = { collateral: {}, debt: {} };
+        reserves.forEach(r => {
+          balances.collateral![r.underlying] = new Dec(balances.collateral![r.underlying] || 0).add(r.supplied.toString()).toString();
+          balances.debt![r.underlying] = new Dec(balances.debt![r.underlying] || 0).add(r.totalDebt.toString()).toString();
+        });
+        return balances;
+      });
+    }
+    for (const market of supported(CompoundMarkets(network), network)) {
+      const v2 = market.value === CompoundVersions.CompoundV2;
+      balanceTask(address, v2 ? 'compoundV2' : 'compoundV3', market.value, () => (v2
+        ? _getCompoundV2AccountBalances(client, network, block, false, address, compoundV2CollateralAssets.map(a => a.address as EthAddress))
+        : _getCompoundV3AccountBalances(client, network, block, false, address, market.baseMarketAddress)));
+    }
+    for (const market of supported(MorphoBlueMarkets(network), network)) balanceTask(address, 'morphoBlue', market.value, () => _getMorphoBlueAccountBalances(client, network, block, false, address, market), true);
+    for (const market of supported(MorphoMidnightMarkets(network), network)) balanceTask(address, 'morphoMidnight', market.value, () => _getMorphoMidnightAccountBalances(client, network, block, false, address, market, true), true);
+    if (network === NetworkNumber.Eth) for (const market of supported(CrvUsdMarkets(network), network)) balanceTask(address, 'crvUsd', market.value, () => _getCrvUsdAccountBalances(client, network, block, false, address, market.controllerAddress, true));
+    if ([NetworkNumber.Eth, NetworkNumber.Arb].includes(network)) for (const market of supported(LlamaLendMarkets(network), network)) balanceTask(address, 'llamaLend', market.value, () => _getLlamaLendAccountBalances(client, network, block, false, address, market.controllerAddress, true));
+    if (network === NetworkNumber.Eth) {
+      balanceTask(address, 'liquity', 'trove', () => _getLiquityAccountBalances(client, network, block, false, address));
+      tasks.push(run(address, 'maker', 'discovery', async () => {
+        const cdps = await _getUserCdps(client, network, address);
+        await Promise.all(cdps.map(cdp => run(address, 'maker', String(cdp.id), async () => {
+          const [collateral, debt] = await read('McdVat', 'urns', [cdp.ilk, cdp.urn]);
+          const rate = positive(debt) ? (await shared(`maker:${cdp.ilk}`, () => read('McdVat', 'ilks', [cdp.ilk])))[1] : 0;
+          await add(address, 'maker', String(cdp.id), { collateral: { [cdp.asset]: units(collateral) }, debt: { DAI: new Dec(units(debt)).mul(units(rate, 27)).toString() } }, true);
+        })));
+      }));
+      for (const market of supported(LiquityV2Markets(network), network)) {
+        tasks.push(run(address, 'liquityV2', market.value, async () => {
+          const nft = await shared(`nft:${market.value}`, () => nftRead(market.marketAddress, 'troveNFT'));
+          const count = await nftRead(nft, 'balanceOf', [address]);
+          if (count === BigInt(0)) return;
+          const logs = await client.getLogs({
+            address: nft, event: transfer, args: { to: address }, fromBlock: BigInt(nftContractCreationBlockMapping[market.value]), toBlock: snapshot,
+          });
+          const owned = (await Promise.all([...new Set(logs.map(log => log.args.tokenId!))].map(async id => {
+            try { return (await nftRead(nft, 'ownerOf', [id])).toLowerCase() === address ? id : null; } catch { return null; }
+          }))).filter((id): id is bigint => id !== null);
+          if (BigInt(owned.length) !== count) summaries[address].errors.push(`liquityV2:${market.value}: Not all owned troves could be discovered`);
+          await Promise.all(owned.map(id => run(address, 'liquityV2', `${market.value}:${id}`, async () => {
+            const data = await read(market.isLegacy ? 'LiquityV2LegacyView' : 'LiquityV2View', 'getTroveInfo', [market.marketAddress, id]);
+            if (data.owner.toLowerCase() !== address) throw new Error('Trove ownership changed');
+            await add(address, 'liquityV2', `${market.value}:${id}`, { collateral: { [market.collateralToken]: data.collAmount.toString() }, debt: { [market.debtToken]: data.debtAmount.toString() } });
+          })));
+        }));
+      }
+    }
+    if ([NetworkNumber.Eth, NetworkNumber.Arb, NetworkNumber.Base, NetworkNumber.Plasma].includes(network)) {
+      tasks.push(run(address, 'fluid', 'discovery', async () => {
+        const [positions, vaults] = await read('FluidView', 'getUserPositions', [address]);
+        await Promise.all(positions.map((p: any, i: number) => run(address, 'fluid', String(p.nftId), async () => {
+          if (positive(p.supply) || positive(p.borrow)) await add(address, 'fluid', String(p.nftId), parseFluidBalances(p, vaults[i], network), true);
+        })));
+      }));
+    }
+  }
+  await Promise.all(tasks);
+  if (options.signal?.aborted) return { summaries: {}, rateLimited: transport.isRateLimited() };
+  if (tokens.size) {
+    try { prices = await options.resolvePrices(network, [...tokens], options.signal); } catch (error) {
+      for (const summary of Object.values(summaries)) if (summary.positions.length) summary.errors.push(`Prices: ${String(error)}`);
+    }
+  }
+  if (options.signal?.aborted) return { summaries: {}, rateLimited: transport.isRateLimited() };
+  valuations.forEach(value => value());
+  for (const summary of Object.values(summaries)) {
+    summary.positions.sort((a, b) => a.id.localeCompare(b.id));
+    summary.protocols = [...new Set(summary.positions.map(p => p.protocol))];
+    summary.suppliedUsd = summary.positions.reduce((total, p) => total.add(p.suppliedUsd || 0), new Dec(0)).toString();
+    summary.valuationComplete = summary.positions.every(p => p.suppliedUsd !== null && p.debtUsd !== null);
+    summary.errors = [...new Set(summary.errors)];
+    if (summary.errors.length) summary.status = 'partial';
+  }
+  return { summaries, rateLimited: transport.isRateLimited() };
+}

package/src/portfolio/lendingSummaryTransport.ts

@@ -0,0 +1,84 @@
+import {
+  decodeFunctionData, decodeFunctionResult, encodeFunctionData, encodeFunctionResult, multicall3Abi,
+} from 'viem';
+import { EthereumProvider } from '../types/common';
+
+const errorText = (error: unknown) => {
+  const detail = error as { message?: string; code?: number; status?: number };
+  return `${detail?.message || String(error)} ${detail?.code || ''} ${detail?.status || ''}`;
+};
+const logRangeLimit = (error: unknown) => /block range|too many (results|logs)|query returned|response.*size|range.*limit/i.test(errorText(error));
+const oversized = (error: unknown) => /413|request.*(large|size)|response.*(large|size)|out of gas|gas (required|limit)|exceeds.*gas|execution.*limit/i.test(errorText(error));
+
+export const isLendingSummaryRateLimit = (error: unknown): boolean => !oversized(error) && !logRangeLimit(error) && /429|rate.?limit|too many requests|compute units|limit exceeded/i.test(errorText(error));
+
+/** One limiter for all reads, including split multicalls. No retries after cancellation/429. */
+export function lendingSummaryTransport(provider: EthereumProvider, signal?: AbortSignal, blockNumber?: bigint, maxCalldataBytes = 32_000) {
+  let pinnedBlock = blockNumber;
+  let active = 0;
+  let rateLimit: unknown;
+  const waiting: (() => void)[] = [];
+  const check = () => {
+    if (signal?.aborted) throw new Error('Lending summary cancelled');
+    // Keep the provider's original error code/message, including plain RPC error objects.
+    // eslint-disable-next-line @typescript-eslint/no-throw-literal
+    if (rateLimit !== undefined) throw rateLimit;
+  };
+  const send = async (args: Parameters<EthereumProvider['request']>[0]) => {
+    if (active >= 4) await new Promise<void>(resolve => { waiting.push(resolve); });
+    else active++;
+    try {
+      check();
+      return await provider.request(args);
+    } catch (error) {
+      if (isLendingSummaryRateLimit(error)) rateLimit = error;
+      throw error;
+    } finally {
+      const next = waiting.shift();
+      if (next) next();
+      else active--;
+    }
+  };
+  const request: EthereumProvider['request'] = async (args) => {
+    check();
+    const params = [...(args.params || [])] as any[];
+    if (pinnedBlock !== undefined) {
+      const block = `0x${pinnedBlock.toString(16)}`;
+      if (args.method === 'eth_blockNumber') return block;
+      if (['eth_call', 'eth_getCode'].includes(args.method)) params[1] = block;
+    }
+    const call = params[0];
+    const isMulticall = args.method === 'eth_call' && call?.data?.startsWith('0x82ad56cb');
+    const splitMulticall = async (error: unknown) => {
+      const { args: [calls] } = decodeFunctionData({ abi: multicall3Abi, data: call.data });
+      if (!calls || calls.length < 2) throw error;
+      // Sequential halves keep the same concurrency bound and retain per-call failures.
+      const results = [];
+      for (const half of [calls.slice(0, Math.ceil(calls.length / 2)), calls.slice(Math.ceil(calls.length / 2))]) {
+        const data = encodeFunctionData({ abi: multicall3Abi, functionName: 'aggregate3', args: [half] });
+        const encoded = await request({ ...args, params: [{ ...call, data }, ...params.slice(1)] });
+        results.push(...decodeFunctionResult({ abi: multicall3Abi, functionName: 'aggregate3', data: encoded }));
+      }
+      return encodeFunctionResult({ abi: multicall3Abi, functionName: 'aggregate3', result: results });
+    };
+    // Viem's batch size counts inner calls only. Also bound the fully encoded calldata.
+    if (isMulticall && (call.data.length - 2) / 2 > maxCalldataBytes) return splitMulticall(new Error('Single call exceeds summary calldata limit'));
+    try {
+      return await send({ ...args, params });
+    } catch (error) {
+      check();
+      if (args.method === 'eth_getLogs' && logRangeLimit(error)) {
+        const from = BigInt(call.fromBlock);
+        const to = BigInt(call.toBlock);
+        if (from >= to) throw error;
+        const middle = (from + to) / BigInt(2);
+        const first = await request({ ...args, params: [{ ...call, toBlock: `0x${middle.toString(16)}` }] });
+        const last = await request({ ...args, params: [{ ...call, fromBlock: `0x${(middle + BigInt(1)).toString(16)}` }] });
+        return [...first, ...last];
+      }
+      if (!isMulticall || !oversized(error)) throw error;
+      return splitMulticall(error);
+    }
+  };
+  return { provider: { request } as EthereumProvider, isRateLimited: () => rateLimit !== undefined, pinBlock: (value: bigint) => { pinnedBlock = value; } };
+}