@defisaver/positions-sdk 2.1.161-portfolio-api-1-dev → 2.1.161-portfolio-api-2-dev

package/src/portfolio/index.ts

@@ -27,8 +27,11 @@ import {
   LlamaLendGlobalMarketData,
   MorphoBlueMarketInfo,
   MorphoMidnightMarketInfo,
+  PortfolioDataOptions,
   PortfolioMarketsData,
   PortfolioPositionsData,
+  PortfolioRewardsData,
+  PortfolioStakingPositionsData,
   SparkMarketsData,
 } from '../types';
 import { _getCompoundV3AccountData, _getCompoundV3MarketsData } from '../compoundV3';
@@ -52,13 +55,18 @@ 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): Promise<{
+export async function getPortfolioData(provider: EthereumProvider, network: NetworkNumber, defaultProvider: EthereumProvider, addresses: EthAddress[], isSim = false, options: PortfolioDataOptions = {}): Promise<{
   positions: PortfolioPositionsData;
-  stakingPositions: any;
-  rewardsData: any;
+  stakingPositions: PortfolioStakingPositionsData;
+  rewardsData: PortfolioRewardsData;
   markets: PortfolioMarketsData;
 }> {
   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));
@@ -112,8 +120,8 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
   };
 
   const positions: PortfolioPositionsData = {};
-  const stakingPositions: any = {};
-  const rewardsData: any = {};
+  const stakingPositions: PortfolioStakingPositionsData = {};
+  const rewardsData: PortfolioRewardsData = {};
   const allAddresses = [...addresses];
 
   for (const address of allAddresses) {
@@ -138,7 +146,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 addresses) {
+  for (const address of stakingAddresses) {
     stakingPositions[address.toLowerCase() as EthAddress] = {
       aaveV3: {},
       morphoBlue: {},
@@ -152,15 +160,21 @@ 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: {},
+      merkl: { error: '', data: null },
       aaveV3: {},
       spark: {},
-      spk: {},
-      king: {},
+      spk: { error: '', data: null },
+      king: { error: '', data: null },
       ethena: {},
+      uniswap: { error: '', data: null },
     };
   }
 
@@ -236,54 +250,54 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
     }),
 
     // === STAKING DATA (independent of market data) ===
-    ...addresses.map(async (address) => {
+    ...stakingAddresses.map(async (address) => {
       try {
         if (!isFluidSupported) return;
-        stakingPositions[address.toLowerCase()].fluid = await _getAllUserEarnPositionsWithFTokens(client, network, address);
+        stakingPositions[address.toLowerCase() as EthAddress].fluid = await _getAllUserEarnPositionsWithFTokens(client, network, address);
       } 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 };
+        stakingPositions[address.toLowerCase() as EthAddress].fluid = { error: `Error fetching Fluid lend data for address ${address}`, data: null };
       }
     }),
-    ...addresses.map(async (address) => {
+    ...stakingAddresses.map(async (address) => {
       try {
         if (!isMainnet) return;
-        stakingPositions[address.toLowerCase()].liquity = await getLiquityStakingData(client, network, address);
+        stakingPositions[address.toLowerCase() as EthAddress].liquity = await getLiquityStakingData(client, network, address);
       } 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 };
+        stakingPositions[address.toLowerCase() as EthAddress].liquity = { error: `Error fetching Liquity staking data for address ${address}`, data: null };
       }
     }),
