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

package/cjs/types/spark.d.ts

@@ -1,5 +1,4 @@
 import { EthAddress, MMAssetData, MMPositionData, MMUsedAsset, NetworkNumber } from './common';
-import { IncentiveData } from './aave';
 export declare enum SparkVersions {
     SparkV1 = "v1default"
 }
@@ -48,8 +47,6 @@ export interface SparkAssetData extends MMAssetData {
     eModeCategory: number;
     eModeCategoryData: SparkEModeCategoryData;
     liquidationRatio: string;
-    supplyIncentives?: IncentiveData[];
-    borrowIncentives?: IncentiveData[];
 }
 export interface SparkAssetsData {
     [token: string]: SparkAssetData;

package/esm/aaveV2/index.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import Dec from 'decimal.js';
 import { assetAmountInEth, getAssetInfo } from '@defisaver/tokens';
+import { IncentiveKind, } from '../types/common';
 import { calculateNetApy, getStakingApy } from '../staking';
 import { ethToWeth, wethToEth, wethToEthByAddress } from '../services/utils';
 import { AaveLoanInfoV2ContractViem, createViemContractFromConfigFunc } from '../contracts';
@@ -56,15 +57,18 @@ export const _getAaveV2MarketsData = (provider, network, selectedMarket) => __aw
         totalBorrow: assetAmountInEth(market.totalBorrow.toString(), selectedMarket.assets[i]),
         totalBorrowVar: assetAmountInEth(market.totalBorrowVar.toString(), selectedMarket.assets[i]),
         priceInEth: new Dec(market.price.toString()).div(1e18).toString(),
-        incentiveSupplyToken: 'AAVE',
-        incentiveBorrowToken: 'AAVE',
-        incentiveSupplyApy: '0',
+        supplyIncentives: [],
+        borrowIncentives: [],
         price: new Dec(market.price.toString()).div(1e18).mul(ethPrice).toString(),
     }));
     const stEthMarket = markets.find(({ symbol }) => symbol === 'stETH');
     if (stEthMarket) {
-        stEthMarket.incentiveSupplyApy = yield getStakingApy('stETH');
-        stEthMarket.incentiveSupplyToken = 'stETH';
+        stEthMarket.supplyIncentives.push({
+            apy: yield getStakingApy('stETH'),
+            token: 'stETH',
+            incentiveKind: IncentiveKind.Staking,
+            description: 'Native stETH yield.',
+        });
     }
     const payload = {};
     // Sort by market size

package/esm/aaveV3/index.d.ts

@@ -1,6 +1,8 @@
 import { Client } from 'viem';
 import { AaveMarketInfo, AaveV3MarketData, AaveV3PositionData, AaveV3UsedAssets, EModeCategoryDataMapping } from '../types/aave';
 import { Blockish, EthAddress, EthereumProvider, NetworkNumber, PositionBalances } from '../types/common';
+import { getMeritCampaigns } from './merit';
+import { getMerkleCampaigns } from './merkl';
 export declare const aaveV3EmodeCategoriesMapping: (extractedState: any, usedAssets: AaveV3UsedAssets) => {
     [key: number]: EModeCategoryDataMapping;
 };
