@defisaver/positions-sdk 2.1.2 → 2.1.4

package/src/aaveV3/merit.ts

@@ -1,94 +1,94 @@
-
-import { DEFAULT_TIMEOUT } from '../services/utils';
-import { NetworkNumber } from '../types/common';
-import { aprToApy } from '../moneymarket';
-import { AaveVersions, MeritTokenRewardMap } 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:
-Record<
-NetworkNumber,
-Partial<Record<
-AaveVersions,
-Record<string, {
-  rewardTokenSymbol: string;
-  action: 'supply' | 'borrow' | 'stake';
-  message?: string;
-  supplyTokens?: string[],
-  borrowTokens?: string[],
-}>
->>
-> = {
-  [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 = async (): Promise<Record<string, number | null>> => {
-  try {
-    const response = await fetch('https://apps.aavechan.com/api/merit/aprs', {
-      signal: AbortSignal.timeout(DEFAULT_TIMEOUT),
-    });
-    const data = await response.json();
-    return data.currentAPR.actionsAPR as Record<string, number | null>;
-  } catch (error) {
-    console.error('Failed to fetch merit rewards data:', error);
-    return {};
-  }
-};
-
-export const getMeritCampaigns = async (chainId: NetworkNumber, market: AaveVersions): Promise<MeritTokenRewardMap> => {
-  const meritData = await fetchMeritRewardsData();
-  const relevantCampaigns = {
-    supply: {},
-    borrow: {},
-  } as MeritTokenRewardMap;
-  Object.entries(MERIT_DATA_MAP[chainId]?.[market] || {})
-    .filter(([key, rewardData]) => !!meritData[key])
-    .forEach(([key, rewardData]) => {
-      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}` : ''}`,
-      };
-      rewardData.supplyTokens?.forEach(token => {
-        relevantCampaigns.supply[token] = reward;
-      });
-      rewardData.borrowTokens?.forEach(token => {
-        relevantCampaigns.borrow[token] = reward;
-      });
-    });
-  return relevantCampaigns;
-};
+
+import { DEFAULT_TIMEOUT } from '../services/utils';
+import { NetworkNumber } from '../types/common';
+import { aprToApy } from '../moneymarket';
+import { AaveVersions, MeritTokenRewardMap } 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:
+Record<
+NetworkNumber,
+Partial<Record<
+AaveVersions,
+Record<string, {
+  rewardTokenSymbol: string;
+  action: 'supply' | 'borrow' | 'stake';
+  message?: string;
+  supplyTokens?: string[],
+  borrowTokens?: string[],
+}>
+>>
+> = {
+  [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 = async (): Promise<Record<string, number | null>> => {
+  try {
+    const response = await fetch('https://apps.aavechan.com/api/merit/aprs', {
+      signal: AbortSignal.timeout(DEFAULT_TIMEOUT),
+    });
+    const data = await response.json();
+    return data.currentAPR.actionsAPR as Record<string, number | null>;
+  } catch (error) {
+    console.error('Failed to fetch merit rewards data:', error);
+    return {};
+  }
+};
+
+export const getMeritCampaigns = async (chainId: NetworkNumber, market: AaveVersions): Promise<MeritTokenRewardMap> => {
+  const meritData = await fetchMeritRewardsData();
+  const relevantCampaigns = {
+    supply: {},
+    borrow: {},
+  } as MeritTokenRewardMap;
+  Object.entries(MERIT_DATA_MAP[chainId]?.[market] || {})
+    .filter(([key, rewardData]) => !!meritData[key])
+    .forEach(([key, rewardData]) => {
+      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}` : ''}`,
+      };
+      rewardData.supplyTokens?.forEach(token => {
+        relevantCampaigns.supply[token] = reward;
+      });
+      rewardData.borrowTokens?.forEach(token => {
+        relevantCampaigns.borrow[token] = reward;
+      });
+    });
+  return relevantCampaigns;
+};

package/src/aaveV3/merkl.ts

