@defisaver/positions-sdk 2.0.13 → 2.0.14-dev-portfolio

package/esm/umbrella/index.d.ts

@@ -0,0 +1,5 @@
+import { Client } from 'viem';
+import { EthAddress, NetworkNumber } from '../types/common';
+export declare const getUmbrellaData: (provider: Client, network: NetworkNumber, address: EthAddress) => Promise<{
+    [k: string]: any;
+}>;

package/esm/umbrella/index.js

@@ -0,0 +1,46 @@
+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 { AaveUmbrellaViewViem, AaveV3ViewContractViem } from '../contracts';
+import { compareAddresses, convertHybridArraysToObjects, getEthAmountForDecimals } from '../services/utils';
+import { findMatching, tokenEntries } from './umbrellaUtils';
+const umbrella = '0xD400fc38ED4732893174325693a63C30ee3881a8';
+const aaveOracle = '0x54586bE62E3c3580375aE3723C145253060Ca0C2';
+export const getUmbrellaData = (provider, network, address) => __awaiter(void 0, void 0, void 0, function* () {
+    const umbrellaView = AaveUmbrellaViewViem(provider, network);
+    const aaveV3View = AaveV3ViewContractViem(provider, network);
+    const [tokensAggregatedData, additionalUmbrellaStakingData, userAggregatedData] = yield Promise.all([
+        umbrellaView.read.getTokensAggregatedData([umbrella, aaveOracle]),
+        aaveV3View.read.getAdditionalUmbrellaStakingData([umbrella, address]),
+        umbrellaView.read.getUserAggregatedData([umbrella, address]),
+    ]);
+    return Object.fromEntries(tokenEntries.map(([symbol, tokenAddr]) => {
+        // @ts-ignore
+        const fromTokens = convertHybridArraysToObjects(findMatching(tokensAggregatedData, tokenAddr));
+        // @ts-ignore
+        const fromUser = convertHybridArraysToObjects(findMatching(userAggregatedData, tokenAddr));
+        // @ts-ignore
+        const fromAdditionalData = convertHybridArraysToObjects(findMatching(additionalUmbrellaStakingData, tokenAddr));
+        const data = Object.assign(Object.assign(Object.assign(Object.assign({}, fromTokens), fromUser), fromAdditionalData), { account: {
+                stakeUserBalance: (fromUser === null || fromUser === void 0 ? void 0 : fromUser.stakeUserBalance) || '0',
+                rewardsTokenUserData: convertHybridArraysToObjects(fromUser === null || fromUser === void 0 ? void 0 : fromUser.rewardsTokenUserData) || [],
+                userCooldownAmount: (fromAdditionalData === null || fromAdditionalData === void 0 ? void 0 : fromAdditionalData.userCooldownAmount) || '0',
+                userEndOfCooldown: (fromAdditionalData === null || fromAdditionalData === void 0 ? void 0 : fromAdditionalData.userEndOfCooldown) || '0',
+                userWithdrawalWindow: (fromAdditionalData === null || fromAdditionalData === void 0 ? void 0 : fromAdditionalData.userWithdrawalWindow) || '0',
+            } });
+        const stakeTokenData = data.stakeTokenData;
+        return [symbol, Object.assign(Object.assign({}, data), { stakeTokenData: Object.assign(Object.assign({}, stakeTokenData), { price: getEthAmountForDecimals(stakeTokenData.price, 8) }), stkTokenToWaTokenRate: getEthAmountForDecimals(data.stkTokenToWaTokenRate, stakeTokenData.decimals), waTokenToATokenRate: getEthAmountForDecimals(data.waTokenToATokenRate, stakeTokenData.decimals), totalShares: getEthAmountForDecimals(data.totalShares, stakeTokenData.decimals), totalAssets: getEthAmountForDecimals(data.totalAssets, stakeTokenData.decimals), targetLiquidity: getEthAmountForDecimals(data.targetLiquidity, stakeTokenData.decimals), rewardsTokenData: data.rewardsTokenData.map((tokenData) => (Object.assign(Object.assign({}, tokenData), { rewardTokenData: Object.assign(Object.assign({}, tokenData.rewardTokenData), { price: getEthAmountForDecimals(tokenData.rewardTokenData.price, 8) }) }))), rewardsEmissionRates: data.rewardsEmissionRates.map((rate, i) => {
+                    const tokenData = data.rewardsTokenData[i].rewardTokenData;
+                    return getEthAmountForDecimals(rate, tokenData.decimals);
+                }), account: Object.assign(Object.assign({}, data.account), { stakeUserBalance: getEthAmountForDecimals(data.account.stakeUserBalance, stakeTokenData.decimals), userCooldownAmount: getEthAmountForDecimals(data.account.userCooldownAmount, stakeTokenData.decimals), rewardsTokenUserData: data.account.rewardsTokenUserData.map((reward) => {
+                        const tokenData = data.rewardsTokenData.find((tknData) => compareAddresses(tknData.rewardTokenData.token, reward.reward));
+                        return (Object.assign(Object.assign({}, reward), { currentReward: getEthAmountForDecimals(reward.currentReward, tokenData.rewardTokenData.decimals) }));
+                    }) }) })];
+    }));
+});

