@defisaver/positions-sdk 2.1.167 → 2.1.168

package/esm/aaveV4/index.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import Dec from 'decimal.js';
 import { assetAmountInEth, assetAmountInWei, getAssetInfoByAddress } from '@defisaver/tokens';
-import { getViemProvider } from '../services/viem';
+import { getViemProvider, setViemBlockNumber } from '../services/viem';
 import { IncentiveKind, } from '../types';
 import { AaveV4ViewContractViem } from '../contracts';
 import { getStakingApy, STAKING_ASSETS } from '../staking';
@@ -251,6 +251,8 @@ export function _getAaveV4AccountData(provider_1, network_1, spokeData_1, addres
             riskPremiumBps });
     });
 }
+/** Shared raw read; no spoke metadata or market enrichment. */
+export const _getAaveV4LoanBalances = (provider, network, block, address, spoke) => (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/esm/compoundV2/index.d.ts

@@ -17,7 +17,7 @@ export declare const EMPTY_COMPOUND_DATA: {
     borrowStableSupplyUnstable: boolean;
     exposure: string;
 };
-export declare const _getCompoundV2AccountBalances: (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress) => Promise<PositionBalances>;
+export declare const _getCompoundV2AccountBalances: (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, tokens?: EthAddress[]) => Promise<PositionBalances>;
 export declare const getCompoundV2AccountBalances: (provider: EthereumProvider, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress) => Promise<PositionBalances>;
 export declare const _getCompoundV2AccountData: (provider: Client, network: NetworkNumber, address: EthAddress, assetsData: CompoundV2AssetsData) => Promise<CompoundV2PositionData>;
 export declare const getCompoundV2AccountData: (provider: EthereumProvider, network: NetworkNumber, address: EthAddress, assetsData: CompoundV2AssetsData) => Promise<CompoundV2PositionData>;

package/esm/compoundV2/index.js

@@ -101,7 +101,7 @@ const getAllMarketAddresses = (provider, network, block) => __awaiter(void 0, vo
     const contract = ComptrollerContractViem(provider, network);
     return contract.read.getAllMarkets(setViemBlockNumber(block));
 });