@@ -1,74 +1,74 @@
-import { aprToApy } from '../moneymarket';
-import { DEFAULT_TIMEOUT, wethToEth } from '../services/utils';
-import {
-  MerkleRewardMap, MerklOpportunity, OpportunityAction, OpportunityStatus,
-} from '../types';
-import { EthAddress, NetworkNumber } from '../types/common';
-
-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: string) => {
-  if (_symbol.startsWith('a')) {
-    return `a${getAaveUnderlyingSymbol(_symbol)}`;
-  }
-  return _symbol;
-};
-
-export const getMerkleCampaigns = async (chainId: NetworkNumber): Promise<MerkleRewardMap> => {
-  try {
-    const res = await 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 = await res.json() as MerklOpportunity[];
-    const relevantOpportunities = opportunities
-      .filter((o: MerklOpportunity) => o.chainId === chainId)
-      .filter((o: MerklOpportunity) => o.status === OpportunityStatus.LIVE);
-    return relevantOpportunities.reduce((acc, opportunity) => {
-      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 = opportunity.explorerAddress?.toLowerCase() as EthAddress;
-        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 = opportunity.explorerAddress?.toLowerCase() as EthAddress;
-        if (!acc[borrowAToken]) acc[borrowAToken] = {};
-        acc[borrowAToken].borrow = {
-          apy: aprToApy(opportunity.apr),
-          // rewardToken: rewardToken.address,
-          rewardTokenSymbol: rewardToken.symbol,
-          description,
-          identifier: opportunity.identifier,
-        };
-      }
-      return acc;
-    }, {} as MerkleRewardMap);
-  } catch (e) {
-    console.error('Failed to fetch Merkle campaigns', e);
-    return {};
-  }
-};
-
+import { aprToApy } from '../moneymarket';
+import { DEFAULT_TIMEOUT, wethToEth } from '../services/utils';
+import {
+  MerkleRewardMap, MerklOpportunity, OpportunityAction, OpportunityStatus,
+} from '../types';
+import { EthAddress, NetworkNumber } from '../types/common';
+
+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: string) => {
+  if (_symbol.startsWith('a')) {
+    return `a${getAaveUnderlyingSymbol(_symbol)}`;
+  }
+  return _symbol;
+};
+
+export const getMerkleCampaigns = async (chainId: NetworkNumber): Promise<MerkleRewardMap> => {
+  try {
+    const res = await 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 = await res.json() as MerklOpportunity[];
+    const relevantOpportunities = opportunities
+      .filter((o: MerklOpportunity) => o.chainId === chainId)
+      .filter((o: MerklOpportunity) => o.status === OpportunityStatus.LIVE);
+    return relevantOpportunities.reduce((acc, opportunity) => {
+      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 = opportunity.explorerAddress?.toLowerCase() as EthAddress;
+        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 = opportunity.explorerAddress?.toLowerCase() as EthAddress;
+        if (!acc[borrowAToken]) acc[borrowAToken] = {};
+        acc[borrowAToken].borrow = {
+          apy: aprToApy(opportunity.apr),
+          // rewardToken: rewardToken.address,
+          rewardTokenSymbol: rewardToken.symbol,
+          description,
+          identifier: opportunity.identifier,
+        };
+      }
+      return acc;
+    }, {} as MerkleRewardMap);
+  } catch (e) {
+    console.error('Failed to fetch Merkle campaigns', e);
+    return {};
+  }
+};
+

package/src/claiming/aaveV3.ts

