@defisaver/positions-sdk 2.1.148-dev → 2.1.149-shifter-v2-dev

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,9 +9,9 @@ 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, getMorphoMidnightEarn } from '../morphoMidnight';
+import { _getMorphoMidnightAccountData, _getMorphoMidnightMarketData } from '../morphoMidnight';
 import { AaveVersions, CompoundVersions, } from '../types';
 import { _getCompoundV3AccountData, _getCompoundV3MarketsData } from '../compoundV3';
 import { _getSparkAccountData, _getSparkMarketsData } from '../spark';
@@ -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 { getCompoundV3Rewards } from '../claiming/compV3';
@@ -107,7 +107,6 @@ export function getPortfolioData(provider_1, network_1, defaultProvider_1, addre
             stakingPositions[address.toLowerCase()] = {
                 aaveV3: {},
                 morphoBlue: {},
-                morphoMidnight: {},
                 compoundV3: {},
                 spark: {},
                 aaveV2: {},
@@ -475,32 +474,9 @@ export function getPortfolioData(provider_1, network_1, defaultProvider_1, addre
             }))).flat(),
             ...morphoMidnightMarkets.map((market) => addresses.map((address) => __awaiter(this, void 0, void 0, function* () {
                 try {
-                    const [accDataPromise, earnDataPromise] = yield Promise.allSettled([
-                        _getMorphoMidnightAccountData(client, network, address, market, morphoMidnightMarketsData[market.value]),
-                        getMorphoMidnightEarn(client, network, address, market, morphoMidnightMarketsData[market.value]),
-                    ]);
-                    if (accDataPromise.status === 'rejected') {
-                        console.error(`Error fetching MorphoMidnight account data for address ${address} on market ${market.value}:`, accDataPromise.reason);
-                        positions[address.toLowerCase()].morphoMidnight[market.value] = { error: `Error fetching MorphoMidnight account data for address ${address} on market ${market.value}`, data: null };
-                    }
-                    if (earnDataPromise.status === 'rejected') {
-                        console.error(`Error fetching MorphoMidnight account data for address ${address} on market ${market.value}:`, earnDataPromise.reason);
-                        positions[address.toLowerCase()].morphoMidnight[market.value] = { error: `Error fetching MorphoMidnight account data for address ${address} on market ${market.value}`, data: null };
-                    }
-                    if (accDataPromise.status !== 'rejected') {
-                        const accData = accDataPromise.value;
-                        if (new Dec(accData.suppliedUsd).gt(0))
-                            positions[address.toLowerCase()].morphoMidnight[market.value] = { error: '', data: accData };
-                    }
-                    if (earnDataPromise.status !== 'rejected') {
-                        const earnData = earnDataPromise.value;
-                        if (earnData && new Dec(earnData.amount).gt(0)) {
-                            stakingPositions[address.toLowerCase()].morphoMidnight[market.value] = {
-                                error: '',
-                                data: earnData,
-                            };
-                        }
-                    }
+                    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 };
                 }
                 catch (error) {
                     console.error(`Error fetching MorphoMidnight account data for address ${address} on market ${market.value}:`, error);
@@ -627,4 +603,290 @@ 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 morphoMidnightMarkets = Object.values(MorphoMidnightMarkets(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: {},
+            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: {},
+                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);
+            })),
+            ...morphoMidnightMarkets.map((market) => __awaiter(this, void 0, void 0, function* () {
+                markets.morphoMidnightMarketsData[market.value] = yield _getMorphoMidnightMarketData(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(),
+            ...morphoMidnightMarkets.map((market) => addresses.map((address) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const accData = yield _getMorphoMidnightAccountData(client, network, address, market, markets.morphoMidnightMarketsData[market.value]);
+                    if (new Dec(accData.suppliedUsd).gt(0))
+                        positions[address.toLowerCase()].morphoMidnight[market.value] = { error: '', data: accData };
+                }
+                catch (error) {
+                    console.error(`Error fetching MorphoMidnight account data for address ${address} on market ${market.value}:`, error);
+                    positions[address.toLowerCase()].morphoMidnight[market.value] = { error: `Error fetching MorphoMidnight 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/types/portfolio.d.ts

@@ -1,15 +1,16 @@
-import { AaveV2PositionData, AaveV3PositionData, AaveVersions } from './aave';
-import { AaveV4AccountData, AaveV4SpokesType } from './aaveV4';
+import { AaveV2MarketData, AaveV2PositionData, AaveV3MarketData, AaveV3PositionData, AaveVersions } from './aave';
+import { AaveV4AccountData, AaveV4SpokeData, AaveV4SpokesType } from './aaveV4';
 import { EthAddress } from './common';
-import { CompoundV2PositionData, CompoundV3PositionData, CompoundVersions } from './compound';
-import { CrvUSDUserData, CrvUSDVersions } from './curveUsd';
-import { FluidVaultData } from './fluid';
+import { CompoundV2MarketsData, CompoundV2PositionData, CompoundV3MarketsData, CompoundV3PositionData, CompoundVersions } from './compound';
+import { CrvUSDGlobalMarketData, CrvUSDUserData, CrvUSDVersions } from './curveUsd';
+import { FluidMarketData, FluidVaultData } from './fluid';
 import { LiquityTroveInfo } from './liquity';
-import { LlamaLendUserData, LlamaLendVersionsType } from './llamaLend';
-import { CdpData } from './maker';
-import { MorphoBluePositionData, MorphoBlueVersions } from './morphoBlue';
-import { MorphoMidnightPositionData, MorphoMidnightVersions } from './morphoMidnight';
-import { SparkPositionData, SparkVersions } from './spark';
+import { LiquityV2MarketData } from './liquityV2';
+import { LlamaLendGlobalMarketData, LlamaLendUserData, LlamaLendVersionsType } from './llamaLend';
+import { CdpData, IlkInfo } from './maker';
+import { MorphoBlueMarketInfo, MorphoBluePositionData, MorphoBlueVersions } from './morphoBlue';
+import { MorphoMidnightMarketInfo, MorphoMidnightPositionData, MorphoMidnightVersions } from './morphoMidnight';
+import { SparkMarketsData, SparkPositionData, SparkVersions } from './spark';
 export interface PortfolioProtocolData<T> {
     error: string;
     data: T | null;
@@ -59,3 +60,18 @@ export interface PortfolioPositionsDataForAddress {
 export interface PortfolioPositionsData {
     [key: EthAddress]: PortfolioPositionsDataForAddress;
 }
+export interface PortfolioMarketsData {
+    morphoMarketsData: Record<string, MorphoBlueMarketInfo>;
+    morphoMidnightMarketsData: Record<string, MorphoMidnightMarketInfo>;
+    compoundV3MarketsData: Record<string, CompoundV3MarketsData>;
+    sparkMarketsData: Record<string, SparkMarketsData>;
+    aaveV3MarketsData: Record<string, AaveV3MarketData>;
+    aaveV2MarketsData: Record<string, AaveV2MarketData>;
+    compoundV2MarketsData: Record<string, CompoundV2MarketsData>;
+    crvUsdMarketsData: Record<string, CrvUSDGlobalMarketData>;
+    llamaLendMarketsData: Record<string, LlamaLendGlobalMarketData>;
+    liquityV2MarketsData: Record<string, LiquityV2MarketData>;
+    aaveV4SpokesData: Record<string, AaveV4SpokeData>;
+    fluidMarketsData: Record<string, FluidMarketData>;
+    makerMarketsData: Record<string, IlkInfo>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/positions-sdk",
-  "version": "2.1.148-dev",
+  "version": "2.1.149-shifter-v2-dev",
   "description": "",
   "main": "./cjs/index.js",
   "module": "./esm/index.js",

package/src/fluid/index.ts

@@ -1830,3 +1830,43 @@ export const _getUserPositionsPortfolio = async (provider: PublicClient, network
     userData: userData[i],
   })).filter(md => md.marketData !== undefined);
 };
+
+
+export const _getAllFluidMarketDataPortfolio = async (provider: PublicClient, network: NetworkNumber): Promise<Record<string, FluidMarketData>> => {
+  const versions = getFluidVersionsDataForNetwork(network);
+  if (versions.length === 0) return {};
+
+  const view = FluidViewContractViem(provider, network);
+  const vaultsData = await Promise.all(versions.map((version) => view.read.getVaultData([version.marketAddress])));
+
+  const tokens = Array.from(new Set(vaultsData.map((vaultData) => {
+    const vaultTokens = [getAssetInfoByAddress(vaultData.supplyToken0, network).symbol, getAssetInfoByAddress(vaultData.borrowToken0, network).symbol];
+    if (vaultData.supplyToken1 && !compareAddresses(ZERO_ADDRESS, vaultData.supplyToken1)) vaultTokens.push(getAssetInfoByAddress(vaultData.supplyToken1, network).symbol);
+    if (vaultData.borrowToken1 && !compareAddresses(ZERO_ADDRESS, vaultData.borrowToken1)) vaultTokens.push(getAssetInfoByAddress(vaultData.borrowToken1, network).symbol);
+    return vaultTokens;
+  }).flat()));
+
+  // ETH and WBTC needed for other tokens prices
+  if (!tokens.includes('ETH')) tokens.push('ETH');
+  if (!tokens.includes('WBTC')) tokens.push('WBTC');
+
+  const [tokenPrices, merklCampaigns] = await Promise.all([
+    getTokensPricesForPortfolio(tokens, provider, network),
+    getFluidMerklCampaigns(network),
+  ]);
+
+  const parsedMarketsData = await Promise.all(vaultsData.map(async (vaultData) => parseMarketData(provider, vaultData, network, tokenPrices)));
+
+  const marketsData: Record<string, FluidMarketData> = {};
+  parsedMarketsData.forEach((marketData, i) => {
+    if (!marketData) return;
+    marketsData[versions[i].value] = attachFluidMerklIncentives(marketData, merklCampaigns);
+  });
+
+  return marketsData;
+};
+
+export const getAllFluidMarketDataPortfolio = async (
+  provider: EthereumProvider,
+  network: NetworkNumber,
+): Promise<Record<string, FluidMarketData>> => _getAllFluidMarketDataPortfolio(getViemProvider(provider, network, { batch: { multicall: true } }), network);

package/src/maker/index.ts

@@ -1,15 +1,17 @@
 import Dec from 'decimal.js';
 import {
-  assetAmountInEth, bytesToString, getAssetInfo, ilkToAsset,
+  assetAmountInEth, bytesToString, getAssetInfo, ilkToAsset, stringToBytes,
 } from '@defisaver/tokens';
 import { Client, PublicClient } from 'viem';
 import {
-  Blockish, EthAddress, EthereumProvider, NetworkNumber, PositionBalances,
+  Blockish, EthAddress, EthereumProvider, HexString, NetworkNumber, PositionBalances,
 } from '../types/common';
 import {
   getConfigContractAddress, McdDogContractViem, McdGetCdpsContractViem, McdJugContractViem, McdSpotterContractViem, McdVatContractViem, McdViewContractViem,
 } from '../contracts';
-import { CdpData, CdpInfo, CdpType } from '../types';
+import {
+  CdpData, CdpInfo, CdpType, IlkInfo,
+} from '../types';
 import { wethToEth } from '../services/utils';
 import { parseCollateralInfo } from '../helpers/makerHelpers';
 import { getViemProvider, setViemBlockNumber } from '../services/viem';
@@ -129,44 +131,70 @@ export const getUserCdps = async (
   userAddress: EthAddress,
 ): Promise<CdpInfo[]> => _getUserCdps(getViemProvider(provider, network), network, userAddress);
 
-export const _getMakerCdpData = async (provider: Client, network: NetworkNumber, cdp: CdpInfo): Promise<CdpData> => {
+export const _getMakerIlksData = async (provider: Client, network: NetworkNumber, ilkLabels: string[]): Promise<Record<string, IlkInfo>> => {
   const vatContract = McdVatContractViem(provider, network);
   const spotterContract = McdSpotterContractViem(provider, network);
   const dogContract = McdDogContractViem(provider, network);
   const jugContract = McdJugContractViem(provider, network);
 
+  const par = await spotterContract.read.par();
+
+  const ilksInfo = await Promise.all(ilkLabels.map(async (ilkLabel) => {
+    const ilk = stringToBytes(ilkLabel) as HexString;
+    const [
+      [_, mat],
+      [artGlobal, rate, spot, line],
+      [duty],
+      futureRate,
+      chop,
+    ] = await Promise.all([
+      spotterContract.read.ilks([ilk]),
+      vatContract.read.ilks([ilk]),
+      jugContract.read.ilks([ilk]),
+      jugContract.read.drip([ilk]),
+      dogContract.read.chop([ilk]),
+    ]);
+
+    return parseCollateralInfo(
+      ilk,
+      par.toString(),
+      mat.toString(),
+      artGlobal.toString(),
+      rate.toString(),
+      spot.toString(),
+      line.toString(),
+      duty.toString(),
+      futureRate.toString(),
+      chop.toString(),
+    );
+  }));
+
+  return Object.fromEntries(ilksInfo.map((ilkInfo) => [ilkInfo.ilkLabel, ilkInfo]));
+};
+
+export const getMakerIlksData = async (
+  provider: EthereumProvider,
+  network: NetworkNumber,
+  ilkLabels: string[],
+): Promise<Record<string, IlkInfo>> => _getMakerIlksData(getViemProvider(provider, network, { batch: { multicall: true } }), network, ilkLabels);
+
+/**
+ * @param ilkInfo optional precomputed ilk data (from `_getMakerIlksData`); when provided the per-ilk reads are skipped
+ */
+export const _getMakerCdpData = async (provider: Client, network: NetworkNumber, cdp: CdpInfo, ilkInfo?: IlkInfo): Promise<CdpData> => {
+  const vatContract = McdVatContractViem(provider, network);
+
   const [
     [ink, art],
     coll,
-    par,
-    [_, mat],
-    [artGlobal, rate, spot, line],
-    [duty],
-    futureRate,
-    chop,
+    fetchedIlkInfo,
   ] = await Promise.all([
     vatContract.read.urns([cdp.ilk, cdp.urn]),
     vatContract.read.gem([cdp.ilk, cdp.urn]),
-    spotterContract.read.par(),
-    spotterContract.read.ilks([cdp.ilk]),
-    vatContract.read.ilks([cdp.ilk]),
-    jugContract.read.ilks([cdp.ilk]),
-    jugContract.read.drip([cdp.ilk]),
-    dogContract.read.chop([cdp.ilk]),
+    ilkInfo || _getMakerIlksData(provider, network, [cdp.ilkLabel]).then((ilks) => ilks[cdp.ilkLabel]),
   ]);
 
-  const collInfo = parseCollateralInfo(
-    cdp.ilk,
-    par.toString(),
-    mat.toString(),
-    artGlobal.toString(),
-    rate.toString(),
-    spot.toString(),
-    line.toString(),
-    duty.toString(),
-    futureRate.toString(),
-    chop.toString(),
-  );
+  const collInfo = fetchedIlkInfo;
 
   const collateral = assetAmountInEth(ink.toString(), `MCD-${cdp.asset}`);
 

package/src/markets/index.ts

@@ -29,4 +29,5 @@ export {
   getFTokenAddress,
   getFluidMarketInfoByAddress,
 } from './fluid';
-export { AaveV4Spokes, findAaveV4SpokeByAddress } from './aaveV4';
+export { AaveV4Spokes, findAaveV4SpokeByAddress } from './aaveV4';
+export { MakerActiveIlks } from './maker';

package/src/markets/maker/index.ts

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