@defisaver/positions-sdk 2.1.1 → 2.1.3

package/esm/types/claiming.d.ts

@@ -0,0 +1,93 @@
+import { EthAddress } from './common';
+export declare enum ClaimType {
+    /** Rewards from AAVE - various tokens & aTokens (supplied to protocol) */
+    AAVE_REWARDS = "AAVE_REWARDS",
+    /** Merit rewards from AAVE (various tokens) */
+    AAVE_MERIT_REWARDS = "AAVE_MERIT_REWARDS",
+    /** Rewards from Compound V3 (only in COMP) */
+    COMPOUND_V3_COMP = "COMPOUND_V3_COMP",
+    /** Rewards from Spark (wstETH only for now) */
+    SPARK_REWARDS = "SPARK_REWARDS",
+    /** Rewards from Morpho */
+    MORPHO = "MORPHO",
+    /** Rewards from King (prev LTR^2 - received for weETH holding) */
+    KING_REWARDS = "KING_REWARDS",
+    /** Spark Airdrop */
+    SPARK_AIRDROP = "SPARK_AIRDROP",
+    /** Spark Airdrop */
+    SPARK_WST_ETH_REWARDS = "SPARK_WST_ETH_REWARDS"
+}
+type _ClaimableTokenPartial = {
+    symbol: string;
+    underlyingSymbol: string;
+    tokenAddress: EthAddress;
+    amount: string;
+    walletAddress: EthAddress;
+    label: string;
+};
+export type AaveRewardsClaimableToken = _ClaimableTokenPartial & {
+    claimType: ClaimType.AAVE_REWARDS;
+    additionalClaimFields: {
+        marketAddress: EthAddress;
+        aTokenAddresses: string[];
+        isAaveToken: boolean;
+    };
+};
+export type AaveMeritRewardsClaimableToken = _ClaimableTokenPartial & {
+    claimType: ClaimType.AAVE_MERIT_REWARDS;
+    additionalClaimFields: {
+        accumulated: string;
+        proof: string[];
+        decimals: string;
+        unclaimed: string;
+    };
+};
+export type SparkRewardsClaimableToken = _ClaimableTokenPartial & {
+    claimType: ClaimType.SPARK_REWARDS;
+    additionalClaimFields: {
+        sparkAssetAddresses: string[];
+    };
+};
+export type KingRewardsClaimableToken = _ClaimableTokenPartial & {
+    claimType: ClaimType.KING_REWARDS;
+    additionalClaimFields: {
+        allRewardsAmount: string;
+        merkleRoot: string;
+        merkleProofs: string[];
+    };
+};
+export type MorphoClaimableToken = _ClaimableTokenPartial & {
+    claimType: ClaimType.MORPHO;
+    additionalClaimFields: {
+        originalAmount: string;
+        merkleProofs: string[];
+        distributor: EthAddress;
+        isLegacy: boolean;
+        txData: string;
+    };
+};
+export type CompoundV3CompClaimableToken = _ClaimableTokenPartial & {
+    claimType: ClaimType.COMPOUND_V3_COMP;
+    additionalClaimFields: {
+        marketAddress: EthAddress;
+    };
+};
+export declare enum SparkAirdropType {
+    SPARK_IGNITION = "spark-ignition",
+    PRE_FARMING_AND_SOCIAL = "pre-farming-and-social"
+}
+export type SparkAirdropClaimableToken = _ClaimableTokenPartial & {
+    claimType: ClaimType.SPARK_AIRDROP;
+    additionalClaimFields: {
+        merkleRoot: string;
+        merkleProofs: string[];
+        epoch: number;
+        rewardType: SparkAirdropType;
+        allRewardsAmount: string;
+    };
+};
+export type SparkWstEthRewardsClaimableToken = _ClaimableTokenPartial & {
+    claimType: ClaimType.SPARK_WST_ETH_REWARDS;
+};
+export type ClaimableToken = AaveRewardsClaimableToken | AaveMeritRewardsClaimableToken | CompoundV3CompClaimableToken | MorphoClaimableToken | SparkRewardsClaimableToken | KingRewardsClaimableToken | SparkAirdropClaimableToken | SparkWstEthRewardsClaimableToken;
+export {};

package/esm/types/claiming.js

