@defisaver/positions-sdk 2.0.15-dev → 2.0.15-dev-3

package/esm/aaveV3/index.js

@@ -15,9 +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 { getAaveUnderlyingSymbol, getMerkleCampaigns } from './rewards';
+import { getMeritCampaigns } from './merit';
+import { getAaveUnderlyingSymbol, getMerkleCampaigns } from './merkl';
 export const aaveV3EmodeCategoriesMapping = (extractedState, usedAssets) => {
     const { eModeCategoriesData } = extractedState;
     const usedAssetsValues = Object.values(usedAssets);
@@ -52,12 +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, merkleRewardsMap] = 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 = {};
@@ -139,58 +141,76 @@ 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, index) => __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            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;
+                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) {
                     // when borrowing assets whose value increases over time
-                    _market.incentiveBorrowApy = new Dec(_market.incentiveSupplyApy).mul(-1).toString();
-                    _market.incentiveBorrowToken = _market.symbol;
                     _market.borrowIncentives.push({
-                        apy: _market.incentiveBorrowApy,
-                        token: _market.incentiveBorrowToken,
-                        incentiveKind: 'reward',
+                        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 { apr, rewardTokenSymbol, description } = merkleRewardsMap[aTokenAddress].supply;
+                const { apy, rewardTokenSymbol, description, identifier, } = merkleRewardsMap[aTokenAddress].supply;
                 _market.supplyIncentives.push({
-                    apy: aprToApy(apr),
+                    apy,
                     token: rewardTokenSymbol,
-                    incentiveKind: 'reward',
+                    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,
+                    token: rewardTokenSymbol,
+                    incentiveKind: IncentiveKind.Reward,
+                    description,
+                    eligibilityId: identifier,
+                });
+            }
+            if (meritRewardsMap.supply[_market.symbol]) {
+                const { apy, rewardTokenSymbol, description } = meritRewardsMap.supply[_market.symbol];
+                _market.supplyIncentives.push({
+                    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,
                 });
             }
-            // const aTokenDebtAddress = '0xTODO';
-            // if (merkleRewardsMap[aTokenDebtAddress]?.supply) {
-            //   const { apr, rewardTokenSymbol, description } = merkleRewardsMap[aTokenDebtAddress].supply;
-            //   _market.borrowIncentives.push({
-            //     apy: aprToApy(apr),
-            //     token: rewardTokenSymbol,
-            //     incentiveKind: 'reward',
-            //     description,
-            //   });
-            // }
             if (!rewardForMarket)
                 return;
             // @ts-ignore
@@ -198,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();
@@ -211,12 +228,10 @@ 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();
                     _market.supplyIncentives.push({
                         token: getAaveUnderlyingSymbol(supplyRewardData.rewardTokenSymbol),
                         apy: rewardApy,
-                        incentiveKind: 'reward',
+                        incentiveKind: IncentiveKind.Reward,
                         description: 'Eligible for protocol-level incentives.',
                     });
                 }
@@ -226,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();
@@ -238,12 +250,10 @@ 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();
                     _market.borrowIncentives.push({
                         token: getAaveUnderlyingSymbol(borrowRewardData.rewardTokenSymbol),
                         apy: rewardApy,
-                        incentiveKind: 'reward',
+                        incentiveKind: IncentiveKind.Reward,
                         description: 'Eligible for protocol-level incentives.',
                     });
                 }

package/esm/aaveV3/merit.d.ts

@@ -0,0 +1,17 @@
+import { NetworkNumber } from '../types/common';
+import { AaveVersions } from '../types';
+type RewardInfo = {
+    apy: string;
+    rewardTokenSymbol: string;
+    description: string;
+};
+type MeritTokenRewardMap = {
+    supply: Record<string, RewardInfo>;
+    borrow: Record<string, RewardInfo>;
+};
+/**
+ * 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>;
+export {};

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/{rewards.d.ts → merkl.d.ts}

@@ -1,14 +1,19 @@
 import { EthAddress, NetworkNumber } from '../types/common';
 type RewardInfo = {
-    apr: number;
-    rewardToken: EthAddress;
+    apy: string;
     rewardTokenSymbol: string;
     description: string;
+    identifier: string;
 };
 type MerkleRewardMap = Record<EthAddress, {
     supply?: RewardInfo;
     borrow?: RewardInfo;
 }>;
 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>;
 export {};

package/esm/aaveV3/{rewards.js → merkl.js}

@@ -7,6 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { aprToApy } from '../moneymarket';
 import { DEFAULT_TIMEOUT, wethToEth } from '../services/utils';
 var OpportunityAction;
 (function (OpportunityAction) {
@@ -32,6 +33,16 @@ export const getAaveUnderlyingSymbol = (_symbol = '') => {
         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', {
@@ -42,29 +53,33 @@ export const getMerkleCampaigns = (chainId) => __awaiter(void 0, void 0, void 0,
         const opportunities = yield res.json();
         const relevantOpportunities = opportunities
             .filter((o) => o.chainId === chainId)
-            .filter((o) => o.liveCampaigns > 0);
+            .filter((o) => o.status === OpportunityStatus.LIVE);
         return relevantOpportunities.reduce((acc, opportunity) => {
+            var _a, _b;
             const rewardToken = opportunity.rewardsRecord.breakdowns[0].token;
-            if (opportunity.action === OpportunityAction.LEND) {
-                const supplyAToken = opportunity.explorerAddress.toLowerCase();
+            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 = {
-                    apr: opportunity.apr,
-                    rewardToken: rewardToken.address,
-                    rewardTokenSymbol: getAaveUnderlyingSymbol(rewardToken.symbol),
-                    description: `Eligible for incentives through Merkl. \n${opportunity.description}`,
+                    apy: aprToApy(opportunity.apr),
+                    // rewardToken: rewardToken.address,
+                    rewardTokenSymbol: rewardToken.symbol,
+                    description,
+                    identifier: opportunity.identifier,
                 };
             }
-            if (opportunity.action === OpportunityAction.BORROW) {
-                const borrowAToken = opportunity.explorerAddress.toLowerCase();
+            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 = {
-                    apr: opportunity.apr,
-                    rewardToken: rewardToken.address,
-                    rewardTokenSymbol: getAaveUnderlyingSymbol(rewardToken.symbol),
-                    description: `Eligible for incentives through Merkl. \n${opportunity.description}`,
+                    apy: aprToApy(opportunity.apr),
+                    // rewardToken: rewardToken.address,
+                    rewardTokenSymbol: rewardToken.symbol,
+                    description,
+                    identifier: opportunity.identifier,
                 };
             }
             return acc;

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,8 +44,12 @@ 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);