@defisaver/positions-sdk 2.1.158 → 2.1.159-shifter-v2-dev

package/esm/markets/maker/index.js

@@ -0,0 +1,10 @@
+export const MakerActiveIlks = [
+    'ETH-A',
+    'ETH-B',
+    'ETH-C',
+    'WSTETH-A',
+    'WSTETH-B',
+    'WBTC-A',
+    'WBTC-B',
+    'WBTC-C',
+];

package/esm/morphoMidnight/index.js

@@ -12,7 +12,7 @@ import { assetAmountInEth, getAssetInfoByAddress } from '@defisaver/tokens';
 import { NetworkNumber, } from '../types/common';
 import { DFSFeedRegistryContractViem, FeedRegistryContractViem, MorphoMidnightViewContractViem, } from '../contracts';
 import { MorphoMidnightBorrowInfoStatus, } from '../types';
-import { USD_QUOTE } from '../constants';
+import { USD_QUOTE, ZERO_BYTES32 } from '../constants';
 import { calculateNetApy } from '../staking';
 import { isMainnetNetwork, wethToEth } from '../services/utils';
 import { getMorphoMidnightAggregatedPositionData, getMorphoMidnightUserBorrowInfo } from '../helpers/morphoMidnightHelpers';
@@ -97,6 +97,9 @@ export function _getMorphoMidnightMarketData(provider, network, selectedMarket)
         const utillization = new Dec(totalUnits).eq(0) ? '0' : new Dec(totalDebt).div(totalUnits).mul(100).toString();
         return {
             id: marketInfo.id,
+            // Markets are created lazily on the first position, and `getMarketInfo` answers an uncreated id with
+            // a zeroed struct rather than a revert — only the echoed id says whether the market exists yet.
+            isCreated: marketInfo.id.toLowerCase() !== ZERO_BYTES32,
             loanToken: loanSym,
             collaterals: collateralSymbols,
             maturity: selectedMarket.maturity,

package/esm/portfolio/index.d.ts

@@ -1,9 +1,13 @@
 import { EthAddress, EthereumProvider, NetworkNumber } from '../types/common';
-import { PortfolioPositionsData } from '../types';
+import { PortfolioMarketsData, PortfolioPositionsData } from '../types';
 export declare function getPortfolioData(provider: EthereumProvider, network: NetworkNumber, defaultProvider: EthereumProvider, addresses: EthAddress[], isSim?: boolean): Promise<{
     positions: PortfolioPositionsData;
     stakingPositions: any;
     rewardsData: any;
     markets: any;
 }>;
+export declare function getShifterPortfolioData(provider: EthereumProvider, network: NetworkNumber, defaultProvider: EthereumProvider, addresses: EthAddress[], isSim?: boolean): Promise<{
+    positions: PortfolioPositionsData;
+    markets: PortfolioMarketsData;
+}>;
 export * from './discovery';

package/esm/portfolio/index.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import Dec from 'decimal.js';
 import { NetworkNumber } from '../types/common';
-import { AaveMarkets, AaveV4Spokes, CompoundMarkets, CrvUsdMarkets, LiquityV2Markets, LlamaLendMarkets, MorphoBlueMarkets, MorphoMidnightMarkets, SparkMarkets, } from '../markets';
+import { AaveMarkets, AaveV4Spokes, CompoundMarkets, CrvUsdMarkets, LiquityV2Markets, LlamaLendMarkets, MakerActiveIlks, MorphoBlueMarkets, MorphoMidnightMarkets, SparkMarkets, } from '../markets';
 import { _getMorphoBlueAccountData, _getMorphoBluePortfolioMarketData, getMorphoEarn } from '../morphoBlue';
 import { _getMorphoMidnightAccountData, _getMorphoMidnightMarketData } from '../morphoMidnight';
 import { AaveVersions, CompoundVersions, } from '../types';
@@ -19,13 +19,13 @@ import { _getCurveUsdGlobalData, _getCurveUsdUserData } from '../curveUsd';
 import { _getLlamaLendGlobalData, _getLlamaLendUserData } from '../llamaLend';
 import { _getAaveV3AccountData, _getAaveV3MarketData, getStakeAaveData } from '../aaveV3';
 import { ZERO_ADDRESS } from '../constants';
-import { _getMakerCdpData, _getUserCdps } from '../maker';
+import { _getMakerCdpData, _getMakerIlksData, _getUserCdps } from '../maker';
 import { _getAaveV2AccountData, _getAaveV2MarketsData } from '../aaveV2';
 import { _getCompoundV2AccountData, _getCompoundV2MarketsData } from '../compoundV2';
 import { getViemProvider } from '../services/viem';
 import { _getLiquityTroveInfo, getLiquityStakingData } from '../liquity';
 import { _getLiquityV2MarketData, getLiquitySAndYBold, getLiquityV2Staking } from '../liquityV2';
-import { _getAllUserEarnPositionsWithFTokens, _getUserPositionsPortfolio } from '../fluid';
+import { _getAllFluidMarketDataPortfolio, _getAllUserEarnPositionsWithFTokens, _getUserPositionsPortfolio } from '../fluid';
 import { getUmbrellaData } from '../umbrella';
 import { getMerklUnclaimedRewards, getUnclaimedRewardsForAllMarkets } from '../claiming/aaveV3';
 import { fetchSparkAirdropRewards, fetchSparkRewards } from '../claiming/spark';
@@ -465,7 +465,11 @@ export function getPortfolioData(provider_1, network_1, defaultProvider_1, addre
                 }
             }))).flat(),
             ...morphoMidnightMarkets.map((market) => addresses.map((address) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
                 try {
+                    // Markets are created lazily on the first position, so an uncreated one can hold no position.
+                    if (!((_a = morphoMidnightMarketsData[market.value]) === null || _a === void 0 ? void 0 : _a.isCreated))
+                        return;
                     const accData = yield _getMorphoMidnightAccountData(client, network, address, market, morphoMidnightMarketsData[market.value]);
                     if (new Dec(accData.suppliedUsd).gt(0))
                         positions[address.toLowerCase()].morphoMidnight[market.value] = { error: '', data: accData };
@@ -595,4 +599,275 @@ export function getPortfolioData(provider_1, network_1, defaultProvider_1, addre
         };
     });
 }
