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

package/src/liquityV2/index.ts

@@ -425,7 +425,7 @@ export const _getLiquityV2TroveData = async (
   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: LiquityV2TroveData = {
     usedAssets,
@@ -434,10 +434,11 @@ export const _getLiquityV2TroveData = async (
     interestBatchManager,
     debtInFront,
     lastInterestRateAdjTime,
-    liqRatio,
+    liqRatio: minCollRatio,
+    borrowLimitRatio,
     troveStatus: LIQUITY_V2_TROVE_STATUS_ENUM[parseInt(data.status.toString(), 10)],
     ...getLiquityV2AggregatedPositionData({
-      usedAssets, assetsData, minCollRatio: liqRatio, interestRate,
+      usedAssets, assetsData, minCollRatio: borrowLimitRatio, interestRate, liqRatio: minCollRatio,
     }),
     collRatio,
   };

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 {
+  MORPHO_BLUE_MERKL_OPPORTUNITY_TYPES,
+  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,120 @@
+import { aprToApy } from '../moneymarket';
+import { LONGER_TIMEOUT } from '../services/utils';
+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 const MORPHO_BLUE_MERKL_OPPORTUNITY_TYPES = ['MORPHOSUPPLY', 'MORPHOCOLLATERAL', 'MORPHOBORROW'] as const;
+
+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
+    && (MORPHO_BLUE_MERKL_OPPORTUNITY_TYPES as readonly string[]).includes(o.type)
+    // 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');
+
+  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. 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 = 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),
+    });
+    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 [];
+  }
+};
+
+/**
+ * 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/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/liquityV2.ts

@@ -94,6 +94,7 @@ export interface LiquityV2AggregatedTroveData {
   suppliedUsd: string,
   borrowedUsd: string,
   borrowLimitUsd: string,
+  liquidationLimitUsd: string,
   leftToBorrowUsd: string,
   netApy: string,
   incentiveUsd: string,
@@ -112,9 +113,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/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