@defisaver/positions-sdk 2.1.142-dev → 2.1.143

package/esm/portfolio/index.js

@@ -26,7 +26,7 @@ import { _getLiquityTroveInfo, getLiquityStakingData } from '../liquity';
 import { _getLiquityV2MarketData, getLiquitySAndYBold, getLiquityV2Staking } from '../liquityV2';
 import { _getAllUserEarnPositionsWithFTokens, _getUserPositionsPortfolio } from '../fluid';
 import { getUmbrellaData } from '../umbrella';
-import { getMeritUnclaimedRewards, getUnclaimedRewardsForAllMarkets } from '../claiming/aaveV3';
+import { getMerklUnclaimedRewards, getUnclaimedRewardsForAllMarkets } from '../claiming/aaveV3';
 import { getCompoundV3Rewards } from '../claiming/compV3';
 import { fetchSparkAirdropRewards, fetchSparkRewards } from '../claiming/spark';
 import { getKingRewards } from '../claiming/king';
@@ -114,7 +114,7 @@ export function getPortfolioData(provider_1, network_1, defaultProvider_1, addre
                 },
             };
             rewardsData[address.toLowerCase()] = {
-                aaveV3merit: {},
+                merkl: {},
                 aaveV3: {},
                 compV3: {},
                 spark: {},
@@ -335,12 +335,12 @@ export function getPortfolioData(provider_1, network_1, defaultProvider_1, addre
             }))).flat(),
             ...addresses.map((address) => __awaiter(this, void 0, void 0, function* () {
                 try {
-                    const aaveMeritData = yield getMeritUnclaimedRewards(address, network);
-                    rewardsData[address.toLowerCase()].aaveV3merit = { error: '', data: aaveMeritData };
+                    const merklData = yield getMerklUnclaimedRewards(address, network);
+                    rewardsData[address.toLowerCase()].merkl = { error: '', data: merklData };
                 }
                 catch (error) {
-                    console.error(`Error fetching Aave V3 Merit rewards data for address ${address}:`, error);
-                    rewardsData[address.toLowerCase()].aaveV3merit = { error: `Error fetching Aave V3 Merit rewards data for address ${address}`, data: null };
+                    console.error(`Error fetching Merkl rewards data for address ${address}:`, error);
+                    rewardsData[address.toLowerCase()].merkl = { error: `Error fetching Merkl rewards data for address ${address}`, data: null };
                 }
             })),
             ...aaveV3Markets.map(market => addresses.map((address) => __awaiter(this, void 0, void 0, function* () {

package/esm/services/merkl.d.ts

@@ -0,0 +1,6 @@
+import { MerklOpportunity } from '../types';
+/**
+ * Fetches every page matching the query. Merkl returns 20 opportunities by default, so omitting
+ * `items` and advancing `page` avoids imposing a client-side maximum on the result set.
+ */
+export declare const fetchAllMerklOpportunities: (query: Record<string, string>) => Promise<MerklOpportunity[]>;

package/esm/services/merkl.js

@@ -0,0 +1,35 @@
+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 { LONGER_TIMEOUT } from './utils';
+const MERKL_OPPORTUNITIES_URL = 'https://fe.defisaver.com/api/merkl/opportunities';
+/**
+ * Fetches every page matching the query. Merkl returns 20 opportunities by default, so omitting
+ * `items` and advancing `page` avoids imposing a client-side maximum on the result set.
+ */
+export const fetchAllMerklOpportunities = (query) => __awaiter(void 0, void 0, void 0, function* () {
+    const opportunities = [];
+    let page = 0;
+    let pageOpportunities;
+    do {
+        const searchParams = new URLSearchParams(Object.assign(Object.assign({}, query), { page: page.toString() }));
+        const res = yield fetch(`${MERKL_OPPORTUNITIES_URL}?${searchParams}`, {
+            signal: AbortSignal.timeout(LONGER_TIMEOUT),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to fetch Merkl opportunities page ${page}`);
+        const data = yield res.json(); // eslint-disable-line no-await-in-loop
+        if (!Array.isArray(data))
+            throw new Error(`Invalid Merkl opportunities response on page ${page}`);
+        pageOpportunities = data;
+        opportunities.push(...pageOpportunities);
+        page += 1;
+    } while (pageOpportunities.length > 0);
+    return opportunities;
+});

package/esm/types/claiming.d.ts

@@ -4,6 +4,8 @@ export declare enum ClaimType {
     AAVE_REWARDS = "AAVE_REWARDS",
     /** Merit rewards from AAVE (various tokens) */
     AAVE_MERIT_REWARDS = "AAVE_MERIT_REWARDS",
+    /** Rewards distributed through Merkl across supported protocols */
+    MERKL_REWARDS = "MERKL_REWARDS",
     /** Rewards from Compound V3 (only in COMP) */
     COMPOUND_V3_COMP = "COMPOUND_V3_COMP",
     /** Rewards from Spark (wstETH only for now) */
@@ -43,6 +45,15 @@ export type AaveMeritRewardsClaimableToken = _ClaimableTokenPartial & {
         unclaimed: string;
     };
 };
+export type MerklRewardsClaimableToken = _ClaimableTokenPartial & {
+    claimType: ClaimType.MERKL_REWARDS;
+    additionalClaimFields: {
+        accumulated: string;
+        proof: string[];
+        decimals: string;
+        unclaimed: string;
+    };
+};
 export type SparkRewardsClaimableToken = _ClaimableTokenPartial & {
     claimType: ClaimType.SPARK_REWARDS;
     additionalClaimFields: {
@@ -91,5 +102,5 @@ export type UniswapAirdropClaimableToken = _ClaimableTokenPartial & {
         proof: string[];
     };
 };
-export type ClaimableToken = AaveRewardsClaimableToken | AaveMeritRewardsClaimableToken | CompoundV3CompClaimableToken | SparkRewardsClaimableToken | KingRewardsClaimableToken | SparkAirdropClaimableToken | SparkWstEthRewardsClaimableToken | EthenaAirdropClaimableToken;
+export type ClaimableToken = AaveRewardsClaimableToken | AaveMeritRewardsClaimableToken | MerklRewardsClaimableToken | CompoundV3CompClaimableToken | SparkRewardsClaimableToken | KingRewardsClaimableToken | SparkAirdropClaimableToken | SparkWstEthRewardsClaimableToken | EthenaAirdropClaimableToken;
 export {};

package/esm/types/claiming.js

@@ -4,6 +4,8 @@ export var ClaimType;
     ClaimType["AAVE_REWARDS"] = "AAVE_REWARDS";
     /** Merit rewards from AAVE (various tokens) */
     ClaimType["AAVE_MERIT_REWARDS"] = "AAVE_MERIT_REWARDS";
+    /** Rewards distributed through Merkl across supported protocols */
+    ClaimType["MERKL_REWARDS"] = "MERKL_REWARDS";
     /** Rewards from Compound V3 (only in COMP) */
     ClaimType["COMPOUND_V3_COMP"] = "COMPOUND_V3_COMP";
     /** Rewards from Spark (wstETH only for now) */

package/esm/types/common.d.ts

@@ -6,6 +6,9 @@ export declare enum IncentiveSide {
     Supply = "supply",
     Borrow = "borrow"
 }
+export declare enum IncentiveSource {
+    Merkl = "merkl"
+}
 export declare enum IncentiveEligibilityId {
     AaveV3EthenaLiquidLeverage = "0x0dC599DBB180E64E42b87332FDeC3a551445ea44BORROW_BL",
     AaveV3ArbitrumEthSupply = "0x5d16261c6715a653248269861bbacf68a9774cde",
@@ -25,6 +28,7 @@ export interface IncentiveData {
     token: string;
     apy: string;
     incentiveKind?: IncentiveKind;
+    source?: IncentiveSource;
     description?: string;
     eligibilityId?: IncentiveEligibilityId;
 }

package/esm/types/common.js

@@ -8,6 +8,10 @@ export var IncentiveSide;
     IncentiveSide["Supply"] = "supply";
     IncentiveSide["Borrow"] = "borrow";
 })(IncentiveSide || (IncentiveSide = {}));
+export var IncentiveSource;
+(function (IncentiveSource) {
+    IncentiveSource["Merkl"] = "merkl";
+})(IncentiveSource || (IncentiveSource = {}));
 export var IncentiveEligibilityId;
 (function (IncentiveEligibilityId) {
     IncentiveEligibilityId["AaveV3EthenaLiquidLeverage"] = "0x0dC599DBB180E64E42b87332FDeC3a551445ea44BORROW_BL";

package/esm/types/fluid.d.ts

@@ -319,6 +319,8 @@ export interface FluidAggregatedVaultData {
     leftToBorrowUsd: string;
     netApy: string;
     incentiveUsd: string;
+    merklSupplyIncentives: IncentiveData[];
+    merklBorrowIncentives: IncentiveData[];
     ratio: string;
     collRatio: string;
     minRatio: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/positions-sdk",
-  "version": "2.1.142-dev",
+  "version": "2.1.143",
   "description": "",
   "main": "./cjs/index.js",
   "module": "./esm/index.js",

package/src/aaveV3/merkl.ts

@@ -1,5 +1,6 @@
 import { aprToApy } from '../moneymarket';
-import { LONGER_TIMEOUT, wethToEth } from '../services/utils';
+import { fetchAllMerklOpportunities } from '../services/merkl';
+import { wethToEth } from '../services/utils';
 import {
   MerkleRewardMap, MerklOpportunity, OpportunityAction, OpportunityStatus,
   EthAddress, NetworkNumber,
@@ -31,13 +32,10 @@ export const formatAaveAsset = (_symbol: string) => {
 
 export const getMerkleCampaigns = async (chainId: NetworkNumber): Promise<MerkleRewardMap> => {
   try {
-    // status/items narrow the query because Merkl paginates at 20 items by default — an
-    // unfiltered query silently drops live campaigns once the protocol has enough opportunities
-    const res = await fetch('https://fe.defisaver.com/api/merkl/opportunities?mainProtocolId=aave&status=LIVE&items=100', {
-      signal: AbortSignal.timeout(LONGER_TIMEOUT),
+    const opportunities = await fetchAllMerklOpportunities({
+      mainProtocolId: 'aave',
+      status: OpportunityStatus.LIVE,
     });
-    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);
@@ -74,4 +72,3 @@ export const getMerkleCampaigns = async (chainId: NetworkNumber): Promise<Merkle
     return {};
   }
 };
-

package/src/aaveV4/merkl.ts

@@ -1,5 +1,5 @@
 import { aprToApy } from '../moneymarket';
-import { LONGER_TIMEOUT } from '../services/utils';
+import { fetchAllMerklOpportunities } from '../services/merkl';
 import {
   AaveV4MerklRewardMap,
   AaveV4ReserveAssetData,
@@ -67,11 +67,11 @@ export const buildAaveV4MerklRewardMap = (opportunities: MerklOpportunity[], cha
 
 export const getAaveV4MerkleCampaigns = async (chainId: NetworkNumber): Promise<AaveV4MerklRewardMap> => {
   try {
-    const res = await fetch('https://fe.defisaver.com/api/merkl/opportunities?mainProtocolId=aave&type=AAVE_V4_HUB_SUPPLY,AAVE_V4_HUB_BORROW,AAVE_V4_SPOKE_SUPPLY,AAVE_V4_SPOKE_BORROW&status=LIVE&items=100', {
-      signal: AbortSignal.timeout(LONGER_TIMEOUT),
+    const opportunities = await fetchAllMerklOpportunities({
+      mainProtocolId: 'aave',
+      type: 'AAVE_V4_HUB_SUPPLY,AAVE_V4_HUB_BORROW,AAVE_V4_SPOKE_SUPPLY,AAVE_V4_SPOKE_BORROW',
+      status: OpportunityStatus.LIVE,
     });
-    if (!res.ok) throw new Error('Failed to fetch Aave V4 Merkle campaigns');
-    const opportunities = await res.json() as MerklOpportunity[];
     return buildAaveV4MerklRewardMap(opportunities, chainId);
   } catch (e) {
     console.error('Failed to fetch Aave V4 Merkle campaigns', e);

package/src/claiming/aaveV3.ts

@@ -1,7 +1,7 @@
 import { Client } from 'viem';
 import Dec from 'decimal.js';
 import { EthAddress, NetworkNumber } from '../types';
-import { ClaimableToken, ClaimType } from '../types/claiming';
+import { ClaimableToken, ClaimType, MerklRewardsClaimableToken } from '../types/claiming';
 import {
   AaveIncentiveDataProviderV3ContractViem,
   AaveRewardsControllerViem,
@@ -103,18 +103,18 @@ export async function getUnclaimedRewardsForAllMarkets(
   return mapAaveRewardsToClaimableTokens(Object.values(totalUnclaimedPerRewardToken), marketAddress, walletAddress);
 }
 
-export async function getMeritUnclaimedRewards(account: EthAddress, network: NetworkNumber): Promise<ClaimableToken[]> {
+export async function getMerklUnclaimedRewards(account: EthAddress, network: NetworkNumber): Promise<MerklRewardsClaimableToken[]> {
   let data;
   try {
     const res = await fetch(`https://fe.defisaver.com/api/merkl/get-user-rewards/${account}?chainId=${network}`,
       { signal: AbortSignal.timeout(LONGER_TIMEOUT) });
     data = await res.json();
   } catch (error) {
-    console.error('External API Failure: Aave Merit', error);
+    console.error('External API Failure: Merkl rewards', error);
     data = [];
   }
 
-  const claimableTokens: ClaimableToken[] = [];
+  const claimableTokens: MerklRewardsClaimableToken[] = [];
 
   // Merkl (or our proxy, on a non-2xx) can return a non-array error body; `fetch` doesn't throw on
   // HTTP errors, so guard before iterating. Mirrors the app-side getMeritUnclaimedRewards.
@@ -137,12 +137,12 @@ export async function getMeritUnclaimedRewards(account: EthAddress, network: Net
       const unclaimed = getEthAmountForDecimals(unclaimedAmount, token.decimals);
 
       claimableTokens.push({
-        claimType: ClaimType.AAVE_MERIT_REWARDS,
+        claimType: ClaimType.MERKL_REWARDS,
         amount: unclaimed,
         symbol: token.symbol,
         tokenAddress: token.address,
         walletAddress: account,
-        label: 'AAVE Merit Rewards',
+        label: 'Merkl Rewards',
         underlyingSymbol: getAaveUnderlyingSymbol(token.symbol),
         additionalClaimFields: {
           accumulated: amount,
@@ -155,4 +155,16 @@ export async function getMeritUnclaimedRewards(account: EthAddress, network: Net
   });
 
   return claimableTokens;
-}
+}
+
+export async function getMeritUnclaimedRewards(account: EthAddress, network: NetworkNumber): Promise<ClaimableToken[]> {
+  const rewards = await getMerklUnclaimedRewards(account, network);
+
+  return rewards
+    .filter(reward => reward.symbol.startsWith('a'))
+    .map(reward => ({
+      ...reward,
+      claimType: ClaimType.AAVE_MERIT_REWARDS,
+      label: 'AAVE Merit Rewards',
+    }));
+}

package/src/compoundV3/merkl.ts

@@ -1,6 +1,7 @@
 import { getAssetInfoByAddress } from '@defisaver/tokens';
 import { aprToApy } from '../moneymarket';
-import { compareAddresses, LONGER_TIMEOUT, wethToEth } from '../services/utils';
+import { fetchAllMerklOpportunities } from '../services/merkl';
+import { compareAddresses, wethToEth } from '../services/utils';
 import {
   CompoundV3AssetData,
   IncentiveData,
@@ -22,12 +23,10 @@ import {
  */
 export const getCompoundV3MerklOpportunities = async (): Promise<MerklOpportunity[]> => {
   try {
-    const res = await fetch('https://fe.defisaver.com/api/merkl/opportunities?mainProtocolId=compound-v3&status=LIVE&items=100', {
-      signal: AbortSignal.timeout(LONGER_TIMEOUT),
+    return await fetchAllMerklOpportunities({
+      mainProtocolId: 'compound-v3',
+      status: OpportunityStatus.LIVE,
     });
-    if (!res.ok) throw new Error('Failed to fetch Compound V3 Merkl campaigns');
-    const data = await res.json();
-    return Array.isArray(data) ? data as MerklOpportunity[] : [];
   } catch (e) {
     console.error('Failed to fetch Compound V3 Merkl campaigns', e);
     return [];

package/src/fluid/index.ts

@@ -69,7 +69,7 @@ import { getViemProvider } from '../services/viem';
 import { attachFluidMerklIncentives, getFluidMerklCampaigns } from './merkl';
 
 export {
-  FLUID_MERKL_OPPORTUNITY_TYPES,
+  FluidMerklOpportunityType,
   buildFluidMerklRewardMap,
   getFluidMerklCampaigns,
   attachFluidMerklIncentives,
@@ -1154,6 +1154,8 @@ export const EMPTY_FLUID_DATA = {
   minRatio: '0',
   netApy: '0',
   incentiveUsd: '0',
+  merklSupplyIncentives: [],
+  merklBorrowIncentives: [],
   totalInterestUsd: '0',
   isSubscribedToAutomation: false,
   automationResubscribeRequired: false,
@@ -1809,9 +1811,13 @@ export const _getUserPositionsPortfolio = async (provider: PublicClient, network
   if (!tokens.includes('ETH')) tokens.push('ETH');
   if (!tokens.includes('WBTC')) tokens.push('WBTC');
 
-  const tokenPrices = await getTokensPricesForPortfolio(tokens, provider, network);
+  const [tokenPrices, merklCampaigns] = await Promise.all([
+    getTokensPricesForPortfolio(tokens, provider, network),
+    getFluidMerklCampaigns(network),
+  ]);
 
-  const parsedMarketData = (await Promise.all(data[1].map(async (vaultData) => parseMarketData(provider, vaultData, network, tokenPrices))));
+  const parsedMarketData = (await Promise.all(data[1].map(async (vaultData) => parseMarketData(provider, vaultData, network, tokenPrices))))
+    .map(marketData => (marketData ? attachFluidMerklIncentives(marketData, merklCampaigns) : marketData));
 
   const userData = data[0].map((position, i) => (parsedMarketData[i] && { ...parseUserData(position, parsedMarketData[i]) }));
 

package/src/fluid/merkl.ts

@@ -1,11 +1,13 @@
+import memoize from 'memoizee';
 import { aprToApy } from '../moneymarket';
-import { LONGER_TIMEOUT } from '../services/utils';
+import { fetchAllMerklOpportunities } from '../services/merkl';
 import {
   FluidMarketData,
   FluidMerklRewardMap,
   IncentiveData,
   IncentiveEligibilityId,
   IncentiveKind,
+  IncentiveSource,
   MerklOpportunity,
   NetworkNumber,
   OpportunityStatus,
@@ -25,7 +27,10 @@ import {
  * ids apply unconditionally, mirroring Aave V3. Whitelist-gated campaigns only accrue to
  * whitelisted addresses, so they are skipped rather than advertised to every user.
  */
-export const FLUID_MERKL_OPPORTUNITY_TYPES = ['FLUIDVAULT_COLLATERAL', 'FLUIDVAULT_BORROW'] as const;
+export enum FluidMerklOpportunityType {
+  Collateral = 'FLUIDVAULT_COLLATERAL',
+  Borrow = 'FLUIDVAULT_BORROW',
+}
 
 // '0x' + 20-byte vault address; conditional campaigns append a marker after it
 const VAULT_ADDRESS_LENGTH = 42;
@@ -36,6 +41,7 @@ const buildMerklIncentive = (opportunity: MerklOpportunity): IncentiveData => {
     apy: aprToApy(opportunity.apr),
     token,
     incentiveKind: IncentiveKind.Reward,
+    source: IncentiveSource.Merkl,
     description: `Eligible for ${token} rewards through Merkl.${opportunity.description ? `\n${opportunity.description}` : ''}`,
     eligibilityId: opportunity.identifier as IncentiveEligibilityId,
   };
@@ -47,13 +53,13 @@ export const buildFluidMerklRewardMap = (opportunities: MerklOpportunity[], chai
   opportunities
     .filter((o) => o.chainId === chainId)
     .filter((o) => o.status === OpportunityStatus.LIVE)
-    .filter((o) => (FLUID_MERKL_OPPORTUNITY_TYPES as readonly string[]).includes(o.type))
+    .filter((o) => Object.values(FluidMerklOpportunityType).includes(o.type as FluidMerklOpportunityType))
     .filter((o) => !o.identifier?.includes('WHITELIST'))
     .forEach((o) => {
       const vaultAddress = o.identifier?.slice(0, VAULT_ADDRESS_LENGTH).toLowerCase();
       if (!vaultAddress || vaultAddress.length !== VAULT_ADDRESS_LENGTH) return;
       if (!result[vaultAddress]) result[vaultAddress] = { supply: [], borrow: [] };
-      result[vaultAddress][o.type === 'FLUIDVAULT_BORROW' ? 'borrow' : 'supply'].push(buildMerklIncentive(o));
+      result[vaultAddress][o.type === FluidMerklOpportunityType.Borrow ? 'borrow' : 'supply'].push(buildMerklIncentive(o));
     });
 
   return result;
@@ -61,22 +67,21 @@ export const buildFluidMerklRewardMap = (opportunities: MerklOpportunity[], chai
 
 /**
  * Fetches live vault-scoped Fluid campaigns for the chain, keyed by vault address. Never throws —
- * on any failure it returns an empty map, so Merkl being down can't break market data. The query
- * is narrowed by `type=` and capped at `items=100` because Merkl paginates at 20 items by default.
+ * on any failure it returns an empty map, so Merkl being down can't break market data.
  */
-export const getFluidMerklCampaigns = async (chainId: NetworkNumber): Promise<FluidMerklRewardMap> => {
+export const getFluidMerklCampaigns = memoize(async (chainId: NetworkNumber): Promise<FluidMerklRewardMap> => {
   try {
-    const res = await fetch(`https://fe.defisaver.com/api/merkl/opportunities?mainProtocolId=fluid&type=${FLUID_MERKL_OPPORTUNITY_TYPES.join(',')}&status=LIVE&items=100`, {
-      signal: AbortSignal.timeout(LONGER_TIMEOUT),
+    const opportunities = await fetchAllMerklOpportunities({
+      mainProtocolId: 'fluid',
+      type: Object.values(FluidMerklOpportunityType).join(','),
+      status: OpportunityStatus.LIVE,
     });
-    if (!res.ok) throw new Error('Failed to fetch Fluid Merkl campaigns');
-    const opportunities = await res.json();
-    return buildFluidMerklRewardMap(Array.isArray(opportunities) ? opportunities : [], chainId);
+    return buildFluidMerklRewardMap(opportunities, chainId);
   } catch (e) {
     console.error('Failed to fetch Fluid Merkl campaigns', e);
     return {};
   }
-};
+}, { promise: true, maxAge: 60 * 1000 });
 
 /**
  * Appends the vault's Merkl campaigns to its assets' incentive arrays — supply rewards on every

package/src/helpers/fluidHelpers/index.ts

@@ -5,16 +5,56 @@ import {
   FluidAssetsData, FluidDexBorrowDataStructOutput, FluidDexSupplyDataStructOutput, FluidUsedAsset,
   FluidUsedAssets,
   FluidVaultType,
+  IncentiveData,
+  IncentiveSource,
   InnerFluidMarketData,
 } from '../../types';
 import {
   calcLeverageLiqPrice, getAssetsTotal, getExposure, isLeveragedPos,
 } from '../../moneymarket';
-import { calculateNetApy } from '../../staking';
-import { LeverageType, MMAssetsData } from '../../types/common';
+import { calculateInterestEarned, calculateNetApy, EligibilityMapping } from '../../staking';
+import { IncentiveSide, LeverageType, MMAssetsData } from '../../types/common';
 import { getEthAmountForDecimals } from '../../services/utils';
 
-const calculateNetApyDex = ({ marketData, suppliedUsd, borrowedUsd }: { marketData: InnerFluidMarketData, suppliedUsd: string, borrowedUsd: string }) => {
+export const getUniqueFluidMerklIncentives = (assetsData: FluidAssetsData, side: IncentiveSide): IncentiveData[] => {
+  const field = side === IncentiveSide.Supply ? 'supplyIncentives' : 'borrowIncentives';
+  const incentives = Object.values(assetsData)
+    .flatMap(asset => asset[field])
+    .filter(incentive => incentive.source === IncentiveSource.Merkl);
+
+  return [...new Map(incentives.map(incentive => [
+    [incentive.eligibilityId, incentive.token, incentive.apy, incentive.description].join('|'),
+    incentive,
+  ])).values()];
+};
+
+const getMerklIncentiveInterest = (
+  incentives: IncentiveData[],
+  principal: string,
+  usedAssets: FluidUsedAssets,
+) => incentives.reduce((total, { apy, eligibilityId }) => {
+  const eligibilityCheck = eligibilityId ? EligibilityMapping[eligibilityId] : null;
+  const { isEligible, eligibleUSDAmount } = eligibilityCheck
+    ? eligibilityCheck(usedAssets, undefined)
+    : { isEligible: true, eligibleUSDAmount: principal };
+  const incentiveInterest = isEligible ? calculateInterestEarned(eligibleUSDAmount, apy, 'year', true) : 0;
+
+  return new Dec(total).add(incentiveInterest).toString();
+}, '0');
+
+const calculateNetApyDex = ({
+  marketData,
+  assetsData,
+  usedAssets,
+  suppliedUsd,
+  borrowedUsd,
+}: {
+  marketData: InnerFluidMarketData,
+  assetsData: FluidAssetsData,
+  usedAssets: FluidUsedAssets,
+  suppliedUsd: string,
+  borrowedUsd: string,
+}) => {
   const {
     borrowRate,
     supplyRate,
@@ -29,7 +69,21 @@ const calculateNetApyDex = ({ marketData, suppliedUsd, borrowedUsd }: { marketDa
 
   const borrowIncentive = new Dec(incentiveBorrowRate || '0').mul(borrowedUsd).div(100).toString();
   const supplyIncentive = new Dec(incentiveSupplyRate || '0').mul(suppliedUsd).div(100).toString();
-  const incentiveUsd = new Dec(supplyIncentive).minus(borrowIncentive).toString();
+  const merklSupplyIncentive = getMerklIncentiveInterest(
+    getUniqueFluidMerklIncentives(assetsData, IncentiveSide.Supply),
+    suppliedUsd,
+    usedAssets,
+  );
+  const merklBorrowIncentive = getMerklIncentiveInterest(
+    getUniqueFluidMerklIncentives(assetsData, IncentiveSide.Borrow),
+    borrowedUsd,
+    usedAssets,
+  );
+  const incentiveUsd = new Dec(supplyIncentive)
+    .minus(borrowIncentive)
+    .add(merklSupplyIncentive)
+    .add(merklBorrowIncentive)
+    .toString();
 
   const borrowInterest = new Dec(totalBorrowRate).mul(borrowedUsd).div(100).toString();
   const supplyInterest = new Dec(totalSupplyRate).mul(suppliedUsd).div(100).toString();
@@ -66,7 +120,15 @@ borrowShares?: string,
     : new Dec(marketData.debtSharePrice!).mul(borrowShares!).toString();
 
   const isDex = [FluidVaultType.T2, FluidVaultType.T3, FluidVaultType.T4].includes(marketData.vaultType);
-  const { netApy, incentiveUsd, totalInterestUsd } = isDex ? calculateNetApyDex({ marketData, suppliedUsd: payload.suppliedUsd, borrowedUsd: payload.borrowedUsd }) : calculateNetApy({ usedAssets, assetsData: assetsData as unknown as MMAssetsData });
+  payload.merklSupplyIncentives = getUniqueFluidMerklIncentives(assetsData, IncentiveSide.Supply);
+  payload.merklBorrowIncentives = getUniqueFluidMerklIncentives(assetsData, IncentiveSide.Borrow);
+  const { netApy, incentiveUsd, totalInterestUsd } = isDex ? calculateNetApyDex({
+    marketData,
+    assetsData,
+    usedAssets,
+    suppliedUsd: payload.suppliedUsd,
+    borrowedUsd: payload.borrowedUsd,
+  }) : calculateNetApy({ usedAssets, assetsData: assetsData as unknown as MMAssetsData });
   payload.netApy = netApy;
   payload.incentiveUsd = incentiveUsd;
   payload.totalInterestUsd = totalInterestUsd;
@@ -337,4 +399,4 @@ export const mergeUsedAssets = (existing: Partial<FluidUsedAsset> = {}, addition
   ...EMPTY_USED_ASSET,
   ...existing,
   ...additional,
-});
+});

package/src/morphoBlue/index.ts

@@ -22,7 +22,7 @@ import { getViemProvider, setViemBlockNumber } from '../services/viem';
 import { addMorphoBlueMerklOpportunitiesToMarketInfo, getMorphoBlueMerklOpportunities } from './merkl';
 
 export {
-  MORPHO_BLUE_MERKL_OPPORTUNITY_TYPES,
+  MorphoBlueMerklOpportunityType,
   addMorphoBlueMerklOpportunitiesToMarketInfo,
   getMorphoBlueMerklOpportunities,
   addMorphoBlueMerklRewardsToMarketInfo,

package/src/morphoBlue/merkl.ts

@@ -1,5 +1,5 @@
 import { aprToApy } from '../moneymarket';
-import { LONGER_TIMEOUT } from '../services/utils';
+import { fetchAllMerklOpportunities } from '../services/merkl';
 import {
   IncentiveData,
   IncentiveKind,
@@ -23,7 +23,11 @@ import {
  * identifier (e.g. `0x54cf…c46WHITELIST_CAMPAIGN`); their rewards only accrue to whitelisted
  * addresses, so they are skipped rather than advertised to every user.
  */
-export const MORPHO_BLUE_MERKL_OPPORTUNITY_TYPES = ['MORPHOSUPPLY', 'MORPHOCOLLATERAL', 'MORPHOBORROW'] as const;
+export enum MorphoBlueMerklOpportunityType {
+  Supply = 'MORPHOSUPPLY',
+  Collateral = 'MORPHOCOLLATERAL',
+  Borrow = 'MORPHOBORROW',
+}
 
 const MERKL_DESCRIPTION_MARKER = 'through Merkl';
 
@@ -61,16 +65,16 @@ export const addMorphoBlueMerklOpportunitiesToMarketInfo = (
 
   const relevant = opportunities.filter((o) => o.chainId === chainId
     && o.status === OpportunityStatus.LIVE
-    && (MORPHO_BLUE_MERKL_OPPORTUNITY_TYPES as readonly string[]).includes(o.type)
+    && Object.values(MorphoBlueMerklOpportunityType).includes(o.type as MorphoBlueMerklOpportunityType)
     // a suffixed identifier marks a whitelist-gated campaign — skip those
     && o.identifier?.length === MARKET_ID_PREFIX_LENGTH
     && o.identifier.toLowerCase() === marketIdPrefix);
   if (!relevant.length) return marketInfo;
 
-  const incentivesByType = (type: string) => relevant.filter((o) => o.type === type).map(buildMerklIncentive);
-  const collateralSupply = incentivesByType('MORPHOCOLLATERAL');
-  const loanSupply = incentivesByType('MORPHOSUPPLY');
-  const loanBorrow = incentivesByType('MORPHOBORROW');
+  const incentivesByType = (type: MorphoBlueMerklOpportunityType) => relevant.filter((o) => o.type === type).map(buildMerklIncentive);
+  const collateralSupply = incentivesByType(MorphoBlueMerklOpportunityType.Collateral);
+  const loanSupply = incentivesByType(MorphoBlueMerklOpportunityType.Supply);
+  const loanBorrow = incentivesByType(MorphoBlueMerklOpportunityType.Borrow);
 
   return {
     ...marketInfo,
@@ -91,18 +95,15 @@ export const addMorphoBlueMerklOpportunitiesToMarketInfo = (
 
 /**
  * Fetches live market-scoped Morpho Blue campaigns for all chains. Never throws — on any failure
- * it returns an empty list, so Merkl being down can't break market data. The query is narrowed by
- * `type=` and capped at `items=100` because Merkl paginates at 20 items by default — an
- * unfiltered protocol query would silently drop campaigns once Morpho has enough opportunities.
+ * it returns an empty list, so Merkl being down can't break market data.
  */
 export const getMorphoBlueMerklOpportunities = async (): Promise<MerklOpportunity[]> => {
   try {
-    const res = await fetch(`https://fe.defisaver.com/api/merkl/opportunities?mainProtocolId=morpho&type=${MORPHO_BLUE_MERKL_OPPORTUNITY_TYPES.join(',')}&status=LIVE&items=100`, {
-      signal: AbortSignal.timeout(LONGER_TIMEOUT),
+    return await fetchAllMerklOpportunities({
+      mainProtocolId: 'morpho',
+      type: Object.values(MorphoBlueMerklOpportunityType).join(','),
+      status: OpportunityStatus.LIVE,
     });
-    if (!res.ok) throw new Error('Failed to fetch Morpho Blue Merkl campaigns');
-    const data = await res.json();
-    return Array.isArray(data) ? data as MerklOpportunity[] : [];
   } catch (e) {
     console.error('Failed to fetch Morpho Blue Merkl campaigns', e);
     return [];

package/src/portfolio/index.ts

@@ -41,7 +41,7 @@ import { _getLiquityTroveInfo, getLiquityStakingData } from '../liquity';
 import { _getLiquityV2MarketData, getLiquitySAndYBold, getLiquityV2Staking } from '../liquityV2';
 import { _getAllUserEarnPositionsWithFTokens, _getUserPositionsPortfolio } from '../fluid';
 import { getUmbrellaData } from '../umbrella';
-import { getMeritUnclaimedRewards, getUnclaimedRewardsForAllMarkets } from '../claiming/aaveV3';
+import { getMerklUnclaimedRewards, getUnclaimedRewardsForAllMarkets } from '../claiming/aaveV3';
 import { getCompoundV3Rewards } from '../claiming/compV3';
 import { fetchSparkAirdropRewards, fetchSparkRewards } from '../claiming/spark';
 import { getKingRewards } from '../claiming/king';
@@ -143,7 +143,7 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
     };
 
     rewardsData[address.toLowerCase() as EthAddress] = {
-      aaveV3merit: {},
+      merkl: {},
       aaveV3: {},
       compV3: {},
       spark: {},
@@ -352,11 +352,11 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
     })).flat(),
     ...addresses.map(async (address) => {
       try {
-        const aaveMeritData = await getMeritUnclaimedRewards(address, network);
-        rewardsData[address.toLowerCase() as EthAddress].aaveV3merit = { error: '', data: aaveMeritData };
+        const merklData = await getMerklUnclaimedRewards(address, network);
+        rewardsData[address.toLowerCase() as EthAddress].merkl = { error: '', data: merklData };
       } catch (error) {
-        console.error(`Error fetching Aave V3 Merit rewards data for address ${address}:`, error);
-        rewardsData[address.toLowerCase() as EthAddress].aaveV3merit = { error: `Error fetching Aave V3 Merit rewards data for address ${address}`, data: null };
+        console.error(`Error fetching Merkl rewards data for address ${address}:`, error);
+        rewardsData[address.toLowerCase() as EthAddress].merkl = { error: `Error fetching Merkl rewards data for address ${address}`, data: null };
       }
     }),
     ...aaveV3Markets.map(market => addresses.map(async (address) => {