package/esm/umbrella/umbrellaUtils.d.ts

@@ -0,0 +1,22 @@
+export declare enum UmbrellaStaking {
+    UmbrellaGHO = "UmbrellaGHO",
+    UmbrellaUSDC = "UmbrellaUSDC",
+    UmbrellaUSDT = "UmbrellaUSDT",
+    UmbrellaETH = "UmbrellaETH"
+}
+export declare const tokenMapping: {
+    readonly UmbrellaUSDC: "0x6bf183243FdD1e306ad2C4450BC7dcf6f0bf8Aa6";
+    readonly UmbrellaUSDT: "0xA484Ab92fe32B143AEE7019fC1502b1dAA522D31";
+    readonly UmbrellaETH: "0xaAFD07D53A7365D3e9fb6F3a3B09EC19676B73Ce";
+    readonly UmbrellaGHO: "0x4f827A63755855cDf3e8f3bcD20265C833f15033";
+};
+export declare const normalize: (addr?: string) => string;
+export declare const tokenEntries: string[][];
+export declare const extractAddress: (item?: {
+    stakeToken?: string;
+    stkToken?: string;
+    stakeTokenData?: {
+        token?: string;
+    };
+}) => string;
+export declare const findMatching: (dataset: any[], targetAddr: string) => any;

package/esm/umbrella/umbrellaUtils.js

@@ -0,0 +1,28 @@
+export var UmbrellaStaking;
+(function (UmbrellaStaking) {
+    UmbrellaStaking["UmbrellaGHO"] = "UmbrellaGHO";
+    UmbrellaStaking["UmbrellaUSDC"] = "UmbrellaUSDC";
+    UmbrellaStaking["UmbrellaUSDT"] = "UmbrellaUSDT";
+    UmbrellaStaking["UmbrellaETH"] = "UmbrellaETH";
+})(UmbrellaStaking || (UmbrellaStaking = {}));
+export const tokenMapping = {
+    [UmbrellaStaking.UmbrellaUSDC]: '0x6bf183243FdD1e306ad2C4450BC7dcf6f0bf8Aa6',
+    [UmbrellaStaking.UmbrellaUSDT]: '0xA484Ab92fe32B143AEE7019fC1502b1dAA522D31',
+    [UmbrellaStaking.UmbrellaETH]: '0xaAFD07D53A7365D3e9fb6F3a3B09EC19676B73Ce',
+    [UmbrellaStaking.UmbrellaGHO]: '0x4f827A63755855cDf3e8f3bcD20265C833f15033',
+};
+// ----- chat gpt code for result mapping ---------
+export const normalize = (addr) => { var _a, _b; return (_b = (_a = addr === null || addr === void 0 ? void 0 : addr.toLowerCase) === null || _a === void 0 ? void 0 : _a.call(addr)) !== null && _b !== void 0 ? _b : ''; };
+export const tokenEntries = Object.entries(tokenMapping).map(([symbol, address]) => [
+    symbol,
+    normalize(address),
+]);
+// 👇 Define how to extract the token address from each source type
+export const extractAddress = (item) => {
+    var _a;
+    return normalize((item === null || item === void 0 ? void 0 : item.stakeToken)
+        || (item === null || item === void 0 ? void 0 : item.stkToken)
+        || ((_a = item === null || item === void 0 ? void 0 : item.stakeTokenData) === null || _a === void 0 ? void 0 : _a.token));
+};
+// 👇 Utility to find the matching object in a dataset
+export const findMatching = (dataset, targetAddr) => dataset.find((item) => extractAddress(item) === targetAddr);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/positions-sdk",
-  "version": "2.0.13",
+  "version": "2.0.14-dev-portfolio",
   "description": "",
   "main": "./cjs/index.js",
   "module": "./esm/index.js",