@@ -32,3 +34,4 @@ export declare const getAaveV3AccountBalances: (provider: EthereumProvider, netw
 export declare const _getAaveV3AccountData: (provider: Client, network: NetworkNumber, address: EthAddress, extractedState: any, blockNumber?: "latest" | number) => Promise<AaveV3PositionData>;
 export declare const getAaveV3AccountData: (provider: EthereumProvider, network: NetworkNumber, address: EthAddress, extractedState: any, blockNumber?: "latest" | number) => Promise<AaveV3PositionData>;
 export declare const getAaveV3FullPositionData: (provider: EthereumProvider, network: NetworkNumber, address: EthAddress, market: AaveMarketInfo) => Promise<AaveV3PositionData>;
+export { getMeritCampaigns, getMerkleCampaigns, };

package/esm/aaveV3/index.js

@@ -15,8 +15,10 @@ import { AAVE_V3 } from '../markets/aave';
 import { aprToApy, calculateBorrowingAssetLimit } from '../moneymarket';
 import { ethToWeth, isEnabledOnBitmap, isLayer2Network, wethToEth, wethToEthByAddress, } from '../services/utils';
 import { getStakingApy, STAKING_ASSETS } from '../staking';
-import { NetworkNumber, } from '../types/common';
+import { IncentiveKind, NetworkNumber, } from '../types/common';
 import { getViemProvider, setViemBlockNumber } from '../services/viem';
+import { getMeritCampaigns } from './merit';
+import { getAaveUnderlyingSymbol, getMerkleCampaigns } from './merkl';
 export const aaveV3EmodeCategoriesMapping = (extractedState, usedAssets) => {
     const { eModeCategoriesData } = extractedState;
     const usedAssetsValues = Object.values(usedAssets);
@@ -51,11 +53,13 @@ export function _getAaveV3MarketData(provider_1, network_1, market_1) {
         const marketAddress = market.providerAddress;
         const networksWithIncentives = [NetworkNumber.Eth, NetworkNumber.Arb, NetworkNumber.Opt, NetworkNumber.Linea];
         // eslint-disable-next-line prefer-const
-        let [loanInfo, eModesInfo, isBorrowAllowed, rewardInfo] = yield Promise.all([
+        let [loanInfo, eModesInfo, isBorrowAllowed, rewardInfo, merkleRewardsMap, meritRewardsMap] = yield Promise.all([
             loanInfoContract.read.getFullTokensInfo([marketAddress, _addresses], setViemBlockNumber(blockNumber)),
             loanInfoContract.read.getAllEmodes([marketAddress], setViemBlockNumber(blockNumber)),
             loanInfoContract.read.isBorrowAllowed([marketAddress], setViemBlockNumber(blockNumber)), // Used on L2s check for PriceOracleSentinel (mainnet will always return true)
             networksWithIncentives.includes(network) ? aaveIncentivesContract.read.getReservesIncentivesData([marketAddress], setViemBlockNumber(blockNumber)) : null,
+            getMerkleCampaigns(network),
+            getMeritCampaigns(network, market.value),
         ]);
         isBorrowAllowed = isLayer2Network(network) ? isBorrowAllowed : true;
         const eModeCategoriesData = {};
@@ -137,47 +141,74 @@ export function _getAaveV3MarketData(provider_1, network_1, market_1) {
                 isolationModeBorrowingEnabled: tokenMarket.isolationModeBorrowingEnabled,
                 isFlashLoanEnabled: tokenMarket.isFlashLoanEnabled,
                 aTokenAddress: tokenMarket.aTokenAddress,
+                vTokenAddress: tokenMarket.debtTokenAddress,
+                supplyIncentives: [],
+                borrowIncentives: [],
             });
         })));
         // Get incentives data
