@defisaver/positions-sdk 2.1.161-portfolio-api-2-dev → 2.1.162-npm-token-dev

package/src/portfolio/index.ts

@@ -27,11 +27,7 @@ import {
   LlamaLendGlobalMarketData,
   MorphoBlueMarketInfo,
   MorphoMidnightMarketInfo,
-  PortfolioDataOptions,
-  PortfolioMarketsData,
   PortfolioPositionsData,
-  PortfolioRewardsData,
-  PortfolioStakingPositionsData,
   SparkMarketsData,
 } from '../types';
 import { _getCompoundV3AccountData, _getCompoundV3MarketsData } from '../compoundV3';
@@ -55,18 +51,13 @@ import { fetchEthenaAirdropRewards } from '../claiming/ethena';
 import { _getAaveV4AccountData, _getAaveV4SpokeData } from '../aaveV4';
 import { getUniswapRewards } from '../claiming/uniswap';
 
-export async function getPortfolioData(provider: EthereumProvider, network: NetworkNumber, defaultProvider: EthereumProvider, addresses: EthAddress[], isSim = false, options: PortfolioDataOptions = {}): Promise<{
+export async function getPortfolioData(provider: EthereumProvider, network: NetworkNumber, defaultProvider: EthereumProvider, addresses: EthAddress[], isSim = false): Promise<{
   positions: PortfolioPositionsData;
-  stakingPositions: PortfolioStakingPositionsData;
-  rewardsData: PortfolioRewardsData;
-  markets: PortfolioMarketsData;
+  stakingPositions: any;
+  rewardsData: any;
+  markets: any;
 }> {
   const isMainnet = network === NetworkNumber.Eth;
-  const includeStaking = options.staking !== false;
-  const includeRewards = options.rewards !== false;
-  // The addresses staking and rewards are read for: none when left out, so their fetches below make no calls.
-  const stakingAddresses = includeStaking ? addresses : [];
-  const rewardsAddresses = includeRewards ? addresses : [];
   const isFluidSupported = [NetworkNumber.Eth, NetworkNumber.Arb, NetworkNumber.Base, NetworkNumber.Plasma].includes(network);
 
   const morphoMarkets = Object.values(MorphoBlueMarkets(network)).filter((market) => market.chainIds.includes(network));
@@ -105,7 +96,7 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
   const liquityV2MarketsData: Record<string, LiquityV2MarketData> = {};
   const aaveV4SpokesData: Record<string, AaveV4SpokeData> = {};
 
-  const markets: PortfolioMarketsData = {
+  const markets = {
     morphoMarketsData,
     morphoMidnightMarketsData,
     compoundV3MarketsData,
@@ -120,8 +111,8 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
   };
 
   const positions: PortfolioPositionsData = {};
-  const stakingPositions: PortfolioStakingPositionsData = {};
-  const rewardsData: PortfolioRewardsData = {};
+  const stakingPositions: any = {};
+  const rewardsData: any = {};
   const allAddresses = [...addresses];
 
   for (const address of allAddresses) {
@@ -146,7 +137,7 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
   }
 
   // TODO: check default values, probably needed when fetching portfolio on unsupported networks
-  for (const address of stakingAddresses) {
+  for (const address of addresses) {
     stakingPositions[address.toLowerCase() as EthAddress] = {
       aaveV3: {},
       morphoBlue: {},
@@ -160,21 +151,15 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
         error: '',
         data: {},
       },
-      // Set by the sBOLD/yBOLD fetch below, whether it succeeds or fails.
-      liquityV2SBoldYBold: { error: '', data: null },
     };
-  }
 
-  for (const address of rewardsAddresses) {
-    // merkl, spk, king and uniswap are set by their fetches below, whether they succeed or fail.
     rewardsData[address.toLowerCase() as EthAddress] = {
-      merkl: { error: '', data: null },
+      merkl: {},
       aaveV3: {},
       spark: {},
-      spk: { error: '', data: null },
-      king: { error: '', data: null },
+      spk: {},
+      king: {},
       ethena: {},
-      uniswap: { error: '', data: null },
     };
   }
 
@@ -250,54 +235,54 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
     }),
 
     // === STAKING DATA (independent of market data) ===
-    ...stakingAddresses.map(async (address) => {
+    ...addresses.map(async (address) => {
       try {
         if (!isFluidSupported) return;
-        stakingPositions[address.toLowerCase() as EthAddress].fluid = await _getAllUserEarnPositionsWithFTokens(client, network, address);
+        stakingPositions[address.toLowerCase()].fluid = await _getAllUserEarnPositionsWithFTokens(client, network, address);
       } catch (error) {
         console.error(`Error fetching Fluid lend data for address ${address}:`, error);
-        stakingPositions[address.toLowerCase() as EthAddress].fluid = { error: `Error fetching Fluid lend data for address ${address}`, data: null };
+        stakingPositions[address.toLowerCase()].fluid = { error: `Error fetching Fluid lend data for address ${address}`, data: null };
       }
     }),
-    ...stakingAddresses.map(async (address) => {
+    ...addresses.map(async (address) => {
       try {
         if (!isMainnet) return;
-        stakingPositions[address.toLowerCase() as EthAddress].liquity = await getLiquityStakingData(client, network, address);
+        stakingPositions[address.toLowerCase()].liquity = await getLiquityStakingData(client, network, address);
       } catch (error) {
         console.error(`Error fetching Liquity staking data for address ${address}:`, error);
-        stakingPositions[address.toLowerCase() as EthAddress].liquity = { error: `Error fetching Liquity staking data for address ${address}`, data: null };
+        stakingPositions[address.toLowerCase()].liquity = { error: `Error fetching Liquity staking data for address ${address}`, data: null };
       }
     }),
-    ...stakingAddresses.map(async (address) => {
+    ...addresses.map(async (address) => {
       try {
         if (!isMainnet) return;
-        stakingPositions[address.toLowerCase() as EthAddress].aaveV3 = await getStakeAaveData(client, network, address);
+        stakingPositions[address.toLowerCase()].aaveV3 = await getStakeAaveData(client, network, address);
       } catch (error) {
         console.error(`Error fetching Aave V3 staking data for address ${address}:`, error);
-        stakingPositions[address.toLowerCase() as EthAddress].aaveV3 = { error: `Error fetching Aave V3 staking data for address ${address}`, data: null };
+        stakingPositions[address.toLowerCase()].aaveV3 = { error: `Error fetching Aave V3 staking data for address ${address}`, data: null };
       }
     }),
-    ...stakingAddresses.map(async (address) => {
+    ...addresses.map(async (address) => {
       try {
         if (!isMainnet) return;
-        stakingPositions[address.toLowerCase() as EthAddress].umbrella = await getUmbrellaData(client, network, address);
+        stakingPositions[address.toLowerCase()].umbrella = await getUmbrellaData(client, network, address);
       } catch (error) {
         console.error(`Error fetching Umbrella staking data for address ${address}:`, error);
-        stakingPositions[address.toLowerCase() as EthAddress].umbrella = { error: `Error fetching Umbrella staking data for address ${address}`, data: null };
+        stakingPositions[address.toLowerCase()].umbrella = { error: `Error fetching Umbrella staking data for address ${address}`, data: null };
       }
     }),
     // Liquity V2 staking
-    ...liquityV2MarketsStaking.map(market => stakingAddresses.map(async (address) => {
+    ...liquityV2MarketsStaking.map(market => addresses.map(async (address) => {
       try {
         if (!isMainnet) {
-          stakingPositions[address.toLowerCase() as EthAddress].liquityV2[market.value] = { error: '', data: null };
+          stakingPositions[address.toLowerCase()].liquityV2[market.value] = { error: '', data: null };
           return;
         }
         const liquityV2StakingData = await getLiquityV2Staking(client, network, market.value, address);
-        stakingPositions[address.toLowerCase() as EthAddress].liquityV2[market.value] = { error: '', data: liquityV2StakingData };
+        stakingPositions[address.toLowerCase()].liquityV2[market.value] = { error: '', data: liquityV2StakingData };
       } catch (error) {
         console.error(`Error fetching Liquity V2 staking data for address ${address}, market ${market.value}:`, error);
-        stakingPositions[address.toLowerCase() as EthAddress].liquityV2[market.value] = { error: `Error fetching Liquity V2 staking data for address ${address}`, data: null };
+        stakingPositions[address.toLowerCase()].liquityV2[market.value] = { error: `Error fetching Liquity V2 staking data for address ${address}`, data: null };
       }
     })).flat(),
 
@@ -306,13 +291,13 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
     (async () => {
       try {
         if (!isMainnet) {
-          for (const address of rewardsAddresses) {
-            rewardsData[address.toLowerCase() as EthAddress].king = { error: '', data: [] };
+          for (const address of addresses) {
+            rewardsData[address.toLowerCase()].king = { error: '', data: [] };
           }
           return;
         }
-        const kingRewards = await getKingRewards(client, network, rewardsAddresses);
-        for (const address of rewardsAddresses) {
+        const kingRewards = await getKingRewards(client, network, addresses);
+        for (const address of addresses) {
           const lowerAddress = address.toLowerCase() as EthAddress;
           rewardsData[lowerAddress].king = {
             error: '',
@@ -321,7 +306,7 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
         }
       } catch (error) {
         console.error('Error fetching King rewards data in batch:', error);
-        for (const address of rewardsAddresses) {
+        for (const address of addresses) {
           rewardsData[address.toLowerCase() as EthAddress].king = {
             error: 'Error fetching King rewards data in batch',
             data: null,
@@ -333,13 +318,13 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
     (async () => {
       try {
         if (!isMainnet) {
-          for (const address of rewardsAddresses) {
-            rewardsData[address.toLowerCase() as EthAddress].uniswap = { error: '', data: [] };
+          for (const address of addresses) {
+            rewardsData[address.toLowerCase()].uniswap = { error: '', data: [] };
           }
           return;
         }
-        const uniswapRewards = await getUniswapRewards(client, network, rewardsAddresses);
-        for (const address of rewardsAddresses) {
+        const uniswapRewards = await getUniswapRewards(client, network, addresses);
+        for (const address of addresses) {
           const lowerAddress = address.toLowerCase() as EthAddress;
           rewardsData[lowerAddress].uniswap = {
             error: '',
@@ -348,7 +333,7 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
         }
       } catch (error) {
         console.error('Error fetching Uniswap rewards data in batch:', error);
-        for (const address of rewardsAddresses) {
+        for (const address of addresses) {
           rewardsData[address.toLowerCase() as EthAddress].uniswap = {
             error: 'Error fetching Uniswap rewards data in batch',
             data: null,
@@ -356,10 +341,10 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
         }
       }
     })(),
-    ...sparkMarkets.map((market) => rewardsAddresses.map(async address => {
+    ...sparkMarkets.map((market) => addresses.map(async address => {
       try {
         if (!isMainnet) {
-          rewardsData[address.toLowerCase() as EthAddress].spark[market.value] = { error: '', data: [] };
+          rewardsData[address.toLowerCase()].spark[market.value] = { error: '', data: [] };
           return;
         }
         const sparkData = await fetchSparkRewards(client, network, address, market.providerAddress);
@@ -369,7 +354,7 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
         rewardsData[address.toLowerCase() as EthAddress].spark[market.value] = { error: `Error fetching Spark rewards data for address ${address}`, data: null };
       }
     })).flat(),
-    ...rewardsAddresses.map(async (address) => {
+    ...addresses.map(async (address) => {
       try {
         const merklData = await getMerklUnclaimedRewards(address, network);
         rewardsData[address.toLowerCase() as EthAddress].merkl = { error: '', data: merklData };
@@ -378,28 +363,27 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
         rewardsData[address.toLowerCase() as EthAddress].merkl = { error: `Error fetching Merkl rewards data for address ${address}`, data: null };
       }
     }),
-    ...aaveV3Markets.map(market => rewardsAddresses.map(async (address) => {
+    ...aaveV3Markets.map(market => addresses.map(async (address) => {
       try {
         const aaveData = await getUnclaimedRewardsForAllMarkets(client, network, address, market.providerAddress);
         rewardsData[address.toLowerCase() as EthAddress].aaveV3[market.value] = { error: '', data: aaveData };
       } catch (error) {
         console.error(`Error fetching Aave V3 Merit rewards data for address ${address}:`, error);
-        // This market only: the other markets keep their rewards.
-        rewardsData[address.toLowerCase() as EthAddress].aaveV3[market.value] = { error: `Error fetching Aave V3 rewards data for address ${address} on market ${market.value}`, data: null };
+        rewardsData[address.toLowerCase() as EthAddress].aaveV3 = { error: `Error fetching Aave V3 rewards data for address ${address}`, data: null };
       }
     })).flat(),
     // Batch Spark Airdrop rewards
     (async () => {
       try {
         if (!isMainnet) {
-          for (const address of rewardsAddresses) {
-            rewardsData[address.toLowerCase() as EthAddress].spk = { error: '', data: [] };
+          for (const address of addresses) {
+            rewardsData[address.toLowerCase()].spk = { error: '', data: [] };
           }
           return;
         }
 
-        const sparkAirdropRewards = await fetchSparkAirdropRewards(client, network, rewardsAddresses);
-        for (const address of rewardsAddresses) {
+        const sparkAirdropRewards = await fetchSparkAirdropRewards(client, network, addresses);
+        for (const address of addresses) {
           const lowerAddress = address.toLowerCase() as EthAddress;
           rewardsData[lowerAddress].spk = {
             error: '',
@@ -408,7 +392,7 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
         }
       } catch (error) {
         console.error('Error fetching Spark Airdrop rewards data in batch:', error);
-        for (const address of rewardsAddresses) {
+        for (const address of addresses) {
           rewardsData[address.toLowerCase() as EthAddress].spk = {
             error: 'Error fetching Spark Airdrop rewards data in batch',
             data: null,
@@ -422,8 +406,8 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
           return;
         }
 
-        const ethenaAirdropRewards = await fetchEthenaAirdropRewards(rewardsAddresses);
-        for (const address of rewardsAddresses) {
+        const ethenaAirdropRewards = await fetchEthenaAirdropRewards(addresses);
+        for (const address of addresses) {
           const lowerAddress = address.toLowerCase() as EthAddress;
           rewardsData[lowerAddress].ethena = {
             error: '',
@@ -432,7 +416,7 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
         }
       } catch (error) {
         console.error('Error fetching Ethena Airdrop rewards data:', error);
-        for (const address of rewardsAddresses) {
+        for (const address of addresses) {
           rewardsData[address.toLowerCase() as EthAddress].ethena = {
             error: 'Error fetching Ethena Airdrop rewards data in batch',
             data: null,
@@ -465,16 +449,15 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
       try {
         const [accDataPromise, earnDataPromise] = await Promise.allSettled([
           _getMorphoBlueAccountData(client, network, address, market, morphoMarketsData[market.value]),
-          includeStaking ? getMorphoEarn(client, network, address, market, morphoMarketsData[market.value]) : null,
+          getMorphoEarn(client, network, address, market, morphoMarketsData[market.value]),
         ]);
         if (accDataPromise.status === 'rejected') {
           console.error(`Error fetching MorphoBlue account data for address ${address} on market ${market.value}:`, accDataPromise.reason);
           positions[address.toLowerCase() as EthAddress].morphoBlue[market.value] = { error: `Error fetching MorphoBlue account data for address ${address} on market ${market.value}`, data: null };
         }
         if (earnDataPromise.status === 'rejected') {
-          // An Earn failure belongs to the staking entry: the lending position is not the one that failed.
-          console.error(`Error fetching MorphoBlue earn data for address ${address} on market ${market.value}:`, earnDataPromise.reason);
-          stakingPositions[address.toLowerCase() as EthAddress].morphoBlue[market.value] = { error: `Error fetching MorphoBlue earn data for address ${address} on market ${market.value}`, data: null };
+          console.error(`Error fetching MorphoBlue account data for address ${address} on market ${market.value}:`, earnDataPromise.reason);
+          positions[address.toLowerCase() as EthAddress].morphoBlue[market.value] = { error: `Error fetching MorphoBlue account data for address ${address} on market ${market.value}`, data: null };
         }
         if (accDataPromise.status !== 'rejected') {
           const accData = accDataPromise.value;
@@ -523,9 +506,7 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
         positions[address.toLowerCase() as EthAddress].spark[market.value] = { error: `Error fetching Spark account data for address ${address} on market ${market.value}`, data: null };
       }
     })).flat(),
-    // flatMap, not map: each CDP's fetch has to be one of the awaited promises, or getPortfolioData can return
-    // before a vault's data lands and the vault is missing from the result.
-    ...addresses.flatMap((address) => (makerCdps[address.toLowerCase() as EthAddress] ?? []).map(async (cdpInfo) => {
+    ...addresses.map(async (address) => makerCdps[address.toLowerCase() as EthAddress]?.map(async (cdpInfo) => {
       try {
         const cdpData = await _getMakerCdpData(client, network, cdpInfo);
         if (cdpData) {
@@ -535,7 +516,7 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
         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, aaveV2MarketsData[market.value].assetsData, market);
@@ -587,13 +568,13 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
       }
     })).flat(),
     // liquity sBold/yBold and staking options
-    ...stakingAddresses.map(async (address) => {
+    ...addresses.map(async (address) => {
       try {
         if (!isMainnet) {
           stakingPositions[address.toLowerCase() as EthAddress].liquityV2SBoldYBold = { error: '', data: null };
           return;
         }
-        const data = await getLiquitySAndYBold(client, network, stakingPositions[address.toLowerCase() as EthAddress].liquityV2, address);
+        const data = await getLiquitySAndYBold(client, network, stakingPositions[address.toLowerCase()].liquityV2, address);
         stakingPositions[address.toLowerCase() as EthAddress].liquityV2SBoldYBold = { error: '', data };
       } catch (error) {
         console.error(`Error fetching SBold/YBold data for address ${address}:`, error);

package/src/savings/index.ts

@@ -32,7 +32,8 @@ export const getSavingsData = async (
   network: NetworkNumber,
   accounts: EthAddress[],
 ) => {
-  const morphoVaultsList = Object.keys(morphoVaults.morphoVaultsOptions.MORPHO_VAULTS) as MorphoVaultType[];
+  const morphoVaultsList = (Object.keys(morphoVaults.morphoVaultsOptions.MORPHO_VAULTS) as MorphoVaultType[])
+    .filter((key) => morphoVaults.morphoVaultsOptions.getMorphoVault(key).network === network);
   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[];
@@ -42,7 +43,7 @@ export const getSavingsData = async (
   const savingsData: SavingsData = {};
 
   await Promise.all([
-    ...(network === NetworkNumber.Eth ? [
+    ...(morphoVaultsList.length ? [
       (async () => {
         try {
           const vaults = morphoVaultsList.map((vaultKey) => morphoVaults.morphoVaultsOptions.getMorphoVault(vaultKey));
@@ -52,6 +53,8 @@ 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, SavingsVaultData,
+  EthAddress, EthereumProvider, NetworkNumber, MorphoVault, MorphoVaultType, MorphoVaultVersion, SavingsVaultData,
 } from '../../types';
 import { getViemProvider } from '../../services/viem';
-import { getMorphoVaultContractViem } from '../../contracts';
+import { getErc4626ContractViem, getMorphoVaultContractViem } from '../../contracts';
 import { MORPHO_API_URL } from '../../constants';
 
 export {
@@ -17,38 +17,49 @@ export {
 // Morpho API caps list page size at 100 items
 const MORPHO_API_PAGE_SIZE = 100;
 
-const vaultsLiquidityQuery = `
+const buildLiquidityQuery = (listField: 'vaults' | 'vaultV2s') => `
   query VaultsLiquidity($addresses: [String!], $chainIds: [Int!]) {
-    vaults(first: ${MORPHO_API_PAGE_SIZE}, where: { address_in: $addresses, chainId_in: $chainIds }) {
+    ${listField}(first: ${MORPHO_API_PAGE_SIZE}, where: { address_in: $addresses, chainId_in: $chainIds }) {
       items {
         address
-        liquidity {
-          underlying
-        }
+        liquidity${listField === 'vaults' ? ' {\n          underlying\n        }' : ''}
       }
     }
 }`;
 
+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 in a single API request (chunked if over the page cap),
+ * Fetches liquidity for all given vaults, one API request per vault version (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 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 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 liquidityByAddress: Record<string, string> = {};
-  await Promise.all(chunks.map(async (chunk) => {
-    const data = await graphqlRequest(MORPHO_API_URL, vaultsLiquidityQuery, {
+  await Promise.all(requests.map(async ({ version, chunk }) => {
+    const { field, query } = liquidityQueries[version];
+    const data = await graphqlRequest(MORPHO_API_URL, query, {
       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 { vaults: { items: { address: string, liquidity: { underlying: string | number | null } | null }[] | null } };
+    }) as Record<string, { items: LiquidityItem[] | null }>;
 
-    (data.vaults.items || []).forEach((item) => {
-      if (item?.liquidity?.underlying !== undefined && item.liquidity?.underlying !== null) {
-        liquidityByAddress[item.address.toLowerCase()] = String(item.liquidity.underlying);
+    (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);
       }
     });
   }));
@@ -63,7 +74,22 @@ const getBatchedViemProvider = (provider: EthereumProvider, network: NetworkNumb
   },
 });
 
-const getMorphoVaultChainData = async (provider: Client, morphoVault: MorphoVault, accounts: EthAddress[]) => {
+// 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 morphoVaultContract = getMorphoVaultContractViem(provider, morphoVault.address);
 
   const shares: Record<EthAddress, bigint> = {};
@@ -84,20 +110,46 @@ const getMorphoVaultChainData = async (provider: Client, morphoVault: MorphoVaul
   };
 };
 
+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: Awaited<ReturnType<typeof getMorphoVaultChainData>>,
+  chainData: MorphoVaultChainData,
   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;
+  } = chainData.v1!;
 
   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)