+export function getShifterPortfolioData(provider_1, network_1, defaultProvider_1, addresses_1) {
+    return __awaiter(this, arguments, void 0, function* (provider, network, defaultProvider, addresses, isSim = false) {
+        const isMainnet = network === NetworkNumber.Eth;
+        const isFluidSupported = [NetworkNumber.Eth, NetworkNumber.Arb, NetworkNumber.Base, NetworkNumber.Plasma].includes(network);
+        const morphoMarkets = Object.values(MorphoBlueMarkets(network)).filter((market) => market.chainIds.includes(network));
+        const compoundV3Markets = Object.values(CompoundMarkets(network)).filter((market) => market.chainIds.includes(network) && market.value !== CompoundVersions.CompoundV2);
+        const sparkMarkets = Object.values(SparkMarkets(network)).filter((market) => market.chainIds.includes(network));
+        const aaveV3Markets = [AaveVersions.AaveV3, AaveVersions.AaveV3Lido, AaveVersions.AaveV3Etherfi].map((version) => AaveMarkets(network)[version]).filter((market) => market.chainIds.includes(network));
+        const aaveV2Markets = [AaveVersions.AaveV2].map((version) => AaveMarkets(network)[version]).filter((market) => market.chainIds.includes(network));
+        const compoundV2Markets = [CompoundVersions.CompoundV2].map((version) => CompoundMarkets(network)[version]).filter((market) => market.chainIds.includes(network));
+        const crvUsdMarkets = Object.values(CrvUsdMarkets(network)).filter((market) => market.chainIds.includes(network));
+        const llamaLendMarkets = [NetworkNumber.Eth, NetworkNumber.Arb].includes(network) ? Object.values(LlamaLendMarkets(network)).filter((market) => market.chainIds.includes(network)) : [];
+        const liquityV2Markets = [NetworkNumber.Eth].includes(network) ? Object.values(LiquityV2Markets(network)) : [];
+        const aaveV4Spokes = Object.values(AaveV4Spokes(network)).filter((market) => market.chainIds.includes(network));
+        const args = [network, { batch: { multicall: { batchSize: isSim ? 2000 : 2500000 } } }];
+        const client = getViemProvider(provider, ...args);
+        const defaultClient = getViemProvider(defaultProvider, ...args);
+        const markets = {
+            morphoMarketsData: {},
+            morphoMidnightMarketsData: {}, // Morpho Midnight is not fetched for the shifter; key kept so the payload shape is stable
+            compoundV3MarketsData: {},
+            sparkMarketsData: {},
+            aaveV3MarketsData: {},
+            aaveV2MarketsData: {},
+            compoundV2MarketsData: {},
+            crvUsdMarketsData: {},
+            llamaLendMarketsData: {},
+            liquityV2MarketsData: {},
+            aaveV4SpokesData: {},
+            fluidMarketsData: {},
+            makerMarketsData: {},
+        };
+        const makerCdps = {};
+        const positions = {};
+        for (const address of addresses) {
+            positions[address.toLowerCase()] = {
+                aaveV3: {},
+                aaveV4: {},
+                morphoBlue: {},
+                morphoMidnight: {}, // not fetched for the shifter (see markets above)
+                compoundV3: {},
+                spark: {},
+                maker: {},
+                aaveV2: {},
+                compoundV2: {},
+                liquity: {},
+                crvUsd: {},
+                llamaLend: {},
+                fluid: {
+                    error: '',
+                    data: {},
+                },
+            };
+        }
+        yield Promise.allSettled([
+            // === MARKET DATA (needs to be fetched first) ===
+            ...morphoMarkets.map((market) => __awaiter(this, void 0, void 0, function* () {
+                markets.morphoMarketsData[market.value] = yield _getMorphoBluePortfolioMarketData(client, network, market);
+            })),
+            ...compoundV3Markets.map((market) => __awaiter(this, void 0, void 0, function* () {
+                markets.compoundV3MarketsData[market.value] = yield _getCompoundV3MarketsData(client, network, market, defaultClient);
+            })),
+            ...sparkMarkets.map((market) => __awaiter(this, void 0, void 0, function* () {
+                markets.sparkMarketsData[market.value] = yield _getSparkMarketsData(client, network, market);
+            })),
+            ...aaveV3Markets.map((market) => __awaiter(this, void 0, void 0, function* () {
+                markets.aaveV3MarketsData[market.value] = yield _getAaveV3MarketData(client, network, market);
+            })),
+            ...aaveV4Spokes.map((spoke) => __awaiter(this, void 0, void 0, function* () {
+                markets.aaveV4SpokesData[spoke.value] = yield _getAaveV4SpokeData(client, network, spoke);
+            })),
+            ...aaveV2Markets.map((market) => __awaiter(this, void 0, void 0, function* () {
+                markets.aaveV2MarketsData[market.value] = yield _getAaveV2MarketsData(client, network, market);
+            })),
+            ...compoundV2Markets.map((market) => __awaiter(this, void 0, void 0, function* () {
+                markets.compoundV2MarketsData[market.value] = yield _getCompoundV2MarketsData(client, network);
+            })),
+            ...crvUsdMarkets.map((market) => __awaiter(this, void 0, void 0, function* () {
+                markets.crvUsdMarketsData[market.value] = yield _getCurveUsdGlobalData(client, network, market);
+            })),
+            ...llamaLendMarkets.map((market) => __awaiter(this, void 0, void 0, function* () {
+                markets.llamaLendMarketsData[market.value] = yield _getLlamaLendGlobalData(client, network, market);
+            })),
+            ...liquityV2Markets.map((market) => __awaiter(this, void 0, void 0, function* () {
+                markets.liquityV2MarketsData[market.value] = yield _getLiquityV2MarketData(client, network, market);
+            })),
+            (() => __awaiter(this, void 0, void 0, function* () {
+                if (!isFluidSupported)
+                    return;
+                try {
+                    markets.fluidMarketsData = yield _getAllFluidMarketDataPortfolio(client, network);
+                }
+                catch (error) {
+                    console.error('Error fetching Fluid markets data:', error);
+                }
+            }))(),
+            (() => __awaiter(this, void 0, void 0, function* () {
+                if (!isMainnet)
+                    return; // Maker CDPs are only available on mainnet
+                try {
+                    markets.makerMarketsData = yield _getMakerIlksData(client, network, MakerActiveIlks);
+                }
+                catch (error) {
+                    console.error('Error fetching Maker ilks data:', error);
+                }
+            }))(),
+            // === INDEPENDENT USER DATA (doesn't depend on market data) ===
+            ...addresses.map((address) => __awaiter(this, void 0, void 0, function* () {
+                if (!isMainnet)
+                    return; // Maker CDPs are only available on mainnet
+                const makerCdp = yield _getUserCdps(client, network, address);
+                makerCdps[address.toLowerCase()] = makerCdp;
+            })),
+            ...addresses.map((address) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    if (!isFluidSupported)
+                        return; // Fluid is not available on Optimism
+                    const userPositions = (yield _getUserPositionsPortfolio(client, network, address));
+                    for (const position of userPositions) {
+                        if (position.userData && new Dec(position.userData.suppliedUsd).gt(0)) {
+                            positions[address.toLowerCase()].fluid.data[position.userData.nftId] = position.userData;
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error(`Error fetching Fluid positions for address ${address}:`, error);
+                    positions[address.toLowerCase()].fluid = {
+                        error: `Error fetching Fluid positions for address ${address}`,
+                        data: {},
+                    };
+                }
+            })),
+        ]);
+        yield Promise.all([
+            ...aaveV3Markets.map((market) => addresses.map((address) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const accData = yield _getAaveV3AccountData(client, network, address, Object.assign({ selectedMarket: market }, markets.aaveV3MarketsData[market.value]));
+                    if (new Dec(accData.suppliedUsd).gt(0))
+                        positions[address.toLowerCase()].aaveV3[market.value] = { error: '', data: accData };
+                }
+                catch (error) {
+                    console.error(`Error fetching AaveV3 account data for address ${address} on market ${market.value}:`, error);
+                    positions[address.toLowerCase()].aaveV3[market.value] = { error: `Error fetching AaveV3 account data for address ${address} on market ${market.value}`, data: null };
+                }
+            }))).flat(),
+            ...aaveV4Spokes.map((spoke) => addresses.map((address) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const accData = yield _getAaveV4AccountData(client, network, markets.aaveV4SpokesData[spoke.value], address);
+                    if (new Dec(accData.suppliedUsd).gt(0))
+                        positions[address.toLowerCase()].aaveV4[spoke.value] = { error: '', data: accData };
+                }
+                catch (error) {
+                    console.error(`Error fetching AaveV4 account data for address ${address} on spoke ${spoke.value}:`, error);
+                    positions[address.toLowerCase()].aaveV4[spoke.value] = { error: `Error fetching AaveV4 account data for address ${address} on spoke ${spoke.value}`, data: null };
+                }
+            }))).flat(),
+            ...morphoMarkets.map((market) => addresses.map((address) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const accData = yield _getMorphoBlueAccountData(client, network, address, market, markets.morphoMarketsData[market.value]);
+                    if (new Dec(accData.suppliedUsd).gt(0))
+                        positions[address.toLowerCase()].morphoBlue[market.value] = { error: '', data: accData };
+                }
+                catch (error) {
+                    console.error(`Error fetching MorphoBlue account data for address ${address} on market ${market.value}:`, error);
+                    positions[address.toLowerCase()].morphoBlue[market.value] = { error: `Error fetching MorphoBlue account data for address ${address} on market ${market.value}`, data: null };
+                }
+            }))).flat(),
+            ...compoundV3Markets.map((market) => addresses.map((address) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const accData = yield _getCompoundV3AccountData(client, network, address, ZERO_ADDRESS, { selectedMarket: market, assetsData: markets.compoundV3MarketsData[market.value].assetsData });
+                    if (new Dec(accData.suppliedUsd).gt(0))
+                        positions[address.toLowerCase()].compoundV3[market.value] = { error: '', data: accData };
+                }
+                catch (error) {
+                    console.error(`Error fetching CompoundV3 account data for address ${address} on market ${market.value}:`, error);
+                    positions[address.toLowerCase()].compoundV3[market.value] = { error: `Error fetching CompoundV3 account data for address ${address} on market ${market.value}`, data: null };
+                }
+            }))).flat(),
+            ...sparkMarkets.map((market) => addresses.map((address) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const accData = yield _getSparkAccountData(client, network, address, { selectedMarket: market, assetsData: markets.sparkMarketsData[market.value].assetsData, eModeCategoriesData: markets.sparkMarketsData[market.value].eModeCategoriesData });
+                    if (new Dec(accData.suppliedUsd).gt(0))
+                        positions[address.toLowerCase()].spark[market.value] = { error: '', data: accData };
+                }
+                catch (error) {
+                    console.error(`Error fetching Spark account data for address ${address} on market ${market.value}:`, error);
+                    positions[address.toLowerCase()].spark[market.value] = { error: `Error fetching Spark account data for address ${address} on market ${market.value}`, data: null };
+                }
+            }))).flat(),
+            ...addresses.map((address) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                return (_a = makerCdps[address.toLowerCase()]) === null || _a === void 0 ? void 0 : _a.map((cdpInfo) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        // reuse ilk data fetched for the markets payload; ilks outside the active set are fetched on demand
+                        const cdpData = yield _getMakerCdpData(client, network, cdpInfo, markets.makerMarketsData[cdpInfo.ilkLabel]);
+                        if (cdpData) {
+                            positions[address.toLowerCase()].maker[cdpInfo.id] = { error: '', data: cdpData };
+                        }
+                    }
+                    catch (error) {
+                        console.error(`Error fetching Maker CDP data for address ${address} with ID ${cdpInfo.id}:`, error);
+                        positions[address.toLowerCase()].maker[cdpInfo.id] = { error: `Error fetching Maker CDP data for address ${address} with ID ${cdpInfo.id}`, data: null };
+                    }
+                }));
+            })).flat(),
+            ...aaveV2Markets.map((market) => addresses.map((address) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const accData = yield _getAaveV2AccountData(client, network, address, markets.aaveV2MarketsData[market.value].assetsData, market);
+                    if (new Dec(accData.suppliedUsd).gt(0))
+                        positions[address.toLowerCase()].aaveV2[market.value] = { error: '', data: accData };
+                }
+                catch (error) {
+                    console.error(`Error fetching AaveV2 account data for address ${address}:`, error);
+                    positions[address.toLowerCase()].aaveV2[market.value] = { error: `Error fetching AaveV2 account data for address ${address}`, data: null };
+                }
+            }))).flat(),
+            ...compoundV2Markets.map((market) => addresses.map((address) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const accData = yield _getCompoundV2AccountData(client, network, address, markets.compoundV2MarketsData[market.value].assetsData);
+                    if (new Dec(accData.suppliedUsd).gt(0))
+                        positions[address.toLowerCase()].compoundV2[market.value] = { error: '', data: accData };
+                }
+                catch (error) {
+                    console.error(`Error fetching CompoundV2 account data for address ${address}:`, error);
+                    positions[address.toLowerCase()].compoundV2[market.value] = { error: `Error fetching CompoundV2 account data for address ${address}`, data: null };
+                }
+            }))).flat(),
+            ...addresses.map((address) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    if (!isMainnet)
+                        return; // Liquity trove info is only available on mainnet
+                    const troveInfo = yield _getLiquityTroveInfo(client, network, address);
+                    if (new Dec(troveInfo.collateral).gt(0))
+                        positions[address.toLowerCase()].liquity = { error: '', data: troveInfo };
+                }
+                catch (error) {
+                    console.error(`Error fetching Liquity trove info for address ${address}:`, error);
+                    positions[address.toLowerCase()].liquity = { error: `Error fetching Liquity trove info for address ${address}`, data: null };
+                }
+            })),
+            ...crvUsdMarkets.map((market) => addresses.map((address) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const accData = yield _getCurveUsdUserData(client, network, address, market, markets.crvUsdMarketsData[market.value].activeBand);
+                    if (new Dec(accData.suppliedUsd).gt(0) || new Dec(accData.borrowedUsd).gt(0)) {
+                        positions[address.toLowerCase()].crvUsd[market.value] = { error: '', data: Object.assign(Object.assign({}, accData), { borrowRate: markets.crvUsdMarketsData[market.value].borrowRate }) };
+                    }
+                }
+                catch (error) {
+                    console.error(`Error fetching Curve USD account data for address ${address} on market ${market.value}:`, error);
+                    positions[address.toLowerCase()].crvUsd[market.value] = { error: `Error fetching Curve USD account data for address ${address} on market ${market.value}`, data: null };
+                }
+            }))).flat(),
+            ...llamaLendMarkets.map((market) => addresses.map((address) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const accData = yield _getLlamaLendUserData(client, network, address, market, markets.llamaLendMarketsData[market.value]);
+                    if (new Dec(accData.suppliedUsd).gt(0) || new Dec(accData.borrowedUsd).gt(0)) {
+                        positions[address.toLowerCase()].llamaLend[market.value] = { error: '', data: Object.assign(Object.assign({}, accData), { borrowRate: markets.llamaLendMarketsData[market.value].borrowRate }) };
+                    }
+                }
+                catch (error) {
+                    console.error(`Error fetching LlamaLend account data for address ${address} on market ${market.value}:`, error);
+                    positions[address.toLowerCase()].llamaLend[market.value] = { error: `Error fetching LlamaLend account data for address ${address} on market ${market.value}`, data: null };
+                }
+            }))).flat(),
+        ]);
+        return {
+            positions,
+            markets,
+        };
+    });
+}
 export * from './discovery';