@@ -0,0 +1,24 @@
+export var ClaimType;
+(function (ClaimType) {
+    /** Rewards from AAVE - various tokens & aTokens (supplied to protocol) */
+    ClaimType["AAVE_REWARDS"] = "AAVE_REWARDS";
+    /** Merit rewards from AAVE (various tokens) */
+    ClaimType["AAVE_MERIT_REWARDS"] = "AAVE_MERIT_REWARDS";
+    /** Rewards from Compound V3 (only in COMP) */
+    ClaimType["COMPOUND_V3_COMP"] = "COMPOUND_V3_COMP";
+    /** Rewards from Spark (wstETH only for now) */
+    ClaimType["SPARK_REWARDS"] = "SPARK_REWARDS";
+    /** Rewards from Morpho */
+    ClaimType["MORPHO"] = "MORPHO";
+    /** Rewards from King (prev LTR^2 - received for weETH holding) */
+    ClaimType["KING_REWARDS"] = "KING_REWARDS";
+    /** Spark Airdrop */
+    ClaimType["SPARK_AIRDROP"] = "SPARK_AIRDROP";
+    /** Spark Airdrop */
+    ClaimType["SPARK_WST_ETH_REWARDS"] = "SPARK_WST_ETH_REWARDS";
+})(ClaimType || (ClaimType = {}));
+export var SparkAirdropType;
+(function (SparkAirdropType) {
+    SparkAirdropType["SPARK_IGNITION"] = "spark-ignition";
+    SparkAirdropType["PRE_FARMING_AND_SOCIAL"] = "pre-farming-and-social";
+})(SparkAirdropType || (SparkAirdropType = {}));

package/esm/types/common.d.ts

@@ -3,7 +3,7 @@ export declare enum IncentiveKind {
     Reward = "reward"
 }
 export declare enum IncentiveEligibilityId {
-    AaveV3EthenaLiquidLeverage = "0x8772bb231f3af13ead41d7ecf6abd60f5f716ec8BORROW_BL",
+    AaveV3EthenaLiquidLeverage = "0x7361e6f04060154e0268a8402b073cbf97e11ae3BORROW_BL",
     AaveV3ArbitrumEthSupply = "0x5d16261c6715a653248269861bbacf68a9774cde",
     AaveV3ArbitrumETHLSBorrow = "0x0c84331e39d6658Cd6e6b9ba04736cC4c4734351"
 }

package/esm/types/common.js

@@ -5,7 +5,7 @@ export var IncentiveKind;
 })(IncentiveKind || (IncentiveKind = {}));
 export var IncentiveEligibilityId;
 (function (IncentiveEligibilityId) {
-    IncentiveEligibilityId["AaveV3EthenaLiquidLeverage"] = "0x8772bb231f3af13ead41d7ecf6abd60f5f716ec8BORROW_BL";
+    IncentiveEligibilityId["AaveV3EthenaLiquidLeverage"] = "0x7361e6f04060154e0268a8402b073cbf97e11ae3BORROW_BL";
     IncentiveEligibilityId["AaveV3ArbitrumEthSupply"] = "0x5d16261c6715a653248269861bbacf68a9774cde";
     IncentiveEligibilityId["AaveV3ArbitrumETHLSBorrow"] = "0x0c84331e39d6658Cd6e6b9ba04736cC4c4734351";
 })(IncentiveEligibilityId || (IncentiveEligibilityId = {}));

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.1.1",
+  "version": "2.1.3",
   "description": "",
   "main": "./cjs/index.js",
   "module": "./esm/index.js",

package/src/aaveV2/index.ts

@@ -106,7 +106,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,11 +28,12 @@ import {
   EModeCategoryDataMapping,
 } from '../types/aave';
 import {
-  Blockish, EthAddress, EthereumProvider, IncentiveEligibilityId, IncentiveKind, NetworkNumber, PositionBalances,
+  Blockish, EthAddress, EthereumProvider, IncentiveEligibilityId, IncentiveKind, NetworkNumber, PositionBalances, HexString,
 } from '../types/common';
 import { getViemProvider, setViemBlockNumber } from '../services/viem';
 import { getMeritCampaigns } from './merit';
 import { getAaveUnderlyingSymbol, getMerkleCampaigns } from './merkl';
+import { SECONDS_PER_DAY, SECONDS_PER_YEAR } from '../constants';
 
 export const aaveV3EmodeCategoriesMapping = (extractedState: any, usedAssets: AaveV3UsedAssets) => {
   const { eModeCategoriesData }: { assetsData: AaveV3AssetsData, eModeCategoriesData: EModeCategoriesData } = extractedState;
@@ -360,7 +363,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);
 
@@ -510,6 +514,100 @@ export const getAaveV3FullPositionData = async (provider: EthereumProvider, netw
   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,
+  };
+};
+
 export {
   getMeritCampaigns,
   getMerkleCampaigns,

package/src/claiming/aaveV3.ts

@@ -0,0 +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;
+}

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