@defisaver/positions-sdk 2.0.13 → 2.0.14-dev-portfolio1

package/src/portfolio/index.ts

@@ -2,9 +2,15 @@ import Dec from 'decimal.js';
 import { EthAddress, EthereumProvider, NetworkNumber } from '../types/common';
 import {
   AaveMarkets,
-  CompoundMarkets, CrvUsdMarkets, EulerV2Markets, LlamaLendMarkets, MorphoBlueMarkets, SparkMarkets,
+  CompoundMarkets,
+  CrvUsdMarkets,
+  EulerV2Markets,
+  LiquityV2Markets,
+  LlamaLendMarkets,
+  MorphoBlueMarkets,
+  SparkMarkets,
 } from '../markets';
-import { _getMorphoBlueAccountData, _getMorphoBlueMarketData } from '../morphoBlue';
+import { _getMorphoBlueAccountData, _getMorphoBlueMarketData, getMorphoEarn } from '../morphoBlue';
 import {
   AaveV2MarketData,
   AaveV3MarketData,
@@ -15,6 +21,7 @@ import {
   CompoundVersions,
   CrvUSDGlobalMarketData,
   EulerV2FullMarketData,
+  LiquityV2MarketData,
   LlamaLendGlobalMarketData,
   MorphoBlueMarketInfo,
   PortfolioPositionsData,
@@ -25,18 +32,29 @@ import { _getSparkAccountData, _getSparkMarketsData } from '../spark';
 import { _getEulerV2AccountData, _getEulerV2MarketsData } from '../eulerV2';
 import { _getCurveUsdGlobalData, _getCurveUsdUserData } from '../curveUsd';
 import { _getLlamaLendGlobalData, _getLlamaLendUserData } from '../llamaLend';
-import { _getAaveV3AccountData, _getAaveV3MarketData } from '../aaveV3';
+import { _getAaveV3AccountData, _getAaveV3MarketData, getStakeAaveData } from '../aaveV3';
 import { ZERO_ADDRESS } from '../constants';
 import { _getMakerCdpData, _getUserCdps } from '../maker';
 import { _getAaveV2AccountData, _getAaveV2MarketsData } from '../aaveV2';
 import { _getCompoundV2AccountData, _getCompoundV2MarketsData } from '../compoundV2';
 import { getViemProvider } from '../services/viem';
-import { _getLiquityTroveInfo } from '../liquity';
-import { _getLiquityV2MarketData, _getLiquityV2TroveData, _getLiquityV2UserTroveIds } from '../liquityV2';
-import { _getUserPositionsPortfolio } from '../fluid';
+import { _getLiquityTroveInfo, getLiquityStakingData } from '../liquity';
+import { getLiquityV2Staking, _getLiquityV2MarketData, getLiquitySAndYBold } from '../liquityV2';
+import { _getAllUserEarnPositionsWithFTokens, _getUserPositionsPortfolio } from '../fluid';
 import { getEulerV2SubAccounts } from '../helpers/eulerHelpers';
+import { getUmbrellaData } from '../umbrella';
+import { getMeritUnclaimedRewards, getUnclaimedRewardsForAllMarkets } from '../claiming/aaveV3';
+import { getCompoundV3Rewards } from '../claiming/compV3';
+import { fetchSparkAirdropRewards, fetchSparkRewards } from '../claiming/spark';
+import { fetchMorphoBlueRewards } from '../claiming/morphoBlue';
+import { getKingRewards } from '../claiming/king';
 
-export async function getPortfolioData(provider: EthereumProvider, network: NetworkNumber, defaultProvider: EthereumProvider, addresses: EthAddress[], summerFiAddresses: EthAddress[]): Promise<PortfolioPositionsData> {
+export async function getPortfolioData(provider: EthereumProvider, network: NetworkNumber, defaultProvider: EthereumProvider, addresses: EthAddress[], summerFiAddresses: EthAddress[]): Promise<{
+  positions: PortfolioPositionsData;
+  stakingPositions: any;
+  rewardsData: any;
+  markets: any;
+}> {
   const isMainnet = network === NetworkNumber.Eth;
   const isFluidSupported = [NetworkNumber.Eth, NetworkNumber.Arb, NetworkNumber.Base].includes(network);
 
@@ -49,6 +67,8 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
   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 liquityV2MarketsStaking = [NetworkNumber.Eth].includes(network) ? Object.values(LiquityV2Markets(network)).filter(market => !market.isLegacy) : [];
 
   const client = getViemProvider(provider, network, {
     batch: {
@@ -75,9 +95,26 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
   const compoundV2MarketsData: Record<string, CompoundV2MarketsData> = {};
   const crvUsdMarketsData: Record<string, CrvUSDGlobalMarketData> = {};
   const llamaLendMarketsData: Record<string, LlamaLendGlobalMarketData> = {};
+  const liquityV2MarketsData: Record<string, LiquityV2MarketData> = {};
+
+  const markets = {
+    morphoMarketsData,
+    compoundV3MarketsData,
+    sparkMarketsData,
+    eulerV2MarketsData,
+    aaveV3MarketsData,
+    aaveV2MarketsData,
+    compoundV2MarketsData,
+    crvUsdMarketsData,
+    llamaLendMarketsData,
+    liquityV2MarketsData,
+  };
 
   const positions: PortfolioPositionsData = {};
+  const stakingPositions: any = {};
+  const rewardsData: any = {};
   const allAddresses = [...addresses, ...summerFiAddresses];
+
   for (const address of allAddresses) {
     positions[address.toLowerCase() as EthAddress] = {
       aaveV3: {},
@@ -98,7 +135,36 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
     };
   }
 
+  // TODO: check default values, probably needed when fetching portfolio on unsupported networks
+  for (const address of addresses) {
+    stakingPositions[address.toLowerCase() as EthAddress] = {
+      aaveV3: {},
+      morphoBlue: {},
+      compoundV3: {},
+      spark: {},
+      aaveV2: {},
+      compoundV2: {},
+      liquity: {},
+      liquityV2: {},
+      fluid: {
+        error: '',
+        data: {},
+      },
+    };
+
+    rewardsData[address.toLowerCase() as EthAddress] = {
+      aaveV3merit: {},
+      aaveV3: {},
+      compV3: {},
+      spark: {},
+      spk: {},
+      king: {},
+      morpho: {},
+    };
+  }
+
   await Promise.allSettled([
+    // === MARKET DATA (needs to be fetched first) ===
     ...morphoMarkets.map(async (market) => {
       const marketData = await _getMorphoBlueMarketData(client, network, market);
       morphoMarketsData[market.value] = marketData;
@@ -119,11 +185,6 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
       const marketData = await _getAaveV3MarketData(client, network, market);
       aaveV3MarketsData[market.value] = marketData;
     }),
-    ...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;
-    }),
     ...aaveV2Markets.map(async (market) => {
       const marketData = await _getAaveV2MarketsData(client, network, market);
       aaveV2MarketsData[market.value] = marketData;
@@ -140,6 +201,17 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
       const marketData = await _getLlamaLendGlobalData(client, network, market);
       llamaLendMarketsData[market.value] = marketData;
     }),
+    ...liquityV2Markets.map(async (market) => {
+      const marketData = await _getLiquityV2MarketData(client, network, market);
+      liquityV2MarketsData[market.value] = marketData;
+    }),
+
+    // === 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
@@ -157,6 +229,180 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
         };
       }
     }),
+
+    // === STAKING DATA (independent of market data) ===
+    ...addresses.map(async (address) => {
+      try {
+        if (!isFluidSupported) return;
+        const fluidLendData = await _getAllUserEarnPositionsWithFTokens(client, network, address);
+        stakingPositions[address.toLowerCase()].fluid = fluidLendData;
+      } catch (error) {
+        console.error(`Error fetching Fluid lend data for address ${address}:`, error);
+        stakingPositions[address.toLowerCase()].fluid = { error: `Error fetching Fluid lend data for address ${address}`, data: null };
+      }
+    }),
+    ...addresses.map(async (address) => {
+      try {
+        if (!isMainnet) return;
+        const liquityStakingData = await getLiquityStakingData(client, network, address);
+        stakingPositions[address.toLowerCase()].liquity = liquityStakingData;
+      } catch (error) {
+        console.error(`Error fetching Liquity staking data for address ${address}:`, error);
+        stakingPositions[address.toLowerCase()].liquity = { error: `Error fetching Liquity staking data for address ${address}`, data: null };
+      }
+    }),
+    ...addresses.map(async (address) => {
+      try {
+        if (!isMainnet) return;
+        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()].aaveV3 = { error: `Error fetching Aave V3 staking data for address ${address}`, data: null };
+      }
+    }),
+    ...addresses.map(async (address) => {
+      try {
+        if (!isMainnet) return;
+        const umbrellaStakingData = await getUmbrellaData(client, network, address);
+        stakingPositions[address.toLowerCase()].umbrella = umbrellaStakingData;
+      } catch (error) {
+        console.error(`Error fetching Umbrella staking data for address ${address}:`, error);
+        stakingPositions[address.toLowerCase()].umbrella = { error: `Error fetching Umbrella staking data for address ${address}`, data: null };
+      }
+    }),
+    // Liquity V2 staking
+    ...liquityV2MarketsStaking.map(market => addresses.map(async (address) => {
+      try {
+        if (!isMainnet) {
+          stakingPositions[address.toLowerCase()].liquityV2[market.value] = { error: '', data: null };
+          return;
+        }
+        const liquityV2StakingData = await getLiquityV2Staking(client, network, market.value, address);
+        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()].liquityV2[market.value] = { error: `Error fetching Liquity V2 staking data for address ${address}`, data: null };
+      }
+    })).flat(),
+
+    // === REWARDS DATA (independent of market data) ===
+    // Batch King rewards
+    (async () => {
+      try {
+        if (!isMainnet) {
+          for (const address of addresses) {
+            rewardsData[address.toLowerCase()].king = { error: '', data: [] };
+          }
+          return;
+        }
+        const kingRewards = await getKingRewards(client, network, addresses);
+        for (const address of addresses) {
+          const lowerAddress = address.toLowerCase() as EthAddress;
+          rewardsData[lowerAddress].king = {
+            error: '',
+            data: kingRewards[lowerAddress] || [],
+          };
+        }
+      } catch (error) {
+        console.error('Error fetching King rewards data in batch:', error);
+        for (const address of addresses) {
+          rewardsData[address.toLowerCase() as EthAddress].king = {
+            error: 'Error fetching King rewards data in batch',
+            data: null,
+          };
+        }
+      }
+    })(),
+    ...sparkMarkets.map((market) => addresses.map(async address => {
+      try {
+        if (!isMainnet) {
+          rewardsData[address.toLowerCase()].spark[market.value] = { error: '', data: [] };
+          return;
+        }
+        const sparkData = await fetchSparkRewards(client, network, address, market.providerAddress);
+        rewardsData[address.toLowerCase() as EthAddress].spark[market.value] = { error: '', data: sparkData };
+      } catch (error) {
+        console.error(`Error fetching Spark rewards data for address ${address}, market ${market.value}:`, error);
+        rewardsData[address.toLowerCase() as EthAddress].spark[market.value] = { error: `Error fetching Spark rewards data for address ${address}`, data: null };
+      }
+    })).flat(),
+    // CompV3 rewards
+    ...compoundV3Markets.map(market => addresses.map(async (address) => {
+      try {
+        const compV3Rewards = await getCompoundV3Rewards(client, network, address, market.baseMarketAddress);
+        rewardsData[address.toLowerCase() as EthAddress].compV3[market.value] = { error: '', data: compV3Rewards };
+      } catch (error) {
+        console.error(`Error fetching Compound V3 rewards data for address ${address}:`, error);
+        rewardsData[address.toLowerCase() as EthAddress].compV3[market.value] = { error: `Error fetching Compound V3 rewards data for address ${address}`, data: null };
+      }
+    })).flat(),
+    ...addresses.map(async (address) => {
+      try {
+        const aaveMeritData = await getMeritUnclaimedRewards(address, network);
+        rewardsData[address.toLowerCase() as EthAddress].aaveV3merit = { error: '', data: aaveMeritData };
+      } catch (error) {
+        console.error(`Error fetching Aave V3 Merit rewards data for address ${address}:`, error);
+        rewardsData[address.toLowerCase() as EthAddress].aaveV3merit = { error: `Error fetching Aave V3 Merit rewards data for address ${address}`, data: null };
+      }
+    }),
+    ...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);
+        rewardsData[address.toLowerCase() as EthAddress].aaveV3 = { error: `Error fetching Aave V3 rewards data for address ${address}`, data: null };
+      }
+    })).flat(),
+    // Batch Morpho Blue rewards
+    (async () => {
+      try {
+        const morphoRewards = await fetchMorphoBlueRewards(client, network, addresses);
+        for (const address of addresses) {
+          const lowerAddress = address.toLowerCase() as EthAddress;
+          rewardsData[lowerAddress].morpho = {
+            error: '',
+            data: morphoRewards[lowerAddress] || [],
+          };
+        }
+      } catch (error) {
+        console.error('Error fetching Morpho Blue rewards data in batch:', error);
+        for (const address of addresses) {
+          rewardsData[address.toLowerCase() as EthAddress].morpho = {
+            error: 'Error fetching Morpho Blue rewards data in batch',
+            data: null,
+          };
+        }
+      }
+    })(),
+    // Batch Spark Airdrop rewards
+    (async () => {
+      try {
+        if (!isMainnet) {
+          for (const address of addresses) {
+            rewardsData[address.toLowerCase()].king = { error: '', data: [] };
+          }
+          return;
+        }
+
+        const sparkAirdropRewards = await fetchSparkAirdropRewards(client, network, addresses);
+        for (const address of addresses) {
+          const lowerAddress = address.toLowerCase() as EthAddress;
+          rewardsData[lowerAddress].spk = {
+            error: '',
+            data: sparkAirdropRewards[lowerAddress] || [],
+          };
+        }
+      } catch (error) {
+        console.error('Error fetching Spark Airdrop rewards data in batch:', error);
+        for (const address of addresses) {
+          rewardsData[address.toLowerCase() as EthAddress].spk = {
+            error: 'Error fetching Spark Airdrop rewards data in batch',
+            data: null,
+          };
+        }
+      }
+    })(),
   ]);
 
 
