@defisaver/positions-sdk 2.0.15-dev.0 → 2.1.1-dev.0

package/src/eulerV2/index.ts

@@ -1,7 +1,9 @@
 import Dec from 'decimal.js';
 import { assetAmountInEth, getAssetInfoByAddress } from '@defisaver/tokens';
 import { Client } from 'viem';
-import { EthAddress, EthereumProvider, NetworkNumber } from '../types/common';
+import {
+  EthAddress, EthereumProvider, IncentiveKind, NetworkNumber,
+} from '../types/common';
 import { getStakingApy, STAKING_ASSETS } from '../staking';
 import {
   compareAddresses, getEthAmountForDecimals, isMaxuint, wethToEth, wethToEthByAddress,
@@ -87,12 +89,18 @@ export const _getEulerV2MarketsData = async (provider: Client, network: NetworkN
       supplyRate,
       utilization: new Dec(utilizationRate).mul(100).toString(),
       governorAdmin: collateral.governorAdmin,
+      supplyIncentives: [],
+      borrowIncentives: [],
     });
   });
   for (const coll of colls) {
     if (STAKING_ASSETS.includes(coll.symbol)) {
-      coll.incentiveSupplyApy = await getStakingApy(coll.symbol);
-      coll.incentiveSupplyToken = coll.symbol;
+      coll.supplyIncentives.push({
+        apy: await getStakingApy(coll.symbol),
+        token: coll.symbol,
+        incentiveKind: IncentiveKind.Staking,
+        description: `Native ${coll.symbol} yield.`,
+      });
     }
   }
   const isEscrow = data.collaterals.length === 0;
