@defisaver/positions-sdk 2.1.141-dev → 2.1.142-dev

package/esm/liquityV2/index.js

@@ -309,15 +309,14 @@ export const _getLiquityV2TroveData = (provider_1, network_1, _a, ...args_1) =>
     const interestBatchManager = data.interestBatchManager;
     const lastInterestRateAdjTime = data.lastInterestRateAdjTime.toString();
     const hasInterestBatchManager = !compareAddresses(interestBatchManager, ZERO_ADDRESS);
-    const liqRatio = hasInterestBatchManager ? new Dec(minCollRatio).add(batchCollRatio).toString() : minCollRatio;
+    const borrowLimitRatio = hasInterestBatchManager ? new Dec(minCollRatio).add(batchCollRatio).toString() : minCollRatio;
     const payload = Object.assign(Object.assign({ usedAssets,
         troveId,
         interestRate,
         interestBatchManager,
         debtInFront,
-        lastInterestRateAdjTime,
-        liqRatio, troveStatus: LIQUITY_V2_TROVE_STATUS_ENUM[parseInt(data.status.toString(), 10)] }, getLiquityV2AggregatedPositionData({
-        usedAssets, assetsData, minCollRatio: liqRatio, interestRate,
+        lastInterestRateAdjTime, liqRatio: minCollRatio, borrowLimitRatio, troveStatus: LIQUITY_V2_TROVE_STATUS_ENUM[parseInt(data.status.toString(), 10)] }, getLiquityV2AggregatedPositionData({
+        usedAssets, assetsData, minCollRatio: borrowLimitRatio, interestRate, liqRatio: minCollRatio,
     })), { collRatio });
     return payload;
 });

package/esm/morphoBlue/index.d.ts

@@ -1,6 +1,7 @@
 import { Client } from 'viem';
 import { Blockish, EthAddress, EthereumProvider, NetworkNumber, PositionBalances } from '../types/common';
 import { MorphoBlueEarnData, MorphoBlueMarketData, MorphoBlueMarketInfo, MorphoBlueMarketRewards, MorphoBluePositionData } from '../types';
+export { MORPHO_BLUE_MERKL_OPPORTUNITY_TYPES, addMorphoBlueMerklOpportunitiesToMarketInfo, getMorphoBlueMerklOpportunities, addMorphoBlueMerklRewardsToMarketInfo, } from './merkl';
 export declare const addMorphoBlueRewardsToMarketInfo: (marketInfo: MorphoBlueMarketInfo, rewards: MorphoBlueMarketRewards) => MorphoBlueMarketInfo;
 export declare function _getMorphoBlueMarketData(provider: Client, network: NetworkNumber, selectedMarket: MorphoBlueMarketData): Promise<MorphoBlueMarketInfo>;
 export declare function _getMorphoBluePortfolioMarketData(provider: Client, network: NetworkNumber, selectedMarket: MorphoBlueMarketData): Promise<MorphoBlueMarketInfo>;

package/esm/morphoBlue/index.js

@@ -17,6 +17,8 @@ import { isMainnetNetwork, wethToEth } from '../services/utils';
 import { getBorrowRate, getMorphoBlueAggregatedPositionData, getRewardsForMarket, getSupplyRate, } from '../helpers/morphoBlueHelpers';
 import { getChainlinkAssetAddress } from '../services/priceService';
 import { getViemProvider, setViemBlockNumber } from '../services/viem';