@@ -172,8 +418,31 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
     })).flat(),
     ...morphoMarkets.map((market) => addresses.map(async (address) => {
       try {
-        const accData = await _getMorphoBlueAccountData(client, network, address, market, morphoMarketsData[market.value]);
-        if (new Dec(accData.suppliedUsd).gt(0)) positions[address.toLowerCase() as EthAddress].morphoBlue[market.value] = { error: '', data: accData };
+        const [accDataPromise, earnDataPromise] = await Promise.allSettled([
+          _getMorphoBlueAccountData(client, network, address, market, morphoMarketsData[market.value]),
+          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') {
+          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;
+          if (new Dec(accData.suppliedUsd).gt(0)) positions[address.toLowerCase() as EthAddress].morphoBlue[market.value] = { error: '', data: accData };
+        }
+        if (earnDataPromise.status !== 'rejected') {
+          const earnData = earnDataPromise.value;
+          if (earnData && new Dec(earnData.amount).gt(0)) {
+            stakingPositions[address.toLowerCase() as EthAddress].morphoBlue[market.value] = {
+              error: '',
+              data: earnData,
+            };
+          }
+        }
       } 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 };
@@ -279,7 +548,25 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
         positions[address.toLowerCase() as EthAddress].llamaLend[market.value] = { error: `Error fetching LlamaLend account data for address ${address} on market ${market.value}`, data: null };
       }
     })).flat(),