@@ -1,155 +1,155 @@
-import { Client } from 'viem';
-import Dec from 'decimal.js';
-import { EthAddress, NetworkNumber } from '../types/common';
-import { ClaimableToken, ClaimType } from '../types/claiming';
-import {
-  AaveIncentiveDataProviderV3ContractViem,
-  AaveRewardsControllerViem,
-} from '../contracts';
-import { compareAddresses, getEthAmountForDecimals } from '../services/utils';
-import { getAaveUnderlyingSymbol } from '../helpers/aaveHelpers';
-
-type AaveReward = {
-  amount: string;
-  symbol: string;
-  underlyingAsset: string;
-  rewardTokenAddress: string;
-  aTokenAddresses: string[];
-};
-
-const mapAaveRewardsToClaimableTokens = (aaveRewards: AaveReward[], marketAddress: EthAddress, walletAddress: EthAddress) => aaveRewards.map(reward => ({
-  symbol: reward.symbol,
-  amount: reward.amount,
-  claimType: ClaimType.AAVE_REWARDS as const,
-  tokenAddress: reward.rewardTokenAddress as EthAddress,
-  underlyingSymbol: reward.underlyingAsset,
-  walletAddress,
-  label: 'AAVE Rewards',
-  additionalClaimFields: {
-    marketAddress,
-    aTokenAddresses: reward.aTokenAddresses,
-    isAaveToken: reward.symbol.startsWith('a'),
-  },
-}));
-
-export async function getUnclaimedRewardsForAllMarkets(
-  provider: Client,
-  network: NetworkNumber,
-  walletAddress: EthAddress,
-  marketAddress: EthAddress,
-): Promise<ClaimableToken[]> {
-  const contract = AaveIncentiveDataProviderV3ContractViem(provider, network);
-  const tokensData = await contract.read.getUserReservesIncentivesData([marketAddress, walletAddress]);
-  const allTokensDataArrays = tokensData.reduce((acc: any[], val) => {
-    acc.push(val.aTokenIncentivesUserData.userRewardsInformation);
-    acc.push(val.vTokenIncentivesUserData.userRewardsInformation);
-    return acc;
-  }, []);
-  const allATokens = tokensData.reduce((acc, val) => {
-    acc.push(val.aTokenIncentivesUserData.tokenAddress);
-    acc.push(val.vTokenIncentivesUserData.tokenAddress);
-    return acc;
-  }, [] as string[]);
-  // array of rewards for each market (aToken/vToken)
-  // reward can be any token like wstETH, but also aToken like aWETH
-  const aaveRewardsController = AaveRewardsControllerViem(provider, network);
-  const rewardsPerAAsset = await Promise.all(allATokens.map(
-    (token: string) => aaveRewardsController.read.getAllUserRewards([[token as EthAddress], walletAddress])));
-
-  // match amounts to token symbol, parse decimal amounts
-  const rewardsPerAAssetWithInfo = rewardsPerAAsset.map((rewardForAAsset, aaIndex) => {
-    const rewardsList = rewardForAAsset[0];
-    const amounts = rewardForAAsset[1];
-
-    const rewardsDataArraysForAAsset = allTokensDataArrays[aaIndex];
-    const aTokenAddress = allATokens[aaIndex];
-    return rewardsList.map((rewardTokenAddress, rewardIndex) => {
-      const dataArrIndex = rewardsDataArraysForAAsset.findIndex((arr: { rewardTokenAddress: string | undefined; }) => compareAddresses(arr.rewardTokenAddress, rewardTokenAddress));
-      const amountWei = amounts[rewardIndex];
-      const amount = getEthAmountForDecimals(amountWei.toString(), rewardsDataArraysForAAsset[dataArrIndex]?.rewardTokenDecimals);
-      const symbol = rewardsDataArraysForAAsset[dataArrIndex]?.rewardTokenSymbol || '';
-      const underlyingAsset = getAaveUnderlyingSymbol(symbol);
-      return ({
-        amount,
-        symbol,
-        underlyingAsset,
-        rewardTokenAddress,
-        aTokenAddress,
-      });
-    });
-  });
-
-  // sum all unclaimed rewards of all markets per each token
-  // (e.g. how much awstETH is claimable in total from both aUSDC and awstETH markets)
-  const totalUnclaimedPerRewardToken: Record<string, any> = {};
-  rewardsPerAAssetWithInfo
-    .flat()
-    .forEach(({
-      amount, symbol, underlyingAsset, rewardTokenAddress, aTokenAddress,
-    }) => {
-      if (+amount > 0) {
-        if (!totalUnclaimedPerRewardToken[symbol]) {
-          totalUnclaimedPerRewardToken[symbol] = {
-            amount, symbol, underlyingAsset, rewardTokenAddress, aTokenAddresses: [aTokenAddress],
-          };
-        } else {
-          totalUnclaimedPerRewardToken[symbol].amount =
-                new Dec(totalUnclaimedPerRewardToken[symbol].amount).add(amount).toString();
-          totalUnclaimedPerRewardToken[symbol].aTokenAddresses.push(aTokenAddress);
-        }
-      }
-    }, []);
-
-  return mapAaveRewardsToClaimableTokens(Object.values(totalUnclaimedPerRewardToken), marketAddress, walletAddress);
-}
-
-export async function getMeritUnclaimedRewards(account: EthAddress, network: NetworkNumber, acceptMorpho: boolean = true): Promise<ClaimableToken[]> {
-  let data;
-  try {
-    const res = await fetch(`https://api.merkl.xyz/v4/users/${account}/rewards?chainId=${network}`,
-      { signal: AbortSignal.timeout(3000) });
-    data = await res.json();
-  } catch (error) {
-    console.error('External API Failure: Aave Merit', error);
-    data = [];
-  }
-
-  const claimableTokens: ClaimableToken[] = [];
-
-  data.forEach((item: { rewards: any[]; }) => {
-    item.rewards.forEach(reward => {
-      const {
-        token,
-        amount,
-        claimed,
-        proofs,
-      } = reward;
-
-      const isTokenMorpho = token.symbol === 'MORPHO';
-      if (!token || !token.symbol || amount === '0' || (isTokenMorpho && !acceptMorpho)) return;
-
-      const unclaimedAmount = new Dec(amount).minus(claimed || 0).toString();
-      if (unclaimedAmount === '0') return;
-
-      const unclaimed = getEthAmountForDecimals(unclaimedAmount, token.decimals);
-
-      claimableTokens.push({
-        claimType: ClaimType.AAVE_MERIT_REWARDS,
-        amount: unclaimed,
-        symbol: token.symbol,
-        tokenAddress: token.address,
-        walletAddress: account,
-        label: 'AAVE Merit Rewards',
-        underlyingSymbol: getAaveUnderlyingSymbol(token.symbol),
-        additionalClaimFields: {
-          accumulated: amount,
-          proof: proofs,
-          decimals: token.decimals,
-          unclaimed: unclaimedAmount,
-        },
-      });
-    });
-  });
-
-  return claimableTokens;
+import { Client } from 'viem';
+import Dec from 'decimal.js';
+import { EthAddress, NetworkNumber } from '../types/common';
+import { ClaimableToken, ClaimType } from '../types/claiming';
+import {
+  AaveIncentiveDataProviderV3ContractViem,
+  AaveRewardsControllerViem,
+} from '../contracts';
+import { compareAddresses, getEthAmountForDecimals } from '../services/utils';
+import { getAaveUnderlyingSymbol } from '../helpers/aaveHelpers';
+
+type AaveReward = {
+  amount: string;
+  symbol: string;
+  underlyingAsset: string;
+  rewardTokenAddress: string;
+  aTokenAddresses: string[];
+};
+
+const mapAaveRewardsToClaimableTokens = (aaveRewards: AaveReward[], marketAddress: EthAddress, walletAddress: EthAddress) => aaveRewards.map(reward => ({
+  symbol: reward.symbol,
+  amount: reward.amount,
+  claimType: ClaimType.AAVE_REWARDS as const,
+  tokenAddress: reward.rewardTokenAddress as EthAddress,
+  underlyingSymbol: reward.underlyingAsset,
+  walletAddress,
+  label: 'AAVE Rewards',
+  additionalClaimFields: {
+    marketAddress,
+    aTokenAddresses: reward.aTokenAddresses,
+    isAaveToken: reward.symbol.startsWith('a'),
+  },
+}));
+
+export async function getUnclaimedRewardsForAllMarkets(
+  provider: Client,
+  network: NetworkNumber,
+  walletAddress: EthAddress,
+  marketAddress: EthAddress,
+): Promise<ClaimableToken[]> {
+  const contract = AaveIncentiveDataProviderV3ContractViem(provider, network);
+  const tokensData = await contract.read.getUserReservesIncentivesData([marketAddress, walletAddress]);
+  const allTokensDataArrays = tokensData.reduce((acc: any[], val) => {
+    acc.push(val.aTokenIncentivesUserData.userRewardsInformation);
+    acc.push(val.vTokenIncentivesUserData.userRewardsInformation);
+    return acc;
+  }, []);
+  const allATokens = tokensData.reduce((acc, val) => {
+    acc.push(val.aTokenIncentivesUserData.tokenAddress);
+    acc.push(val.vTokenIncentivesUserData.tokenAddress);
+    return acc;
+  }, [] as string[]);
+  // array of rewards for each market (aToken/vToken)
+  // reward can be any token like wstETH, but also aToken like aWETH
+  const aaveRewardsController = AaveRewardsControllerViem(provider, network);
+  const rewardsPerAAsset = await Promise.all(allATokens.map(
+    (token: string) => aaveRewardsController.read.getAllUserRewards([[token as EthAddress], walletAddress])));
+
+  // match amounts to token symbol, parse decimal amounts
+  const rewardsPerAAssetWithInfo = rewardsPerAAsset.map((rewardForAAsset, aaIndex) => {
+    const rewardsList = rewardForAAsset[0];
+    const amounts = rewardForAAsset[1];
+
+    const rewardsDataArraysForAAsset = allTokensDataArrays[aaIndex];
+    const aTokenAddress = allATokens[aaIndex];
+    return rewardsList.map((rewardTokenAddress, rewardIndex) => {
+      const dataArrIndex = rewardsDataArraysForAAsset.findIndex((arr: { rewardTokenAddress: string | undefined; }) => compareAddresses(arr.rewardTokenAddress, rewardTokenAddress));
+      const amountWei = amounts[rewardIndex];
+      const amount = getEthAmountForDecimals(amountWei.toString(), rewardsDataArraysForAAsset[dataArrIndex]?.rewardTokenDecimals);
+      const symbol = rewardsDataArraysForAAsset[dataArrIndex]?.rewardTokenSymbol || '';
+      const underlyingAsset = getAaveUnderlyingSymbol(symbol);
+      return ({
+        amount,
+        symbol,
+        underlyingAsset,
+        rewardTokenAddress,
+        aTokenAddress,
+      });
+    });
+  });
+
+  // sum all unclaimed rewards of all markets per each token
+  // (e.g. how much awstETH is claimable in total from both aUSDC and awstETH markets)
+  const totalUnclaimedPerRewardToken: Record<string, any> = {};
+  rewardsPerAAssetWithInfo
+    .flat()
+    .forEach(({
+      amount, symbol, underlyingAsset, rewardTokenAddress, aTokenAddress,
+    }) => {
+      if (+amount > 0) {
+        if (!totalUnclaimedPerRewardToken[symbol]) {
+          totalUnclaimedPerRewardToken[symbol] = {
+            amount, symbol, underlyingAsset, rewardTokenAddress, aTokenAddresses: [aTokenAddress],
+          };
+        } else {
+          totalUnclaimedPerRewardToken[symbol].amount =
+                new Dec(totalUnclaimedPerRewardToken[symbol].amount).add(amount).toString();
+          totalUnclaimedPerRewardToken[symbol].aTokenAddresses.push(aTokenAddress);
+        }
+      }
+    }, []);
+
+  return mapAaveRewardsToClaimableTokens(Object.values(totalUnclaimedPerRewardToken), marketAddress, walletAddress);
+}
+
+export async function getMeritUnclaimedRewards(account: EthAddress, network: NetworkNumber, acceptMorpho: boolean = true): Promise<ClaimableToken[]> {
+  let data;
+  try {
+    const res = await fetch(`https://api.merkl.xyz/v4/users/${account}/rewards?chainId=${network}`,
+      { signal: AbortSignal.timeout(3000) });
+    data = await res.json();
+  } catch (error) {
+    console.error('External API Failure: Aave Merit', error);
+    data = [];
+  }
+
+  const claimableTokens: ClaimableToken[] = [];
+
+  data.forEach((item: { rewards: any[]; }) => {
+    item.rewards.forEach(reward => {
+      const {
+        token,
+        amount,
+        claimed,
+        proofs,
+      } = reward;
+
+      const isTokenMorpho = token.symbol === 'MORPHO';
+      if (!token || !token.symbol || amount === '0' || (isTokenMorpho && !acceptMorpho)) return;
+
+      const unclaimedAmount = new Dec(amount).minus(claimed || 0).toString();
+      if (unclaimedAmount === '0') return;
+
+      const unclaimed = getEthAmountForDecimals(unclaimedAmount, token.decimals);
+
+      claimableTokens.push({
+        claimType: ClaimType.AAVE_MERIT_REWARDS,
+        amount: unclaimed,
+        symbol: token.symbol,
+        tokenAddress: token.address,
+        walletAddress: account,
+        label: 'AAVE Merit Rewards',
+        underlyingSymbol: getAaveUnderlyingSymbol(token.symbol),
+        additionalClaimFields: {
+          accumulated: amount,
+          proof: proofs,
+          decimals: token.decimals,
+          unclaimed: unclaimedAmount,
+        },
+      });
+    });
+  });
+
+  return claimableTokens;
 }