+import { addMorphoBlueMerklOpportunitiesToMarketInfo, getMorphoBlueMerklOpportunities } from './merkl';
+export { MORPHO_BLUE_MERKL_OPPORTUNITY_TYPES, addMorphoBlueMerklOpportunitiesToMarketInfo, getMorphoBlueMerklOpportunities, addMorphoBlueMerklRewardsToMarketInfo, } from './merkl';
 const HARDCODED_USD_STABLE_PRICE = '100000000'; // $1 with 8 decimals
 const getMorphoRewardIncentives = (apy) => [{
         token: 'MORPHO',
@@ -119,15 +121,15 @@ function getMorphoBlueMarketDataInternal(provider, network, selectedMarket) {
 }
 export function _getMorphoBlueMarketData(provider, network, selectedMarket) {
     return __awaiter(this, void 0, void 0, function* () {
-        const marketInfo = yield getMorphoBlueMarketDataInternal(provider, network, selectedMarket);
-        try {
-            const rewards = yield getRewardsForMarket(selectedMarket.marketId, network);
-            return addMorphoBlueRewardsToMarketInfo(marketInfo, rewards);
-        }
-        catch (error) {
-            console.error(error);
-            return addMorphoBlueRewardsToMarketInfo(marketInfo, { supplyApy: '0', borrowApy: '0' });
-        }
+        const [marketInfo, rewards, merklOpportunities] = yield Promise.all([
+            getMorphoBlueMarketDataInternal(provider, network, selectedMarket),
+            getRewardsForMarket(selectedMarket.marketId, network).catch((error) => {
+                console.error(error);
+                return { supplyApy: '0', borrowApy: '0' };
+            }),
+            getMorphoBlueMerklOpportunities(),
+        ]);
+        return addMorphoBlueMerklOpportunitiesToMarketInfo(addMorphoBlueRewardsToMarketInfo(marketInfo, rewards), selectedMarket, network, merklOpportunities);
     });
 }
 export function _getMorphoBluePortfolioMarketData(provider, network, selectedMarket) {

package/esm/morphoBlue/merkl.d.ts

@@ -0,0 +1,33 @@
+import { MerklOpportunity, MorphoBlueMarketData, MorphoBlueMarketInfo, NetworkNumber } from '../types';
+/**
+ * Merkl tags Morpho Blue market-level reward campaigns via the opportunity `type` field:
+ *   - MORPHOSUPPLY     → reward for supplying the market's loan asset
+ *   - MORPHOCOLLATERAL → reward for depositing the market's collateral asset
+ *   - MORPHOBORROW     → reward for borrowing the market's loan asset
+ * (MORPHOVAULT/ERC20LOGPROCESSOR are MetaMorpho vault campaigns and MORPHOSUPPLY_SINGLETOKEN is
+ * token-wide rather than market-scoped, so none of them belong on per-market data.)
+ *
+ * A campaign identifies its market via `identifier` — the first 20 bytes of the 32-byte Morpho
+ * market id, formatted as a checksummed address. Whitelist-gated campaigns append a marker to that
+ * identifier (e.g. `0x54cf…c46WHITELIST_CAMPAIGN`); their rewards only accrue to whitelisted
+ * addresses, so they are skipped rather than advertised to every user.
+ */
+export declare const MORPHO_BLUE_MERKL_OPPORTUNITY_TYPES: readonly ["MORPHOSUPPLY", "MORPHOCOLLATERAL", "MORPHOBORROW"];
+/**
+ * Appends the given live Merkl campaigns for the market to its `assetsData` incentive arrays
+ * (collateral supply / loan supply / loan borrow). Existing Merkl incentives are replaced rather
+ * than duplicated, so re-applying on refreshed data is safe.
+ */
+export declare const addMorphoBlueMerklOpportunitiesToMarketInfo: (marketInfo: MorphoBlueMarketInfo, selectedMarket: MorphoBlueMarketData, chainId: NetworkNumber, opportunities: MerklOpportunity[]) => MorphoBlueMarketInfo;
+/**
+ * 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.
+ */
+export declare const getMorphoBlueMerklOpportunities: () => Promise<MerklOpportunity[]>;
+/**
+ * Fetches live Merkl campaigns and appends the ones for the market to its `assetsData` incentive
+ * arrays. Never throws — on any failure the market info is returned unchanged.
+ */
+export declare const addMorphoBlueMerklRewardsToMarketInfo: (marketInfo: MorphoBlueMarketInfo, selectedMarket: MorphoBlueMarketData, network: NetworkNumber) => Promise<MorphoBlueMarketInfo>;

package/esm/morphoBlue/merkl.js

@@ -0,0 +1,95 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { aprToApy } from '../moneymarket';
+import { LONGER_TIMEOUT } from '../services/utils';
+import { IncentiveKind, OpportunityStatus, } from '../types';
+/**
+ * Merkl tags Morpho Blue market-level reward campaigns via the opportunity `type` field:
+ *   - MORPHOSUPPLY     → reward for supplying the market's loan asset
+ *   - MORPHOCOLLATERAL → reward for depositing the market's collateral asset
+ *   - MORPHOBORROW     → reward for borrowing the market's loan asset
+ * (MORPHOVAULT/ERC20LOGPROCESSOR are MetaMorpho vault campaigns and MORPHOSUPPLY_SINGLETOKEN is
+ * token-wide rather than market-scoped, so none of them belong on per-market data.)
+ *
+ * A campaign identifies its market via `identifier` — the first 20 bytes of the 32-byte Morpho
+ * market id, formatted as a checksummed address. Whitelist-gated campaigns append a marker to that
+ * 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'];
+const MERKL_DESCRIPTION_MARKER = 'through Merkl';
+// '0x' + first 20 bytes of the market id
+const MARKET_ID_PREFIX_LENGTH = 42;
+const buildMerklIncentive = (opportunity) => {
+    var _a, _b, _c, _d, _e, _f;
+    const token = ((_d = (_c = (_b = (_a = opportunity.rewardsRecord) === null || _a === void 0 ? void 0 : _a.breakdowns) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.token) === null || _d === void 0 ? void 0 : _d.symbol) || ((_f = (_e = opportunity.tokens) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.symbol) || '';
+    return {
+        apy: aprToApy(opportunity.apr),
+        token,
+        incentiveKind: IncentiveKind.Reward,
+        description: `Eligible for ${token} rewards through Merkl.${opportunity.description ? `\n${opportunity.description}` : ''}`,
+    };
+};
+const withoutMerklIncentives = (incentives = []) => incentives
+    .filter(({ description }) => !(description === null || description === void 0 ? void 0 : description.includes(MERKL_DESCRIPTION_MARKER)));
+/**
+ * Appends the given live Merkl campaigns for the market to its `assetsData` incentive arrays
+ * (collateral supply / loan supply / loan borrow). Existing Merkl incentives are replaced rather
+ * than duplicated, so re-applying on refreshed data is safe.
+ */
+export const addMorphoBlueMerklOpportunitiesToMarketInfo = (marketInfo, selectedMarket, chainId, opportunities) => {
+    const marketIdPrefix = (selectedMarket.marketId || '').slice(0, MARKET_ID_PREFIX_LENGTH).toLowerCase();
+    const collateralAsset = marketInfo.assetsData[marketInfo.collateralToken];
+    const loanAsset = marketInfo.assetsData[marketInfo.loanToken];
+    if (marketIdPrefix.length !== MARKET_ID_PREFIX_LENGTH || !collateralAsset || !loanAsset)
+        return marketInfo;
+    const relevant = opportunities.filter((o) => {
+        var _a;
+        return o.chainId === chainId
+            && o.status === OpportunityStatus.LIVE
+            && MORPHO_BLUE_MERKL_OPPORTUNITY_TYPES.includes(o.type)
+            // a suffixed identifier marks a whitelist-gated campaign — skip those
+            && ((_a = o.identifier) === null || _a === void 0 ? void 0 : _a.length) === MARKET_ID_PREFIX_LENGTH
+            && o.identifier.toLowerCase() === marketIdPrefix;
+    });
+    if (!relevant.length)
+        return marketInfo;
+    const incentivesByType = (type) => relevant.filter((o) => o.type === type).map(buildMerklIncentive);
+    const collateralSupply = incentivesByType('MORPHOCOLLATERAL');
+    const loanSupply = incentivesByType('MORPHOSUPPLY');
+    const loanBorrow = incentivesByType('MORPHOBORROW');
+    return Object.assign(Object.assign({}, marketInfo), { assetsData: Object.assign(Object.assign({}, marketInfo.assetsData), { [marketInfo.collateralToken]: Object.assign(Object.assign({}, collateralAsset), { supplyIncentives: [...withoutMerklIncentives(collateralAsset.supplyIncentives), ...collateralSupply] }), [marketInfo.loanToken]: Object.assign(Object.assign({}, loanAsset), { supplyIncentives: [...withoutMerklIncentives(loanAsset.supplyIncentives), ...loanSupply], borrowIncentives: [...withoutMerklIncentives(loanAsset.borrowIncentives), ...loanBorrow] }) }) });
+};
+/**
+ * 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.
+ */
+export const getMorphoBlueMerklOpportunities = () => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield 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),
+        });
+        if (!res.ok)
+            throw new Error('Failed to fetch Morpho Blue Merkl campaigns');
+        const data = yield res.json();
+        return Array.isArray(data) ? data : [];
+    }
+    catch (e) {
+        console.error('Failed to fetch Morpho Blue Merkl campaigns', e);
+        return [];
+    }
+});
+/**
+ * Fetches live Merkl campaigns and appends the ones for the market to its `assetsData` incentive
+ * arrays. Never throws — on any failure the market info is returned unchanged.
+ */
+export const addMorphoBlueMerklRewardsToMarketInfo = (marketInfo, selectedMarket, network) => __awaiter(void 0, void 0, void 0, function* () { return addMorphoBlueMerklOpportunitiesToMarketInfo(marketInfo, selectedMarket, network, yield getMorphoBlueMerklOpportunities()); });