+    // liquity sBold/yBold and staking options
+    ...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()].liquityV2, address);
+        stakingPositions[address.toLowerCase() as EthAddress].liquityV2SBoldYBold = { error: '', data };
+      } catch (error) {
+        console.error(`Error fetching SBold/YBold data for address ${address}:`, error);
+      }
+    }),
   ]);
 
-  return positions;
+  return {
+    positions,
+    stakingPositions,
+    rewardsData,
+    markets,
+  };
 }

package/src/services/utils.ts

@@ -61,4 +61,40 @@ export const isMaxuint = (amount: string) => compareAddresses(MAXUINT, amount);
 
 export const isMainnetNetwork = (network: NetworkNumber) => network === NetworkNumber.Eth;
 
-export const DEFAULT_TIMEOUT = 2000; // 2 seconds
+export const DEFAULT_TIMEOUT = 2000; // 2 seconds
+
+/**
+ * Converts web3 hybrid response (that can be used as objects and arrays, so has duplicated values) to objects.
+ * @param value
+ */
+export const convertHybridArraysToObjects = (value: any): any => {
+  if (Array.isArray(value)) {
+    const keys = Object.keys(value);
+    const hasNamedKeys = keys.some((key) => Number.isNaN(Number(key)));
+
+    // If array has named keys, treat it as an object and keep only those
+    if (hasNamedKeys) {
+      const result: Record<string, any> = {};
+      for (const [key, val] of Object.entries(value)) {
+        if (Number.isNaN(Number(key))) {
+          result[key] = convertHybridArraysToObjects(val);
+        }
+      }
+      return result;
+    }
+
+    // Else, treat as a regular array
+    return value.map(convertHybridArraysToObjects);
+  }
+
+  // If it's an object (but not an array), recurse into its values
+  if (value && typeof value === 'object') {
+    const result: Record<string, any> = {};
+    for (const [key, val] of Object.entries(value)) {
+      result[key] = convertHybridArraysToObjects(val);
+    }
+    return result;
+  }
+
+  return value;
+};

