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

package/cjs/types/fluid.d.ts

@@ -1,4 +1,4 @@
-import { EthAddress, NetworkNumber } from './common';
+import { EthAddress, IncentiveData, NetworkNumber } from './common';
 export interface FluidMarketInfo {
     chainIds: number[];
     label: string;
@@ -181,10 +181,8 @@ export interface FluidAssetData {
     symbol: string;
     address: string;
     price: string;
-    incentiveSupplyApy?: string;
-    incentiveSupplyToken?: string;
-    incentiveBorrowApy?: string;
-    incentiveBorrowToken?: string;
+    supplyIncentives: IncentiveData[];
+    borrowIncentives: IncentiveData[];
     totalSupply: string;
     totalBorrow: string;
     canBeSupplied: boolean;

package/cjs/types/index.d.ts

@@ -10,3 +10,5 @@ export * from './llamaLend';
 export * from './euler';
 export * from './fluid';
 export * from './portfolio';
+export * from './merit';
+export * from './merkl';

package/cjs/types/index.js

@@ -26,3 +26,5 @@ __exportStar(require("./llamaLend"), exports);
 __exportStar(require("./euler"), exports);
 __exportStar(require("./fluid"), exports);
 __exportStar(require("./portfolio"), exports);
+__exportStar(require("./merit"), exports);
+__exportStar(require("./merkl"), exports);

package/cjs/types/liquityV2.d.ts

@@ -1,4 +1,4 @@
-import { EthAddress, NetworkNumber } from './common';
+import { EthAddress, IncentiveData, NetworkNumber } from './common';
 export declare enum LiquityV2Versions {
     LiquityV2Eth = "liquityv2eth",
     LiquityV2WstEth = "liquityv2wsteth",
@@ -37,14 +37,14 @@ export interface LiquityV2AssetData {
     symbol: string;
     address: string;
     price: string;
-    incentiveSupplyApy?: string;
-    incentiveSupplyToken?: string;
     totalSupply: string;
     totalBorrow: string;
     canBeSupplied: boolean;
     canBeBorrowed: boolean;
     leftToBorrowGlobal: string;
     leftToWithdrawGlobal: string;
+    supplyIncentives: IncentiveData[];
+    borrowIncentives: IncentiveData[];
 }
 export type LiquityV2AssetsData = {
     [key: string]: LiquityV2AssetData;

package/cjs/types/llamaLend.d.ts

@@ -1,4 +1,4 @@
-import { EthAddress, NetworkNumber } from './common';
+import { EthAddress, IncentiveData, NetworkNumber } from './common';
 import { BandData, UserBandData } from './curveUsd';
 export declare enum LLVersionsEth {
     LLWstethCrvusd = "llamaLendwstETHcrvUSD",
@@ -74,6 +74,8 @@ export interface LlamaLendAssetData {
     canBeSupplied?: boolean;
     canBeBorrowed?: boolean;
     shares?: string;
+    supplyIncentives: IncentiveData[];
+    borrowIncentives: IncentiveData[];
 }
 export type LlamaLendAssetsData = {
     [key: string]: LlamaLendAssetData;

package/cjs/types/merit.d.ts

@@ -0,0 +1,9 @@
+export type MeritRewardInfo = {
+    apy: string;
+    rewardTokenSymbol: string;
+    description: string;
+};
+export type MeritTokenRewardMap = {
+    supply: Record<string, MeritRewardInfo>;
+    borrow: Record<string, MeritRewardInfo>;
+};

package/cjs/types/merit.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/types/merkl.d.ts

@@ -0,0 +1,75 @@
+import { EthAddress } from './common';
+export declare enum OpportunityAction {
+    LEND = "LEND",
+    BORROW = "BORROW"
+}
+export declare enum OpportunityStatus {
+    LIVE = "LIVE",
+    PAST = "PAST",
+    UPCOMING = "UPCOMING"
+}
+export type MerklOpportunity = {
+    chainId: number;
+    type: string;
+    identifier: EthAddress;
+    name: string;
+    status: OpportunityStatus;
+    action: OpportunityAction;
+    tvl: number;
+    apr: number;
+    dailyRewards: number;
+    tags: [];
+    id: string;
+    explorerAddress?: EthAddress;
+    description?: string;
+    tokens: {
+        id: string;
+        name: string;
+        chainId: number;
+        address: EthAddress;
+        decimals: number;
+        icon: string;
+        verified: boolean;
+        isTest: boolean;
+        price: number;
+        symbol: string;
+    }[];
+    rewardsRecord: {
+        id: string;
+        total: number;
+        timestamp: string;
+        breakdowns: {
+            token: {
+                id: string;
+                name: string;
+                chainId: number;
+                address: EthAddress;
+                decimals: number;
+                symbol: string;
+                displaySymbol: string;
+                icon: string;
+                verified: boolean;
+                isTest: boolean;
+                type: string;
+                isNative: boolean;
+                price: number;
+            };
+            amount: string;
+            value: number;
+            distributionType: string;
+            id: string;
+            campaignId: string;
+            dailyRewardsRecordId: string;
+        }[];
+    };
+};
+export type MerkleRewardInfo = {
+    apy: string;
+    rewardTokenSymbol: string;
+    description: string;
+    identifier: string;
+};
+export type MerkleRewardMap = Record<EthAddress, {
+    supply?: MerkleRewardInfo;
+    borrow?: MerkleRewardInfo;
+}>;

package/cjs/types/merkl.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpportunityStatus = exports.OpportunityAction = void 0;
+var OpportunityAction;
+(function (OpportunityAction) {
+    OpportunityAction["LEND"] = "LEND";
+    OpportunityAction["BORROW"] = "BORROW";
+})(OpportunityAction || (exports.OpportunityAction = OpportunityAction = {}));
+var OpportunityStatus;
+(function (OpportunityStatus) {
+    OpportunityStatus["LIVE"] = "LIVE";
+    OpportunityStatus["PAST"] = "PAST";
+    OpportunityStatus["UPCOMING"] = "UPCOMING";
+})(OpportunityStatus || (exports.OpportunityStatus = OpportunityStatus = {}));

package/cjs/types/morphoBlue.d.ts

@@ -1,4 +1,4 @@
-import { EthAddress, MMUsedAssets, NetworkNumber } from './common';
+import { EthAddress, IncentiveData, MMUsedAssets, NetworkNumber } from './common';
 export declare enum MorphoBlueVersions {
     MorphoBlueWstEthUSDC = "morphobluewstethusdc",// wstETH/USDC
     MorphoBlueSDAIUSDC = "morphobluesdaiusdc",// sDAI/USDC
@@ -81,10 +81,8 @@ export interface MorphoBlueAssetData {
     price: string;
     supplyRate: string;
     borrowRate: string;
-    incentiveSupplyApy?: string;
-    incentiveSupplyToken?: string;
-    incentiveBorrowApy?: string;
-    incentiveBorrowToken?: string;
+    supplyIncentives: IncentiveData[];
+    borrowIncentives: IncentiveData[];
     totalSupply?: string;
     totalBorrow?: string;
     canBeSupplied?: boolean;

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 {};
+    }
+});