package/esm/staking/eligibility.d.ts

@@ -19,6 +19,10 @@ export declare const isEligibleForAaveV3ArbitrumETHLSBorrow: (usedAssets: MMUsed
     isEligible: boolean;
     eligibleUSDAmount: string;
 };
+export declare const isEligibleForCompoundV3PufEthWethBorrow: (usedAssets: MMUsedAssets) => {
+    isEligible: boolean;
+    eligibleUSDAmount: string;
+};
 export declare const EligibilityMapping: {
     [key in IncentiveEligibilityId]: (usedAssets: MMUsedAssets, optionalData: any) => {
         isEligible: boolean;

package/esm/staking/eligibility.js

@@ -60,10 +60,19 @@ export const isEligibleForAaveV3ArbitrumETHLSBorrow = (usedAssets) => {
     const ETHAmountBorrowed = ((_a = usedAssets.ETH) === null || _a === void 0 ? void 0 : _a.borrowedUsd) || '0';
     return { isEligible: true, eligibleUSDAmount: ETHAmountBorrowed };
 };
+// "Borrow WETH with pufETH collateral" — rewards are calculated as min(collateral * 80% LTV, borrow amount)
+export const isEligibleForCompoundV3PufEthWethBorrow = (usedAssets) => {
+    var _a, _b;
+    const collateralUsd = ((_a = usedAssets.pufETH) === null || _a === void 0 ? void 0 : _a.suppliedUsd) || '0';
+    const borrowedUsd = ((_b = usedAssets.ETH) === null || _b === void 0 ? void 0 : _b.borrowedUsd) || '0';
+    const eligibleUSDAmount = Dec.min(new Dec(collateralUsd).mul('0.8'), borrowedUsd).toString();
+    return { isEligible: new Dec(eligibleUSDAmount).gt(0), eligibleUSDAmount };
+};
 export const EligibilityMapping = {
     [IncentiveEligibilityId.AaveV3EthenaLiquidLeverage]: isEligibleForEthenaUSDeRewards,
     [IncentiveEligibilityId.AaveV3ArbitrumEthSupply]: isEligibleForAaveV3ArbitrumEthSupply,
     [IncentiveEligibilityId.AaveV3ArbitrumETHLSBorrow]: isEligibleForAaveV3ArbitrumETHLSBorrow,
     [IncentiveEligibilityId.AaveV3EthenaLiquidLeveragePlasma]: isEligibleForEthenaUSDeRewards,
     [IncentiveEligibilityId.AaveV3EthenaLiquidLeveragePlasmaGHO]: isEligibleForEthenaGHORewards,
+    [IncentiveEligibilityId.CompoundV3PufEthWethBorrow]: isEligibleForCompoundV3PufEthWethBorrow,
 };

package/esm/types/common.d.ts

@@ -11,7 +11,8 @@ export declare enum IncentiveEligibilityId {
     AaveV3ArbitrumEthSupply = "0x5d16261c6715a653248269861bbacf68a9774cde",
     AaveV3ArbitrumETHLSBorrow = "0x0c84331e39d6658Cd6e6b9ba04736cC4c4734351",
     AaveV3EthenaLiquidLeveragePlasma = "0x2E8f1FA9c73F9d975B46BDFe40C92b6dDEFA3f31BORROW_BL",
-    AaveV3EthenaLiquidLeveragePlasmaGHO = "2b2f6fefcd3df634"
+    AaveV3EthenaLiquidLeveragePlasmaGHO = "2b2f6fefcd3df634",
+    CompoundV3PufEthWethBorrow = "e6e49b79e83041f9"
 }
 export declare enum LeverageType {
     Long = "long",

package/esm/types/common.js

@@ -15,6 +15,7 @@ export var IncentiveEligibilityId;
     IncentiveEligibilityId["AaveV3ArbitrumETHLSBorrow"] = "0x0c84331e39d6658Cd6e6b9ba04736cC4c4734351";
     IncentiveEligibilityId["AaveV3EthenaLiquidLeveragePlasma"] = "0x2E8f1FA9c73F9d975B46BDFe40C92b6dDEFA3f31BORROW_BL";
     IncentiveEligibilityId["AaveV3EthenaLiquidLeveragePlasmaGHO"] = "2b2f6fefcd3df634";
+    IncentiveEligibilityId["CompoundV3PufEthWethBorrow"] = "e6e49b79e83041f9";
 })(IncentiveEligibilityId || (IncentiveEligibilityId = {}));
 export var LeverageType;
 (function (LeverageType) {

package/esm/types/liquityV2.d.ts

@@ -84,6 +84,7 @@ export interface LiquityV2AggregatedTroveData {
     suppliedUsd: string;
     borrowedUsd: string;
     borrowLimitUsd: string;
+    liquidationLimitUsd: string;
     leftToBorrowUsd: string;
     netApy: string;
     incentiveUsd: string;
@@ -101,9 +102,11 @@ export interface LiquityV2TroveData {
     ratio: string;
     collRatio: string;
     liqRatio: string;
+    borrowLimitRatio: string;
     interestRate: string;
     leftToBorrowUsd: string;
     borrowLimitUsd: string;
+    liquidationLimitUsd: string;
     suppliedUsd: string;
     borrowedUsd: string;
     netApy: string;

package/esm/types/merkl.d.ts

@@ -76,6 +76,14 @@ export type MerkleRewardMap = Record<EthAddress, {
 export type AaveV4MerklScopedReward = {
     [side in IncentiveSide]?: IncentiveData;
 };
+/**
+ * Fluid vault-scoped Merkl campaigns keyed by lowercase vault address — `supply` rewards apply to
+ * the vault's collateral side, `borrow` rewards to its debt side.
+ */
+export type FluidMerklRewardMap = Record<string, {
+    supply: IncentiveData[];
+    borrow: IncentiveData[];
+}>;
 /**
  * Aave V4 Merkl reward campaigns split by scope:
  *   - `hub`: keyed by `${hubAddress}_${underlyingAddress}` (both lowercase) — rewards for supplying/borrowing via a hub

package/package.json

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

package/src/aaveV3/merkl.ts

@@ -31,7 +31,9 @@ export const formatAaveAsset = (_symbol: string) => {
 
 export const getMerkleCampaigns = async (chainId: NetworkNumber): Promise<MerkleRewardMap> => {
   try {
-    const res = await fetch('https://fe.defisaver.com/api/merkl/opportunities?mainProtocolId=aave', {
+    // 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),
     });
     if (!res.ok) throw new Error('Failed to fetch Merkle campaigns');
@@ -40,7 +42,8 @@ export const getMerkleCampaigns = async (chainId: NetworkNumber): Promise<Merkle
       .filter((o: MerklOpportunity) => o.chainId === chainId)
       .filter((o: MerklOpportunity) => o.status === OpportunityStatus.LIVE);
     return relevantOpportunities.reduce((acc, opportunity) => {
-      const rewardToken = opportunity.rewardsRecord.breakdowns[0].token;
+      const rewardToken = opportunity.rewardsRecord?.breakdowns?.[0]?.token;
+      if (!rewardToken) return acc;
       const description = `Eligible for ${formatAaveAsset(rewardToken.symbol)} rewards through Merkl. ${opportunity.description ? `\n${opportunity.description}` : ''}`;
       if (opportunity.action === OpportunityAction.LEND && opportunity.explorerAddress) {
         const supplyAToken = opportunity.explorerAddress?.toLowerCase() as EthAddress;

package/src/aaveV4/merkl.ts

@@ -67,7 +67,7 @@ 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', {
+    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),
     });
     if (!res.ok) throw new Error('Failed to fetch Aave V4 Merkle campaigns');

package/src/compoundV3/index.ts

@@ -24,6 +24,9 @@ import {
   getEthPrice, getCompPrice, getUSDCPrice, getWstETHPrice,
 } from '../services/priceService';
 import { getViemProvider, setViemBlockNumber } from '../services/viem';
+import { attachCompoundV3MerklIncentives, getCompoundV3MerklOpportunities } from './merkl';
+
+export { getCompoundV3MerklOpportunities, attachCompoundV3MerklIncentives } from './merkl';
 
 const getSupportedAssetsAddressesForMarket = (selectedMarket: CompoundMarketData, network: NetworkNumber) => selectedMarket.collAssets.map(asset => getAssetInfo(ethToWeth(asset), network)).map(addr => addr.address.toLowerCase());
 
@@ -41,12 +44,13 @@ const getBaseAssetPriceFunction = (asset: string) => {
 export const _getCompoundV3MarketsData = async (provider: Client, network: NetworkNumber, selectedMarket: CompoundMarketData, defaultProvider: Client): Promise<CompoundV3MarketsData> => {
   const contract = CompV3ViewContractViem(provider, network);
 
-  const [baseAssetPrice, compPrice, baseTokenInfo, collInfos, govInfo] = await Promise.all([
+  const [baseAssetPrice, compPrice, baseTokenInfo, collInfos, govInfo, merklOpportunities] = await Promise.all([
     getBaseAssetPriceFunction(selectedMarket.baseAsset)(defaultProvider),
     getCompPrice(defaultProvider),
     contract.read.getFullBaseTokenInfo([selectedMarket.baseMarketAddress]),
     contract.read.getFullCollInfos([selectedMarket.baseMarketAddress]),
     contract.read.getGovernanceInfoFull([selectedMarket.baseMarketAddress]),
+    getCompoundV3MerklOpportunities(),
   ]);
 
   const { isSupplyPaused, isWithdrawPaused } = govInfo;
@@ -72,6 +76,7 @@ export const _getCompoundV3MarketsData = async (provider: Client, network: Netwo
   const payload: CompoundV3AssetsData = {};
 
   const baseObj = { ...base, ...(await getIncentiveApys(base, compPrice)) };
+  attachCompoundV3MerklIncentives(baseObj, colls, selectedMarket.baseMarketAddress, network, merklOpportunities);
   const allAssets = [baseObj, ...colls];
 
   allAssets

package/src/compoundV3/merkl.ts

@@ -0,0 +1,77 @@
+import { getAssetInfoByAddress } from '@defisaver/tokens';
+import { aprToApy } from '../moneymarket';
+import { compareAddresses, LONGER_TIMEOUT, wethToEth } from '../services/utils';
+import {
+  CompoundV3AssetData,
+  IncentiveData,
+  IncentiveEligibilityId,
+  IncentiveKind,
+  MerklOpportunity,
+  NetworkNumber,
+  OpportunityAction,
+  OpportunityStatus,
+} from '../types';
+
+/**
+ * Merkl tags Compound V3 reward campaigns with COMPOUND_V3_* opportunity types (e.g.
+ * COMPOUND_V3_BORROW_FROM_COLLATERAL) and identifies the comet via `explorerAddress`. Campaign
+ * identifiers are opaque hashes, passed through as `eligibilityId` so conditional campaigns —
+ * like borrow-from-collateral ones, whose reward is min(collateral * LTV, borrow amount) — can
+ * be gated and sized by a curated check in EligibilityMapping; unknown ids apply
+ * unconditionally, mirroring Aave V3.
+ */
+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),
+    });
+    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 [];
+  }
+};
+
+const buildMerklIncentive = (opportunity: MerklOpportunity): IncentiveData => {
+  const token = opportunity.rewardsRecord?.breakdowns?.[0]?.token?.symbol || opportunity.tokens?.[0]?.symbol || '';
+  return {
+    apy: aprToApy(opportunity.apr),
+    token,
+    incentiveKind: IncentiveKind.Reward,
+    description: `Eligible for ${token} rewards through Merkl.${opportunity.description ? `\n${opportunity.description}` : ''}`,
+    eligibilityId: opportunity.identifier as IncentiveEligibilityId,
+  };
+};
+
+/**
+ * Appends the comet's Merkl campaigns to its assets' incentive arrays (mutating them, like the
+ * staking incentives are attached). BORROW campaigns land on the base asset — the only borrowable
+ * one — while LEND campaigns land on the asset the campaign's first token resolves to.
+ */
+export const attachCompoundV3MerklIncentives = (
+  baseAsset: CompoundV3AssetData,
+  collAssets: CompoundV3AssetData[],
+  baseMarketAddress: string,
+  chainId: NetworkNumber,
+  opportunities: MerklOpportunity[],
+): void => {
+  opportunities
+    .filter((o) => o.chainId === chainId
+      && o.status === OpportunityStatus.LIVE
+      && typeof o.type === 'string' && o.type.startsWith('COMPOUND_V3')
+      && o.explorerAddress && compareAddresses(o.explorerAddress, baseMarketAddress))
+    .forEach((o) => {
+      const incentive = buildMerklIncentive(o);
+      if (o.action === OpportunityAction.BORROW) {
+        baseAsset.borrowIncentives.push(incentive);
+      } else if (o.action === OpportunityAction.LEND) {
+        const campaignTokenAddress = o.tokens?.[0]?.address;
+        if (!campaignTokenAddress) return;
+        const campaignSymbol = wethToEth(getAssetInfoByAddress(campaignTokenAddress, chainId).symbol);
+        const target = [baseAsset, ...collAssets].find((asset) => asset.symbol === campaignSymbol);
+        target?.supplyIncentives.push(incentive);
+      }
+    });
+};

package/src/fluid/index.ts

@@ -66,6 +66,14 @@ import {
 } from '../services/priceService';
 import { getStakingApy, STAKING_ASSETS } from '../staking';
 import { getViemProvider } from '../services/viem';
+import { attachFluidMerklIncentives, getFluidMerklCampaigns } from './merkl';
+
+export {
+  FLUID_MERKL_OPPORTUNITY_TYPES,
+  buildFluidMerklRewardMap,
+  getFluidMerklCampaigns,
+  attachFluidMerklIncentives,
+} from './merkl';
 
 export const EMPTY_USED_ASSET = {
   isSupplied: false,
@@ -1442,9 +1450,13 @@ const parseUserData = (userPositionData: FluidUserPositionStructOutputStruct, va
 export const _getFluidMarketData = async (provider: PublicClient, network: NetworkNumber, market: FluidMarketInfo) => {
   const view = FluidViewContractViem(provider, network);
 
-  const data = await view.read.getVaultData([market.marketAddress]);
+  const [data, merklCampaigns] = await Promise.all([
+    view.read.getVaultData([market.marketAddress]),
+    getFluidMerklCampaigns(network),
+  ]);
 
-  return parseMarketData(provider, data, network);
+  const marketData = await parseMarketData(provider, data, network);
+  return marketData ? attachFluidMerklIncentives(marketData, merklCampaigns) : marketData;
 };
 
 export const getFluidMarketData = async (
@@ -1500,11 +1512,15 @@ export const getFluidPosition = async (
 
 export const _getFluidPositionWithMarket = async (provider: PublicClient, network: NetworkNumber, vaultId: string) => {
   const view = FluidViewContractViem(provider, network);
-  const data = await view.read.getPositionByNftId([BigInt(vaultId)]);
-  const marketData = await parseMarketData(provider, data[1], network);
-  if (!marketData) {
+  const [data, merklCampaigns] = await Promise.all([
+    view.read.getPositionByNftId([BigInt(vaultId)]),
+    getFluidMerklCampaigns(network),
+  ]);
+  const parsedMarketData = await parseMarketData(provider, data[1], network);
+  if (!parsedMarketData) {
     return;
   }
+  const marketData = attachFluidMerklIncentives(parsedMarketData, merklCampaigns);
   const userData = parseUserData(data[0], marketData);
 
   return {
@@ -1522,8 +1538,14 @@ export const getFluidPositionWithMarket = async (
 export const _getAllFluidMarketDataChunked = async (network: NetworkNumber, provider: PublicClient) => {
   const versions = getFluidVersionsDataForNetwork(network);
   const view = FluidViewContractViem(provider, network);
-  const data = await Promise.all(versions.map((version) => view.read.getVaultData([version.marketAddress])));
-  return Promise.all(data.map(async (item, i) => parseMarketData(provider, item, network)));
+  const [data, merklCampaigns] = await Promise.all([
+    Promise.all(versions.map((version) => view.read.getVaultData([version.marketAddress]))),
+    getFluidMerklCampaigns(network),
+  ]);
+  return Promise.all(data.map(async (item) => {
+    const marketData = await parseMarketData(provider, item, network);
+    return marketData ? attachFluidMerklIncentives(marketData, merklCampaigns) : marketData;
+  }));
 };
 
 export const getAllFluidMarketDataChunked = async (

package/src/fluid/merkl.ts

@@ -0,0 +1,97 @@
+import { aprToApy } from '../moneymarket';
+import { LONGER_TIMEOUT } from '../services/utils';
+import {
+  FluidMarketData,
+  FluidMerklRewardMap,
+  IncentiveData,
+  IncentiveEligibilityId,
+  IncentiveKind,
+  MerklOpportunity,
+  NetworkNumber,
+  OpportunityStatus,
+} from '../types';
+
+/**
+ * Merkl tags Fluid vault-scoped reward campaigns via the opportunity `type` field:
+ *   - FLUIDVAULT_COLLATERAL → reward for supplying collateral to the vault
+ *   - FLUIDVAULT_BORROW     → reward for borrowing from the vault
+ * (ERC20LOGPROCESSOR campaigns target fToken earn positions rather than vaults, so they don't
+ * belong on vault market data.)
+ *
+ * A campaign identifies its vault via `identifier` — the vault address. Conditional campaigns
+ * append a marker to it (e.g. `0x5668…eeaBORROW_BL`, excluding holders who borrow the reward
+ * asset elsewhere); those are still attached, with the full identifier passed through as
+ * `eligibilityId` so a curated check in EligibilityMapping can gate them in net APY — unknown
+ * 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;
+
+// '0x' + 20-byte vault address; conditional campaigns append a marker after it
+const VAULT_ADDRESS_LENGTH = 42;
+
+const buildMerklIncentive = (opportunity: MerklOpportunity): IncentiveData => {
+  const token = opportunity.rewardsRecord?.breakdowns?.[0]?.token?.symbol || opportunity.tokens?.[0]?.symbol || '';
+  return {
+    apy: aprToApy(opportunity.apr),
+    token,
+    incentiveKind: IncentiveKind.Reward,
+    description: `Eligible for ${token} rewards through Merkl.${opportunity.description ? `\n${opportunity.description}` : ''}`,
+    eligibilityId: opportunity.identifier as IncentiveEligibilityId,
+  };
+};
+
+export const buildFluidMerklRewardMap = (opportunities: MerklOpportunity[], chainId: NetworkNumber): FluidMerklRewardMap => {
+  const result: FluidMerklRewardMap = {};
+
+  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) => !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));
+    });
+
+  return result;
+};
+
+/**
+ * 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.
+ */
+export const getFluidMerklCampaigns = 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),
+    });
+    if (!res.ok) throw new Error('Failed to fetch Fluid Merkl campaigns');
+    const opportunities = await res.json();
+    return buildFluidMerklRewardMap(Array.isArray(opportunities) ? opportunities : [], chainId);
+  } catch (e) {
+    console.error('Failed to fetch Fluid Merkl campaigns', e);
+    return {};
+  }
+};
+
+/**
+ * Appends the vault's Merkl campaigns to its assets' incentive arrays — supply rewards on every
+ * suppliable asset and borrow rewards on every borrowable one. Smart collateral/debt vaults hold
+ * the position across both pair tokens, so the pro-rata reward APY applies to each side's value.
+ */
+export const attachFluidMerklIncentives = (marketData: FluidMarketData, campaigns: FluidMerklRewardMap): FluidMarketData => {
+  const vaultCampaigns = campaigns[marketData.marketData.marketAddress?.toLowerCase()];
+  if (!vaultCampaigns || (!vaultCampaigns.supply.length && !vaultCampaigns.borrow.length)) return marketData;
+
+  const assetsData = Object.fromEntries(Object.entries(marketData.assetsData).map(([symbol, asset]) => [symbol, {
+    ...asset,
+    supplyIncentives: asset.canBeSupplied ? [...asset.supplyIncentives, ...vaultCampaigns.supply] : asset.supplyIncentives,
+    borrowIncentives: asset.canBeBorrowed ? [...asset.borrowIncentives, ...vaultCampaigns.borrow] : asset.borrowIncentives,
+  }]));
+
+  return { ...marketData, assetsData };
+};

package/src/helpers/liquityV2Helpers/index.ts

@@ -52,16 +52,19 @@ export const getLiquityV2AggregatedPositionData = ({
   assetsData,
   minCollRatio,
   interestRate,
+  liqRatio,
 }: {
   usedAssets: LiquityV2UsedAssets
   assetsData: LiquityV2AssetsData
   minCollRatio: string
   interestRate: string
+  liqRatio?: string // liquidation threshold (MCR), when different from minCollRatio (MCR + BCR for troves in a batch)
 }): LiquityV2AggregatedTroveData => {
   const payload = {} as LiquityV2AggregatedTroveData;
   payload.suppliedUsd = getAssetsTotal(usedAssets, (usedAsset: LiquityV2UsedAsset) => usedAsset, ({ suppliedUsd }: { suppliedUsd: string }) => suppliedUsd);
   payload.borrowedUsd = getAssetsTotal(usedAssets, (usedAsset: LiquityV2UsedAsset) => usedAsset, ({ borrowedUsd }: { borrowedUsd: string }) => borrowedUsd);
   payload.borrowLimitUsd = new Dec(payload.suppliedUsd).div(minCollRatio).mul(100).toString();
+  payload.liquidationLimitUsd = new Dec(payload.suppliedUsd).div(liqRatio ?? minCollRatio).mul(100).toString();
   const leftToBorrowUsd = new Dec(payload.borrowLimitUsd).sub(payload.borrowedUsd);
   payload.leftToBorrowUsd = leftToBorrowUsd.lte('0') ? '0' : leftToBorrowUsd.toString();
   payload.ratio = (+payload.suppliedUsd && +payload.borrowedUsd) ? new Dec(payload.borrowLimitUsd).div(payload.borrowedUsd).mul(100).toString() : '0';
@@ -77,7 +80,7 @@ export const getLiquityV2AggregatedPositionData = ({
   payload.liquidationPrice = '';
   if (leveragedType !== '') {
     const assetPrice = assetsData[leveragedAsset].price;
-    payload.liquidationPrice = calcLeverageLiqPrice(leveragedType, assetPrice, payload.borrowedUsd, payload.borrowLimitUsd);
+    payload.liquidationPrice = calcLeverageLiqPrice(leveragedType, assetPrice, payload.borrowedUsd, payload.liquidationLimitUsd);
   }
   payload.exposure = getExposure(payload.borrowedUsd, payload.suppliedUsd);