package/esm/savings/index.js

@@ -27,16 +27,16 @@ export const getSavingsData = (provider, network, accounts) => __awaiter(void 0,
     const savingsData = {};
     yield Promise.all([
         ...(network === NetworkNumber.Eth ? [
-            ...morphoVaultsList.map((vaultKey) => __awaiter(void 0, void 0, void 0, function* () {
+            (() => __awaiter(void 0, void 0, void 0, function* () {
                 try {
-                    const vault = morphoVaults.morphoVaultsOptions.getMorphoVault(vaultKey);
-                    const data = yield morphoVaults.getMorphoVaultData(provider, network, vault, accounts);
-                    savingsData[vaultKey] = data;
+                    const vaults = morphoVaultsList.map((vaultKey) => morphoVaults.morphoVaultsOptions.getMorphoVault(vaultKey));
+                    const data = yield morphoVaults.getMorphoVaultsData(provider, network, vaults, accounts);
+                    Object.assign(savingsData, data);
                 }
                 catch (err) {
-                    console.error(`[getSavingsData] Error fetching morpho vault ${vaultKey}:`, err);
+                    console.error('[getSavingsData] Error fetching morpho vaults:', err);
                 }
-            })),
+            }))(),
             ...yearnVaultsList.map((vaultKey) => __awaiter(void 0, void 0, void 0, function* () {
                 try {
                     const vault = yearnVaults.yearnVaultsOptions.getYearnVault(vaultKey);

package/esm/savings/morphoVaults/index.d.ts

@@ -1,7 +1,19 @@
 import { Client } from 'viem';
 import * as morphoVaultsOptions from './options';
-import { EthAddress, EthereumProvider, NetworkNumber } from '../../types/common';
-import { MorphoVault, SavingsVaultData } from '../../types';
+import { EthAddress, EthereumProvider, NetworkNumber, MorphoVault, MorphoVaultType, SavingsVaultData } from '../../types';
 export { morphoVaultsOptions, };
-export declare const _getMorphoVaultData: (provider: Client, network: NetworkNumber, morphoVault: MorphoVault, accounts: EthAddress[]) => Promise<SavingsVaultData>;
+/**
+ * Fetches liquidity for all given vaults in a single API request (chunked if over the page cap),
+ * returned as a map keyed by lowercased vault address. A vault missing from the API response is
+ * absent from the map.
+ */
+export declare const fetchMorphoVaultsLiquidity: (network: NetworkNumber, vaults: MorphoVault[]) => Promise<Record<string, string>>;
+/**
+ * Fetches data for all given vaults with a single Morpho API request for their liquidity,
+ * instead of one request per vault. The on-chain reads run in parallel with the API request.
+ * A vault whose on-chain reads fail or that is missing from the API response is left out of
+ * the result; a failed API request rejects, leaving all vaults out.
+ */
+export declare const _getMorphoVaultsData: (provider: Client, network: NetworkNumber, vaults: MorphoVault[], accounts: EthAddress[]) => Promise<Partial<Record<MorphoVaultType, SavingsVaultData>>>;
+export declare function getMorphoVaultsData(provider: EthereumProvider, network: NetworkNumber, vaults: MorphoVault[], accounts: EthAddress[]): Promise<Partial<Record<MorphoVaultType, SavingsVaultData>>>;
 export declare function getMorphoVaultData(provider: EthereumProvider, network: NetworkNumber, morphoVault: MorphoVault, accounts: EthAddress[]): Promise<SavingsVaultData>;

package/esm/savings/morphoVaults/index.js

@@ -14,38 +14,73 @@ import * as morphoVaultsOptions from './options';
 import { getViemProvider } from '../../services/viem';
 import { getMorphoVaultContractViem } from '../../contracts';
 export { morphoVaultsOptions, };
-const vaultDataQuery = `
-  query VaultByAddress($address: String!, $chainId: Int!) {
-    vaultByAddress(address: $address, chainId: $chainId) {
-      address
-      state {
-        totalAssets
-        totalAssetsUsd
-        totalSupply
-      }
-      liquidity {
-        underlying
-        usd
+const MORPHO_BLUE_API = 'https://api.morpho.org/graphql';
+// Morpho API caps list page size at 100 items
+const MORPHO_API_PAGE_SIZE = 100;
+const vaultsLiquidityQuery = `
+  query VaultsLiquidity($addresses: [String!], $chainIds: [Int!]) {
+    vaults(first: ${MORPHO_API_PAGE_SIZE}, where: { address_in: $addresses, chainId_in: $chainIds }) {
+      items {
+        address
+        liquidity {
+          underlying
+        }
       }
     }
 }`;
-const MORPHO_BLUE_API = 'https://api.morpho.org/graphql';
-export const _getMorphoVaultData = (provider, network, morphoVault, accounts) => __awaiter(void 0, void 0, void 0, function* () {
+/**
+ * Fetches liquidity for all given vaults in a single API request (chunked if over the page cap),
+ * returned as a map keyed by lowercased vault address. A vault missing from the API response is
+ * absent from the map.
+ */
+export const fetchMorphoVaultsLiquidity = (network, vaults) => __awaiter(void 0, void 0, void 0, function* () {
+    const chunks = [];
+    for (let i = 0; i < vaults.length; i += MORPHO_API_PAGE_SIZE)
+        chunks.push(vaults.slice(i, i + MORPHO_API_PAGE_SIZE));
+    const liquidityByAddress = {};
+    yield Promise.all(chunks.map((chunk) => __awaiter(void 0, void 0, void 0, function* () {
+        const data = yield graphqlRequest(MORPHO_BLUE_API, vaultsLiquidityQuery, {
+            addresses: chunk.map((vault) => vault.address),
+            chainIds: [network],
+            // the BigInt scalar serializes as a JSON number when it fits in Number.MAX_SAFE_INTEGER, a string otherwise
+        });
+        (data.vaults.items || []).forEach((item) => {
+            var _a, _b;
+            if (((_a = item === null || item === void 0 ? void 0 : item.liquidity) === null || _a === void 0 ? void 0 : _a.underlying) !== undefined && ((_b = item.liquidity) === null || _b === void 0 ? void 0 : _b.underlying) !== null) {
+                liquidityByAddress[item.address.toLowerCase()] = String(item.liquidity.underlying);
+            }
+        });
+    })));
+    return liquidityByAddress;
+});
+const getBatchedViemProvider = (provider, network) => getViemProvider(provider, network, {
+    batch: {
+        multicall: {
+            batchSize: 250000,
+        },
+    },
+});
+const getMorphoVaultChainData = (provider, morphoVault, accounts) => __awaiter(void 0, void 0, void 0, function* () {
     const morphoVaultContract = getMorphoVaultContractViem(provider, morphoVault.address);
     const shares = {};
-    const [totalAssets, totalSupply, decimals, decimalsOffset, vaultData] = yield Promise.all([
+    const [totalAssets, totalSupply, decimals, decimalsOffset] = yield Promise.all([
         morphoVaultContract.read.totalAssets(),
         morphoVaultContract.read.totalSupply(),
         morphoVaultContract.read.decimals(),
         morphoVaultContract.read.DECIMALS_OFFSET(),
-        graphqlRequest(MORPHO_BLUE_API, vaultDataQuery, { address: morphoVault.address, chainId: network }),
         ...accounts.map((account) => __awaiter(void 0, void 0, void 0, function* () {
             const share = yield morphoVaultContract.read.balanceOf([account]);
             shares[account] = share;
         })),
     ]);
+    return {
+        totalAssets, totalSupply, decimals, decimalsOffset, shares,
+    };
+});
+const formatMorphoVaultData = (morphoVault, chainData, liquidityUnderlying, accounts) => {
+    const { totalAssets, totalSupply, decimals, decimalsOffset, shares, } = chainData;
     const poolSize = assetAmountInEth(totalAssets.toString(), morphoVault.asset);
-    const liquidity = assetAmountInEth(vaultData.vaultByAddress.liquidity.underlying, morphoVault.asset);
+    const liquidity = assetAmountInEth(liquidityUnderlying, morphoVault.asset);
     const supplied = {};
     accounts.forEach((account) => {
         const share = shares[account] || BigInt(0);
@@ -60,15 +95,49 @@ export const _getMorphoVaultData = (provider, network, morphoVault, accounts) =>
         asset: morphoVault.asset,
         optionType: morphoVault.type,
     };
+};
+/**
+ * Fetches data for all given vaults with a single Morpho API request for their liquidity,
+ * instead of one request per vault. The on-chain reads run in parallel with the API request.
+ * A vault whose on-chain reads fail or that is missing from the API response is left out of
+ * the result; a failed API request rejects, leaving all vaults out.
+ */
+export const _getMorphoVaultsData = (provider, network, vaults, accounts) => __awaiter(void 0, void 0, void 0, function* () {
+    const [liquidityByAddress, chainData] = yield Promise.all([
+        fetchMorphoVaultsLiquidity(network, vaults),
+        Promise.all(vaults.map((vault) => getMorphoVaultChainData(provider, vault, accounts).catch((err) => {
+            console.error(`[getMorphoVaultsData] Error fetching on-chain data for morpho vault ${vault.type}:`, err);
+            return null;
+        }))),
+    ]);
+    const savingsData = {};
+    vaults.forEach((vault, i) => {
+        const vaultChainData = chainData[i];
+        if (!vaultChainData)
+            return;
+        const liquidityUnderlying = liquidityByAddress[vault.address.toLowerCase()];
+        if (liquidityUnderlying === undefined) {
+            console.error(`[getMorphoVaultsData] Vault ${vault.type} (${vault.address}) missing from Morpho API response`);
+            return;
+        }
+        savingsData[vault.type] = formatMorphoVaultData(vault, vaultChainData, liquidityUnderlying, accounts);
+    });
+    return savingsData;
 });
+export function getMorphoVaultsData(provider, network, vaults, accounts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return _getMorphoVaultsData(getBatchedViemProvider(provider, network), network, vaults, accounts);
+    });
+}
 export function getMorphoVaultData(provider, network, morphoVault, accounts) {
     return __awaiter(this, void 0, void 0, function* () {
-        return _getMorphoVaultData(getViemProvider(provider, network, {
-            batch: {
-                multicall: {
-                    batchSize: 2500000,
-                },
-            },
-        }), network, morphoVault, accounts);
+        const [liquidityByAddress, chainData] = yield Promise.all([
+            fetchMorphoVaultsLiquidity(network, [morphoVault]),
+            getMorphoVaultChainData(getBatchedViemProvider(provider, network), morphoVault, accounts),
+        ]);
+        const liquidityUnderlying = liquidityByAddress[morphoVault.address.toLowerCase()];
+        if (liquidityUnderlying === undefined)
+            throw new Error(`Vault ${morphoVault.address} missing from Morpho API response`);
+        return formatMorphoVaultData(morphoVault, chainData, liquidityUnderlying, accounts);
     });
 }

package/esm/types/aave.d.ts

@@ -126,6 +126,7 @@ export interface AavePositionData extends MMPositionData {
     minRatio: string;
     collRatio: string;
     safetyRatioWithLtvZeroFallback?: string;
+    safetyRatio?: string;
     suppliedUsd: string;
     borrowedUsd: string;
     borrowLimitUsd: string;
@@ -159,6 +160,7 @@ export interface AaveV3AggregatedPositionData {
     collRatio: string;
     borrowLimitWithLtvZeroFallbackUsd: string;
     safetyRatioWithLtvZeroFallback: string;
+    safetyRatio: string;
     netApy: string;
     incentiveUsd: string;
     totalInterestUsd: string;

package/esm/types/aaveV4.d.ts

@@ -169,6 +169,7 @@ export interface AaveV4AggregatedPositionData {
     leftToBorrowUsd: string;
     ratio: string;
     collRatio: string;
+    safetyRatio: string;
     liqRatio: string;
     liqPercent: string;
     leveragedType: LeverageType;

package/esm/types/compound.d.ts

@@ -96,6 +96,7 @@ export interface CompoundAggregatedPositionData {
     leftToBorrowUsd: string;
     ratio: string;
     collRatio: string;
+    safetyRatio: string;
     netApy: string;
     incentiveUsd: string;
     totalInterestUsd: string;
@@ -115,6 +116,7 @@ export interface CompoundAggregatedPositionData {
 export interface CompoundPositionData extends MMPositionData {
     ratio: string;
     minRatio: string;
+    safetyRatio?: string;
     suppliedUsd: string;
     borrowedUsd: string;
     borrowLimitUsd: string;

package/esm/types/fluid.d.ts

@@ -323,6 +323,7 @@ export interface FluidAggregatedVaultData {
     merklBorrowIncentives: IncentiveData[];
     ratio: string;
     collRatio: string;
+    safetyRatio: string;
     minRatio: string;
     totalInterestUsd: string;
     leveragedType?: LeverageType;

package/esm/types/liquity.d.ts

@@ -24,6 +24,7 @@ export interface LiquityTroveInfo {
     totalETH: string;
     totalLUSD: string;
     minCollateralRatio: number;
+    safetyRatio: string;
     priceForRecovery: string;
     debtInFront: string;
     exposure: string;

package/esm/types/liquityV2.d.ts

@@ -94,6 +94,7 @@ export interface LiquityV2AggregatedTroveData {
     liquidationPrice: string;
     ratio: string;
     collRatio: string;
+    safetyRatio: string;
     exposure: string;
 }
 export interface LiquityV2TroveData {
@@ -101,6 +102,7 @@ export interface LiquityV2TroveData {
     troveId: string;
     ratio: string;
     collRatio: string;
+    safetyRatio?: string;
     liqRatio: string;
     borrowLimitRatio: string;
     interestRate: string;

package/esm/types/maker.d.ts

@@ -43,6 +43,7 @@ export interface CdpData {
     debtAssetMarketPrice: string;
     liquidationPrice: string;
     ratio: string;
+    safetyRatio: string;
     liqRatio: string;
     liqPercent: number;
     assetPrice: string;