@@ -134,6 +142,8 @@ export const _getEulerV2MarketsData = async (provider: Client, network: NetworkN
     governorAdmin: data.governorAdmin,
     vaultType,
     name: data.name,
+    supplyIncentives: [],
+    borrowIncentives: [],
   };
 
   const assetsData: EulerV2AssetsData = {

package/src/fluid/index.ts

@@ -4,7 +4,9 @@ import {
   AssetData, getAssetInfo, getAssetInfoByAddress,
 } from '@defisaver/tokens';
 import { Client, PublicClient } from 'viem';
-import { EthAddress, EthereumProvider, NetworkNumber } from '../types/common';
+import {
+  EthAddress, EthereumProvider, IncentiveKind, NetworkNumber,
+} from '../types/common';
 import {
   FluidAggregatedVaultData,
   FluidAssetData, FluidAssetsData,
@@ -298,15 +300,19 @@ const parseT1MarketData = async (provider: PublicClient, data: FluidVaultDataStr
     canBeBorrowed: false,
     supplyRate,
     borrowRate: '0',
+    supplyIncentives: [],
+    borrowIncentives: [],
   };
 
   if (STAKING_ASSETS.includes(collAsset.symbol)) {
-    collAssetData.incentiveSupplyApy = await getStakingApy(collAsset.symbol);
-    collAssetData.incentiveSupplyToken = collAsset.symbol;
+    collAssetData.supplyIncentives.push({
+      apy: await getStakingApy(collAsset.symbol),
+      token: collAssetData.symbol,
+      incentiveKind: IncentiveKind.Staking,
+      description: `Native ${collAssetData.symbol} yield.`,
+    });
   }
 
-  const incentiveSupplyRate = collAssetData.incentiveSupplyApy;
-
   const debtAssetData: FluidAssetData = {
     symbol: debtAsset.symbol,
     address: debtAsset.address,
@@ -317,14 +323,18 @@ const parseT1MarketData = async (provider: PublicClient, data: FluidVaultDataStr
     canBeBorrowed: true,
     supplyRate: '0',
     borrowRate,
+    supplyIncentives: [],
+    borrowIncentives: [],
   };
   if (STAKING_ASSETS.includes(debtAssetData.symbol)) {
-    debtAssetData.incentiveBorrowApy = await getStakingApy(debtAsset.symbol);
-    debtAssetData.incentiveBorrowToken = debtAsset.symbol;
+    debtAssetData.borrowIncentives.push({
+      apy: new Dec(await getStakingApy(debtAsset.symbol)).mul(-1).toString(),
+      token: debtAssetData.symbol,
+      incentiveKind: IncentiveKind.Reward,
+      description: `Due to the native yield of ${debtAssetData.symbol}, the value of the debt would increase over time.`,
+    });
   }
 
-  const incentiveBorrowRate = debtAssetData.incentiveBorrowApy;
-
   const assetsData = {
     [collAsset.symbol]: collAssetData,
     [debtAsset.symbol]: debtAssetData,
@@ -370,9 +380,9 @@ const parseT1MarketData = async (provider: PublicClient, data: FluidVaultDataStr
     liquidationMaxLimit,
     borrowRate,
     supplyRate,
-    incentiveSupplyRate,
-    incentiveBorrowRate,
     oraclePrice,
+    incentiveSupplyRate: collAssetData.supplyIncentives[0]?.apy || '0',
+    incentiveBorrowRate: debtAssetData.borrowIncentives[0]?.apy || '0',
   };
 
   return {
@@ -430,10 +440,16 @@ const parseT2MarketData = async (provider: PublicClient, data: FluidVaultDataStr
     withdrawable: withdrawable0,
     tokenPerSupplyShare: token0PerSupplyShare,
     supplyReserves: reservesSupplyToken0,
+    supplyIncentives: [],
+    borrowIncentives: [],
   };
   if (STAKING_ASSETS.includes(collFirstAssetData.symbol!)) {
-    collFirstAssetData.incentiveSupplyApy = await getStakingApy(collAsset0.symbol);
-    collFirstAssetData.incentiveSupplyToken = collAsset0.symbol;
+    collFirstAssetData.supplyIncentives!.push({
+      apy: await getStakingApy(collAsset0.symbol),
+      token: collAsset0.symbol,
+      incentiveKind: IncentiveKind.Staking,
+      description: `Native ${collAsset0.symbol} yield.`,
+    });
   }
 
   const collSecondAssetData: Partial<FluidAssetData> = {
@@ -447,14 +463,20 @@ const parseT2MarketData = async (provider: PublicClient, data: FluidVaultDataStr
     utilization: utilizationSupply1,
     tokenPerSupplyShare: token1PerSupplyShare,
     supplyReserves: reservesSupplyToken1,
+    supplyIncentives: [],
+    borrowIncentives: [],
   };
   if (STAKING_ASSETS.includes(collSecondAssetData.symbol!)) {
-    collSecondAssetData.incentiveSupplyApy = await getStakingApy(collAsset1.symbol);
-    collSecondAssetData.incentiveSupplyToken = collAsset1.symbol;
+    collSecondAssetData.supplyIncentives!.push({
+      apy: await getStakingApy(collAsset1.symbol),
+      token: collAsset1.symbol,
+      incentiveKind: IncentiveKind.Staking,
+      description: `Native ${collAsset1.symbol} yield.`,
+    });
   }
 
   const marketSupplyRate = getMarketRateForDex(token1PerSupplyShare, token0PerSupplyShare, supplyRate0, supplyRate1, collFirstAssetData.price!, collSecondAssetData.price!);
-  const incentiveSupplyRate = getAdditionalMarketRateForDex(token1PerSupplyShare, token0PerSupplyShare, collFirstAssetData.incentiveSupplyApy!, collSecondAssetData.incentiveSupplyApy!, collFirstAssetData.price!, collSecondAssetData.price!);
+  const incentiveSupplyRate = getAdditionalMarketRateForDex(token1PerSupplyShare, token0PerSupplyShare, collFirstAssetData.supplyIncentives![0]?.apy || '0', collSecondAssetData.supplyIncentives![0]?.apy || '0', collFirstAssetData.price!, collSecondAssetData.price!);
   const tradingSupplyRate = await getTradingApy(data.dexSupplyData.dexPool as EthAddress);
 
   const borrowRate = new Dec(data.borrowRateVault).div(100).toString();
@@ -465,13 +487,19 @@ const parseT2MarketData = async (provider: PublicClient, data: FluidVaultDataStr
     totalBorrow: data.totalBorrowVault.toString(),
     canBeBorrowed: true,
     borrowRate,
+    supplyIncentives: [],
+    borrowIncentives: [],
   };
   if (STAKING_ASSETS.includes(debtAssetData.symbol!)) {
-    debtAssetData.incentiveBorrowApy = await getStakingApy(debtAsset.symbol);
-    debtAssetData.incentiveBorrowToken = debtAsset.symbol;
+    debtAssetData.borrowIncentives!.push({
+      apy: new Dec(await getStakingApy(debtAsset.symbol)).mul(-1).toString(),
+      token: debtAsset.symbol,
+      incentiveKind: IncentiveKind.Reward,
+      description: `Due to the native yield of ${debtAsset.symbol}, the value of the debt would increase over time.`,
+    });
   }
 
-  const incentiveBorrowRate = debtAssetData.incentiveBorrowApy;
+  const incentiveBorrowRate = new Dec(debtAssetData.borrowIncentives![0]?.apy || '0').mul(-1).toString();
 
   const assetsData: FluidAssetsData = ([
     [collAsset0.symbol, collFirstAssetData],
@@ -599,13 +627,19 @@ const parseT3MarketData = async (provider: PublicClient, data: FluidVaultDataStr
     totalSupply: data.totalSupplyVault.toString(),
     canBeSupplied: true,
     supplyRate,
+    supplyIncentives: [],
+    borrowIncentives: [],
   };
   if (STAKING_ASSETS.includes(collAssetData.symbol!)) {
-    collAssetData.incentiveSupplyApy = await getStakingApy(collAsset.symbol);
-    collAssetData.incentiveSupplyToken = collAsset.symbol;
+    collAssetData.supplyIncentives!.push({
+      apy: await getStakingApy(collAsset.symbol),
+      token: collAsset.symbol,
+      incentiveKind: IncentiveKind.Staking,
+      description: `Native ${collAsset.symbol} yield.`,
+    });
   }
 
-  const incentiveSupplyRate = collAssetData.incentiveSupplyApy;
+  const incentiveSupplyRate = collAssetData.supplyIncentives?.[0]?.apy || '0';
 
   const debtAsset0Data: Partial<FluidAssetData> = {
     symbol: debtAsset0.symbol,
@@ -618,10 +652,16 @@ const parseT3MarketData = async (provider: PublicClient, data: FluidVaultDataStr
     utilization: utilizationBorrow0,
     tokenPerBorrowShare: token0PerBorrowShare,
     borrowReserves: reservesBorrowToken0,
+    supplyIncentives: [],
+    borrowIncentives: [],
   };
   if (STAKING_ASSETS.includes(debtAsset0Data.symbol!)) {
-    debtAsset0Data.incentiveSupplyApy = await getStakingApy(debtAsset0.symbol);
-    debtAsset0Data.incentiveSupplyToken = debtAsset0.symbol;
+    debtAsset0Data.borrowIncentives!.push({
+      apy: new Dec(await getStakingApy(debtAsset0.symbol)).mul(-1).toString(),
+      token: debtAsset0.symbol,
+      incentiveKind: IncentiveKind.Reward,
+      description: `Due to the native yield of ${debtAsset0.symbol}, the value of the debt would increase over time.`,
+    });
   }
 
   const debtAsset1Data: Partial<FluidAssetData> = {
@@ -635,13 +675,19 @@ const parseT3MarketData = async (provider: PublicClient, data: FluidVaultDataStr
     utilization: utilizationBorrow1,
     tokenPerBorrowShare: token1PerBorrowShare,
     borrowReserves: reservesBorrowToken1,
+    supplyIncentives: [],
+    borrowIncentives: [],
   };
   if (STAKING_ASSETS.includes(debtAsset1Data.symbol!)) {
-    debtAsset1Data.incentiveSupplyApy = await getStakingApy(debtAsset1.symbol);
-    debtAsset1Data.incentiveSupplyToken = debtAsset1.symbol;
+    debtAsset1Data.borrowIncentives!.push({
+      apy: new Dec(await getStakingApy(debtAsset1.symbol)).mul(-1).toString(),
+      token: debtAsset1.symbol,
+      incentiveKind: IncentiveKind.Reward,
+      description: `Due to the native yield of ${debtAsset1.symbol}, the value of the debt would increase over time.`,
+    });
   }
   const marketBorrowRate = getMarketRateForDex(token1PerBorrowShare, token0PerBorrowShare, borrowRate0, borrowRate1, debtAsset0Data.price!, debtAsset1Data.price!);
-  const incentiveBorrowRate = getAdditionalMarketRateForDex(token1PerBorrowShare, token0PerBorrowShare, debtAsset0Data.incentiveSupplyApy!, debtAsset1Data.incentiveSupplyApy!, debtAsset0Data.price!, debtAsset1Data.price!);
+  const incentiveBorrowRate = getAdditionalMarketRateForDex(token1PerBorrowShare, token0PerBorrowShare, new Dec(debtAsset0Data.borrowIncentives![0]?.apy || '0').mul(-1).toString(), new Dec(debtAsset1Data.borrowIncentives![0]?.apy || '0').mul(-1).toString(), debtAsset0Data.price!, debtAsset1Data.price!);
   const tradingBorrowRate = await getTradingApy(data.dexBorrowData.dexPool as EthAddress);
 
   const assetsData: FluidAssetsData = ([
@@ -797,10 +843,16 @@ const parseT4MarketData = async (provider: PublicClient, data: FluidVaultDataStr
     withdrawable: withdrawable0,
     tokenPerSupplyShare: token0PerSupplyShare,
     supplyReserves: reservesSupplyToken0,
+    supplyIncentives: [],
+    borrowIncentives: [],
   };
   if (STAKING_ASSETS.includes(collAsset0Data.symbol!)) {
-    collAsset0Data.incentiveSupplyApy = await getStakingApy(collAsset0.symbol);
-    collAsset0Data.incentiveSupplyToken = collAsset0.symbol;
+    collAsset0Data.supplyIncentives!.push({
+      apy: await getStakingApy(collAsset0.symbol),
+      token: collAsset0.symbol,
+      incentiveKind: IncentiveKind.Staking,
+      description: `Native ${collAsset0.symbol} yield.`,
+    });
   }
 
   const collAsset1Data: Partial<FluidAssetData> = {
@@ -814,10 +866,16 @@ const parseT4MarketData = async (provider: PublicClient, data: FluidVaultDataStr
     utilization: utilizationSupply1,
     tokenPerSupplyShare: token1PerSupplyShare,
     supplyReserves: reservesSupplyToken1,
+    supplyIncentives: [],
+    borrowIncentives: [],
   };
   if (STAKING_ASSETS.includes(collAsset1Data.symbol!)) {
-    collAsset1Data.incentiveSupplyApy = await getStakingApy(collAsset1.symbol);
-    collAsset1Data.incentiveSupplyToken = collAsset1.symbol;
+    collAsset1Data.supplyIncentives!.push({
+      apy: await getStakingApy(collAsset1.symbol),
+      token: collAsset1.symbol,
+      incentiveKind: IncentiveKind.Staking,
+      description: `Native ${collAsset1.symbol} yield.`,
+    });
   }
 
   const debtAsset0Data: Partial<FluidAssetData> = {
@@ -831,10 +889,16 @@ const parseT4MarketData = async (provider: PublicClient, data: FluidVaultDataStr
     utilization: utilizationBorrow0,
     tokenPerBorrowShare: token0PerBorrowShare,
     borrowReserves: reservesBorrowToken0,
+    supplyIncentives: [],
+    borrowIncentives: [],
   };
   if (STAKING_ASSETS.includes(debtAsset0Data.symbol!)) {
-    debtAsset0Data.incentiveSupplyApy = await getStakingApy(debtAsset0.symbol);
-    debtAsset0Data.incentiveSupplyToken = debtAsset0.symbol;
+    debtAsset0Data.borrowIncentives!.push({
+      apy: new Dec(await getStakingApy(debtAsset0.symbol)).mul(-1).toString(),
+      token: debtAsset0.symbol,
+      incentiveKind: IncentiveKind.Reward,
+      description: `Due to the native yield of ${debtAsset0.symbol}, the value of the debt would increase over time.`,
+    });
   }
 
   const debtAsset1Data: Partial<FluidAssetData> = {
@@ -848,19 +912,25 @@ const parseT4MarketData = async (provider: PublicClient, data: FluidVaultDataStr
     utilization: utilizationBorrow1,
     tokenPerBorrowShare: token1PerBorrowShare,
     borrowReserves: reservesBorrowToken1,
+    supplyIncentives: [],
+    borrowIncentives: [],
   };
   if (STAKING_ASSETS.includes(debtAsset1Data.symbol!)) {
-    debtAsset1Data.incentiveSupplyApy = await getStakingApy(debtAsset1.symbol);
-    debtAsset1Data.incentiveSupplyToken = debtAsset1.symbol;
+    debtAsset1Data.borrowIncentives!.push({
+      apy: new Dec(await getStakingApy(debtAsset1.symbol)).mul(-1).toString(),
+      token: debtAsset1.symbol,
+      incentiveKind: IncentiveKind.Reward,
+      description: `Due to the native yield of ${debtAsset1.symbol}, the value of the debt would increase over time.`,
+    });
   }
   const marketInfo = getFluidMarketInfoById(+(data.vaultId.toString()), network);
 
   const marketBorrowRate = getMarketRateForDex(token1PerBorrowShare, token0PerBorrowShare, borrowRate0, borrowRate1, debtAsset0Data.price!, debtAsset1Data.price!);
-  const incentiveBorrowRate = getAdditionalMarketRateForDex(token1PerBorrowShare, token0PerBorrowShare, debtAsset0Data.incentiveSupplyApy!, debtAsset1Data.incentiveSupplyApy!, debtAsset0Data.price!, debtAsset1Data.price!);
+  const incentiveBorrowRate = getAdditionalMarketRateForDex(token1PerBorrowShare, token0PerBorrowShare, new Dec(debtAsset0Data.borrowIncentives![0]?.apy || '0').mul(-1).toString(), new Dec(debtAsset1Data.borrowIncentives![0]?.apy || '0').mul(-1).toString(), debtAsset0Data.price!, debtAsset1Data.price!);
   const tradingBorrowRate = await getTradingApy(data.dexBorrowData.dexPool as EthAddress);
 
   const marketSupplyRate = getMarketRateForDex(token1PerSupplyShare, token0PerSupplyShare, supplyRate0, supplyRate1, collAsset0Data.price!, collAsset1Data.price!);
-  const incentiveSupplyRate = getAdditionalMarketRateForDex(token1PerSupplyShare, token0PerSupplyShare, collAsset0Data.incentiveSupplyApy!, collAsset1Data.incentiveSupplyApy!, collAsset0Data.price!, collAsset1Data.price!);
+  const incentiveSupplyRate = getAdditionalMarketRateForDex(token1PerSupplyShare, token0PerSupplyShare, collAsset0Data.supplyIncentives![0]?.apy || '0', collAsset1Data.supplyIncentives![0]?.apy || '0', collAsset0Data.price!, collAsset1Data.price!);
   const tradingSupplyRate = await getTradingApy(data.dexSupplyData.dexPool as EthAddress);
 
   const assetsData: FluidAssetsData = ([

package/src/helpers/aaveHelpers/index.ts

@@ -106,7 +106,6 @@ export const aaveAnyGetAggregatedPositionData = ({
   const { netApy, incentiveUsd, totalInterestUsd } = calculateNetApy({
     usedAssets,
     assetsData,
-    isAave: true,
   });
   payload.netApy = netApy;
   payload.incentiveUsd = incentiveUsd;

package/src/helpers/compoundHelpers/index.ts

@@ -3,13 +3,17 @@ import { assetAmountInWei, getAssetInfo, getAssetInfoByAddress } from '@defisave
 import {
   BaseAdditionalAssetData, CompoundAggregatedPositionData, CompoundMarketData, CompoundV2AssetsData, CompoundV2UsedAssets, CompoundV3AssetData, CompoundV3AssetsData, CompoundV3UsedAssets, CompoundVersions,
 } from '../../types';
-import { getEthAmountForDecimals, handleWbtcLegacy, wethToEth } from '../../services/utils';
+import {
+  addToArrayIf, getEthAmountForDecimals, handleWbtcLegacy, wethToEth,
+} from '../../services/utils';
 import { BLOCKS_IN_A_YEAR, borrowOperations, SECONDS_PER_YEAR } from '../../constants';
 import {
   aprToApy, calcLeverageLiqPrice, calculateBorrowingAssetLimit, getAssetsTotal, isLeveragedPos,
 } from '../../moneymarket';
-import { calculateNetApy } from '../../staking';
-import { EthAddress, EthereumProvider, NetworkNumber } from '../../types/common';
+import { calculateNetApy, getStakingApy, STAKING_ASSETS } from '../../staking';
+import {
+  EthAddress, EthereumProvider, IncentiveData, IncentiveKind, NetworkNumber,
+} from '../../types/common';
 import { CompoundLoanInfoContractViem, CompV3ViewContractViem } from '../../contracts';
 import { getViemProvider } from '../../services/viem';
 
@@ -34,6 +38,8 @@ export const formatMarketData = (data: any, network: NetworkNumber, baseAssetPri
     borrowRate: '0',
     canBeBorrowed: false,
     canBeSupplied: true,
+    supplyIncentives: [],
+    borrowIncentives: [],
   });
 };
 
@@ -74,24 +80,40 @@ export const formatBaseData = (data: any, network: NetworkNumber, baseAssetPrice
   });
 };
 
-export const getIncentiveApys = (
+export const getIncentiveApys = async (
   baseData: CompoundV3AssetData & BaseAdditionalAssetData,
   compPrice: string,
-): {
-  incentiveSupplyApy: string,
-  incentiveBorrowApy: string,
-  incentiveSupplyToken: string,
-  incentiveBorrowToken: string,
-} => {
-  const incentiveSupplyApy = aprToApy((100 * SECONDS_PER_YEAR * +baseData.rewardSupplySpeed * +compPrice) / +baseData.price / +baseData.totalSupply).toString();
-  const incentiveBorrowApy = aprToApy((100 * SECONDS_PER_YEAR * +baseData.rewardBorrowSpeed * +compPrice) / +baseData.price / +baseData.totalBorrow).toString();
-  return {
-    incentiveSupplyApy,
-    incentiveBorrowApy,
-    incentiveSupplyToken: 'COMP',
-    incentiveBorrowToken: 'COMP',
-  };
-};
+): Promise<{
+  supplyIncentives: IncentiveData[],
+  borrowIncentives: IncentiveData[],
+}> => ({
+  supplyIncentives: [{
+    token: 'COMP',
+    apy: aprToApy((100 * SECONDS_PER_YEAR * +baseData.rewardSupplySpeed * +compPrice) / +baseData.price / +baseData.totalSupply).toString(),
+    incentiveKind: IncentiveKind.Reward,
+    description: 'Eligible for protocol-level COMP incentives.',
+  },
+  ...addToArrayIf(STAKING_ASSETS.includes(baseData.symbol), {
+    apy: await getStakingApy(baseData.symbol),
+    token: baseData.symbol,
+    incentiveKind: IncentiveKind.Staking,
+    description: `Native ${baseData.symbol} yield.`,
+  }),
+  ],
+  borrowIncentives: [{
+    token: 'COMP',
+    apy: aprToApy((100 * SECONDS_PER_YEAR * +baseData.rewardBorrowSpeed * +compPrice) / +baseData.price / +baseData.totalBorrow).toString(),
+    incentiveKind: IncentiveKind.Reward,
+    description: 'Eligible for protocol-level COMP incentives.',
+  },
+  ...addToArrayIf(STAKING_ASSETS.includes(baseData.symbol), {
+    apy: new Dec(await getStakingApy(baseData.symbol)).mul(-1).toString(),
+    token: baseData.symbol,
+    incentiveKind: IncentiveKind.Staking,
+    description: `Due to the native yield of ${baseData.symbol}, the value of the debt would increase over time.`,
+  }),
+  ],
+});
 
 export const getCompoundV2AggregatedData = ({
   usedAssets, assetsData, ...rest

package/src/helpers/eulerHelpers/index.ts

@@ -1,12 +1,12 @@
 import Dec from 'decimal.js';
 import { assetAmountInWei } from '@defisaver/tokens';
 import {
-  EthAddress, EthereumProvider, NetworkNumber,
+  EthAddress, EthereumProvider, MMAssetsData, NetworkNumber,
 } from '../../types/common';
 import {
   calcLeverageLiqPrice, getAssetsTotal, STABLE_ASSETS,
 } from '../../moneymarket';
-import { calculateInterestEarned } from '../../staking';
+import { calculateNetApy } from '../../staking';
 import {
   EulerV2AggregatedPositionData,
   EulerV2AssetsData,
@@ -74,43 +74,6 @@ export const isLeveragedPos = (usedAssets: EulerV2UsedAssets, dustLimit = 5) =>
   };
 };
 
-export const calculateNetApy = (usedAssets: EulerV2UsedAssets, assetsData: EulerV2AssetsData) => {
-  const sumValues = Object.values(usedAssets).reduce((_acc, usedAsset) => {
-    const acc = { ..._acc };
-    const assetData = assetsData[usedAsset.vaultAddress.toLowerCase()];
-
-    if (usedAsset.isSupplied) {
-      const amount = usedAsset.suppliedUsd;
-      acc.suppliedUsd = new Dec(acc.suppliedUsd).add(amount).toString();
-      const rate = assetData.supplyRate;
-      const supplyInterest = calculateInterestEarned(amount, rate as string, 'year', true);
-      acc.supplyInterest = new Dec(acc.supplyInterest).add(supplyInterest.toString()).toString();
-    }
-
-    if (usedAsset.isBorrowed) {
-      const amount = usedAsset.borrowedUsd;
-      acc.borrowedUsd = new Dec(acc.borrowedUsd).add(amount).toString();
-      const rate = assetData.borrowRate;
-      const borrowInterest = calculateInterestEarned(amount, rate as string, 'year', true);
-      acc.borrowInterest = new Dec(acc.borrowInterest).sub(borrowInterest.toString()).toString();
-    }
-
-    return acc;
-  }, {
-    borrowInterest: '0', supplyInterest: '0', incentiveUsd: '0', borrowedUsd: '0', suppliedUsd: '0',
-  });
-
-  const {
-    borrowedUsd, suppliedUsd, borrowInterest, supplyInterest, incentiveUsd,
-  } = sumValues;
-
-  const totalInterestUsd = new Dec(borrowInterest).add(supplyInterest).add(incentiveUsd).toString();
-  const balance = new Dec(suppliedUsd).sub(borrowedUsd);
-  const netApy = new Dec(totalInterestUsd).div(balance).times(100).toString();
-
-  return { netApy, totalInterestUsd, incentiveUsd };
-};
-
 export const getEulerV2AggregatedData = ({
   usedAssets, assetsData, network, ...rest
 }: { usedAssets: EulerV2UsedAssets, assetsData: EulerV2AssetsData, network: NetworkNumber }) => {
@@ -124,7 +87,7 @@ export const getEulerV2AggregatedData = ({
   payload.leftToBorrowUsd = leftToBorrowUsd.lte('0') ? '0' : leftToBorrowUsd.toString();
   payload.ratio = +payload.suppliedUsd ? new Dec(payload.borrowLimitUsd).div(payload.borrowedUsd).mul(100).toString() : '0';
   payload.collRatio = +payload.suppliedUsd ? new Dec(payload.suppliedCollateralUsd).div(payload.borrowedUsd).mul(100).toString() : '0';
-  const { netApy, incentiveUsd, totalInterestUsd } = calculateNetApy(usedAssets, assetsData);
+  const { netApy, incentiveUsd, totalInterestUsd } = calculateNetApy({ usedAssets, assetsData: assetsData as unknown as MMAssetsData });
   payload.netApy = netApy;
   payload.incentiveUsd = incentiveUsd;
   payload.totalInterestUsd = totalInterestUsd;

package/src/helpers/fluidHelpers/index.ts

@@ -299,6 +299,8 @@ const EMPTY_ASSET_DATA = {
   canBeBorrowed: false,
   supplyRate: '0',
   borrowRate: '0',
+  supplyIncentives: [],
+  borrowIncentives: [],
 };
 
 export const mergeAssetData = (existing: Partial<FluidAssetData> = {}, additional: Partial<FluidAssetData>): FluidAssetData => ({

package/src/helpers/liquityV2Helpers/index.ts

@@ -13,8 +13,10 @@ export const calculateNetApyLiquityV2 = (usedAssets: LiquityV2UsedAssets, assets
     if (usedAsset.suppliedUsd) {
       const amount = usedAsset.suppliedUsd;
       acc.suppliedUsd = new Dec(acc.suppliedUsd).add(amount).toString();
-      if (assetData.incentiveSupplyApy) {
-        const incentiveInterest = calculateInterestEarned(amount, assetData.incentiveSupplyApy, 'year', true);
+
+      for (const supplyIncentive of assetData.supplyIncentives) {
+        const { apy } = supplyIncentive;
+        const incentiveInterest = calculateInterestEarned(amount, apy, 'year', true);
         acc.incentiveUsd = new Dec(acc.incentiveUsd).add(incentiveInterest).toString();
       }
     }

package/src/liquityV2/index.ts

@@ -4,7 +4,9 @@ import { Client, PublicClient } from 'viem';
 import {
   createViemContractFromConfigFunc, LiquityV2LegacyViewContractViem, LiquityV2ViewContractViem,
 } from '../contracts';
-import { EthAddress, EthereumProvider, NetworkNumber } from '../types/common';
+import {
+  EthAddress, EthereumProvider, IncentiveKind, NetworkNumber,
+} from '../types/common';
 import {
   LIQUITY_V2_TROVE_STATUS_ENUM,
   LiquityV2AssetsData, LiquityV2MarketData, LiquityV2MarketInfo, LiquityV2TroveData, LiquityV2UsedAssets,
@@ -63,6 +65,8 @@ export const _getLiquityV2MarketData = async (provider: Client, network: Network
     canBeBorrowed: true,
     leftToBorrowGlobal,
     leftToWithdrawGlobal: '0',
+    supplyIncentives: [],
+    borrowIncentives: [],
   };
   assetsData[collateralToken] = {
     symbol: collateralToken,
@@ -74,10 +78,16 @@ export const _getLiquityV2MarketData = async (provider: Client, network: Network
     canBeBorrowed: false,
     leftToBorrowGlobal: '0',
     leftToWithdrawGlobal,
+    supplyIncentives: [],
+    borrowIncentives: [],
   };
   if (STAKING_ASSETS.includes(collateralToken)) {
-    assetsData[collateralToken].incentiveSupplyApy = await getStakingApy(collateralToken);
-    assetsData[collateralToken].incentiveSupplyToken = collateralToken;
+    assetsData[collateralToken].supplyIncentives.push({
+      apy: await getStakingApy(collateralToken),
+      token: collateralToken,
+      incentiveKind: IncentiveKind.Staking,
+      description: `Native ${collateralToken} yield.`,
+    });
   }
 
   return {

package/src/llamaLend/index.ts

@@ -2,10 +2,11 @@ import Dec from 'decimal.js';
 import { assetAmountInEth, getAssetInfo } from '@defisaver/tokens';
 import { Client } from 'viem';
 import {
+  LlamaLendAssetsData,
   LlamaLendGlobalMarketData, LlamaLendMarketData, LlamaLendStatus, LlamaLendUsedAssets, LlamaLendUserData,
 } from '../types';
 import {
-  Blockish, EthAddress, EthereumProvider, NetworkNumber, PositionBalances,
+  Blockish, EthAddress, EthereumProvider, IncentiveKind, NetworkNumber, PositionBalances,
 } from '../types/common';
 import { LlamaLendViewContractViem } from '../contracts';
 import { getLlamaLendAggregatedData } from '../helpers/llamaLendHelpers';
@@ -88,7 +89,7 @@ export const _getLlamaLendGlobalData = async (provider: Client, network: Network
   const debtInAYearBN = new Dec(totalDebt).mul(new Dec(2.718281828459).pow(exponentRate).toNumber());
   const lendRate = debtInAYearBN.minus(totalDebt).div(cap).mul(100).toString();
 
-  const assetsData:any = {};
+  const assetsData: LlamaLendAssetsData = {};
   assetsData[debtAsset] = {
     symbol: debtAsset,
     address: data.debtToken,
@@ -97,6 +98,8 @@ export const _getLlamaLendGlobalData = async (provider: Client, network: Network
     borrowRate,
     canBeSupplied: true,
     canBeBorrowed: true,
+    supplyIncentives: [],
+    borrowIncentives: [],
   };
 
   assetsData[collAsset] = {
@@ -107,11 +110,17 @@ export const _getLlamaLendGlobalData = async (provider: Client, network: Network
     borrowRate: '0',
     canBeSupplied: true,
     canBeBorrowed: false,
+    supplyIncentives: [],
+    borrowIncentives: [],
   };
 
   if (STAKING_ASSETS.includes(collAsset)) {
-    assetsData[collAsset].incentiveSupplyApy = await getStakingApy(collAsset);
-    assetsData[collAsset].incentiveSupplyToken = collAsset;
+    assetsData[collAsset].supplyIncentives.push({
+      apy: await getStakingApy(collAsset),
+      token: collAsset,
+      incentiveKind: IncentiveKind.Staking,
+      description: `Native ${collAsset} yield.`,
+    });
   }
 
   return {

package/src/morphoBlue/index.ts

@@ -2,7 +2,7 @@ import Dec from 'decimal.js';
 import { assetAmountInEth, getAssetInfoByAddress } from '@defisaver/tokens';
 import { Client } from 'viem';
 import {
-  Blockish, EthAddress, EthereumProvider, MMUsedAssets, NetworkNumber, PositionBalances,
+  Blockish, EthAddress, EthereumProvider, IncentiveKind, MMUsedAssets, NetworkNumber, PositionBalances,
 } from '../types/common';
 import {
   DFSFeedRegistryContractViem, FeedRegistryContractViem, MorphoBlueViewContractViem,
@@ -88,10 +88,18 @@ export async function _getMorphoBlueMarketData(provider: Client, network: Networ
     totalBorrow: new Dec(marketInfo.totalBorrowAssets.toString()).div(scale).toString(),
     canBeSupplied: true,
     canBeBorrowed: true,
-    incentiveSupplyApy: morphoSupplyApy,
-    incentiveBorrowApy: morphoBorrowApy,
-    incentiveSupplyToken: 'MORPHO',
-    incentiveBorrowToken: 'MORPHO',
+    supplyIncentives: [{
+      token: 'MORPHO',
+      apy: morphoSupplyApy,
+      incentiveKind: IncentiveKind.Reward,
+      description: 'Eligible for protocol-level MORPHO incentives.',
+    }],
+    borrowIncentives: [{
+      token: 'MORPHO',
+      apy: morphoBorrowApy,
+      incentiveKind: IncentiveKind.Reward,
+      description: 'Eligible for protocol-level MORPHO incentives.',
+    }],
   };
 
   assetsData[wethToEth(collateralTokenInfo.symbol)] = {
@@ -102,10 +110,16 @@ export async function _getMorphoBlueMarketData(provider: Client, network: Networ
     borrowRate: '0',
     canBeSupplied: true,
     canBeBorrowed: false,
+    supplyIncentives: [],
+    borrowIncentives: [],
   };
   if (STAKING_ASSETS.includes(collateralTokenInfo.symbol)) {
-    assetsData[collateralTokenInfo.symbol].incentiveSupplyApy = await getStakingApy(collateralTokenInfo.symbol);
-    assetsData[collateralTokenInfo.symbol].incentiveSupplyToken = collateralTokenInfo.symbol;
+    assetsData[collateralTokenInfo.symbol].supplyIncentives = [{
+      apy: await getStakingApy(collateralTokenInfo.symbol),
+      token: collateralTokenInfo.symbol,
+      incentiveKind: IncentiveKind.Staking,
+      description: `Native ${collateralTokenInfo.symbol} yield.`,
+    }];
   }
 
   return {