@defisaver/positions-sdk 2.1.141 → 2.1.142

package/src/morphoBlue/index.ts

@@ -19,6 +19,15 @@ import {
 import { getChainlinkAssetAddress } from '../services/priceService';
 import { getViemProvider, setViemBlockNumber } from '../services/viem';
 
+import { addMorphoBlueMerklOpportunitiesToMarketInfo, getMorphoBlueMerklOpportunities } from './merkl';
+
+export {
+  MorphoBlueMerklOpportunityType,
+  addMorphoBlueMerklOpportunitiesToMarketInfo,
+  getMorphoBlueMerklOpportunities,
+  addMorphoBlueMerklRewardsToMarketInfo,
+} from './merkl';
+
 const HARDCODED_USD_STABLE_PRICE = '100000000'; // $1 with 8 decimals
 
 const getMorphoRewardIncentives = (apy: string) => [{
@@ -151,15 +160,21 @@ async function getMorphoBlueMarketDataInternal(
 }
 
 export async function _getMorphoBlueMarketData(provider: Client, network: NetworkNumber, selectedMarket: MorphoBlueMarketData): Promise<MorphoBlueMarketInfo> {
-  const marketInfo = await getMorphoBlueMarketDataInternal(provider, network, selectedMarket);
-
-  try {
-    const rewards = await getRewardsForMarket(selectedMarket.marketId, network);
-    return addMorphoBlueRewardsToMarketInfo(marketInfo, rewards);
-  } catch (error) {
-    console.error(error);
-    return addMorphoBlueRewardsToMarketInfo(marketInfo, { supplyApy: '0', borrowApy: '0' });
-  }
+  const [marketInfo, rewards, merklOpportunities] = await 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: Client, network: NetworkNumber, selectedMarket: MorphoBlueMarketData): Promise<MorphoBlueMarketInfo> {

package/src/morphoBlue/merkl.ts

@@ -0,0 +1,121 @@
+import { aprToApy } from '../moneymarket';
+import { fetchAllMerklOpportunities } from '../services/merkl';
+import {
+  IncentiveData,
+  IncentiveKind,
+  MerklOpportunity,
+  MorphoBlueMarketData,
+  MorphoBlueMarketInfo,
+  NetworkNumber,
+  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 enum MorphoBlueMerklOpportunityType {
+  Supply = 'MORPHOSUPPLY',
+  Collateral = 'MORPHOCOLLATERAL',
+  Borrow = 'MORPHOBORROW',
+}
+
+const MERKL_DESCRIPTION_MARKER = 'through Merkl';
+
+// '0x' + first 20 bytes of the market id
+const MARKET_ID_PREFIX_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}` : ''}`,
+  };
+};
+
+const withoutMerklIncentives = (incentives: IncentiveData[] = []) => incentives
+  .filter(({ description }) => !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: MorphoBlueMarketInfo,
+  selectedMarket: MorphoBlueMarketData,
+  chainId: NetworkNumber,
+  opportunities: MerklOpportunity[],
+): MorphoBlueMarketInfo => {
+  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) => o.chainId === chainId
+    && o.status === OpportunityStatus.LIVE
+    && 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: 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,
+    assetsData: {
+      ...marketInfo.assetsData,
+      [marketInfo.collateralToken]: {
+        ...collateralAsset,
+        supplyIncentives: [...withoutMerklIncentives(collateralAsset.supplyIncentives), ...collateralSupply],
+      },
+      [marketInfo.loanToken]: {
+        ...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.
+ */
+export const getMorphoBlueMerklOpportunities = async (): Promise<MerklOpportunity[]> => {
+  try {
+    return await fetchAllMerklOpportunities({
+      mainProtocolId: 'morpho',
+      type: Object.values(MorphoBlueMerklOpportunityType).join(','),
+      status: OpportunityStatus.LIVE,
+    });
+  } 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 = async (
+  marketInfo: MorphoBlueMarketInfo,
+  selectedMarket: MorphoBlueMarketData,
+  network: NetworkNumber,
+): Promise<MorphoBlueMarketInfo> => addMorphoBlueMerklOpportunitiesToMarketInfo(marketInfo, selectedMarket, network, await getMorphoBlueMerklOpportunities());

package/src/services/merkl.ts

@@ -0,0 +1,31 @@
+import { MerklOpportunity } from '../types';
+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 = async (query: Record<string, string>): Promise<MerklOpportunity[]> => {
+  const opportunities: MerklOpportunity[] = [];
+  let page = 0;
+  let pageOpportunities: MerklOpportunity[];
+
+  do {
+    const searchParams = new URLSearchParams({ ...query, page: page.toString() });
+    const res = await fetch(`${MERKL_OPPORTUNITIES_URL}?${searchParams}`, { // eslint-disable-line no-await-in-loop
+      signal: AbortSignal.timeout(LONGER_TIMEOUT),
+    });
+    if (!res.ok) throw new Error(`Failed to fetch Merkl opportunities page ${page}`);
+
+    const data = await 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 as MerklOpportunity[];
+    opportunities.push(...pageOpportunities);
+    page += 1;
+  } while (pageOpportunities.length > 0);
+
+  return opportunities;
+};

package/src/staking/eligibility.ts

@@ -97,10 +97,20 @@ export const isEligibleForAaveV3ArbitrumETHLSBorrow = (usedAssets: MMUsedAssets)
   return { isEligible: true, eligibleUSDAmount: ETHAmountBorrowed };
 };
 
+// "Borrow WETH with pufETH collateral" — rewards are calculated as min(collateral * 80% LTV, borrow amount)
+export const isEligibleForCompoundV3PufEthWethBorrow = (usedAssets: MMUsedAssets) => {
+  const collateralUsd = usedAssets.pufETH?.suppliedUsd || '0';
+  const borrowedUsd = usedAssets.ETH?.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: { [key in IncentiveEligibilityId]: (usedAssets: MMUsedAssets, optionalData: any) => { isEligible: boolean; eligibleUSDAmount: string } } = {
   [IncentiveEligibilityId.AaveV3EthenaLiquidLeverage]: isEligibleForEthenaUSDeRewards,
   [IncentiveEligibilityId.AaveV3ArbitrumEthSupply]: isEligibleForAaveV3ArbitrumEthSupply,
   [IncentiveEligibilityId.AaveV3ArbitrumETHLSBorrow]: isEligibleForAaveV3ArbitrumETHLSBorrow,
   [IncentiveEligibilityId.AaveV3EthenaLiquidLeveragePlasma]: isEligibleForEthenaUSDeRewards,
   [IncentiveEligibilityId.AaveV3EthenaLiquidLeveragePlasmaGHO]: isEligibleForEthenaGHORewards,
+  [IncentiveEligibilityId.CompoundV3PufEthWethBorrow]: isEligibleForCompoundV3PufEthWethBorrow,
 };

package/src/types/common.ts

@@ -14,6 +14,7 @@ export enum IncentiveEligibilityId {
   AaveV3ArbitrumETHLSBorrow = '0x0c84331e39d6658Cd6e6b9ba04736cC4c4734351',
   AaveV3EthenaLiquidLeveragePlasma = '0x2E8f1FA9c73F9d975B46BDFe40C92b6dDEFA3f31BORROW_BL',
   AaveV3EthenaLiquidLeveragePlasmaGHO = '2b2f6fefcd3df634',
+  CompoundV3PufEthWethBorrow = 'e6e49b79e83041f9',
 }
 
 export enum LeverageType {

package/src/types/merkl.ts

@@ -72,6 +72,12 @@ export type MerkleRewardMap = Record<EthAddress, { supply?: MerkleRewardInfo; bo
 
 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