-    ...addresses.map(async (address) => {
+    ...stakingAddresses.map(async (address) => {
       try {
         if (!isMainnet) return;
-        stakingPositions[address.toLowerCase()].aaveV3 = await getStakeAaveData(client, network, address);
+        stakingPositions[address.toLowerCase() as EthAddress].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 };
+        stakingPositions[address.toLowerCase() as EthAddress].aaveV3 = { error: `Error fetching Aave V3 staking data for address ${address}`, data: null };
       }
     }),
-    ...addresses.map(async (address) => {
+    ...stakingAddresses.map(async (address) => {
       try {
         if (!isMainnet) return;
-        stakingPositions[address.toLowerCase()].umbrella = await getUmbrellaData(client, network, address);
+        stakingPositions[address.toLowerCase() as EthAddress].umbrella = await getUmbrellaData(client, network, address);
       } 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 };
+        stakingPositions[address.toLowerCase() as EthAddress].umbrella = { error: `Error fetching Umbrella staking data for address ${address}`, data: null };
       }
     }),
     // Liquity V2 staking
-    ...liquityV2MarketsStaking.map(market => addresses.map(async (address) => {
+    ...liquityV2MarketsStaking.map(market => stakingAddresses.map(async (address) => {
       try {
         if (!isMainnet) {
-          stakingPositions[address.toLowerCase()].liquityV2[market.value] = { error: '', data: null };
+          stakingPositions[address.toLowerCase() as EthAddress].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 };
+        stakingPositions[address.toLowerCase() as EthAddress].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 };
+        stakingPositions[address.toLowerCase() as EthAddress].liquityV2[market.value] = { error: `Error fetching Liquity V2 staking data for address ${address}`, data: null };
       }
     })).flat(),
 
@@ -292,13 +306,13 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
     (async () => {
       try {
         if (!isMainnet) {
-          for (const address of addresses) {
-            rewardsData[address.toLowerCase()].king = { error: '', data: [] };
+          for (const address of rewardsAddresses) {
+            rewardsData[address.toLowerCase() as EthAddress].king = { error: '', data: [] };
           }
           return;
         }
-        const kingRewards = await getKingRewards(client, network, addresses);
-        for (const address of addresses) {
+        const kingRewards = await getKingRewards(client, network, rewardsAddresses);
+        for (const address of rewardsAddresses) {
           const lowerAddress = address.toLowerCase() as EthAddress;
           rewardsData[lowerAddress].king = {
             error: '',
@@ -307,7 +321,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 addresses) {
+        for (const address of rewardsAddresses) {
           rewardsData[address.toLowerCase() as EthAddress].king = {
             error: 'Error fetching King rewards data in batch',
             data: null,
@@ -319,13 +333,13 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
     (async () => {
       try {
         if (!isMainnet) {
-          for (const address of addresses) {
-            rewardsData[address.toLowerCase()].uniswap = { error: '', data: [] };
+          for (const address of rewardsAddresses) {
+            rewardsData[address.toLowerCase() as EthAddress].uniswap = { error: '', data: [] };
           }
           return;
         }
-        const uniswapRewards = await getUniswapRewards(client, network, addresses);
-        for (const address of addresses) {
+        const uniswapRewards = await getUniswapRewards(client, network, rewardsAddresses);
+        for (const address of rewardsAddresses) {
           const lowerAddress = address.toLowerCase() as EthAddress;
           rewardsData[lowerAddress].uniswap = {
             error: '',
@@ -334,7 +348,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 addresses) {
+        for (const address of rewardsAddresses) {
           rewardsData[address.toLowerCase() as EthAddress].uniswap = {
             error: 'Error fetching Uniswap rewards data in batch',
             data: null,
@@ -342,10 +356,10 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
         }
       }
     })(),
-    ...sparkMarkets.map((market) => addresses.map(async address => {
+    ...sparkMarkets.map((market) => rewardsAddresses.map(async address => {
       try {
         if (!isMainnet) {
-          rewardsData[address.toLowerCase()].spark[market.value] = { error: '', data: [] };
+          rewardsData[address.toLowerCase() as EthAddress].spark[market.value] = { error: '', data: [] };
           return;
         }
         const sparkData = await fetchSparkRewards(client, network, address, market.providerAddress);
@@ -355,7 +369,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(),
-    ...addresses.map(async (address) => {
+    ...rewardsAddresses.map(async (address) => {
       try {
         const merklData = await getMerklUnclaimedRewards(address, network);
         rewardsData[address.toLowerCase() as EthAddress].merkl = { error: '', data: merklData };
@@ -364,27 +378,28 @@ 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 => addresses.map(async (address) => {
+    ...aaveV3Markets.map(market => rewardsAddresses.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 };
+        // 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 };
       }
     })).flat(),
     // Batch Spark Airdrop rewards
     (async () => {
       try {
         if (!isMainnet) {
-          for (const address of addresses) {
-            rewardsData[address.toLowerCase()].spk = { error: '', data: [] };
+          for (const address of rewardsAddresses) {
+            rewardsData[address.toLowerCase() as EthAddress].spk = { error: '', data: [] };
           }
           return;
         }
 
-        const sparkAirdropRewards = await fetchSparkAirdropRewards(client, network, addresses);
-        for (const address of addresses) {
+        const sparkAirdropRewards = await fetchSparkAirdropRewards(client, network, rewardsAddresses);
+        for (const address of rewardsAddresses) {
           const lowerAddress = address.toLowerCase() as EthAddress;
           rewardsData[lowerAddress].spk = {
             error: '',
@@ -393,7 +408,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 addresses) {
+        for (const address of rewardsAddresses) {
           rewardsData[address.toLowerCase() as EthAddress].spk = {
             error: 'Error fetching Spark Airdrop rewards data in batch',
             data: null,
@@ -407,8 +422,8 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
           return;
         }
 
-        const ethenaAirdropRewards = await fetchEthenaAirdropRewards(addresses);
-        for (const address of addresses) {
+        const ethenaAirdropRewards = await fetchEthenaAirdropRewards(rewardsAddresses);
+        for (const address of rewardsAddresses) {
           const lowerAddress = address.toLowerCase() as EthAddress;
           rewardsData[lowerAddress].ethena = {
             error: '',
@@ -417,7 +432,7 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
         }
       } catch (error) {
         console.error('Error fetching Ethena Airdrop rewards data:', error);
-        for (const address of addresses) {
+        for (const address of rewardsAddresses) {
           rewardsData[address.toLowerCase() as EthAddress].ethena = {
             error: 'Error fetching Ethena Airdrop rewards data in batch',
             data: null,
@@ -450,15 +465,16 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
       try {
         const [accDataPromise, earnDataPromise] = await Promise.allSettled([
           _getMorphoBlueAccountData(client, network, address, market, morphoMarketsData[market.value]),
-          getMorphoEarn(client, network, address, market, morphoMarketsData[market.value]),
+          includeStaking ? getMorphoEarn(client, network, address, market, morphoMarketsData[market.value]) : null,
         ]);
         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 };
+          // 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 };
         }
         if (accDataPromise.status !== 'rejected') {
           const accData = accDataPromise.value;
@@ -571,13 +587,13 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
       }
     })).flat(),
     // liquity sBold/yBold and staking options
-    ...addresses.map(async (address) => {
+    ...stakingAddresses.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);
+        const data = await getLiquitySAndYBold(client, network, stakingPositions[address.toLowerCase() as EthAddress].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/types/aave.ts

@@ -219,3 +219,89 @@ export interface AaveHelperCommon {
   selectedMarket: Partial<AaveMarketInfo>,
   network?: NetworkNumber,
 }
+
+export interface SghoUserData {
+  shares: string;
+  balance: string;
+  maxDeposit: string;
+  maxWithdraw: string;
+  underlyingBalance: string;
+}
+
+export interface SghoData {
+  totalAssets: string;
+  totalSupply: string;
+  supplyCap: string;
+  /** Target savings rate as an APY percent (e.g. "4.25" for 4.25%). */
+  targetRate: string;
+  paused: boolean;
+  user: SghoUserData;
+}
+
+/** stkAAVE, stkGHO and sGHO of an address, from getStakeAaveData. */
+export interface StakeAaveData {
+  activatedCooldown: string,
+  activatedCooldownAmount: string,
+  stkAaveRewardsBalance: string,
+  aaveRewardsBalance: string,
+  stkAaveBalance: string,
+  stkGhoBalance: string,
+  ghoMeritApy: string,
+  stkAaveApy: string,
+  sgho: SghoData,
+}
+
+export interface UmbrellaTokenInfo {
+  token: EthAddress,
+  /** USD, converted from the oracle's 8 decimals. */
+  price: string,
+  name: string,
+  symbol: string,
+  decimals: number,
+}
+
+export interface UmbrellaRewardTokenData {
+  rewardTokenData: UmbrellaTokenInfo,
+  maxEmissionPerSecond: bigint,
+  distributionEnd: bigint,
+}
+
+export interface UmbrellaStakingAccountData {
+  stakeUserBalance: string,
+  rewardsTokenUserData: { reward: EthAddress, currentReward: string }[],
+  userCooldownAmount: string,
+  // Passed through unconverted: the view's bigint, or '0' when the view returns none.
+  userEndOfCooldown: bigint | string,
+  userWithdrawalWindow: bigint | string,
+}
+
+/**
+ * One Umbrella stake token of an address, from getUmbrellaData: the view contracts' structs merged, with the amounts
+ * the app reads converted to decimal strings. The bigint fields are the views' raw values, as the SDK passes them.
+ */
+export interface UmbrellaStakingTokenData {
+  stakeTokenData: UmbrellaTokenInfo,
+  totalAssets: string,
+  targetLiquidity: string,
+  isStakeConfigured: boolean,
+  rewardsTokenData: UmbrellaRewardTokenData[],
+  stakeToken: EthAddress,
+  stakeUserBalance: bigint,
+  rewardsTokenUserData: { reward: EthAddress, currentReward: bigint }[],
+  stkToken: EthAddress,
+  totalShares: string,
+  stkUnderlyingToken: EthAddress,
+  aToken: EthAddress,
+  cooldownPeriod: bigint,
+  unstakeWindow: bigint,
+  stkTokenToWaTokenRate: string,
+  waTokenToATokenRate: string,
+  rewardsEmissionRates: string[],
+  userCooldownAmount: bigint,
+  userEndOfCooldown: bigint,
+  userWithdrawalWindow: bigint,
+  account: UmbrellaStakingAccountData,
+}
+
+/** Keyed by Umbrella stake (UmbrellaGHO, UmbrellaUSDC, UmbrellaUSDT, UmbrellaETH). */
+export type UmbrellaStakingData = Record<string, UmbrellaStakingTokenData>;

package/src/types/fluid.ts

@@ -487,3 +487,17 @@ export interface FluidFTokenDataStructOutput {
   rewardsRate: bigint;
   withdrawable: bigint;
 }
+
+/** One Fluid lending (fToken) deposit of an address, from getAllUserEarnPositionsWithFTokens and getFluidDepositData. */
+export interface FluidEarnPositionData {
+  fTokenAddress: string | undefined,
+  fTokenSymbol: string,
+  decimals: string,
+  totalDeposited: string,
+  withdrawable: string,
+  apy: string,
+  depositRate: string,
+  withdrawRate: string,
+  deposited: string,
+  depositedShares: string,
+}

package/src/types/index.ts

@@ -14,4 +14,5 @@ export * from './merit';
 export * from './merkl';
 export * from './savings';
 export * from './common';
-export * from './aaveV4';
+export * from './aaveV4';
+export * from './claiming';

package/src/types/liquity.ts

@@ -29,4 +29,16 @@ export interface LiquityTroveInfo {
   priceForRecovery: string,
   debtInFront: string,
   exposure: string,
-}
+}
+/** LQTY staking and the LUSD stability pool deposit of an address, from getLiquityStakingData. */
+export interface LiquityStakingData {
+  totalLUSDDeposited: string,
+  totalLQTYStaked: string,
+  stakedLQTY: string,
+  stakedLUSDBalance: string,
+  rewardETH: string,
+  rewardLUSD: string,
+  stabilityRewardETH: string,
+  stabilityRewardLQTY: string,
+  showStakingBalances: boolean,
+}

package/src/types/liquityV2.ts

@@ -131,4 +131,29 @@ export interface LiquityV2TroveData {
   debtInFront: string,
   lastInterestRateAdjTime: string,
   exposure: string,
-}
+}
+/** The stability pool deposit of an address in one market, from getLiquityV2Staking. */
+export interface LiquityV2StakingData {
+  totalBOLDDeposited: string,
+  stakedBOLDBalance: string,
+  stabilityRewardColl: string,
+  stabilityRewardYield: string,
+  showStakingBalances: boolean,
+  debtTokenBalance: string,
+  stabilityPoolApy: string,
+}
+
+/** sBOLD, yBOLD and stYBOLD of an address, from getLiquitySAndYBold. */
+export interface LiquityV2SBoldYBoldData {
+  spApy: string,
+  yBoldApy: string,
+  totalBoldDepositedSBold: string,
+  boldRateSBold: string,
+  maxWithdrawSBold: string,
+  totalBoldDepositedYBold: string,
+  boldRateYBold: string,
+  maxWithdrawYBold: string,
+  sBoldBalance: string,
+  yBoldBalance: string,
+  stYBoldBalance: string,
+}

package/src/types/portfolio.ts

@@ -1,18 +1,31 @@
 import {
-  AaveV2MarketData, AaveV2PositionData, AaveV3MarketData, AaveV3PositionData, AaveVersions,
+  AaveV2MarketData, AaveV2PositionData, AaveV3MarketData, AaveV3PositionData, AaveVersions, StakeAaveData, UmbrellaStakingData,
 } from './aave';
 import { AaveV4AccountData, AaveV4SpokeData, AaveV4SpokesType } from './aaveV4';
+import {
+  AaveRewardsClaimableToken,
+  EthenaAirdropClaimableToken,
+  KingRewardsClaimableToken,
+  MerklRewardsClaimableToken,
+  SparkAirdropClaimableToken,
+  SparkRewardsClaimableToken,
+  UniswapAirdropClaimableToken,
+} from './claiming';
 import { EthAddress } from './common';
 import {
   CompoundV2MarketsData, CompoundV2PositionData, CompoundV3MarketsData, CompoundV3PositionData, CompoundVersions,
 } from './compound';
 import { CrvUSDGlobalMarketData, CrvUSDUserData, CrvUSDVersions } from './curveUsd';
-import { FluidVaultData } from './fluid';
-import { LiquityTroveInfo } from './liquity';
-import { LiquityV2MarketData, LiquityV2TroveData, LiquityV2Versions } from './liquityV2';
+import { FluidEarnPositionData, FluidVaultData } from './fluid';
+import { LiquityStakingData, LiquityTroveInfo } from './liquity';
+import {
+  LiquityV2MarketData, LiquityV2SBoldYBoldData, LiquityV2StakingData, LiquityV2TroveData, LiquityV2Versions,
+} from './liquityV2';
 import { LlamaLendGlobalMarketData, LlamaLendUserData, LlamaLendVersionsType } from './llamaLend';
 import { CdpData } from './maker';
-import { MorphoBlueMarketInfo, MorphoBluePositionData, MorphoBlueVersions } from './morphoBlue';
+import {
+  MorphoBlueEarnData, MorphoBlueMarketInfo, MorphoBluePositionData, MorphoBlueVersions,
+} from './morphoBlue';
 import { MorphoMidnightMarketInfo, MorphoMidnightPositionData, MorphoMidnightVersions } from './morphoMidnight';
 import { SparkMarketsData, SparkPositionData, SparkVersions } from './spark';
 
@@ -21,6 +34,20 @@ export interface PortfolioProtocolData<T> {
   data: T | null,
 }
 
+/** A failed fetch of a protocol that, when it succeeds, getPortfolioData returns unwrapped rather than as `{ error, data }`. */
+export interface PortfolioProtocolError {
+  error: string,
+  data: null,
+}
+
+/** What getPortfolioData reads besides positions and markets. Both default to true. */
+export interface PortfolioDataOptions {
+  /** stakingPositions; with false it comes back as {} and no staking source is read. */
+  staking?: boolean,
+  /** rewardsData; with false it comes back as {} and no rewards source is read. */
+  rewards?: boolean,
+}
+
 export interface PortfolioPositionsDataForAddress {
   aaveV3: {
     [key in AaveVersions]?: PortfolioProtocolData<AaveV3PositionData>;
@@ -68,6 +95,60 @@ export interface PortfolioPositionsData {
   [key: EthAddress]: PortfolioPositionsDataForAddress;
 }
 
+/**
+ * The staking positions getPortfolioData returns for an address. The shapes are uneven, and the DeFi Saver app
+ * parses them as they are: a protocol read once per address comes back unwrapped on success, as
+ * `{ error, data: null }` on failure, and as {} (or Fluid's `{ error: '', data: {} }`) on a network it is not read on.
+ */
+export interface PortfolioStakingPositionsDataForAddress {
+  /** stkAAVE, stkGHO and sGHO; mainnet only. */
+  aaveV3: StakeAaveData | PortfolioProtocolError | {};
+  /** Morpho Blue supply without a borrow (Earn), by market; only markets with a deposit or an error. */
+  morphoBlue: {
+    [key in MorphoBlueVersions]?: PortfolioProtocolData<MorphoBlueEarnData>;
+  };
+  // Never filled; kept so the shape does not change under the app.
+  compoundV3: Record<string, never>;
+  spark: Record<string, never>;
+  aaveV2: Record<string, never>;
+  compoundV2: Record<string, never>;
+  /** LQTY staking and the LUSD stability pool; mainnet only. */
+  liquity: LiquityStakingData | PortfolioProtocolError | {};
+  /** Stability pool deposits, by market; mainnet only, legacy markets left out. */
+  liquityV2: {
+    [key in LiquityV2Versions]?: PortfolioProtocolData<LiquityV2StakingData>;
+  };
+  /** Fluid lending (fToken) deposits; `{ error: '', data: {} }` on a network without Fluid. */
+  fluid: FluidEarnPositionData[] | PortfolioProtocolError | { error: string, data: Record<string, never> };
+  /** Umbrella stakes; absent off mainnet. */
+  umbrella?: UmbrellaStakingData | PortfolioProtocolError;
+  /** sBOLD, yBOLD and stYBOLD; data is null off mainnet. */
+  liquityV2SBoldYBold: PortfolioProtocolData<LiquityV2SBoldYBoldData>;
+}
+
+// A Record rather than an interface: the app casts getPortfolioData's result to its own Record<string, …> type, and an
+// interface with an address index signature is not comparable to one.
+export type PortfolioStakingPositionsData = Record<EthAddress, PortfolioStakingPositionsDataForAddress>;
+
+/** The claimable rewards getPortfolioData returns for an address. Off mainnet only Merkl and Aave V3 are read. */
+export interface PortfolioRewardsDataForAddress {
+  merkl: PortfolioProtocolData<MerklRewardsClaimableToken[]>;
+  aaveV3: {
+    [key in AaveVersions]?: PortfolioProtocolData<AaveRewardsClaimableToken[]>;
+  };
+  spark: {
+    [key in SparkVersions]?: PortfolioProtocolData<SparkRewardsClaimableToken[]>;
+  };
+  /** The SPK airdrop. */
+  spk: PortfolioProtocolData<SparkAirdropClaimableToken[]>;
+  king: PortfolioProtocolData<KingRewardsClaimableToken[]>;
+  /** {} off mainnet. */
+  ethena: PortfolioProtocolData<EthenaAirdropClaimableToken[]> | {};
+  uniswap: PortfolioProtocolData<UniswapAirdropClaimableToken[]>;
+}
+
+export type PortfolioRewardsData = Record<EthAddress, PortfolioRewardsDataForAddress>;
+
 /** The `markets` getPortfolioData returns: every market it read, by protocol, keyed by market or spoke. */
 export interface PortfolioMarketsData {
   morphoMarketsData: Record<string, MorphoBlueMarketInfo>;

package/src/umbrella/index.ts

@@ -1,13 +1,14 @@
 import { Client } from 'viem';
 import { AaveUmbrellaViewViem, AaveV3ViewContractViem } from '../contracts';
 import { EthAddress, NetworkNumber } from '../types/common';
+import { UmbrellaStakingData } from '../types/aave';
 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) => {
+export const getUmbrellaData = async (provider: Client, network: NetworkNumber, address: EthAddress): Promise<UmbrellaStakingData> => {
   const umbrellaView = AaveUmbrellaViewViem(provider, network);
   const aaveV3View = AaveV3ViewContractViem(provider, network);
   const [tokensAggregatedData, additionalUmbrellaStakingData, userAggregatedData] = await Promise.all([