@defisaver/positions-sdk 2.1.160-morpho-stakehouse-dev → 2.1.160-shifter-v2-dev

package/src/portfolio/index.ts

@@ -7,6 +7,7 @@ import {
   CrvUsdMarkets,
   LiquityV2Markets,
   LlamaLendMarkets,
+  MakerActiveIlks,
   MorphoBlueMarkets,
   MorphoMidnightMarkets,
   SparkMarkets,
@@ -27,6 +28,7 @@ import {
   LlamaLendGlobalMarketData,
   MorphoBlueMarketInfo,
   MorphoMidnightMarketInfo,
+  PortfolioMarketsData,
   PortfolioPositionsData,
   SparkMarketsData,
 } from '../types';
@@ -36,13 +38,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';
@@ -547,9 +549,9 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
     }),
     ...crvUsdMarkets.map((market) => addresses.map(async (address) => {
       try {
-        const accData = await _getCurveUsdUserData(client, network, address, market, crvUsdMarketsData[market.value].activeBand);
+        const accData = await _getCurveUsdUserData(client, network, address, market, crvUsdMarketsData[market.value].activeBand, crvUsdMarketsData[market.value].borrowRate);
         if (new Dec(accData.suppliedUsd).gt(0) || new Dec(accData.borrowedUsd).gt(0)) {
-          positions[address.toLowerCase() as EthAddress].crvUsd[market.value] = { error: '', data: { ...accData, borrowRate: crvUsdMarketsData[market.value].borrowRate } };
+          positions[address.toLowerCase() as EthAddress].crvUsd[market.value] = { error: '', data: accData };
         }
       } catch (error) {
         console.error(`Error fetching Curve USD account data for address ${address} on market ${market.value}:`, error);
@@ -591,4 +593,257 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
   };
 }
 
+
+export async function getShifterPortfolioData(provider: EthereumProvider, network: NetworkNumber, defaultProvider: EthereumProvider, addresses: EthAddress[], isSim = false): Promise<{
+  positions: PortfolioPositionsData;
+  markets: PortfolioMarketsData;
+}> {
+  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: [NetworkNumber, any?] = [network, { batch: { multicall: { batchSize: isSim ? 2_000 : 2_500_000 } } }];
+  const client = getViemProvider(provider, ...args);
+  const defaultClient = getViemProvider(defaultProvider, ...args);
+
+  const markets: PortfolioMarketsData = {
+    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: Record<string, CdpInfo[]> = {};
+
+  const positions: PortfolioPositionsData = {};
+
+  for (const address of addresses) {
+    positions[address.toLowerCase() as EthAddress] = {
+      aaveV3: {},
+      aaveV4: {},
+      morphoBlue: {},
+      morphoMidnight: {}, // not fetched for the shifter (see markets above)
+      compoundV3: {},
+      spark: {},
+      maker: {},
+      aaveV2: {},
+      compoundV2: {},
+      liquity: {},
+      crvUsd: {},
+      llamaLend: {},
+      fluid: {
+        error: '',
+        data: {},
+      },
+    };
+  }
+
+  await Promise.allSettled([
+    // === MARKET DATA (needs to be fetched first) ===
+    ...morphoMarkets.map(async (market) => {
+      markets.morphoMarketsData[market.value] = await _getMorphoBluePortfolioMarketData(client, network, market);
+    }),
+    ...compoundV3Markets.map(async (market) => {
+      markets.compoundV3MarketsData[market.value] = await _getCompoundV3MarketsData(client, network, market, defaultClient);
+    }),
+    ...sparkMarkets.map(async (market) => {
+      markets.sparkMarketsData[market.value] = await _getSparkMarketsData(client, network, market);
+    }),
+    ...aaveV3Markets.map(async (market) => {
+      markets.aaveV3MarketsData[market.value] = await _getAaveV3MarketData(client, network, market);
+    }),
+    ...aaveV4Spokes.map(async (spoke) => {
+      markets.aaveV4SpokesData[spoke.value] = await _getAaveV4SpokeData(client, network, spoke);
+    }),
+    ...aaveV2Markets.map(async (market) => {
+      markets.aaveV2MarketsData[market.value] = await _getAaveV2MarketsData(client, network, market);
+    }),
+    ...compoundV2Markets.map(async (market) => {
+      markets.compoundV2MarketsData[market.value] = await _getCompoundV2MarketsData(client, network);
+    }),
+    ...crvUsdMarkets.map(async (market) => {
+      markets.crvUsdMarketsData[market.value] = await _getCurveUsdGlobalData(client, network, market);
+    }),
+    ...llamaLendMarkets.map(async (market) => {
+      markets.llamaLendMarketsData[market.value] = await _getLlamaLendGlobalData(client, network, market);
+    }),
+    ...liquityV2Markets.map(async (market) => {
+      markets.liquityV2MarketsData[market.value] = await _getLiquityV2MarketData(client, network, market);
+    }),
+    (async () => {
+      if (!isFluidSupported) return;
+      try {
+        markets.fluidMarketsData = await _getAllFluidMarketDataPortfolio(client, network);
+      } catch (error) {
+        console.error('Error fetching Fluid markets data:', error);
+      }
+    })(),
+    (async () => {
+      if (!isMainnet) return; // Maker CDPs are only available on mainnet
+      try {
+        markets.makerMarketsData = await _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(async (address) => {
+      if (!isMainnet) return; // Maker CDPs are only available on mainnet
+      const makerCdp = await _getUserCdps(client, network, address);
+      makerCdps[address.toLowerCase() as EthAddress] = makerCdp;
+    }),
+    ...addresses.map(async (address) => {
+      try {
+        if (!isFluidSupported) return; // Fluid is not available on Optimism
+        const userPositions = (await _getUserPositionsPortfolio(client, network, address));
+        for (const position of userPositions) {
+          if (position.userData && new Dec(position.userData.suppliedUsd).gt(0)) {
+            positions[address.toLowerCase() as EthAddress].fluid.data[position.userData.nftId] = position.userData;
+          }
+        }
+      } catch (error) {
+        console.error(`Error fetching Fluid positions for address ${address}:`, error);
+        positions[address.toLowerCase() as EthAddress].fluid = {
+          error: `Error fetching Fluid positions for address ${address}`,
+          data: {},
+        };
+      }
+    }),
+  ]);
+
+  await Promise.all([
+    ...aaveV3Markets.map((market) => addresses.map(async (address) => {
+      try {
+        const accData = await _getAaveV3AccountData(client, network, address, { selectedMarket: market, ...markets.aaveV3MarketsData[market.value] });
+        if (new Dec(accData.suppliedUsd).gt(0)) positions[address.toLowerCase() as EthAddress].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() as EthAddress].aaveV3[market.value] = { error: `Error fetching AaveV3 account data for address ${address} on market ${market.value}`, data: null };
+      }
+    })).flat(),
+    ...aaveV4Spokes.map((spoke) => addresses.map(async (address) => {
+      try {
+        const accData = await _getAaveV4AccountData(client, network, markets.aaveV4SpokesData[spoke.value], address);
+        if (new Dec(accData.suppliedUsd).gt(0)) positions[address.toLowerCase() as EthAddress].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() as EthAddress].aaveV4[spoke.value] = { error: `Error fetching AaveV4 account data for address ${address} on spoke ${spoke.value}`, data: null };
+      }
+    })).flat(),
+    ...morphoMarkets.map((market) => addresses.map(async (address) => {
+      try {
+        const accData = await _getMorphoBlueAccountData(client, network, address, market, markets.morphoMarketsData[market.value]);
+        if (new Dec(accData.suppliedUsd).gt(0)) positions[address.toLowerCase() as EthAddress].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() as EthAddress].morphoBlue[market.value] = { error: `Error fetching MorphoBlue account data for address ${address} on market ${market.value}`, data: null };
+      }
+    })).flat(),
+    ...compoundV3Markets.map((market) => addresses.map(async (address) => {
+      try {
+        const accData = await _getCompoundV3AccountData(client, network, address, ZERO_ADDRESS, { selectedMarket: market, assetsData: markets.compoundV3MarketsData[market.value].assetsData });
+        if (new Dec(accData.suppliedUsd).gt(0)) positions[address.toLowerCase() as EthAddress].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() as EthAddress].compoundV3[market.value] = { error: `Error fetching CompoundV3 account data for address ${address} on market ${market.value}`, data: null };
+      }
+    })).flat(),
+    ...sparkMarkets.map((market) => addresses.map(async (address) => {
+      try {
+        const accData = await _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() as EthAddress].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() as EthAddress].spark[market.value] = { error: `Error fetching Spark account data for address ${address} on market ${market.value}`, data: null };
+      }
+    })).flat(),
+    ...addresses.map(async (address) => makerCdps[address.toLowerCase() as EthAddress]?.map(async (cdpInfo) => {
+      try {
+        // reuse ilk data fetched for the markets payload; ilks outside the active set are fetched on demand
+        const cdpData = await _getMakerCdpData(client, network, cdpInfo, markets.makerMarketsData[cdpInfo.ilkLabel]);
+        if (cdpData) {
+          positions[address.toLowerCase() as EthAddress].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() as EthAddress].maker[cdpInfo.id] = { error: `Error fetching Maker CDP data for address ${address} with ID ${cdpInfo.id}`, data: null };
+      }
+    })).flat(),
+    ...aaveV2Markets.map((market) => addresses.map(async (address) => {
+      try {
+        const accData = await _getAaveV2AccountData(client, network, address, markets.aaveV2MarketsData[market.value].assetsData, market);
+        if (new Dec(accData.suppliedUsd).gt(0)) positions[address.toLowerCase() as EthAddress].aaveV2[market.value] = { error: '', data: accData };
+      } catch (error) {
+        console.error(`Error fetching AaveV2 account data for address ${address}:`, error);
+        positions[address.toLowerCase() as EthAddress].aaveV2[market.value] = { error: `Error fetching AaveV2 account data for address ${address}`, data: null };
+      }
+    })).flat(),
+    ...compoundV2Markets.map((market) => addresses.map(async (address) => {
+      try {
+        const accData = await _getCompoundV2AccountData(client, network, address, markets.compoundV2MarketsData[market.value].assetsData);
+        if (new Dec(accData.suppliedUsd).gt(0)) positions[address.toLowerCase() as EthAddress].compoundV2[market.value] = { error: '', data: accData };
+      } catch (error) {
+        console.error(`Error fetching CompoundV2 account data for address ${address}:`, error);
+        positions[address.toLowerCase() as EthAddress].compoundV2[market.value] = { error: `Error fetching CompoundV2 account data for address ${address}`, data: null };
+      }
+    })).flat(),
+    ...addresses.map(async (address) => {
+      try {
+        if (!isMainnet) return; // Liquity trove info is only available on mainnet
+        const troveInfo = await _getLiquityTroveInfo(client, network, address);
+        if (new Dec(troveInfo.collateral).gt(0)) positions[address.toLowerCase() as EthAddress].liquity = { error: '', data: troveInfo };
+      } catch (error) {
+        console.error(`Error fetching Liquity trove info for address ${address}:`, error);
+        positions[address.toLowerCase() as EthAddress].liquity = { error: `Error fetching Liquity trove info for address ${address}`, data: null };
+      }
+    }),
+    ...crvUsdMarkets.map((market) => addresses.map(async (address) => {
+      try {
+        const accData = await _getCurveUsdUserData(client, network, address, market, markets.crvUsdMarketsData[market.value].activeBand, markets.crvUsdMarketsData[market.value].borrowRate);
+        if (new Dec(accData.suppliedUsd).gt(0) || new Dec(accData.borrowedUsd).gt(0)) {
+          positions[address.toLowerCase() as EthAddress].crvUsd[market.value] = { error: '', data: accData };
+        }
+      } catch (error) {
+        console.error(`Error fetching Curve USD account data for address ${address} on market ${market.value}:`, error);
+        positions[address.toLowerCase() as EthAddress].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(async (address) => {
+      try {
+        const accData = await _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() as EthAddress].llamaLend[market.value] = { error: '', data: { ...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() as EthAddress].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/src/savings/index.ts

@@ -32,8 +32,7 @@ export const getSavingsData = async (
   network: NetworkNumber,
   accounts: EthAddress[],
 ) => {
-  const morphoVaultsList = (Object.keys(morphoVaults.morphoVaultsOptions.MORPHO_VAULTS) as MorphoVaultType[])
-    .filter((key) => morphoVaults.morphoVaultsOptions.getMorphoVault(key).network === network);
+  const morphoVaultsList = Object.keys(morphoVaults.morphoVaultsOptions.MORPHO_VAULTS) as MorphoVaultType[];
   const yearnVaultsList = Object.keys(yearnVaults.yearnVaultsOptions.YEARN_VAULTS) as YearnVaultType[];
   const sparkSavingsVaultsList = Object.keys(sparkSavingsVaults.sparkSavingsVaultsOptions.SPARK_SAVINGS_VAULTS) as SparkSavingsVaultType[];
   const yearnV3VaultsList = Object.keys(yearnV3Vaults.yearnV3VaultsOptions.YEARN_V3_VAULTS) as YearnV3VaultType[];
@@ -43,7 +42,7 @@ export const getSavingsData = async (
   const savingsData: SavingsData = {};
 
   await Promise.all([
-    ...(morphoVaultsList.length ? [
+    ...(network === NetworkNumber.Eth ? [
       (async () => {
         try {
           const vaults = morphoVaultsList.map((vaultKey) => morphoVaults.morphoVaultsOptions.getMorphoVault(vaultKey));
@@ -53,8 +52,6 @@ export const getSavingsData = async (
           console.error('[getSavingsData] Error fetching morpho vaults:', err);
         }
       })(),
-    ] : []),
-    ...(network === NetworkNumber.Eth ? [
       ...yearnVaultsList.map(async (vaultKey) => {
         try {
           const vault = yearnVaults.yearnVaultsOptions.getYearnVault(vaultKey);

package/src/savings/morphoVaults/index.ts

@@ -4,10 +4,10 @@ import { request as graphqlRequest } from 'graphql-request';
 import { assetAmountInEth } from '@defisaver/tokens';
 import * as morphoVaultsOptions from './options';
 import {
-  EthAddress, EthereumProvider, NetworkNumber, MorphoVault, MorphoVaultType, MorphoVaultVersion, SavingsVaultData,
+  EthAddress, EthereumProvider, NetworkNumber, MorphoVault, MorphoVaultType, SavingsVaultData,
 } from '../../types';
 import { getViemProvider } from '../../services/viem';
-import { getErc4626ContractViem, getMorphoVaultContractViem } from '../../contracts';
+import { getMorphoVaultContractViem } from '../../contracts';
 import { MORPHO_API_URL } from '../../constants';
 
 export {
@@ -17,49 +17,38 @@ export {
 // Morpho API caps list page size at 100 items
 const MORPHO_API_PAGE_SIZE = 100;
 
-const buildLiquidityQuery = (listField: 'vaults' | 'vaultV2s') => `
+const vaultsLiquidityQuery = `
   query VaultsLiquidity($addresses: [String!], $chainIds: [Int!]) {
-    ${listField}(first: ${MORPHO_API_PAGE_SIZE}, where: { address_in: $addresses, chainId_in: $chainIds }) {
+    vaults(first: ${MORPHO_API_PAGE_SIZE}, where: { address_in: $addresses, chainId_in: $chainIds }) {
       items {
         address
-        liquidity${listField === 'vaults' ? ' {\n          underlying\n        }' : ''}
+        liquidity {
+          underlying
+        }
       }
     }
 }`;
 
-const liquidityQueries = {
-  [MorphoVaultVersion.V1]: { field: 'vaults', query: buildLiquidityQuery('vaults') },
-  [MorphoVaultVersion.V2]: { field: 'vaultV2s', query: buildLiquidityQuery('vaultV2s') },
-} as const;
-
-type LiquidityItem = { address: string, liquidity: { underlying: string | number | null } | string | number | null };
-
 /**
- * Fetches liquidity for all given vaults, one API request per vault version (chunked if over the page cap),
+ * 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 = async (network: NetworkNumber, vaults: MorphoVault[]): Promise<Record<string, string>> => {
-  const requests: { version: MorphoVaultVersion, chunk: MorphoVault[] }[] = [];
-  [MorphoVaultVersion.V1, MorphoVaultVersion.V2].forEach((version) => {
-    const versionVaults = vaults.filter((vault) => vault.version === version);
-    for (let i = 0; i < versionVaults.length; i += MORPHO_API_PAGE_SIZE) requests.push({ version, chunk: versionVaults.slice(i, i + MORPHO_API_PAGE_SIZE) });
-  });
+  const chunks: MorphoVault[][] = [];
+  for (let i = 0; i < vaults.length; i += MORPHO_API_PAGE_SIZE) chunks.push(vaults.slice(i, i + MORPHO_API_PAGE_SIZE));
 
   const liquidityByAddress: Record<string, string> = {};
-  await Promise.all(requests.map(async ({ version, chunk }) => {
-    const { field, query } = liquidityQueries[version];
-    const data = await graphqlRequest(MORPHO_API_URL, query, {
+  await Promise.all(chunks.map(async (chunk) => {
+    const data = await graphqlRequest(MORPHO_API_URL, 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
-    }) as Record<string, { items: LiquidityItem[] | null }>;
+    }) as { vaults: { items: { address: string, liquidity: { underlying: string | number | null } | null }[] | null } };
 
-    (data[field].items || []).forEach((item) => {
-      // V1 exposes liquidity as { underlying }, V2 as a plain BigInt scalar
-      const underlying = item?.liquidity !== null && typeof item?.liquidity === 'object' ? item.liquidity.underlying : item?.liquidity;
-      if (underlying !== undefined && underlying !== null) {
-        liquidityByAddress[item.address.toLowerCase()] = String(underlying);
+    (data.vaults.items || []).forEach((item) => {
+      if (item?.liquidity?.underlying !== undefined && item.liquidity?.underlying !== null) {
+        liquidityByAddress[item.address.toLowerCase()] = String(item.liquidity.underlying);
       }
     });
   }));
@@ -74,22 +63,7 @@ const getBatchedViemProvider = (provider: EthereumProvider, network: NetworkNumb
   },
 });
 
-// Vault V2 is ERC-4626 but has no decimals offset, so shares are converted with convertToAssets
-const getMorphoVaultV2ChainData = async (provider: Client, morphoVault: MorphoVault, accounts: EthAddress[]) => {
-  const vaultContract = getErc4626ContractViem(provider, morphoVault.address);
-
-  const [totalAssets, suppliedAssets] = await Promise.all([
-    vaultContract.read.totalAssets(),
-    Promise.all(accounts.map(async (account) => {
-      const share = await vaultContract.read.balanceOf([account]);
-      return share === BigInt(0) ? BigInt(0) : vaultContract.read.convertToAssets([share]);
-    })),
-  ]);
-
-  return { totalAssets, suppliedAssets };
-};
-
-const getMorphoVaultV1ChainData = async (provider: Client, morphoVault: MorphoVault, accounts: EthAddress[]) => {
+const getMorphoVaultChainData = async (provider: Client, morphoVault: MorphoVault, accounts: EthAddress[]) => {
   const morphoVaultContract = getMorphoVaultContractViem(provider, morphoVault.address);
 
   const shares: Record<EthAddress, bigint> = {};
@@ -110,46 +84,20 @@ const getMorphoVaultV1ChainData = async (provider: Client, morphoVault: MorphoVa
   };
 };
 
-type MorphoVaultChainData = {
-  v1?: Awaited<ReturnType<typeof getMorphoVaultV1ChainData>>,
-  v2?: Awaited<ReturnType<typeof getMorphoVaultV2ChainData>>,
-};
-
-const getMorphoVaultChainData = async (provider: Client, morphoVault: MorphoVault, accounts: EthAddress[]): Promise<MorphoVaultChainData> => (
-  morphoVault.version === MorphoVaultVersion.V2
-    ? { v2: await getMorphoVaultV2ChainData(provider, morphoVault, accounts) }
-    : { v1: await getMorphoVaultV1ChainData(provider, morphoVault, accounts) }
-);
-
 const formatMorphoVaultData = (
   morphoVault: MorphoVault,
-  chainData: MorphoVaultChainData,
+  chainData: Awaited<ReturnType<typeof getMorphoVaultChainData>>,
   liquidityUnderlying: string,
   accounts: EthAddress[],
 ): SavingsVaultData => {
-  const liquidity = assetAmountInEth(liquidityUnderlying, morphoVault.asset);
-  const supplied: Record<EthAddress, string> = {};
-
-  if (chainData.v2) {
-    const { totalAssets, suppliedAssets } = chainData.v2;
-    accounts.forEach((account, i) => {
-      supplied[account.toLowerCase() as EthAddress] = assetAmountInEth(suppliedAssets[i].toString(), morphoVault.asset);
-    });
-    return {
-      poolSize: assetAmountInEth(totalAssets.toString(), morphoVault.asset),
-      supplied,
-      liquidity,
-      asset: morphoVault.asset,
-      optionType: morphoVault.type,
-    };
-  }
-
   const {
     totalAssets, totalSupply, decimals, decimalsOffset, shares,
-  } = chainData.v1!;
+  } = chainData;
 
   const poolSize = assetAmountInEth(totalAssets.toString(), morphoVault.asset);
+  const liquidity = assetAmountInEth(liquidityUnderlying, morphoVault.asset);
 
+  const supplied: Record<EthAddress, string> = {};
   accounts.forEach((account) => {
     const share = shares[account] || BigInt(0);
     supplied[account.toLowerCase() as EthAddress] = new Dec(new Dec(share.toString()).mul(new Dec(totalAssets.toString()).add(1)).div(new Dec(totalSupply.toString()).add(10 ** decimalsOffset)).div(10 ** 18)