-export const _getCompoundV2AccountBalances = (provider, network, block, addressMapping, address) => __awaiter(void 0, void 0, void 0, function* () {
+export const _getCompoundV2AccountBalances = (provider, network, block, addressMapping, address, tokens) => __awaiter(void 0, void 0, void 0, function* () {
     let balances = {
         collateral: {},
         debt: {},
@@ -109,7 +109,7 @@ export const _getCompoundV2AccountBalances = (provider, network, block, addressM
     if (!address) {
         return balances;
     }
-    const assets = yield getAllMarketAddresses(provider, network, block);
+    const assets = tokens || (yield getAllMarketAddresses(provider, network, block));
     const assetInfo = assets.map(a => getAssetInfoByAddress(a, network));
     const loanInfoContract = CompoundLoanInfoContractViem(provider, network, block);
     const loanInfo = yield loanInfoContract.read.getTokenBalances([address, assets], setViemBlockNumber(block));

package/esm/curveUsd/index.d.ts

@@ -3,7 +3,7 @@ import { CrvUSDGlobalMarketData, CrvUSDMarketData, CrvUSDUserData } from '../typ
 import { Blockish, EthAddress, EthereumProvider, NetworkNumber, PositionBalances } from '../types/common';
 export declare const _getCurveUsdGlobalData: (provider: Client, network: NetworkNumber, selectedMarket: CrvUSDMarketData) => Promise<CrvUSDGlobalMarketData>;
 export declare const getCurveUsdGlobalData: (provider: EthereumProvider, network: NetworkNumber, selectedMarket: CrvUSDMarketData) => Promise<CrvUSDGlobalMarketData>;
-export declare const _getCrvUsdAccountBalances: (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, controllerAddress: EthAddress) => Promise<PositionBalances>;
+export declare const _getCrvUsdAccountBalances: (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, controllerAddress: EthAddress, includeDeposited?: boolean) => Promise<PositionBalances>;
 export declare const getCrvUsdAccountBalances: (provider: EthereumProvider, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, controllerAddress: EthAddress) => Promise<PositionBalances>;
 /**
  * @param borrowRate market borrow APY in % (`CrvUSDGlobalMarketData.borrowRate`); when omitted it is read from the view contract

package/esm/curveUsd/index.js

@@ -99,7 +99,7 @@ const getStatusForUser = (bandRange, activeBand, crvUSDSupplied, collSupplied, h
         return CrvUSDStatus.SoftLiquidated; // or is fully soft liquidated
     return CrvUSDStatus.Nonexistant;
 };
-export const _getCrvUsdAccountBalances = (provider, network, block, addressMapping, address, controllerAddress) => __awaiter(void 0, void 0, void 0, function* () {
+export const _getCrvUsdAccountBalances = (provider_1, network_1, block_1, addressMapping_1, address_1, controllerAddress_1, ...args_1) => __awaiter(void 0, [provider_1, network_1, block_1, addressMapping_1, address_1, controllerAddress_1, ...args_1], void 0, function* (provider, network, block, addressMapping, address, controllerAddress, includeDeposited = false) {
     let balances = {
         collateral: {},
         debt: {},
@@ -118,6 +118,11 @@ export const _getCrvUsdAccountBalances = (provider, network, block, addressMappi
             [addressMapping ? getAssetInfo(wethToEth(selectedMarket.baseAsset), network).address.toLowerCase() : wethToEth(selectedMarket.baseAsset)]: data.debtAmount.toString(),
         },
     };
+    if (includeDeposited) {
+        balances.deposited = {
+            [addressMapping ? getAssetInfo(wethToEth(selectedMarket.baseAsset), network).address.toLowerCase() : wethToEth(selectedMarket.baseAsset)]: data.curveUsdCollateralAmount.toString(),
+        };
+    }
     return balances;
 });
 export const getCrvUsdAccountBalances = (provider, network, block, addressMapping, address, controllerAddress) => __awaiter(void 0, void 0, void 0, function* () { return _getCrvUsdAccountBalances(getViemProvider(provider, network), network, block, addressMapping, address, controllerAddress); });

package/esm/fluid/index.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import Dec from 'decimal.js';
 import { assetAmountInEth, getAssetInfo, getAssetInfoByAddress, } from '@defisaver/tokens';
+import { fluidTokenAmount } from '../helpers/fluidBalances';
 import { IncentiveKind, NetworkNumber, } from '../types/common';
 import { FluidVaultType, } from '../types';
 import { BTCPriceFeedContractViem, DFSFeedRegistryContractViem, ETHPriceFeedContractViem, FeedRegistryContractViem, FluidViewContractViem, } from '../contracts';
@@ -925,8 +926,8 @@ const parseT1UserData = (userPositionData, vaultData) => {
     const collAsset = getAssetInfo(marketData.collAsset0);
     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 = Object.assign(Object.assign({}, EMPTY_USED_ASSET), { symbol: collAsset.symbol, collateral: true, supplied, suppliedUsd: new Dec(supplied).mul(assetsData[collAsset.symbol].price).toString(), isSupplied: new Dec(supplied).gt(0) });
     const debtUsedAsset = Object.assign(Object.assign({}, EMPTY_USED_ASSET), { symbol: debtAsset.symbol, collateral: false, borrowed, borrowedUsd: new Dec(borrowed).mul(assetsData[debtAsset.symbol].price).toString(), isBorrowed: new Dec(borrowed).gt(0) });
     const usedAssets = {
@@ -946,9 +947,9 @@ const parseT2UserData = (userPositionData, vaultData) => {
     const collAsset1 = getAssetInfo(marketData.collAsset1);
     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 supplied0 = new Dec(supplyShares).mul(assetsData[collAsset0.symbol].tokenPerSupplyShare).toString();
-    const supplied1 = new Dec(supplyShares).mul(assetsData[collAsset1.symbol].tokenPerSupplyShare).toString();
+    const borrowed = fluidTokenAmount(userPositionData.borrow, debtAsset.decimals); // this is actual token borrow
+    const supplied0 = fluidTokenAmount(userPositionData.supply, collAsset0.decimals, assetsData[collAsset0.symbol].tokenPerSupplyShare);
+    const supplied1 = fluidTokenAmount(userPositionData.supply, collAsset1.decimals, assetsData[collAsset1.symbol].tokenPerSupplyShare);
     const collUsedAsset0 = {
         symbol: collAsset0.symbol,
         collateral: true,
@@ -991,10 +992,10 @@ const parseT3UserData = (userPositionData, vaultData) => {
     const collAsset = getAssetInfo(marketData.collAsset0);
     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 = {
         symbol: collAsset.symbol,
         collateral: true,
@@ -1039,10 +1040,10 @@ const parseT4UserData = (userPositionData, vaultData) => {
     const debtAsset1 = getAssetInfo(marketData.debtAsset1);
     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 borrowed0 = new Dec(borrowShares).mul(assetsData[debtAsset0.symbol].tokenPerBorrowShare).toString();
-    const borrowed1 = new Dec(borrowShares).mul(assetsData[debtAsset1.symbol].tokenPerBorrowShare).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 = fluidTokenAmount(userPositionData.borrow, debtAsset0.decimals, assetsData[debtAsset0.symbol].tokenPerBorrowShare);
+    const borrowed1 = fluidTokenAmount(userPositionData.borrow, debtAsset1.decimals, assetsData[debtAsset1.symbol].tokenPerBorrowShare);
     const collUsedAsset0 = {
         symbol: collAsset0.symbol,
         collateral: true,

package/esm/helpers/aaveBalances.d.ts

@@ -0,0 +1,5 @@
+import { Client } from 'viem';
+import { AaveMarketInfo, SparkMarketData } from '../types';
+import { Blockish, EthAddress, NetworkNumber, PositionBalances } from '../types/common';
+/** Raw token balances shared by Aave/Spark getters and lending previews. */
+export declare 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>;

package/esm/helpers/aaveBalances.js

@@ -0,0 +1,45 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import Dec from 'decimal.js';
+import { getAssetInfoByAddress } from '@defisaver/tokens';
+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 function getAaveLikeBalances(client, network, block, addressMapping, address, market, view, tokens) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const balances = { collateral: {}, debt: {} };
+        if (!address)
+            return balances;
+        let reserves;
+        if (tokens)
+            reserves = tokens.map(tokenAddress => ({ tokenAddress, symbol: getAssetInfoByAddress(tokenAddress, network).symbol }));
+        else {
+            if (!market.protocolData)
+                throw new Error('Missing protocol data provider');
+            reserves = [...yield createViemContractFromConfigFunc(market.protocolData, market.protocolDataAddress)(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 = (yield 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/esm/helpers/fluidBalances.d.ts

@@ -0,0 +1,6 @@
+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 declare const fluidTokenAmount: (amount: bigint, decimals: number, perShare?: string) => string;
+/** The same token/share conversion used by the full Fluid user parsers, without prices or yield. */
+export declare function parseFluidBalances(position: FluidUserPositionStructOutputStruct, vault: FluidVaultDataStructOutputStruct, network: NetworkNumber): PositionBalances;

package/esm/helpers/fluidBalances.js

@@ -0,0 +1,28 @@
+import Dec from 'decimal.js';
+import { getAssetInfoByAddress } from '@defisaver/tokens';
+/** Convert raw tokens, or raw 18-decimal shares with a human-readable token/share ratio. */
+export const fluidTokenAmount = (amount, decimals, perShare) => (new Dec(amount.toString()).div(new Dec(10).pow(perShare === undefined ? decimals : 18)).mul(perShare !== null && perShare !== void 0 ? perShare : 1).toString());
+/** The same token/share conversion used by the full Fluid user parsers, without prices or yield. */
+export function parseFluidBalances(position, vault, network) {
+    const type = Number(vault.vaultType);
+    if (![10000, 20000, 30000, 40000].includes(type))
+        throw new Error('Unsupported Fluid vault');
+    const side = (amount, tokens, ratios) => {
+        const balances = {};
+        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/esm/liquityV2/index.d.ts

@@ -11,6 +11,14 @@ export type SPYieldGainParameters = {
 };
 export declare const _getLiquityV2MarketData: (provider: Client, network: NetworkNumber, selectedMarket: LiquityV2MarketInfo) => Promise<LiquityV2MarketData>;
 export declare const getLiquityV2MarketData: (provider: EthereumProvider, network: NetworkNumber, selectedMarket: LiquityV2MarketInfo) => Promise<LiquityV2MarketData>;
+export declare const nftContractCreationBlockMapping: {
+    liquityv2eth: number;
+    liquityv2wsteth: number;
+    liquityv2reth: number;
+    liquityv2ethlegacy: number;
+    liquityv2wstethlegacy: number;
+    liquityv2rethlegacy: number;
+};
 export declare const _getLiquityV2UserTroveIds: (provider: PublicClient, network: NetworkNumber, selectedMarket: LiquityV2MarketInfo, troveNFTAddress: EthAddress, limitBlocksForEventFetching: boolean, account: EthAddress) => Promise<{
     troves: {
         troveId: string;

package/esm/liquityV2/index.js

@@ -112,7 +112,7 @@ const getUserTroves = (provider_1, network_1, isLegacy_1, account_1, marketAddre
         return { troves: existingTroves.filter((trove) => trove.ownedByUser), nextFreeTroveIndex };
     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/esm/llamaLend/index.d.ts

@@ -3,7 +3,7 @@ import { LlamaLendGlobalMarketData, LlamaLendMarketData, LlamaLendUserData } fro
 import { Blockish, EthAddress, EthereumProvider, NetworkNumber, PositionBalances } from '../types/common';
 export declare const _getLlamaLendGlobalData: (provider: Client, network: NetworkNumber, selectedMarket: LlamaLendMarketData) => Promise<LlamaLendGlobalMarketData>;
 export declare const getLlamaLendGlobalData: (provider: EthereumProvider, network: NetworkNumber, selectedMarket: LlamaLendMarketData) => Promise<LlamaLendGlobalMarketData>;
-export declare const _getLlamaLendAccountBalances: (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, controllerAddress: EthAddress) => Promise<PositionBalances>;
+export declare const _getLlamaLendAccountBalances: (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, controllerAddress: EthAddress, includeDeposited?: boolean) => Promise<PositionBalances>;
 export declare const getLlamaLendAccountBalances: (provider: EthereumProvider, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, controllerAddress: EthAddress) => Promise<PositionBalances>;
 export declare const _getLlamaLendUserData: (provider: Client, network: NetworkNumber, address: EthAddress, selectedMarket: LlamaLendMarketData, marketData: LlamaLendGlobalMarketData) => Promise<LlamaLendUserData>;
 export declare const getLlamaLendUserData: (provider: EthereumProvider, network: NetworkNumber, address: EthAddress, selectedMarket: LlamaLendMarketData, marketData: LlamaLendGlobalMarketData) => Promise<LlamaLendUserData>;

package/esm/llamaLend/index.js

@@ -153,7 +153,7 @@ const getStatusForUser = (bandRange, activeBand, debtSupplied, collSupplied, hea
         return LlamaLendStatus.SoftLiquidated; // or is fully soft liquidated
     return LlamaLendStatus.Nonexistant;
 };
-export const _getLlamaLendAccountBalances = (provider, network, block, addressMapping, address, controllerAddress) => __awaiter(void 0, void 0, void 0, function* () {
+export const _getLlamaLendAccountBalances = (provider_1, network_1, block_1, addressMapping_1, address_1, controllerAddress_1, ...args_1) => __awaiter(void 0, [provider_1, network_1, block_1, addressMapping_1, address_1, controllerAddress_1, ...args_1], void 0, function* (provider, network, block, addressMapping, address, controllerAddress, includeDeposited = false) {
     let balances = {
         collateral: {},
         debt: {},
@@ -172,6 +172,11 @@ export const _getLlamaLendAccountBalances = (provider, network, block, addressMa
             [addressMapping ? getAssetInfo(wethToEth(selectedMarket.baseAsset), network).address.toLowerCase() : wethToEth(selectedMarket.baseAsset)]: data.debtAmount.toString(),
         },
     };
+    if (includeDeposited) {
+        balances.deposited = {
+            [addressMapping ? getAssetInfo(wethToEth(selectedMarket.baseAsset), network).address.toLowerCase() : wethToEth(selectedMarket.baseAsset)]: data.debtTokenCollateralAmount.toString(),
+        };
+    }
     return balances;
 });
 export const getLlamaLendAccountBalances = (provider, network, block, addressMapping, address, controllerAddress) => __awaiter(void 0, void 0, void 0, function* () { return _getLlamaLendAccountBalances(getViemProvider(provider, network), network, block, addressMapping, address, controllerAddress); });

package/esm/morphoMidnight/index.d.ts

@@ -5,7 +5,7 @@ export declare function _getMorphoMidnightMarketData(provider: Client, network:
 export declare function getMorphoMidnightMarketData(provider: EthereumProvider, network: NetworkNumber, selectedMarket: MorphoMidnightMarketData): Promise<MorphoMidnightMarketInfo>;
 export declare function _getMorphoMidnightAccountData(provider: Client, network: NetworkNumber, account: EthAddress, selectedMarket: MorphoMidnightMarketData, marketInfo: MorphoMidnightMarketInfo): Promise<MorphoMidnightPositionData>;
 export declare function getMorphoMidnightAccountData(provider: EthereumProvider, network: NetworkNumber, account: EthAddress, selectedMarket: MorphoMidnightMarketData, marketInfo: MorphoMidnightMarketInfo): Promise<MorphoMidnightPositionData>;
-export declare const _getMorphoMidnightAccountBalances: (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, selectedMarket: MorphoMidnightMarketData) => Promise<PositionBalances>;
+export declare const _getMorphoMidnightAccountBalances: (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, selectedMarket: MorphoMidnightMarketData, includeCredit?: boolean) => Promise<PositionBalances>;
 export declare const getMorphoMidnightAccountBalances: (provider: EthereumProvider, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, selectedMarket: MorphoMidnightMarketData) => Promise<PositionBalances>;
 export declare function getMorphoMidnightEarn(provider: Client, network: NetworkNumber, account: EthAddress, selectedMarket: MorphoMidnightMarketData, marketInfo: MorphoMidnightMarketInfo): Promise<{
     apy: string;

package/esm/morphoMidnight/index.js

@@ -210,7 +210,7 @@ export function getMorphoMidnightAccountData(provider, network, account, selecte
         return _getMorphoMidnightAccountData(getViemProvider(provider, network), network, account, selectedMarket, marketInfo);
     });
 }
-export const _getMorphoMidnightAccountBalances = (provider, network, block, addressMapping, address, selectedMarket) => __awaiter(void 0, void 0, void 0, function* () {
+export const _getMorphoMidnightAccountBalances = (provider_1, network_1, block_1, addressMapping_1, address_1, selectedMarket_1, ...args_1) => __awaiter(void 0, [provider_1, network_1, block_1, addressMapping_1, address_1, selectedMarket_1, ...args_1], void 0, function* (provider, network, block, addressMapping, address, selectedMarket, includeCredit = false) {
     const balances = { collateral: {}, debt: {} };
     if (!address)
         return balances;
@@ -230,6 +230,11 @@ export const _getMorphoMidnightAccountBalances = (provider, network, block, addr
         collateral[addressMapping ? collInfo.address.toLowerCase() : wethToEth(collInfo.symbol)] = assetAmountInEth(rawAmount, wethToEth(collInfo.symbol));
     });
     balances.collateral = collateral;
+    if (includeCredit) {
+        balances.deposited = {
+            [addressMapping ? loanTokenInfo.address.toLowerCase() : wethToEth(loanTokenInfo.symbol)]: assetAmountInEth(positionInfo.credit.toString(), wethToEth(loanTokenInfo.symbol)),
+        };
+    }
     return balances;
 });
 export const getMorphoMidnightAccountBalances = (provider, network, block, addressMapping, address, selectedMarket) => __awaiter(void 0, void 0, void 0, function* () { return _getMorphoMidnightAccountBalances(getViemProvider(provider, network), network, block, addressMapping, address, selectedMarket); });

package/esm/portfolio/index.d.ts

@@ -11,3 +11,4 @@ export declare function getShifterPortfolioData(provider: EthereumProvider, netw
     markets: PortfolioMarketsData;
 }>;
 export * from './discovery';
+export { getWalletLendingSummaries } from './lendingSummaries';

package/esm/portfolio/index.js

@@ -865,3 +865,4 @@ export function getShifterPortfolioData(provider_1, network_1, defaultProvider_1
     });
 }
 export * from './discovery';
+export { getWalletLendingSummaries } from './lendingSummaries';

package/esm/portfolio/lendingSummaries.d.ts

@@ -0,0 +1,7 @@
+import { EthAddress, EthereumProvider, NetworkNumber } from '../types/common';
+import { LendingSummaryOptions, WalletLendingSummaries } from '../types/lendingSummary';
+/** 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 declare function getWalletLendingSummaries(provider: EthereumProvider, network: NetworkNumber, walletAddresses: EthAddress[], options: LendingSummaryOptions): Promise<WalletLendingSummaries>;

package/esm/portfolio/lendingSummaries.js

@@ -0,0 +1,256 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/* global BigInt */
+import Dec from 'decimal.js';
+import { getAssetInfo, getAssetInfoByAddress } from '@defisaver/tokens';
+import { custom, parseAbi, parseAbiItem, } from 'viem';
+import { AaveMarkets, AaveV4Spokes, CompoundMarkets, compoundV2CollateralAssets, CrvUsdMarkets, LiquityV2Markets, LlamaLendMarkets, MorphoBlueMarkets, MorphoMidnightMarkets, SparkMarkets, } from '../markets';
+import { AaveVersions, CompoundVersions } from '../types';
+import { NetworkNumber, } from '../types/common';
+import { 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, decimals = 18) => new Dec(String(value)).div(new Dec(10).pow(decimals)).toString();
+const positive = (value) => new Dec(String(value)).gt(0);
+const supported = (list, network) => 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 function getWalletLendingSummaries(provider, network, walletAddresses, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        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();
+            }))];
+        const summaries = Object.fromEntries(addresses.map(address => [address, {
+                status: 'complete', positions: [], protocols: [], suppliedUsd: '0', valuationComplete: true, errors: [],
+            }]));
+        if (!addresses.length || ((_a = options.signal) === null || _a === void 0 ? void 0 : _a.aborted))
+            return { summaries: {}, rateLimited: false };
+        const maxCalldataBytes = options.isSim ? 2000 : 32000;
+        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;
+        try {
+            snapshot = (_b = options.blockNumber) !== null && _b !== void 0 ? _b : yield client.getBlockNumber();
+            transport.pinBlock(snapshot);
+        }
+        catch (error) {
+            if ((_c = options.signal) === null || _c === void 0 ? void 0 : _c.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, functionName, args = []) => client.readContract({
+            address: getConfigContractAddress(name, network, block), abi: getConfigContractAbi(name, network, block), functionName, args,
+        });
+        const nftRead = (address, functionName, args = []) => client.readContract({
+            address, abi: nftAbi, functionName, args,
+        });
+        const cache = new Map();
+        const shared = (key, fetch) => {
+            if (!cache.has(key))
+                cache.set(key, fetch());
+            return cache.get(key);
+        };
+        const tasks = [];
+        const tokens = new Set();
+        const valuations = [];
+        let prices = {};
+        const run = (address, protocol, key, work) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                if (!((_a = options.signal) === null || _a === void 0 ? void 0 : _a.aborted))
+                    yield work();
+            }
+            catch (error) {
+                summaries[address].errors.push(`${protocol}:${key}: ${String(error).split('\n')[0]}`);
+            }
+        });
+        const add = (address_1, protocol_1, key_1, balances_1, ...args_1) => __awaiter(this, [address_1, protocol_1, key_1, balances_1, ...args_1], void 0, function* (address, protocol, key, balances, 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'),
+                debtUsd: (debt.some(([, amount]) => positive(amount)) ? null : '0'),
+            };
+            summaries[address].positions.push(entry);
+            const normalize = (amounts) => {
+                const result = {};
+                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();
+                    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'].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, protocol, key, fetch, human = false) => tasks.push(run(address, protocol, key, () => __awaiter(this, void 0, void 0, function* () { return add(address, protocol, key, yield 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)));
+            }
+            for (const spoke of supported(AaveV4Spokes(network), network)) {
+                balanceTask(address, 'aaveV4', spoke.value, () => __awaiter(this, void 0, void 0, function* () {
+                    const { reserves } = yield _getAaveV4LoanBalances(client, network, block, address, spoke.address);
+                    const balances = { 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))
+                    : _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', () => __awaiter(this, void 0, void 0, function* () {
+                    const cdps = yield _getUserCdps(client, network, address);
+                    yield Promise.all(cdps.map(cdp => run(address, 'maker', String(cdp.id), () => __awaiter(this, void 0, void 0, function* () {
+                        const [collateral, debt] = yield read('McdVat', 'urns', [cdp.ilk, cdp.urn]);
+                        const rate = positive(debt) ? (yield shared(`maker:${cdp.ilk}`, () => read('McdVat', 'ilks', [cdp.ilk])))[1] : 0;
+                        yield 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, () => __awaiter(this, void 0, void 0, function* () {
+                        const nft = yield shared(`nft:${market.value}`, () => nftRead(market.marketAddress, 'troveNFT'));
+                        const count = yield nftRead(nft, 'balanceOf', [address]);
+                        if (count === BigInt(0))
+                            return;
+                        const logs = yield client.getLogs({
+                            address: nft, event: transfer, args: { to: address }, fromBlock: BigInt(nftContractCreationBlockMapping[market.value]), toBlock: snapshot,
+                        });
+                        const owned = (yield Promise.all([...new Set(logs.map(log => log.args.tokenId))].map((id) => __awaiter(this, void 0, void 0, function* () {
+                            try {
+                                return (yield nftRead(nft, 'ownerOf', [id])).toLowerCase() === address ? id : null;
+                            }
+                            catch (_a) {
+                                return null;
+                            }
+                        })))).filter((id) => id !== null);
+                        if (BigInt(owned.length) !== count)
+                            summaries[address].errors.push(`liquityV2:${market.value}: Not all owned troves could be discovered`);
+                        yield Promise.all(owned.map(id => run(address, 'liquityV2', `${market.value}:${id}`, () => __awaiter(this, void 0, void 0, function* () {
+                            const data = yield read(market.isLegacy ? 'LiquityV2LegacyView' : 'LiquityV2View', 'getTroveInfo', [market.marketAddress, id]);
+                            if (data.owner.toLowerCase() !== address)
+                                throw new Error('Trove ownership changed');
+                            yield 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', () => __awaiter(this, void 0, void 0, function* () {
+                    const [positions, vaults] = yield read('FluidView', 'getUserPositions', [address]);
+                    yield Promise.all(positions.map((p, i) => run(address, 'fluid', String(p.nftId), () => __awaiter(this, void 0, void 0, function* () {
+                        if (positive(p.supply) || positive(p.borrow))
+                            yield add(address, 'fluid', String(p.nftId), parseFluidBalances(p, vaults[i], network), true);
+                    }))));
+                })));
+            }
+        }
+        yield Promise.all(tasks);
+        if ((_d = options.signal) === null || _d === void 0 ? void 0 : _d.aborted)
+            return { summaries: {}, rateLimited: transport.isRateLimited() };
+        if (tokens.size) {
+            try {
+                prices = yield 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 ((_e = options.signal) === null || _e === void 0 ? void 0 : _e.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/esm/portfolio/lendingSummaryTransport.d.ts

@@ -0,0 +1,8 @@
+import { EthereumProvider } from '../types/common';
+export declare const isLendingSummaryRateLimit: (error: unknown) => boolean;
+/** One limiter for all reads, including split multicalls. No retries after cancellation/429. */
+export declare function lendingSummaryTransport(provider: EthereumProvider, signal?: AbortSignal, blockNumber?: bigint, maxCalldataBytes?: number): {
+    provider: EthereumProvider;
+    isRateLimited: () => boolean;
+    pinBlock: (value: bigint) => void;
+};