-        yield Promise.all(assetsData.map((_market) => __awaiter(this, void 0, void 0, function* () {
+        yield Promise.all(assetsData.map((_market, index) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             /* eslint-disable no-param-reassign */
             // @ts-ignore
             const rewardForMarket = rewardInfo === null || rewardInfo === void 0 ? void 0 : rewardInfo[_market.underlyingTokenAddress];
             const isStakingAsset = STAKING_ASSETS.includes(_market.symbol);
             if (isStakingAsset) {
-                _market.incentiveSupplyApy = yield getStakingApy(_market.symbol);
-                _market.incentiveSupplyToken = _market.symbol;
-                if (!_market.supplyIncentives) {
-                    _market.supplyIncentives = [];
-                }
+                const yieldApy = yield getStakingApy(_market.symbol);
                 _market.supplyIncentives.push({
-                    apy: _market.incentiveSupplyApy || '0',
+                    apy: yieldApy,
                     token: _market.symbol,
-                    incentiveKind: 'staking',
+                    incentiveKind: IncentiveKind.Staking,
+                    description: `Native ${_market.symbol} yield.`,
                 });
-            }
-            if (_market.canBeBorrowed && _market.incentiveSupplyApy) {
-                _market.incentiveBorrowApy = _market.incentiveSupplyApy;
-                _market.incentiveBorrowToken = _market.incentiveSupplyToken;
-                if (!_market.borrowIncentives) {
-                    _market.borrowIncentives = [];
+                if (_market.canBeBorrowed) {
+                    // when borrowing assets whose value increases over time
+                    _market.borrowIncentives.push({
+                        apy: new Dec(yieldApy).mul(-1).toString(),
+                        token: _market.symbol,
+                        incentiveKind: IncentiveKind.Reward,
+                        description: `Due to the native yield of ${_market.symbol}, the value of the debt would increase over time.`,
+                    });
                 }
+            }
+            const aTokenAddress = _market.aTokenAddress.toLowerCase(); // DEV: Should aTokenAddress be in AaveV3AssetData type?
+            if ((_a = merkleRewardsMap[aTokenAddress]) === null || _a === void 0 ? void 0 : _a.supply) {
+                const { apy, rewardTokenSymbol, description, identifier, } = merkleRewardsMap[aTokenAddress].supply;
+                _market.supplyIncentives.push({
+                    apy,
+                    token: rewardTokenSymbol,
+                    incentiveKind: IncentiveKind.Reward,
+                    description,
+                    eligibilityId: identifier,
+                });
+            }
+            const vTokenAddress = _market.vTokenAddress.toLowerCase(); // DEV: Should vTokenAddress be in AaveV3AssetData type?
+            if ((_b = merkleRewardsMap[vTokenAddress]) === null || _b === void 0 ? void 0 : _b.borrow) {
+                const { apy, rewardTokenSymbol, description, identifier, } = merkleRewardsMap[vTokenAddress].borrow;
                 _market.borrowIncentives.push({
-                    apy: _market.incentiveBorrowApy,
-                    token: _market.incentiveBorrowToken,
-                    incentiveKind: 'reward',
+                    apy,
+                    token: rewardTokenSymbol,
+                    incentiveKind: IncentiveKind.Reward,
+                    description,
+                    eligibilityId: identifier,
                 });
             }
-            if (_market.symbol === 'USDe') {
-                const merklApy = yield getStakingApy(_market.symbol);
-                if (!_market.supplyIncentives) {
-                    _market.supplyIncentives = [];
-                }
+            if (meritRewardsMap.supply[_market.symbol]) {
+                const { apy, rewardTokenSymbol, description } = meritRewardsMap.supply[_market.symbol];
                 _market.supplyIncentives.push({
-                    apy: merklApy || '0',
-                    token: _market.symbol,
-                    incentiveKind: 'reward',
+                    apy,
+                    token: rewardTokenSymbol,
+                    incentiveKind: IncentiveKind.Reward,
+                    description,
+                });
+            }
+            if (meritRewardsMap.borrow[_market.symbol]) {
+                const { apy, rewardTokenSymbol, description } = meritRewardsMap.borrow[_market.symbol];
+                _market.borrowIncentives.push({
+                    apy,
+                    token: rewardTokenSymbol,
+                    incentiveKind: IncentiveKind.Reward,
+                    description,
                 });
             }
             if (!rewardForMarket)
@@ -187,10 +218,7 @@ export function _getAaveV3MarketData(provider_1, network_1, market_1) {
                 if (supplyRewardData) {
                     if (+(supplyRewardData.emissionEndTimestamp.toString()) * 1000 < Date.now())
                         return;
-                    _market.incentiveSupplyToken = supplyRewardData.rewardTokenSymbol;
                     // reward token is aave asset
-                    if (supplyRewardData.rewardTokenSymbol.startsWith('a') && supplyRewardData.rewardTokenSymbol.includes(_market.symbol))
-                        _market.incentiveSupplyToken = _market.symbol;
                     const supplyEmissionPerSecond = supplyRewardData.emissionPerSecond;
                     const supplyRewardPrice = new Dec(supplyRewardData.rewardPriceFeed).div(Math.pow(10, +supplyRewardData.priceFeedDecimals))
                         .toString();
@@ -200,15 +228,11 @@ export function _getAaveV3MarketData(provider_1, network_1, market_1) {
                         .div(_market.price)
                         .div(_market.totalSupply)
                         .toString();
-                    _market.incentiveSupplyApy = new Dec(_market.incentiveSupplyApy || '0').add(rewardApy)
-                        .toString();
-                    if (!_market.supplyIncentives) {
-                        _market.supplyIncentives = [];
-                    }
                     _market.supplyIncentives.push({
-                        token: supplyRewardData.rewardTokenSymbol,
+                        token: getAaveUnderlyingSymbol(supplyRewardData.rewardTokenSymbol),
                         apy: rewardApy,
-                        incentiveKind: 'reward',
+                        incentiveKind: IncentiveKind.Reward,
+                        description: 'Eligible for protocol-level incentives.',
                     });
                 }
             });
@@ -217,9 +241,6 @@ export function _getAaveV3MarketData(provider_1, network_1, market_1) {
                 if (borrowRewardData) {
                     if (+(borrowRewardData.emissionEndTimestamp.toString()) * 1000 < Date.now())
                         return;
-                    _market.incentiveBorrowToken = borrowRewardData.rewardTokenSymbol;
-                    if (borrowRewardData.rewardTokenSymbol.startsWith('a') && borrowRewardData.rewardTokenSymbol.includes(_market.symbol))
-                        _market.incentiveBorrowToken = _market.symbol;
                     const supplyEmissionPerSecond = borrowRewardData.emissionPerSecond;
                     const supplyRewardPrice = new Dec(borrowRewardData.rewardPriceFeed).div(Math.pow(10, +borrowRewardData.priceFeedDecimals))
                         .toString();
@@ -229,15 +250,11 @@ export function _getAaveV3MarketData(provider_1, network_1, market_1) {
                         .div(_market.price)
                         .div(_market.totalBorrowVar)
                         .toString();
-                    _market.incentiveBorrowApy = new Dec(_market.incentiveBorrowApy || '0').add(rewardApy)
-                        .toString();
-                    if (!_market.borrowIncentives) {
-                        _market.borrowIncentives = [];
-                    }
                     _market.borrowIncentives.push({
-                        token: borrowRewardData.rewardTokenSymbol,
+                        token: getAaveUnderlyingSymbol(borrowRewardData.rewardTokenSymbol),
                         apy: rewardApy,
-                        incentiveKind: 'reward',
+                        incentiveKind: IncentiveKind.Reward,
+                        description: 'Eligible for protocol-level incentives.',
                     });
                 }
             });
@@ -403,3 +420,4 @@ export const getAaveV3FullPositionData = (provider, network, address, market) =>
     const positionData = yield getAaveV3AccountData(provider, network, address, { assetsData: marketData.assetsData, selectedMarket: market, eModeCategoriesData: marketData.eModeCategoriesData });
     return positionData;
 });
+export { getMeritCampaigns, getMerkleCampaigns, };

package/esm/aaveV3/merit.d.ts

@@ -0,0 +1,7 @@
+import { NetworkNumber } from '../types/common';
+import { AaveVersions, MeritTokenRewardMap } from '../types';
+/**
+ * Fetches merit rewards data from Aave API
+ */
+export declare const fetchMeritRewardsData: () => Promise<Record<string, number | null>>;
+export declare const getMeritCampaigns: (chainId: NetworkNumber, market: AaveVersions) => Promise<MeritTokenRewardMap>;

package/esm/aaveV3/merit.js

@@ -0,0 +1,90 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { DEFAULT_TIMEOUT } from '../services/utils';
+import { NetworkNumber } from '../types/common';
+import { aprToApy } from '../moneymarket';
+import { AaveVersions } from '../types';
+/**
+ * Maps API keys to reward data & actions - hardcoded and needs to be maintained actively.
+ * Mapping based on Aave interface implementation: https://github.com/aave/interface/blob/main/src/hooks/useMeritIncentives.ts
+ * Active campaigns found here: https://apps.aavechan.com/merit
+ */
+const MERIT_DATA_MAP = {
+    [NetworkNumber.Eth]: {
+        [AaveVersions.AaveV3]: {
+            'ethereum-supply-ethx': { rewardTokenSymbol: 'SD', action: 'supply', supplyTokens: ['ETHx'] },
+            'ethereum-supply-rlusd': { rewardTokenSymbol: 'aEthRLUSD', action: 'supply', supplyTokens: ['RLUSD'] },
+            // Campaign disabled here as it's present on Merkl API:
+            // 'ethereum-borrow-eurc': { rewardTokenSymbol: 'aEthEURC', action: 'borrow', borrowTokens: ['EURC'] },
+        },
+        [AaveVersions.AaveV3Lido]: {},
+        [AaveVersions.AaveV3Etherfi]: {},
+    },
+    [NetworkNumber.Arb]: {
+        [AaveVersions.AaveV3]: {},
+    },
+    [NetworkNumber.Opt]: {
+        [AaveVersions.AaveV3]: {},
+    },
+    [NetworkNumber.Base]: {
+        [AaveVersions.AaveV3]: {
+            'base-borrow-usdc': { rewardTokenSymbol: 'USDC', action: 'borrow', borrowTokens: ['USDC'] },
+            'base-borrow-gho': { rewardTokenSymbol: 'GHO', action: 'borrow', borrowTokens: ['GHO'] },
+            'base-borrow-eurc': { rewardTokenSymbol: 'EURC', action: 'borrow', borrowTokens: ['EURC'] },
+        },
+    },
+    [NetworkNumber.Linea]: {
+        [AaveVersions.AaveV3]: {},
+    },
+};
+/**
+ * Fetches merit rewards data from Aave API
+ */
+export const fetchMeritRewardsData = () => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const response = yield fetch('https://apps.aavechan.com/api/merit/aprs', {
+            signal: AbortSignal.timeout(DEFAULT_TIMEOUT),
+        });
+        const data = yield response.json();
+        return data.currentAPR.actionsAPR;
+    }
+    catch (error) {
+        console.error('Failed to fetch merit rewards data:', error);
+        return {};
+    }
+});
+export const getMeritCampaigns = (chainId, market) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const meritData = yield fetchMeritRewardsData();
+    const relevantCampaigns = {
+        supply: {},
+        borrow: {},
+    };
+    Object.entries(((_a = MERIT_DATA_MAP[chainId]) === null || _a === void 0 ? void 0 : _a[market]) || {})
+        .filter(([key, rewardData]) => !!meritData[key])
+        .forEach(([key, rewardData]) => {
+        var _a, _b;
+        const apr = meritData[key];
+        if (!apr)
+            return;
+        const reward = {
+            rewardTokenSymbol: rewardData.rewardTokenSymbol,
+            apy: aprToApy(apr).toString(),
+            description: `Eligible for Merit rewards in ${rewardData.rewardTokenSymbol}. ${rewardData.message ? `\n${rewardData.message}` : ''}`,
+        };
+        (_a = rewardData.supplyTokens) === null || _a === void 0 ? void 0 : _a.forEach(token => {
+            relevantCampaigns.supply[token] = reward;
+        });
+        (_b = rewardData.borrowTokens) === null || _b === void 0 ? void 0 : _b.forEach(token => {
+            relevantCampaigns.borrow[token] = reward;
+        });
+    });
+    return relevantCampaigns;
+});

package/esm/aaveV3/merkl.d.ts

@@ -0,0 +1,9 @@
+import { MerkleRewardMap } from '../types';
+import { NetworkNumber } from '../types/common';
+export declare const getAaveUnderlyingSymbol: (_symbol?: string) => any;
+/**
+ * aEthLidoUSDC -> aUSDC
+ * USDC -> USDC
+ */
+export declare const formatAaveAsset: (_symbol: string) => string;
+export declare const getMerkleCampaigns: (chainId: NetworkNumber) => Promise<MerkleRewardMap>;

package/esm/aaveV3/merkl.js

@@ -0,0 +1,82 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { aprToApy } from '../moneymarket';
+import { DEFAULT_TIMEOUT, wethToEth } from '../services/utils';
+import { OpportunityAction, OpportunityStatus, } from '../types';
+export const getAaveUnderlyingSymbol = (_symbol = '') => {
+    let symbol = _symbol
+        .replace(/^aEthLido/, '')
+        .replace(/^aEthEtherFi/, '')
+        .replace(/^aEth/, '')
+        .replace(/^aArb/, '')
+        .replace(/^aOpt/, '')
+        .replace(/^aBas/, '')
+        .replace(/^aLin/, '');
+    if (symbol.startsWith('a'))
+        symbol = symbol.slice(1);
+    return wethToEth(symbol);
+};
+/**
+ * aEthLidoUSDC -> aUSDC
+ * USDC -> USDC
+ */
+export const formatAaveAsset = (_symbol) => {
+    if (_symbol.startsWith('a')) {
+        return `a${getAaveUnderlyingSymbol(_symbol)}`;
+    }
+    return _symbol;
+};
+export const getMerkleCampaigns = (chainId) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield fetch('https://api.merkl.xyz/v4/opportunities?mainProtocolId=aave', {
+            signal: AbortSignal.timeout(DEFAULT_TIMEOUT),
+        });
+        if (!res.ok)
+            throw new Error('Failed to fetch Merkle campaigns');
+        const opportunities = yield res.json();
+        const relevantOpportunities = opportunities
+            .filter((o) => o.chainId === chainId)
+            .filter((o) => o.status === OpportunityStatus.LIVE);
+        return relevantOpportunities.reduce((acc, opportunity) => {
+            var _a, _b;
+            const rewardToken = opportunity.rewardsRecord.breakdowns[0].token;
+            const description = `Eligible for ${formatAaveAsset(rewardToken.symbol)} rewards through Merkl. ${opportunity.description ? `\n${opportunity.description}` : ''}`;
+            if (opportunity.action === OpportunityAction.LEND && opportunity.explorerAddress) {
+                const supplyAToken = (_a = opportunity.explorerAddress) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+                if (!acc[supplyAToken])
+                    acc[supplyAToken] = {};
+                acc[supplyAToken].supply = {
+                    apy: aprToApy(opportunity.apr),
+                    // rewardToken: rewardToken.address,
+                    rewardTokenSymbol: rewardToken.symbol,
+                    description,
+                    identifier: opportunity.identifier,
+                };
+            }
+            if (opportunity.action === OpportunityAction.BORROW && opportunity.explorerAddress) {
+                const borrowAToken = (_b = opportunity.explorerAddress) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+                if (!acc[borrowAToken])
+                    acc[borrowAToken] = {};
+                acc[borrowAToken].borrow = {
+                    apy: aprToApy(opportunity.apr),
+                    // rewardToken: rewardToken.address,
+                    rewardTokenSymbol: rewardToken.symbol,
+                    description,
+                    identifier: opportunity.identifier,
+                };
+            }
+            return acc;
+        }, {});
+    }
+    catch (e) {
+        console.error('Failed to fetch Merkle campaigns', e);
+        return {};
+    }
+});