package/src/spark/index.ts

@@ -286,7 +286,8 @@ export const _getSparkAccountBalances = async (provider: Client, network: Networ
   // @ts-ignore
   const protocolDataProviderContract = createViemContractFromConfigFunc(market.protocolData, market.protocolDataAddress)(provider, network);
 
-  const reserveTokens = await protocolDataProviderContract.read.getAllReservesTokens(setViemBlockNumber(block));
+  // @ts-ignore
+  const reserveTokens = await protocolDataProviderContract.read.getAllReservesTokens(setViemBlockNumber(block)) as { symbol: string, tokenAddress: EthAddress }[];
   const symbols = reserveTokens.map(({ symbol }: { symbol: string }) => symbol);
   const _addresses = reserveTokens.map(({ tokenAddress }: { tokenAddress: EthAddress }) => tokenAddress);
 

package/src/staking/staking.ts

@@ -54,7 +54,7 @@ const getApyFromDfsApi = async (asset: string) => {
   }
 };
 
-export const STAKING_ASSETS = ['cbETH', 'wstETH', 'cbETH', 'rETH', 'sDAI', 'weETH', 'sUSDe', 'osETH', 'ezETH', 'ETHx', 'rsETH', 'pufETH', 'wrsETH', 'wsuperOETHb', 'sUSDS', 'tETH', 'PT sUSDe Sep', 'PT USDe Sep', 'PT sUSDe Nov'];
+export const STAKING_ASSETS = ['cbETH', 'wstETH', 'cbETH', 'rETH', 'sDAI', 'weETH', 'sUSDe', 'osETH', 'ezETH', 'ETHx', 'rsETH', 'pufETH', 'wrsETH', 'wsuperOETHb', 'sUSDS', 'tETH', 'PT sUSDe Sep', 'PT USDe Sep', 'PT sUSDe Nov', 'PT USDe Nov'];
 
 export const getStakingApy = memoize(async (asset: string) => {
   try {
@@ -80,6 +80,7 @@ export const getStakingApy = memoize(async (asset: string) => {
     if (asset === 'tETH') return await getApyFromDfsApi('tETH');
     if (asset === 'USDe') return await getApyFromDfsApi('USDe');
     if (asset === 'PT sUSDe Nov') return await getApyFromDfsApi('PT sUSDe Nov');
+    if (asset === 'PT USDe Nov') return await getApyFromDfsApi('PT USDe Nov');
   } catch (e) {
     console.error(`Failed to fetch APY for ${asset}`);
   }

package/src/types/claiming.ts

@@ -0,0 +1,109 @@
+import { EthAddress } from './common';
+
+export enum ClaimType {
+  /** Rewards from AAVE - various tokens & aTokens (supplied to protocol) */
+  AAVE_REWARDS = 'AAVE_REWARDS',
+  /** Merit rewards from AAVE (various tokens) */
+  AAVE_MERIT_REWARDS = 'AAVE_MERIT_REWARDS',
+  /** Rewards from Compound V3 (only in COMP) */
+  COMPOUND_V3_COMP = 'COMPOUND_V3_COMP',
+  /** Rewards from Spark (wstETH only for now) */
+  SPARK_REWARDS = 'SPARK_REWARDS',
+  /** Rewards from Morpho */
+  MORPHO = 'MORPHO',
+  /** Rewards from King (prev LTR^2 - received for weETH holding) */
+  KING_REWARDS = 'KING_REWARDS',
+  /** Spark Airdrop */
+  SPARK_AIRDROP = 'SPARK_AIRDROP',
+  /** Spark Airdrop */
+  SPARK_WST_ETH_REWARDS = 'SPARK_WST_ETH_REWARDS', // TODO: This will be removed once we fully refactor spark rewards
+}
+
+type _ClaimableTokenPartial = {
+  symbol: string;
+  underlyingSymbol: string;
+  tokenAddress: EthAddress;
+  amount: string;
+  walletAddress: EthAddress;
+  label: string;
+};
+export type AaveRewardsClaimableToken = _ClaimableTokenPartial & {
+  claimType: ClaimType.AAVE_REWARDS;
+  additionalClaimFields: {
+    marketAddress: EthAddress;
+    aTokenAddresses: string[];
+    isAaveToken: boolean;
+  };
+};
+export type AaveMeritRewardsClaimableToken = _ClaimableTokenPartial & {
+  claimType: ClaimType.AAVE_MERIT_REWARDS;
+  additionalClaimFields: {
+    accumulated: string;
+    proof: string[];
+    decimals: string;
+    unclaimed: string;
+  };
+};
+
+export type SparkRewardsClaimableToken = _ClaimableTokenPartial & {
+  claimType: ClaimType.SPARK_REWARDS;
+  additionalClaimFields: {
+    sparkAssetAddresses: string[];
+  };
+};
+
+export type KingRewardsClaimableToken = _ClaimableTokenPartial & {
+  claimType: ClaimType.KING_REWARDS;
+  additionalClaimFields: {
+    allRewardsAmount: string;
+    merkleRoot: string;
+    merkleProofs: string[];
+  };
+};
+
+export type MorphoClaimableToken = _ClaimableTokenPartial & {
+  claimType: ClaimType.MORPHO,
+  additionalClaimFields: {
+    originalAmount: string,
+    merkleProofs: string[];
+    distributor: EthAddress;
+    isLegacy: boolean;
+    txData: string;
+  }
+};
+
+
+export type CompoundV3CompClaimableToken = _ClaimableTokenPartial & {
+  claimType: ClaimType.COMPOUND_V3_COMP,
+  additionalClaimFields: {
+    marketAddress: EthAddress;
+  }
+};
+
+export enum SparkAirdropType {
+  SPARK_IGNITION = 'spark-ignition',
+  PRE_FARMING_AND_SOCIAL = 'pre-farming-and-social',
+}
+
+export type SparkAirdropClaimableToken = _ClaimableTokenPartial & {
+  claimType: ClaimType.SPARK_AIRDROP,
+  additionalClaimFields: {
+    merkleRoot: string;
+    merkleProofs: string[];
+    epoch: number;
+    rewardType: SparkAirdropType;
+    allRewardsAmount: string;
+  };
+};
+
+export type SparkWstEthRewardsClaimableToken = _ClaimableTokenPartial & { claimType: ClaimType.SPARK_WST_ETH_REWARDS };
+
+export type ClaimableToken =
+    AaveRewardsClaimableToken
+    | AaveMeritRewardsClaimableToken
+    | CompoundV3CompClaimableToken
+    | MorphoClaimableToken
+    | SparkRewardsClaimableToken
+    | KingRewardsClaimableToken
+    | SparkAirdropClaimableToken
+    | SparkWstEthRewardsClaimableToken;

package/src/umbrella/index.ts

@@ -0,0 +1,70 @@
+import { Client } from 'viem';
+import { AaveUmbrellaViewViem, AaveV3ViewContractViem } from '../contracts';
+import { EthAddress, NetworkNumber } from '../types/common';
+import { compareAddresses, convertHybridArraysToObjects, getEthAmountForDecimals } from '../services/utils';
+import { findMatching, tokenEntries } from './umbrellaUtils';
+
+const umbrella = '0xD400fc38ED4732893174325693a63C30ee3881a8';
+const aaveOracle = '0x54586bE62E3c3580375aE3723C145253060Ca0C2';
+
+export const getUmbrellaData = async (provider: Client, network: NetworkNumber, address: EthAddress) => {
+  const umbrellaView = AaveUmbrellaViewViem(provider, network);
+  const aaveV3View = AaveV3ViewContractViem(provider, network);
+  const [tokensAggregatedData, additionalUmbrellaStakingData, userAggregatedData] = await Promise.all([
+    umbrellaView.read.getTokensAggregatedData([umbrella, aaveOracle]),
+    aaveV3View.read.getAdditionalUmbrellaStakingData([umbrella, address]),
+    umbrellaView.read.getUserAggregatedData([umbrella, address]),
+  ]);
+
+  return Object.fromEntries(
+    tokenEntries.map(([symbol, tokenAddr]) => {
+      // @ts-ignore
+      const fromTokens = convertHybridArraysToObjects(findMatching(tokensAggregatedData, tokenAddr));
+      // @ts-ignore
+      const fromUser = convertHybridArraysToObjects(findMatching(userAggregatedData, tokenAddr));
+      // @ts-ignore
+      const fromAdditionalData = convertHybridArraysToObjects(findMatching(additionalUmbrellaStakingData, tokenAddr));
+      const data = {
+        ...fromTokens,
+        ...fromUser,
+        ...fromAdditionalData,
+        account: {
+          stakeUserBalance: fromUser?.stakeUserBalance || '0',
+          rewardsTokenUserData: convertHybridArraysToObjects(fromUser?.rewardsTokenUserData) || [],
+          userCooldownAmount: fromAdditionalData?.userCooldownAmount || '0',
+          userEndOfCooldown: fromAdditionalData?.userEndOfCooldown || '0',
+          userWithdrawalWindow: fromAdditionalData?.userWithdrawalWindow || '0',
+        },
+      };
+
+      const stakeTokenData = data.stakeTokenData;
+
+      return [symbol, {
+        ...data,
+        stakeTokenData: { ...stakeTokenData, price: getEthAmountForDecimals(stakeTokenData.price, 8) },
+        stkTokenToWaTokenRate: getEthAmountForDecimals(data.stkTokenToWaTokenRate, stakeTokenData.decimals),
+        waTokenToATokenRate: getEthAmountForDecimals(data.waTokenToATokenRate, stakeTokenData.decimals),
+        totalShares: getEthAmountForDecimals(data.totalShares, stakeTokenData.decimals),
+        totalAssets: getEthAmountForDecimals(data.totalAssets, stakeTokenData.decimals),
+        targetLiquidity: getEthAmountForDecimals(data.targetLiquidity, stakeTokenData.decimals),
+        rewardsTokenData: data.rewardsTokenData.map((tokenData: { rewardTokenData: { price: string | number; }; }) => ({ ...tokenData, rewardTokenData: { ...tokenData.rewardTokenData, price: getEthAmountForDecimals(tokenData.rewardTokenData.price, 8) } })),
+        rewardsEmissionRates: data.rewardsEmissionRates.map((rate: string, i: number) => {
+          const tokenData = data.rewardsTokenData[i].rewardTokenData;
+          return getEthAmountForDecimals(rate, tokenData.decimals);
+        }),
+        account: {
+          ...data.account,
+          stakeUserBalance: getEthAmountForDecimals(data.account.stakeUserBalance, stakeTokenData.decimals),
+          userCooldownAmount: getEthAmountForDecimals(data.account.userCooldownAmount, stakeTokenData.decimals),
+          rewardsTokenUserData: data.account.rewardsTokenUserData.map((reward: any) => {
+            const tokenData = data.rewardsTokenData.find((tknData: { rewardTokenData: { token: string | undefined; }; }) => compareAddresses(tknData.rewardTokenData.token, reward.reward));
+            return ({
+              ...reward,
+              currentReward: getEthAmountForDecimals(reward.currentReward, tokenData.rewardTokenData.decimals),
+            });
+          }),
+        },
+      }];
+    }),
+  );
+};