@@ -21,7 +21,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@defisaver/tokens": "^1.7.0",
+    "@defisaver/tokens": "^1.7.1",
     "@types/lodash": "^4.17.15",
     "@types/memoizee": "^0.4.12",
     "decimal.js": "^10.6.0",

package/src/aaveV2/index.ts

@@ -103,7 +103,8 @@ export const _getAaveV2AccountBalances = async (provider: Client, network: Netwo
   // @ts-ignore
   const protocolDataProviderContract = createViemContractFromConfigFunc(market.protocolData, market.protocolDataAddress)(provider, network);
 
-  const reserveTokens = await protocolDataProviderContract.read.getAllReservesTokens(setViemBlockNumber(block));
+  // @ts-ignore
+  const reserveTokens = await protocolDataProviderContract.read.getAllReservesTokens(setViemBlockNumber(block)) as { symbol: string, tokenAddress: EthAddress }[];
   const symbols = reserveTokens.map(({ symbol }: { symbol: string }) => symbol);
   const _addresses = reserveTokens.map(({ tokenAddress }: { tokenAddress: EthAddress }) => tokenAddress);
 

package/src/aaveV3/index.ts

@@ -3,8 +3,10 @@ import { Client } from 'viem';
 import Dec from 'decimal.js';
 import {
   AaveIncentiveDataProviderV3ContractViem,
+  AaveIncentivesControllerViem,
   AaveV3ViewContractViem,
   createViemContractFromConfigFunc,
+  StkAAVEViem,
 } from '../contracts';
 import { aaveAnyGetAggregatedPositionData, aaveV3IsInIsolationMode, aaveV3IsInSiloedMode } from '../helpers/aaveHelpers';
 import { AAVE_V3 } from '../markets/aave';
@@ -26,9 +28,10 @@ import {
   EModeCategoryDataMapping,
 } from '../types/aave';
 import {
-  Blockish, EthAddress, EthereumProvider, NetworkNumber, PositionBalances,
+  Blockish, EthAddress, EthereumProvider, HexString, NetworkNumber, PositionBalances,
 } from '../types/common';
 import { getViemProvider, setViemBlockNumber } from '../services/viem';
+import { SECONDS_PER_DAY, SECONDS_PER_YEAR } from '../constants';
 
 export const aaveV3EmodeCategoriesMapping = (extractedState: any, usedAssets: AaveV3UsedAssets) => {
   const { eModeCategoriesData }: { assetsData: AaveV3AssetsData, eModeCategoriesData: EModeCategoriesData } = extractedState;
@@ -337,7 +340,8 @@ export const _getAaveV3AccountBalances = async (provider: Client, network: Netwo
   // @ts-ignore
   const protocolDataProviderContract = createViemContractFromConfigFunc(market.protocolData, market.protocolDataAddress)(provider, network);
 
-  const reserveTokens = await protocolDataProviderContract.read.getAllReservesTokens(setViemBlockNumber(block));
+  // @ts-ignore
+  const reserveTokens = await protocolDataProviderContract.read.getAllReservesTokens(setViemBlockNumber(block)) as { symbol: string, tokenAddress: EthAddress }[];
   const symbols = reserveTokens.map(({ symbol }: { symbol: string }) => symbol);
   const _addresses = reserveTokens.map(({ tokenAddress }: { tokenAddress: EthAddress }) => tokenAddress);
 
@@ -486,3 +490,97 @@ export const getAaveV3FullPositionData = async (provider: EthereumProvider, netw
   const positionData = await getAaveV3AccountData(provider, network, address, { assetsData: marketData.assetsData, selectedMarket: market, eModeCategoriesData: marketData.eModeCategoriesData });
   return positionData;
 };
+
+// aTokens eligible for AAVE rewards
+export const REWARDABLE_ASSETS = [
+  '0x028171bCA77440897B824Ca71D1c56caC55b68A3', // DAI
+  '0x6C3c78838c761c6Ac7bE9F59fe808ea2A6E4379d',
+  '0xD37EE7e4f452C6638c96536e68090De8cBcdb583', // GUSD
+  '0x279AF5b99540c1A3A7E3CDd326e19659401eF99e',
+  '0xBcca60bB61934080951369a648Fb03DF4F96263C', // USDC
+  '0x619beb58998eD2278e08620f97007e1116D5D25b',
+  '0x3Ed3B47Dd13EC9a98b44e6204A523E766B225811', // USDT
+  '0x531842cEbbdD378f8ee36D171d6cC9C4fcf475Ec',
+  '0x9ff58f4fFB29fA2266Ab25e75e2A8b3503311656', // WBTC
+  '0x9c39809Dec7F95F5e0713634a4D0701329B3b4d2',
+  '0x030bA81f1c18d280636F32af80b9AAd02Cf0854e', // WETH
+  '0xF63B34710400CAd3e044cFfDcAb00a0f32E33eCf',
+  '0xa06bC25B5805d5F8d82847D191Cb4Af5A3e873E0', // LINK
+  '0x0b8f12b1788BFdE65Aa1ca52E3e9F3Ba401be16D',
+  '0x6C5024Cd4F8A59110119C56f8933403A539555EB', // SUSD
+  '0xdC6a3Ab17299D9C2A412B0e0a4C1f55446AE0817',
+  '0x5165d24277cD063F5ac44Efd447B27025e888f37', // YFI
+  '0x7EbD09022Be45AD993BAA1CEc61166Fcc8644d97',
+  '0xF256CC7847E919FAc9B808cC216cAc87CCF2f47a', // xSUSHI
+  '0xfAFEDF95E21184E3d880bd56D4806c4b8d31c69A',
+  '0xB9D7CB55f463405CDfBe4E90a6D2Df01C2B92BF1', // UNI
+  '0x5BdB050A92CADcCfCDcCCBFC17204a1C9cC0Ab73',
+  '0xc713e5E149D5D0715DcD1c156a020976e7E56B88', // MKR
+  '0xba728eAd5e496BE00DCF66F650b6d7758eCB50f8',
+  '0x101cc05f4A51C0319f570d5E146a8C625198e636', // TUSD
+  '0x01C0eb1f8c6F1C1bF74ae028697ce7AA2a8b0E92',
+  '0xc9BC48c72154ef3e5425641a3c747242112a46AF', // RAI
+  '0xB5385132EE8321977FfF44b60cDE9fE9AB0B4e6b',
+  '0x272F97b7a56a387aE942350bBC7Df5700f8a4576', // BAL
+  '0x13210D4Fe0d5402bd7Ecbc4B5bC5cFcA3b71adB0',
+  '0x2e8f4bdbe3d47d7d7de490437aea9915d930f1a3', // USDP
+  '0xfdb93b3b10936cf81fa59a02a7523b6e2149b2b7',
+  '0xA361718326c15715591c299427c62086F69923D9', // BUSD
+  '0xbA429f7011c9fa04cDd46a2Da24dc0FF0aC6099c',
+  '0xd4937682df3C8aEF4FE912A96A74121C0829E664', // FRAX
+  '0xfE8F19B17fFeF0fDbfe2671F248903055AFAA8Ca',
+  '0x683923dB55Fead99A79Fa01A27EeC3cB19679cC3', // FEI
+  '0xC2e10006AccAb7B45D9184FcF5b7EC7763f5BaAe',
+  '0x8dAE6Cb04688C62d939ed9B68d32Bc62e49970b1', // CRV
+  '0x00ad8eBF64F141f1C81e9f8f792d3d1631c6c684',
+  '0x6F634c6135D2EBD550000ac92F494F9CB8183dAe', // DPI
+  '0x4dDff5885a67E4EffeC55875a3977D7E60F82ae0',
+] as const;
+
+export const fetchYearlyMeritApyForStakingGho = async () => {
+  try {
+    const response = await fetch('https://apps.aavechan.com/api/merit/aprs', { signal: AbortSignal.timeout(5000) });
+    const data = await response.json();
+    const apr = data?.currentAPR?.actionsAPR?.['ethereum-stkgho'] || '0' as string;
+    const apy = aprToApy(apr);
+    const apyWithDFSBonus = new Dec(apy).mul(1.05).toString(); // 5% bonus for DFS users
+    return apyWithDFSBonus;
+  } catch (e) {
+    const message = 'External API Failure: Failed to fetch yearly merit APY for staking GHO';
+    console.error(message, e);
+    return '0';
+  }
+};
+
+export const getStakeAaveData = async (provider: Client, network: NetworkNumber, address: EthAddress) => {
+  const stkGhoAddress = getAssetInfo('stkGHO').address as HexString;
+  const stkAaveAddress = getAssetInfo('stkAAVE').address as HexString;
+
+  const AaveIncentivesController = AaveIncentivesControllerViem(provider, network);
+  const stkAAVE = StkAAVEViem(provider, network);
+  const stkGHO = createViemContractFromConfigFunc('Erc20', stkGhoAddress as HexString)(provider, network);
+
+
+  const [aaveRewardsBalance, emissionsPerSecond, stkAAVEBalance, stkAAVETotalSupply, stkGHOBalance, ghoMeritApy] = await Promise.all([
+    AaveIncentivesController.read.getRewardsBalance([REWARDABLE_ASSETS, address]),
+    stkAAVE.read.assets([stkAaveAddress]),
+    stkAAVE.read.balanceOf([address]),
+    stkAAVE.read.totalSupply(),
+    stkGHO.read.balanceOf([address]),
+    fetchYearlyMeritApyForStakingGho(),
+  ]);
+
+
+  const stkAaveApy = new Dec(assetAmountInEth(emissionsPerSecond[0].toString(), 'GHO') || 0).mul(SECONDS_PER_YEAR).mul(100).div(assetAmountInEth(stkAAVETotalSupply.toString(), 'stkAAVE'))
+    .toString();
+  return {
+    activatedCooldown: '0',
+    activatedCooldownAmount: '0',
+    stkAaveRewardsBalance: '0',
+    aaveRewardsBalance: assetAmountInEth(aaveRewardsBalance.toString(), 'AAVE'),
+    stkAaveBalance: assetAmountInEth(stkAAVEBalance.toString(), 'stkAAVE'),
+    stkGhoBalance: assetAmountInEth(stkGHOBalance.toString(), 'GHO'),
+    ghoMeritApy,
+    stkAaveApy,
+  };
+};

package/src/claiming/aaveV3.ts

@@ -0,0 +1,163 @@
+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, wethToEth } from '../services/utils';
+
+type AaveReward = {
+  amount: string;
+  symbol: string;
+  underlyingAsset: string;
+  rewardTokenAddress: string;
+  aTokenAddresses: string[];
+};
+
+/**
+ * won't cover all cases
+ */
+export const getAaveUnderlyingSymbol = (_symbol = '') => {
+  let symbol = _symbol
+    .replace(/^aEthLido/, '')
+    .replace(/^aEthEtherFi/, '')
+    .replace(/^aEth/, '')
+    .replace(/^aArb/, '')
+    .replace(/^aOpt/, '')
+    .replace(/^aBas/, '');
+  if (symbol.startsWith('a')) symbol = symbol.slice(1);
+  return wethToEth(symbol);
+};
+
+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[]> {
+  const res = await fetch(`https://api.merkl.xyz/v4/users/${account}/rewards?chainId=${network}`,
+    { signal: AbortSignal.timeout(3000) });
+  const data = await res.json();
+
+  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;
+}

package/src/claiming/compV3.ts

@@ -0,0 +1,23 @@
+import { Client } from 'viem';
+import { assetAmountInEth, getAssetInfoByAddress } from '@defisaver/tokens';
+import { EthAddress, NetworkNumber } from '../types/common';
+import { CompV3ViewContractViem } from '../contracts';
+import { ClaimType } from '../types/claiming';
+
+export const getCompoundV3Rewards = async (provider: Client, network: NetworkNumber, user: EthAddress, market: any) => {
+  const compV3View = CompV3ViewContractViem(provider, network);
+  const rewards = await compV3View.read.getRewardsOwed([market, user]);
+  if (!rewards || rewards.owed.toString() === '0' || getAssetInfoByAddress(rewards.token, network).symbol !== 'COMP') return [];
+  return [{
+    symbol: 'COMP',
+    underlyingSymbol: 'COMP',
+    tokenAddress: rewards.token,
+    amount: assetAmountInEth(rewards.owed.toString() || 0, 'COMP'),
+    walletAddress: user,
+    label: 'Compound V3',
+    claimType: ClaimType.COMPOUND_V3_COMP,
+    additionalClaimFields: {
+      marketAddress: market,
+    },
+  }];
+};

package/src/claiming/index.ts

@@ -0,0 +1,13 @@
+import * as aaveV3Claim from './aaveV3';
+import * as compV3Claim from './compV3';
+import * as kingV3Claim from './king';
+import * as morphoBlueClaim from './morphoBlue';
+import * as sparkClaim from './spark';
+
+export {
+  aaveV3Claim,
+  compV3Claim,
+  kingV3Claim,
+  morphoBlueClaim,
+  sparkClaim,
+};

package/src/claiming/king.ts

@@ -0,0 +1,66 @@
+import Dec from 'decimal.js';
+import { assetAmountInEth } from '@defisaver/tokens';
+import { Client } from 'viem';
+import { UUPSViem } from '../contracts';
+import { EthAddress, HexString, NetworkNumber } from '../types/common';
+import { ClaimType } from '../types/claiming';
+
+export const fetchKingRewards = async (walletAddress: EthAddress) => {
+  try {
+    const res = await fetch(`https://fe.defisaver.com/api/etherfi/get-king-rewards/${walletAddress}`,
+      { signal: AbortSignal.timeout(5000) });
+
+    if (!res.ok) throw new Error(await res.text());
+
+    return await res.json();
+  } catch (err) {
+    console.error('External API Error: Error fetching KING rewards:', err);
+    return { Amount: '0', Root: '', Proofs: [] };
+  }
+};
+
+export const getKingRewards = async (provider: Client, network: NetworkNumber, walletAddresses: EthAddress[]) => {
+  // Fetch all API data in parallel (these are external API calls, can't be batched with multicall)
+  const apiDataPromises = walletAddresses.map(address => fetchKingRewards(address));
+  const apiDataArray = await Promise.all(apiDataPromises);
+
+  // Batch all contract calls using multicall
+  const contract = UUPSViem(provider, network);
+  const cumulativePromises = walletAddresses.map(address => contract.read.cumulativeClaimed([address]),
+  );
+  const cumulativeResults = await Promise.all(cumulativePromises);
+
+  // Process results
+  const results: Record<string, any[]> = {};
+
+  for (let i = 0; i < walletAddresses.length; i++) {
+    const walletAddress = walletAddresses[i];
+    const data = apiDataArray[i];
+    const cumulative = cumulativeResults[i];
+
+    const allRewardsAmount = assetAmountInEth(data.Amount, 'KING');
+    const claimedAmount = assetAmountInEth(cumulative.toString(), 'KING');
+    const amountToClaim = new Dec(allRewardsAmount).sub(claimedAmount);
+
+    if (amountToClaim.lessThanOrEqualTo('0')) {
+      results[walletAddress.toLowerCase() as EthAddress] = [];
+    } else {
+      results[walletAddress.toLowerCase() as EthAddress] = [{
+        symbol: 'KING',
+        underlyingSymbol: 'KING',
+        tokenAddress: '0x8F08B70456eb22f6109F57b8fafE862ED28E6040',
+        amount: amountToClaim.toString(),
+        walletAddress,
+        label: 'weETH',
+        claimType: ClaimType.KING_REWARDS,
+        additionalClaimFields: {
+          allRewardsAmount,
+          merkleRoot: data.Root,
+          merkleProofs: data.Proofs,
+        },
+      }];
+    }
+  }
+
+  return results;
+};

package/src/claiming/morphoBlue.ts

@@ -0,0 +1,119 @@
+import { assetAmountInEth, getAssetInfoByAddress } from '@defisaver/tokens';
+import { Client } from 'viem';
+import Dec from 'decimal.js';
+import { ClaimableToken, ClaimType, MorphoClaimableToken } from '../types/claiming';
+import { EthAddress, NetworkNumber } from '../types/common';
+import { createViemContractFromConfigFunc } from '../contracts';
+import { wethToEth } from '../services/utils';
+
+const MORPHO_ALLOWED_CONTRACTS = [
+  '0x330eefa8a787552DC5cAd3C3cA644844B1E61Ddb',
+  '0x678dDC1d07eaa166521325394cDEb1E4c086DF43',
+  '0x2efd4625d0c149ebadf118ec5446c6de24d916a4',
+];
+
+const MORPHO_ALLOWED_TOKENS = [
+  'MORPHO',
+  'MORPHO Legacy',
+];
+
+export const getMorphoUnderlyingSymbol = (_symbol: string) => {
+  if (_symbol === 'MORPHO Legacy') return 'MORPHO';
+  return wethToEth(_symbol);
+};
+
+
+export const getMorphoBlueRewardsInfo = async (address: EthAddress) => {
+  if (!address) return { claimable: '0' };
+  const res = await fetch(`https://rewards.morpho.org/v1/users/${address}/distributions`,
+    { signal: AbortSignal.timeout(3000) });
+
+  if (!res.ok) throw new Error(await res.text());
+
+  return res.json();
+};
+
+export const fetchMorphoBlueRewards = async (
+  provider: Client,
+  network: NetworkNumber,
+  walletAddresses: EthAddress[],
+): Promise<Record<string, ClaimableToken[]>> => {
+  // Fetch all API data in parallel (these are external API calls, can't be batched with multicall)
+  const apiDataPromises = walletAddresses.map(address => getMorphoBlueRewardsInfo(address));
+  const apiDataArray = await Promise.all(apiDataPromises);
+
+  // Process API data to get claimable tokens for each wallet
+  const allClaimableTokens: Array<{ walletAddress: EthAddress; tokens: ClaimableToken[] }> = [];
+  const contractCallsData: Array<{ walletAddress: EthAddress; tokenAddress: EthAddress; distributor: EthAddress }> = [];
+
+  for (let i = 0; i < walletAddresses.length; i++) {
+    const walletAddress = walletAddresses[i];
+    const data = apiDataArray[i];
+
+    const claimableTokens = data?.data?.reduce((acc: ClaimableToken[], reward: any) => {
+      const token = getAssetInfoByAddress(reward.asset.address);
+      if (!MORPHO_ALLOWED_CONTRACTS.includes(reward?.distributor?.address) || !MORPHO_ALLOWED_TOKENS.includes(token.symbol)) {
+        return acc;
+      }
+
+      // Store contract call data for batching
+      contractCallsData.push({
+        walletAddress,
+        tokenAddress: reward.asset.address,
+        distributor: reward?.distributor?.address,
+      });
+
+      return [
+        ...acc,
+        {
+          symbol: token.symbol,
+          underlyingSymbol: getMorphoUnderlyingSymbol(token.symbol),
+          tokenAddress: reward.asset.address,
+          amount: assetAmountInEth(reward.claimable, token.symbol),
+          walletAddress,
+          label: token.symbol,
+          claimType: ClaimType.MORPHO,
+          additionalClaimFields: {
+            originalAmount: reward.claimable,
+            distributor: reward?.distributor?.address,
+            merkleProofs: reward?.proof,
+            isLegacy: token.symbol === 'MORPHO Legacy',
+            txData: reward?.tx_data,
+          },
+        }];
+    }, []) || [];
+
+    allClaimableTokens.push({ walletAddress, tokens: claimableTokens });
+  }
+
+  // Batch all contract calls using multicall
+  const contractPromises = contractCallsData.map(({ walletAddress, tokenAddress, distributor }) => {
+    const distributorContract = createViemContractFromConfigFunc('MorphoDistributor', distributor)(provider, network);
+    return distributorContract.read.claimed([walletAddress, tokenAddress]);
+  });
+  const contractResults = await Promise.all(contractPromises);
+
+  // Process results
+  const results: Record<string, ClaimableToken[]> = {};
+  let contractCallIndex = 0;
+
+  for (const { walletAddress, tokens } of allClaimableTokens) {
+    const updatedTokens: ClaimableToken[] = [];
+
+    for (let i = 0; i < tokens.length; i++) {
+      const claimableToken = tokens[i];
+      const claimed = assetAmountInEth(contractResults[contractCallIndex].toString(), claimableToken.underlyingSymbol);
+      contractCallIndex++;
+
+      const updatedToken = { ...claimableToken };
+      updatedToken.amount = new Dec(claimableToken.amount).sub(claimed).toString();
+      updatedTokens.push(updatedToken);
+    }
+
+    results[walletAddress.toLowerCase() as EthAddress] = updatedTokens.filter(
+      (claimableToken) => new Dec(claimableToken.amount).gt(0),
+    );
+  }
+
+  return results;
+};