@defisaver/positions-sdk 2.1.166 → 2.1.168-stable-pair-dev

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;
+};

package/esm/portfolio/lendingSummaryTransport.js

@@ -0,0 +1,104 @@
+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 { decodeFunctionData, decodeFunctionResult, encodeFunctionData, encodeFunctionResult, multicall3Abi, } from 'viem';
+const errorText = (error) => {
+    const detail = error;
+    return `${(detail === null || detail === void 0 ? void 0 : detail.message) || String(error)} ${(detail === null || detail === void 0 ? void 0 : detail.code) || ''} ${(detail === null || detail === void 0 ? void 0 : detail.status) || ''}`;
+};
+const logRangeLimit = (error) => /block range|too many (results|logs)|query returned|response.*size|range.*limit/i.test(errorText(error));
+const oversized = (error) => /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) => !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, signal, blockNumber, maxCalldataBytes = 32000) {
+    let pinnedBlock = blockNumber;
+    let active = 0;
+    let rateLimit;
+    const waiting = [];
+    const check = () => {
+        if (signal === null || signal === void 0 ? void 0 : 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 = (args) => __awaiter(this, void 0, void 0, function* () {
+        if (active >= 4)
+            yield new Promise(resolve => { waiting.push(resolve); });
+        else
+            active++;
+        try {
+            check();
+            return yield provider.request(args);
+        }
+        catch (error) {
+            if (isLendingSummaryRateLimit(error))
+                rateLimit = error;
+            throw error;
+        }
+        finally {
+            const next = waiting.shift();
+            if (next)
+                next();
+            else
+                active--;
+        }
+    });
+    const request = (args) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        check();
+        const params = [...(args.params || [])];
+        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' && ((_a = call === null || call === void 0 ? void 0 : call.data) === null || _a === void 0 ? void 0 : _a.startsWith('0x82ad56cb'));
+        const splitMulticall = (error) => __awaiter(this, void 0, void 0, function* () {
+            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 = yield request(Object.assign(Object.assign({}, args), { params: [Object.assign(Object.assign({}, 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 yield send(Object.assign(Object.assign({}, 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 = yield request(Object.assign(Object.assign({}, args), { params: [Object.assign(Object.assign({}, call), { toBlock: `0x${middle.toString(16)}` })] }));
+                const last = yield request(Object.assign(Object.assign({}, args), { params: [Object.assign(Object.assign({}, call), { fromBlock: `0x${(middle + BigInt(1)).toString(16)}` })] }));
+                return [...first, ...last];
+            }
+            if (!isMulticall || !oversized(error))
+                throw error;
+            return splitMulticall(error);
+        }
+    });
+    return { provider: { request }, isRateLimited: () => rateLimit !== undefined, pinBlock: (value) => { pinnedBlock = value; } };
+}

package/esm/spark/index.js

@@ -9,14 +9,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import Dec from 'decimal.js';
 import { assetAmountInEth, assetAmountInWei, getAssetInfo } from '@defisaver/tokens';
+import { getAaveLikeBalances } from '../helpers/aaveBalances';
 import { IncentiveKind, } from '../types/common';
-import { ethToWeth, wethToEth, wethToEthByAddress, } from '../services/utils';
+import { ethToWeth, } from '../services/utils';
 import { calculateNetApy, getStakingApy, STAKING_ASSETS, } from '../staking';
 import { SparkViewContractViem, SparkIncentiveDataProviderContractViem, createViemContractFromConfigFunc, } from '../contracts';
 import { sparkGetAggregatedPositionData, sparkIsInIsolationMode } from '../helpers/sparkHelpers';
 import { aprToApy, calculateBorrowingAssetLimit } from '../moneymarket';
 import { SPARK_V1 } from '../markets/spark';
-import { getViemProvider, setViemBlockNumber } from '../services/viem';
+import { getViemProvider } from '../services/viem';
 export const sparkEmodeCategoriesMapping = (extractedState, usedAssets) => {
     const { assetsData } = extractedState;
     const usedAssetsValues = Object.values(usedAssets);
@@ -228,37 +229,7 @@ export const EMPTY_SPARK_DATA = {
     exposure: 'N/A',
 };
 export const _getSparkAccountBalances = (provider, network, block, addressMapping, address) => __awaiter(void 0, void 0, void 0, function* () {
-    let balances = {
-        collateral: {},
-        debt: {},
-    };
-    if (!address) {
-        return balances;
-    }
-    const loanInfoContract = SparkViewContractViem(provider, network, block);
-    const market = SPARK_V1(network);
-    const marketAddress = market.providerAddress;
-    // @ts-ignore
-    const protocolDataProviderContract = createViemContractFromConfigFunc(market.protocolData, market.protocolDataAddress)(provider, network);
-    // @ts-ignore
-    const reserveTokens = yield protocolDataProviderContract.read.getAllReservesTokens(setViemBlockNumber(block));
-    const symbols = reserveTokens.map(({ symbol }) => symbol);
-    const _addresses = reserveTokens.map(({ tokenAddress }) => tokenAddress);
-    // split addresses in half to avoid gas limit by multicall
-    const middleAddressIndex = Math.floor(_addresses.length / 2);
-    const [tokenBalances1, tokenBalances2] = yield Promise.all([
-        loanInfoContract.read.getTokenBalances([marketAddress, address, _addresses.slice(0, middleAddressIndex)], setViemBlockNumber(block)),
-        loanInfoContract.read.getTokenBalances([marketAddress, address, _addresses.slice(middleAddressIndex, _addresses.length)], setViemBlockNumber(block)),
-    ]);
-    const loanInfo = [...tokenBalances1, ...tokenBalances2];
-    loanInfo.forEach((tokenInfo, i) => {
-        const asset = wethToEth(symbols[i]);
-        const assetAddr = wethToEthByAddress(_addresses[i], network).toLowerCase();
-        balances = {
-            collateral: Object.assign(Object.assign({}, balances.collateral), { [addressMapping ? assetAddr : asset]: tokenInfo.balance.toString() }),
-            debt: Object.assign(Object.assign({}, balances.debt), { [addressMapping ? assetAddr : asset]: new Dec(tokenInfo.borrowsStable.toString()).add(tokenInfo.borrowsVariable.toString()).toString() }),
-        };
-    });
+    const balances = yield getAaveLikeBalances(provider, network, block, addressMapping, address, SPARK_V1(network), 'SparkView');
     return balances;
 });
 export const getSparkAccountBalances = (provider, network, block, addressMapping, address) => __awaiter(void 0, void 0, void 0, function* () { return _getSparkAccountBalances(getViemProvider(provider, network, { batch: { multicall: true } }), network, block, addressMapping, address); });

package/esm/types/common.d.ts

@@ -22,6 +22,7 @@ export declare enum LeverageType {
     Short = "short",
     VolatilePair = "volatile-pair",
     VolatilePairReverse = "volatile-pair-reverse",
+    StablePair = "stable-pair",
     None = ""
 }
 export interface IncentiveData {

package/esm/types/common.js

@@ -27,6 +27,7 @@ export var LeverageType;
     LeverageType["Short"] = "short";
     LeverageType["VolatilePair"] = "volatile-pair";
     LeverageType["VolatilePairReverse"] = "volatile-pair-reverse";
+    LeverageType["StablePair"] = "stable-pair";
     LeverageType["None"] = "";
 })(LeverageType || (LeverageType = {}));
 export var NetworkNumber;

package/esm/types/index.d.ts

@@ -15,3 +15,4 @@ export * from './merkl';
 export * from './savings';
 export * from './common';
 export * from './aaveV4';
+export * from './lendingSummary';

package/esm/types/index.js

@@ -15,3 +15,4 @@ export * from './merkl';
 export * from './savings';
 export * from './common';
 export * from './aaveV4';
+export * from './lendingSummary';

package/esm/types/lendingSummary.d.ts

@@ -0,0 +1,34 @@
+import { EthAddress, NetworkNumber } from './common';
+export type LendingSummaryPosition = {
+    id: string;
+    protocol: string;
+    /** Estimated decimal USD values; null means unavailable, never a verified zero. */
+    suppliedUsd: string | null;
+    debtUsd: string | null;
+};
+export type WalletLendingSummary = {
+    status: 'complete' | 'partial' | 'failed';
+    positions: LendingSummaryPosition[];
+    protocols: string[];
+    /** Sum of known supply values; check valuationComplete before ranking by value. */
+    suppliedUsd: string;
+    valuationComplete: boolean;
+    errors: string[];
+};
+/** Resolve distinct token addresses to USD prices keyed by lowercase address.
+ * Native tokens use their wrapped address. Missing/invalid prices remain unavailable.
+ * Prices are current market estimates; balances may come from a historical/fork snapshot.
+ */
+export type LendingSummaryPriceResolver = (network: NetworkNumber, tokens: EthAddress[], signal?: AbortSignal) => Promise<Record<string, string>>;
+export type LendingSummaryOptions = {
+    resolvePrices: LendingSummaryPriceResolver;
+    signal?: AbortSignal;
+    /** Defaults to a snapshot of the provider's latest block. */
+    blockNumber?: bigint;
+    /** Use the smaller 2 KB calldata limit required by simulation providers. */
+    isSim?: boolean;
+};
+export type WalletLendingSummaries = {
+    summaries: Record<string, WalletLendingSummary>;
+    rateLimited: boolean;
+};

package/esm/types/lendingSummary.js

@@ -0,0 +1 @@
+export {};

package/esm/types/morphoBlue.d.ts

@@ -2,7 +2,6 @@ import { EthAddress, IncentiveData, LeverageType, MMUsedAssets, NetworkNumber }
 export declare enum MorphoBlueVersions {
     MorphoBlueMKRDAI_777 = "morphobluemkrdai_777",// MKR/DAI
     MorphoBlueWoEthEth_860 = "morphobluewoetheth_860",// woETH/ETH
-    MorphoBlueOsEthEth_860 = "morphoblueosetheth_860",// osETH/ETH
     MorphoBlueWeEthEth_860 = "morphoblueweetheth_860",// weETH/ETH
     MorphoBlueWstEthUSDC = "morphobluewstethusdc",// wstETH/USDC
     MorphoBlueSDAIUSDC = "morphobluesdaiusdc",// sDAI/USDC

package/esm/types/morphoBlue.js

@@ -3,7 +3,6 @@ export var MorphoBlueVersions;
     // MAINNET
     MorphoBlueVersions["MorphoBlueMKRDAI_777"] = "morphobluemkrdai_777";
     MorphoBlueVersions["MorphoBlueWoEthEth_860"] = "morphobluewoetheth_860";
-    MorphoBlueVersions["MorphoBlueOsEthEth_860"] = "morphoblueosetheth_860";
     MorphoBlueVersions["MorphoBlueWeEthEth_860"] = "morphoblueweetheth_860";
     MorphoBlueVersions["MorphoBlueWstEthUSDC"] = "morphobluewstethusdc";
     MorphoBlueVersions["MorphoBlueSDAIUSDC"] = "morphobluesdaiusdc";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/positions-sdk",
-  "version": "2.1.166",
+  "version": "2.1.168-stable-pair-dev",
   "description": "",
   "main": "./cjs/index.js",
   "module": "./esm/index.js",

package/src/aaveV2/index.ts

@@ -1,12 +1,13 @@
 import Dec from 'decimal.js';
 import { assetAmountInEth, getAssetInfo } from '@defisaver/tokens';
 import { Client } from 'viem';
+import { getAaveLikeBalances } from '../helpers/aaveBalances';
 import {
   Blockish, EthAddress, EthereumProvider, IncentiveKind, NetworkNumber, PositionBalances,
 } from '../types/common';
 import { calculateNetApy, getStakingApy } from '../staking';
-import { ethToWeth, wethToEth, wethToEthByAddress } from '../services/utils';
-import { AaveLoanInfoV2ContractViem, createViemContractFromConfigFunc } from '../contracts';
+import { ethToWeth, wethToEth } from '../services/utils';
+import { AaveLoanInfoV2ContractViem } from '../contracts';
 import { aprToApy, calculateBorrowingAssetLimit } from '../moneymarket';
 import {
   AaveMarketInfo, AaveV2AssetData, AaveV2AssetsData, AaveV2PositionData, AaveV2UsedAsset, AaveV2UsedAssets,
@@ -89,52 +90,11 @@ export const _getAaveV2MarketsData = async (provider: Client, network: NetworkNu
 export const getAaveV2MarketsData = async (provider: EthereumProvider, network: NetworkNumber, selectedMarket: AaveMarketInfo) => _getAaveV2MarketsData(getViemProvider(provider, network), network, selectedMarket);
 
 export const _getAaveV2AccountBalances = async (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress): Promise<PositionBalances> => {
-  let balances: PositionBalances = {
-    collateral: {},
-    debt: {},
-  };
-
-  if (!address) {
-    return balances;
-  }
-
-  const market = AAVE_V2;
-
-  const loanInfoContract = AaveLoanInfoV2ContractViem(provider, network, block);
-
-  const marketAddress = market.providerAddress;
-  // @ts-ignore
-  const protocolDataProviderContract = createViemContractFromConfigFunc(market.protocolData, market.protocolDataAddress)(provider, network);
-
-  // @ts-ignore
-  const reserveTokens = await protocolDataProviderContract.read.getAllReservesTokens(setViemBlockNumber(block)) as { symbol: string, tokenAddress: EthAddress }[];
-  const symbols = reserveTokens.map(({ symbol }: { symbol: string }) => symbol);
-  const _addresses = reserveTokens.map(({ tokenAddress }: { tokenAddress: EthAddress }) => tokenAddress);
-
-  const loanInfo = await loanInfoContract.read.getTokenBalances([marketAddress, address, _addresses as EthAddress[]], setViemBlockNumber(block));
-
-  loanInfo.forEach((_tokenInfo: any, i: number) => {
-    const asset = wethToEth(symbols[i]);
-    const assetAddr = wethToEthByAddress(_addresses[i], network).toLowerCase();
-    const tokenInfo = { ..._tokenInfo };
-
-    // known bug: stETH leaves 1 wei on every transfer
-    if (asset === 'stETH' && tokenInfo.balance.toString() === '1') {
-      tokenInfo.balance = '0';
-    }
-
-    balances = {
-      collateral: {
-        ...balances.collateral,
-        [addressMapping ? assetAddr : asset]: tokenInfo.balance.toString(),
-      },
-      debt: {
-        ...balances.debt,
-        [addressMapping ? assetAddr : asset]: new Dec(tokenInfo.borrowsStable.toString()).add(tokenInfo.borrowsVariable.toString()).toString(),
-      },
-    };
-  });
-
+  const balances = await getAaveLikeBalances(provider, network, block, addressMapping, address, AAVE_V2, 'AaveLoanInfoV2');
+  if (!address) return balances;
+  // Preserve the legacy getter's stETH transfer-dust convention.
+  const key = addressMapping ? getAssetInfo('stETH', network).address.toLowerCase() : 'stETH';
+  if (balances.collateral?.[key] === '1') balances.collateral[key] = '0';
   return balances;
 };