package/esm/compoundV2/index.js

@@ -12,6 +12,7 @@ import Dec from 'decimal.js';
 import { BLOCKS_IN_A_YEAR } from '../constants';
 import { aprToApy } from '../moneymarket';
 import { compareAddresses, handleWbtcLegacy, wethToEth } from '../services/utils';
+import { IncentiveKind, } from '../types/common';
 import { CompoundLoanInfoContractViem, ComptrollerContractViem } from '../contracts';
 import { compoundV2CollateralAssets } from '../markets';
 import { getCompoundV2AggregatedData } from '../helpers/compoundHelpers';
@@ -33,9 +34,6 @@ export const _getCompoundV2MarketsData = (provider, network) => __awaiter(void 0
         const compBorrowSpeeds = market.compBorrowSpeeds.toString();
         const assetPrice = market.price.toString();
         const pricePrecisionDiff = 18 - getAssetInfo(getAssetInfoByAddress(cAddresses[i]).underlyingAsset).decimals;
-        // compSupplySpeeds/compBorrowSpeeds is per block per market (borrow & supply are separate markets)
-        const incentiveSupplyApy = aprToApy((100 * BLOCKS_IN_A_YEAR * +compSupplySpeeds * +compPrice) / +assetPrice / +totalSupply).toString();
-        const incentiveBorrowApy = aprToApy((100 * BLOCKS_IN_A_YEAR * +compBorrowSpeeds * +compPrice) / +assetPrice / +totalBorrow).toString();
         if (cAddresses[i].toLowerCase() === '0xc11b1268c1a384e55c48c2391d8d480264a3a7f4'.toLowerCase()) {
             symbol = 'WBTC Legacy';
             isWbtcLegacy = true;
@@ -45,10 +43,18 @@ export const _getCompoundV2MarketsData = (provider, network) => __awaiter(void 0
             underlyingTokenAddress: market.underlyingTokenAddress,
             supplyRate: aprToApy(new Dec(BLOCKS_IN_A_YEAR).times(market.supplyRate.toString()).div(1e16).toString()).toString(),
             borrowRate: aprToApy(new Dec(BLOCKS_IN_A_YEAR).times(market.borrowRate.toString()).div(1e16).toString()).toString(),
-            incentiveSupplyToken: 'COMP',
-            incentiveBorrowToken: 'COMP',
-            incentiveSupplyApy,
-            incentiveBorrowApy,
+            supplyIncentives: [{
+                    token: 'COMP',
+                    apy: aprToApy((100 * BLOCKS_IN_A_YEAR * +compSupplySpeeds * +compPrice) / +assetPrice / +totalSupply).toString(),
+                    incentiveKind: IncentiveKind.Reward,
+                    description: 'Eligible for protocol-level COMP incentives.',
+                }],
+            borrowIncentives: [{
+                    token: 'COMP',
+                    apy: aprToApy((100 * BLOCKS_IN_A_YEAR * +compBorrowSpeeds * +compPrice) / +assetPrice / +totalBorrow).toString(),
+                    incentiveKind: IncentiveKind.Reward,
+                    description: 'Eligible for protocol-level COMP incentives.',
+                }],
             collateralFactor: new Dec(market.collateralFactor.toString()).div(1e18).toString(),
             marketLiquidity: assetAmountInEth(market.marketLiquidity.toString(), handleWbtcLegacy(symbol)),
             utilization: new Dec(market.totalBorrow.toString()).div(totalSupply).times(100).toString(),

package/esm/compoundV3/index.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import Dec from 'decimal.js';
 import { assetAmountInEth, getAssetInfo, getAssetInfoByAddress, } from '@defisaver/tokens';
 import { CompV3ViewContractViem } from '../contracts';
+import { IncentiveKind, } from '../types/common';
 import { getStakingApy, STAKING_ASSETS, } from '../staking';
 import { ethToWeth, wethToEth } from '../services/utils';
 import { ZERO_ADDRESS } from '../constants';
@@ -43,13 +44,17 @@ export const _getCompoundV3MarketsData = (provider, network, selectedMarket, def
         .map((coll) => formatMarketData(coll, network, baseAssetPrice));
     for (const coll of colls) {
         if (STAKING_ASSETS.includes(coll.symbol)) {
-            coll.incentiveSupplyApy = yield getStakingApy(coll.symbol);
-            coll.incentiveSupplyToken = coll.symbol;
+            coll.supplyIncentives.push({
+                apy: yield getStakingApy(coll.symbol),
+                token: coll.symbol,
+                incentiveKind: IncentiveKind.Staking,
+                description: `Native ${coll.symbol} yield.`,
+            });
         }
     }
     const base = formatBaseData(baseTokenInfo, network, baseAssetPrice);
     const payload = {};
-    const baseObj = Object.assign(Object.assign({}, base), getIncentiveApys(base, compPrice));
+    const baseObj = Object.assign(Object.assign({}, base), (yield getIncentiveApys(base, compPrice)));
     const allAssets = [baseObj, ...colls];
     allAssets
         .sort((a, b) => {