@defisaver/positions-sdk 2.1.144-dev → 2.1.145

package/src/morphoMidnight/index.ts

@@ -0,0 +1,276 @@
+import Dec from 'decimal.js';
+import { assetAmountInEth, getAssetInfoByAddress } from '@defisaver/tokens';
+import { Client } from 'viem';
+import {
+  Blockish, EthAddress, EthereumProvider, MMAssetsData, MMUsedAssets, NetworkNumber, PositionBalances,
+} from '../types/common';
+import {
+  DFSFeedRegistryContractViem, FeedRegistryContractViem, MorphoMidnightViewContractViem,
+} from '../contracts';
+import {
+  MorphoMidnightAssetsData, MorphoMidnightBorrowInfoStatus, MorphoMidnightMarketData, MorphoMidnightMarketInfo, MorphoMidnightPositionData,
+} from '../types';
+import { USD_QUOTE } from '../constants';
+import { calculateNetApy } from '../staking';
+import { isMainnetNetwork, wethToEth } from '../services/utils';
+import { getMorphoMidnightAggregatedPositionData, getMorphoMidnightUserBorrowInfo } from '../helpers/morphoMidnightHelpers';
+import { getChainlinkAssetAddress } from '../services/priceService';
+import { getViemProvider, setViemBlockNumber } from '../services/viem';
+
+const HARDCODED_USD_STABLE_PRICE = '100000000'; // $1 with 8 decimals
+const nowInSeconds = () => Math.floor(Date.now() / 1000);
+
+export async function _getMorphoMidnightMarketData(provider: Client, network: NetworkNumber, selectedMarket: MorphoMidnightMarketData): Promise<MorphoMidnightMarketInfo> {
+  const { loanToken, collaterals, marketId } = selectedMarket;
+  const loanTokenInfo = getAssetInfoByAddress(loanToken, network);
+  const loanSym = wethToEth(loanTokenInfo.symbol);
+  const loanTokenFeedAddress = getChainlinkAssetAddress(loanTokenInfo.symbol, network);
+
+  const viewContract = MorphoMidnightViewContractViem(provider, network);
+  const isHardcodedUsdStable = ['USDA', 'RLUSD'].includes(loanTokenInfo.symbol);
+
+  let marketInfo;
+  let loanTokenPrice;
+  if (isMainnetNetwork(network)) {
+    const feedRegistryContract = FeedRegistryContractViem(provider, NetworkNumber.Eth);
+    const [_loanTokenPrice, _marketInfo] = await Promise.all([
+      isHardcodedUsdStable ? Promise.resolve(HARDCODED_USD_STABLE_PRICE) : feedRegistryContract.read.latestAnswer([loanTokenFeedAddress, USD_QUOTE]),
+      viewContract.read.getMarketInfo([marketId as `0x${string}`]),
+    ]);
+    marketInfo = _marketInfo;
+    loanTokenPrice = _loanTokenPrice;
+  } else {
+    // Currently only Base is supported
+    const feedRegistryContract = DFSFeedRegistryContractViem(provider, network);
+    const [loanTokenPriceRound, _marketInfo] = await Promise.all([
+      isHardcodedUsdStable ? Promise.resolve([0, HARDCODED_USD_STABLE_PRICE]) : feedRegistryContract.read.latestRoundData([loanTokenFeedAddress, USD_QUOTE]),
+      viewContract.read.getMarketInfo([marketId as `0x${string}`]),
+    ]);
+    marketInfo = _marketInfo;
+    loanTokenPrice = loanTokenPriceRound[1].toString();
+  }
+
+  const loanTokenUsd = new Dec(loanTokenPrice).div(1e8).toString();
+
+  const totalUnits = marketInfo.totalUnits.toString();
+  const withdrawable = marketInfo.withdrawable.toString();
+  const totalDebt = Dec.max(new Dec(totalUnits).sub(withdrawable), 0).toString();
+
+  const assetsData: MorphoMidnightAssetsData = {};
+  assetsData[loanSym] = {
+    symbol: loanSym,
+    address: loanToken,
+    price: loanTokenUsd,
+    supplyRate: '0', // fixed rate is orderbook-derived, not exposed on-chain (MVP)
+    borrowRate: '0',
+    totalSupply: assetAmountInEth(totalUnits, loanSym),
+    totalBorrow: assetAmountInEth(totalDebt, loanSym),
+    canBeSupplied: false,
+    canBeBorrowed: true,
+    supplyIncentives: [],
+    borrowIncentives: [],
+  };
+
+  const collateralSymbols: string[] = [];
+  collaterals.forEach((coll, i) => {
+    const collInfo = getAssetInfoByAddress(coll.token, network);
+    const collSym = wethToEth(collInfo.symbol);
+    collateralSymbols.push(collSym);
+    // Oracle price is returned in loan-token terms, scaled by 10^(36 + loanDec - collDec)
+    const scale = new Dec(10).pow(new Dec(36).add(loanTokenInfo.decimals).sub(collInfo.decimals).toString()).toString();
+    const rawPrice = marketInfo.prices[i] ? marketInfo.prices[i].toString() : '0';
+    const oracleRate = new Dec(rawPrice).div(scale).toString();
+    assetsData[collSym] = {
+      symbol: collSym,
+      address: coll.token,
+      price: new Dec(loanTokenUsd).mul(oracleRate).toString(),
+      supplyRate: '0',
+      borrowRate: '0',
+      lltv: new Dec(coll.lltv).toString(),
+      canBeSupplied: true,
+      canBeBorrowed: false,
+      supplyIncentives: [],
+      borrowIncentives: [],
+    };
+  });
+
+  const utillization = new Dec(totalUnits).eq(0) ? '0' : new Dec(totalDebt).div(totalUnits).mul(100).toString();
+
+  return {
+    id: marketInfo.id,
+    loanToken: loanSym,
+    collaterals: collateralSymbols,
+    maturity: selectedMarket.maturity,
+    isMatured: nowInSeconds() >= selectedMarket.maturity,
+    totalUnits: assetAmountInEth(totalUnits, loanSym),
+    withdrawable: assetAmountInEth(withdrawable, loanSym),
+    totalDebt: assetAmountInEth(totalDebt, loanSym),
+    lossFactor: marketInfo.lossFactor.toString(),
+    tickSpacing: marketInfo.tickSpacing,
+    utillization,
+    assetsData,
+  };
+}
+
+export async function getMorphoMidnightMarketData(provider: EthereumProvider, network: NetworkNumber, selectedMarket: MorphoMidnightMarketData): Promise<MorphoMidnightMarketInfo> {
+  return _getMorphoMidnightMarketData(getViemProvider(provider, network), network, selectedMarket);
+}
+
+export async function _getMorphoMidnightAccountData(provider: Client, network: NetworkNumber, account: EthAddress, selectedMarket: MorphoMidnightMarketData, marketInfo: MorphoMidnightMarketInfo): Promise<MorphoMidnightPositionData> {
+  const { marketId, collaterals } = selectedMarket;
+  const viewContract = MorphoMidnightViewContractViem(provider, network);
+  const positionInfo = await viewContract.read.getPositionInfo([marketId as `0x${string}`, account]);
+
+  const usedAssets: MMUsedAssets = {};
+
+  const loanTokenData = marketInfo.assetsData[marketInfo.loanToken];
+  const credit = assetAmountInEth(positionInfo.credit.toString(), marketInfo.loanToken);
+  const debt = assetAmountInEth(positionInfo.debt.toString(), marketInfo.loanToken);
+  // A user holds either credit (lender) or debt (borrower) in a market, never both.
+  usedAssets[marketInfo.loanToken] = {
+    symbol: marketInfo.loanToken,
+    supplied: credit,
+    borrowed: debt,
+    isSupplied: new Dec(positionInfo.credit.toString()).gt(0),
+    isBorrowed: new Dec(positionInfo.debt.toString()).gt(0),
+    collateral: false,
+    suppliedUsd: new Dec(credit).mul(loanTokenData.price).toString(),
+    borrowedUsd: new Dec(debt).mul(loanTokenData.price).toString(),
+  };
+
+  // positionInfo.collateral is index-aligned with the market's collateral set (0 where unused).
+  collaterals.forEach((coll, i) => {
+    const collInfo = getAssetInfoByAddress(coll.token, network);
+    const collSym = wethToEth(collInfo.symbol);
+    const rawAmount = positionInfo.collateral[i] ? positionInfo.collateral[i].toString() : '0';
+    const supplied = assetAmountInEth(rawAmount, collSym);
+    const collData = marketInfo.assetsData[collSym];
+    usedAssets[collSym] = {
+      symbol: collSym,
+      supplied,
+      borrowed: '0',
+      isSupplied: new Dec(rawAmount).gt(0),
+      isBorrowed: false,
+      collateral: true,
+      suppliedUsd: new Dec(supplied).mul(collData?.price || 0).toString(),
+      borrowedUsd: '0',
+    };
+  });
+
+  // Enrich borrower positions with the orderbook-derived rate + principal/interest split (off-chain).
+  // MidnightView only stores `debt` (= face value at maturity), so we default to full-debt-as-principal and
+  // override from the transactions API when available. Never throw here — the position must still render.
+  let borrowRate = '0';
+  let debtBase = debt; // fallback: treat the full on-chain debt as principal until fill history is known
+  let debtInterest = '0';
+  let borrowInfoStatus = MorphoMidnightBorrowInfoStatus.Available;
+  let assetsDataForApy = marketInfo.assetsData;
+  if (new Dec(positionInfo.debt.toString()).gt(0)) {
+    try {
+      // Curator-agnostic: `/users/:account/positions` is indexed off the Midnight singleton, so it carries
+      // Tenor-curated markets too. Only the *book* differs by curator, and that is quoted elsewhere.
+      const borrowInfo = await getMorphoMidnightUserBorrowInfo(account, marketId, marketInfo.loanToken);
+      if (new Dec(borrowInfo.debtTotal).gt(0)) {
+        borrowRate = borrowInfo.borrowRate;
+        debtBase = borrowInfo.debtBase;
+        debtInterest = borrowInfo.debtInterest;
+        usedAssets[marketInfo.loanToken].borrowRate = borrowRate;
+        // Reflect the real borrow cost in netApy without mutating the shared marketInfo.assetsData.
+        assetsDataForApy = {
+          ...marketInfo.assetsData,
+          [marketInfo.loanToken]: { ...loanTokenData, borrowRate },
+        };
+        const describesChainDebt = new Dec(borrowInfo.debtTotal).eq(debt);
+        const ratePriced = new Dec(borrowRate).gt(0) || new Dec(debtInterest).lte(0);
+        borrowInfoStatus = describesChainDebt && ratePriced
+          ? MorphoMidnightBorrowInfoStatus.Available
+          : MorphoMidnightBorrowInfoStatus.Pending;
+      } else {
+        // No entry for the position: the API does not know it yet, rather than it having no principal.
+        borrowInfoStatus = MorphoMidnightBorrowInfoStatus.Pending;
+      }
+    } catch (err) {
+      // Positions API unreachable — the fallback above still renders, and the next call may succeed.
+      borrowInfoStatus = MorphoMidnightBorrowInfoStatus.Pending;
+    }
+  }
+
+  return {
+    usedAssets,
+    credit,
+    debt,
+    borrowRate,
+    debtBase,
+    debtInterest,
+    borrowInfoStatus,
+    maturity: marketInfo.maturity,
+    isMatured: marketInfo.isMatured,
+    ...getMorphoMidnightAggregatedPositionData({ usedAssets, assetsData: assetsDataForApy, marketInfo }),
+  };
+}
+
+export async function getMorphoMidnightAccountData(provider: EthereumProvider, network: NetworkNumber, account: EthAddress, selectedMarket: MorphoMidnightMarketData, marketInfo: MorphoMidnightMarketInfo): Promise<MorphoMidnightPositionData> {
+  return _getMorphoMidnightAccountData(getViemProvider(provider, network), network, account, selectedMarket, marketInfo);
+}
+
+export const _getMorphoMidnightAccountBalances = async (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, selectedMarket: MorphoMidnightMarketData): Promise<PositionBalances> => {
+  const balances: PositionBalances = { collateral: {}, debt: {} };
+  if (!address) return balances;
+
+  const { marketId, loanToken, collaterals } = selectedMarket;
+  const viewContract = MorphoMidnightViewContractViem(provider, network, block);
+  const positionInfo = await viewContract.read.getPositionInfo([marketId as `0x${string}`, address], setViemBlockNumber(block));
+
+  const loanTokenInfo = getAssetInfoByAddress(loanToken, network);
+  balances.debt = {
+    [addressMapping ? loanTokenInfo.address.toLowerCase() : wethToEth(loanTokenInfo.symbol)]: assetAmountInEth(positionInfo.debt.toString(), wethToEth(loanTokenInfo.symbol)),
+  };
+
+  const collateral: Record<string, string> = {};
+  collaterals.forEach((coll, i) => {
+    const collInfo = getAssetInfoByAddress(coll.token, network);
+    const rawAmount = positionInfo.collateral[i] ? positionInfo.collateral[i].toString() : '0';
+    collateral[addressMapping ? collInfo.address.toLowerCase() : wethToEth(collInfo.symbol)] = assetAmountInEth(rawAmount, wethToEth(collInfo.symbol));
+  });
+  balances.collateral = collateral;
+
+  return balances;
+};
+
+export const getMorphoMidnightAccountBalances = async (
+  provider: EthereumProvider,
+  network: NetworkNumber,
+  block: Blockish,
+  addressMapping: boolean,
+  address: EthAddress,
+  selectedMarket: MorphoMidnightMarketData,
+): Promise<PositionBalances> => _getMorphoMidnightAccountBalances(getViemProvider(provider, network), network, block, addressMapping, address, selectedMarket);
+
+// Lender-side (credit-only) supply position, mirroring getMorphoEarn. `amount` is the credit face value
+// redeemable at maturity; `apy` is '0' in MVP because the fixed yield is orderbook-derived, not on-chain.
+export async function getMorphoMidnightEarn(provider: Client, network: NetworkNumber, account: EthAddress, selectedMarket: MorphoMidnightMarketData, marketInfo: MorphoMidnightMarketInfo): Promise<{ apy: string, amount: string, amountUsd: string }> {
+  const { marketId } = selectedMarket;
+  const viewContract = MorphoMidnightViewContractViem(provider, network);
+  const positionInfo = await viewContract.read.getPositionInfo([marketId as `0x${string}`, account]);
+
+  const loanTokenData = marketInfo.assetsData[marketInfo.loanToken];
+  const credit = assetAmountInEth(positionInfo.credit.toString(), marketInfo.loanToken);
+  const creditUsd = new Dec(credit).mul(loanTokenData.price).toString();
+
+  const usedAssets: MMUsedAssets = {
+    [marketInfo.loanToken]: {
+      symbol: marketInfo.loanToken,
+      supplied: credit,
+      borrowed: '0',
+      isSupplied: new Dec(positionInfo.credit.toString()).gt(0),
+      isBorrowed: false,
+      collateral: false,
+      suppliedUsd: creditUsd,
+      borrowedUsd: '0',
+    },
+  };
+
+  const { netApy } = calculateNetApy({ usedAssets, assetsData: marketInfo.assetsData as unknown as MMAssetsData });
+
+  return { apy: netApy, amount: credit, amountUsd: creditUsd };
+}

package/src/portfolio/discovery.ts

@@ -10,6 +10,7 @@ import {
   CrvUsdMarkets,
   LlamaLendMarkets,
   MorphoBlueMarkets,
+  MorphoMidnightMarkets,
   SparkMarkets,
 } from '../markets';
 import { AaveVersions, CompoundVersions } from '../types';
@@ -19,6 +20,7 @@ import { _getCompoundV3AccountBalances } from '../compoundV3';
 import { _getCrvUsdAccountBalances } from '../curveUsd';
 import { _getLlamaLendAccountBalances } from '../llamaLend';
 import { _getMorphoBlueAccountBalances } from '../morphoBlue';
+import { _getMorphoMidnightAccountBalances } from '../morphoMidnight';
 import { createViemContractFromConfigFunc } from '../contracts';
 
 const hasAnyBalance = (balances: PositionBalances): boolean => (
@@ -109,6 +111,10 @@ export async function getUserPositionsExistence(
     tasks.push(balanceTask(market.value, () => _getMorphoBlueAccountBalances(client, network, block, false, address, market)));
   });
 
+  Object.values(MorphoMidnightMarkets(network)).filter((market) => market.chainIds.includes(network)).forEach((market) => {
+    tasks.push(balanceTask(market.value, () => _getMorphoMidnightAccountBalances(client, network, block, false, address, market)));
+  });
+
   await Promise.all(tasks);
   return existence;
 }

package/src/portfolio/index.ts

@@ -8,9 +8,11 @@ import {
   LiquityV2Markets,
   LlamaLendMarkets,
   MorphoBlueMarkets,
+  MorphoMidnightMarkets,
   SparkMarkets,
 } from '../markets';
 import { _getMorphoBlueAccountData, _getMorphoBluePortfolioMarketData, getMorphoEarn } from '../morphoBlue';
+import { _getMorphoMidnightAccountData, _getMorphoMidnightMarketData, getMorphoMidnightEarn } from '../morphoMidnight';
 import {
   AaveV2MarketData,
   AaveV3MarketData,
@@ -24,6 +26,7 @@ import {
   LiquityV2MarketData,
   LlamaLendGlobalMarketData,
   MorphoBlueMarketInfo,
+  MorphoMidnightMarketInfo,
   PortfolioPositionsData,
   SparkMarketsData,
 } from '../types';
@@ -59,6 +62,7 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
   const isFluidSupported = [NetworkNumber.Eth, NetworkNumber.Arb, NetworkNumber.Base, NetworkNumber.Plasma].includes(network);
 
   const morphoMarkets = Object.values(MorphoBlueMarkets(network)).filter((market) => market.chainIds.includes(network));
+  const morphoMidnightMarkets = Object.values(MorphoMidnightMarkets(network)).filter((market) => market.chainIds.includes(network));
   const compoundV3Markets = Object.values(CompoundMarkets(network)).filter((market) => market.chainIds.includes(network) && market.value !== CompoundVersions.CompoundV2);
   const sparkMarkets = Object.values(SparkMarkets(network)).filter((market) => market.chainIds.includes(network));
   const aaveV3Markets = [AaveVersions.AaveV3, AaveVersions.AaveV3Lido, AaveVersions.AaveV3Etherfi].map((version) => AaveMarkets(network)[version]).filter((market) => market.chainIds.includes(network));
@@ -76,6 +80,7 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
   const defaultClient = getViemProvider(defaultProvider, ...args);
 
   const morphoMarketsData: Record<string, MorphoBlueMarketInfo> = {};
+  const morphoMidnightMarketsData: Record<string, MorphoMidnightMarketInfo> = {};
   const compoundV3MarketsData: Record<string, CompoundV3MarketsData> = {};
   const sparkMarketsData: Record<string, SparkMarketsData> = {};
   const aaveV3MarketsData: Record<string, AaveV3MarketData> = {};
@@ -89,6 +94,7 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
 
   const markets = {
     morphoMarketsData,
+    morphoMidnightMarketsData,
     compoundV3MarketsData,
     sparkMarketsData,
     aaveV3MarketsData,
@@ -110,6 +116,7 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
       aaveV3: {},
       aaveV4: {},
       morphoBlue: {},
+      morphoMidnight: {},
       compoundV3: {},
       spark: {},
       maker: {},
@@ -130,6 +137,7 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
     stakingPositions[address.toLowerCase() as EthAddress] = {
       aaveV3: {},
       morphoBlue: {},
+      morphoMidnight: {},
       compoundV3: {},
       spark: {},
       aaveV2: {},
@@ -159,6 +167,10 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
       const marketData = await _getMorphoBluePortfolioMarketData(client, network, market);
       morphoMarketsData[market.value] = marketData;
     }),
+    ...morphoMidnightMarkets.map(async (market) => {
+      const marketData = await _getMorphoMidnightMarketData(client, network, market);
+      morphoMidnightMarketsData[market.value] = marketData;
+    }),
     ...compoundV3Markets.map(async (market) => {
       const marketData = await _getCompoundV3MarketsData(client, network, market, defaultClient);
       compoundV3MarketsData[market.value] = marketData;
@@ -473,6 +485,38 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
         positions[address.toLowerCase() as EthAddress].morphoBlue[market.value] = { error: `Error fetching MorphoBlue account data for address ${address} on market ${market.value}`, data: null };
       }
     })).flat(),
+    ...morphoMidnightMarkets.map((market) => addresses.map(async (address) => {
+      try {
+        const [accDataPromise, earnDataPromise] = await Promise.allSettled([
+          _getMorphoMidnightAccountData(client, network, address, market, morphoMidnightMarketsData[market.value]),
+          getMorphoMidnightEarn(client, network, address, market, morphoMidnightMarketsData[market.value]),
+        ]);
+        if (accDataPromise.status === 'rejected') {
+          console.error(`Error fetching MorphoMidnight account data for address ${address} on market ${market.value}:`, accDataPromise.reason);
+          positions[address.toLowerCase() as EthAddress].morphoMidnight[market.value] = { error: `Error fetching MorphoMidnight account data for address ${address} on market ${market.value}`, data: null };
+        }
+        if (earnDataPromise.status === 'rejected') {
+          console.error(`Error fetching MorphoMidnight account data for address ${address} on market ${market.value}:`, earnDataPromise.reason);
+          positions[address.toLowerCase() as EthAddress].morphoMidnight[market.value] = { error: `Error fetching MorphoMidnight account data for address ${address} on market ${market.value}`, data: null };
+        }
+        if (accDataPromise.status !== 'rejected') {
+          const accData = accDataPromise.value;
+          if (new Dec(accData.suppliedUsd).gt(0)) positions[address.toLowerCase() as EthAddress].morphoMidnight[market.value] = { error: '', data: accData };
+        }
+        if (earnDataPromise.status !== 'rejected') {
+          const earnData = earnDataPromise.value;
+          if (earnData && new Dec(earnData.amount).gt(0)) {
+            stakingPositions[address.toLowerCase() as EthAddress].morphoMidnight[market.value] = {
+              error: '',
+              data: earnData,
+            };
+          }
+        }
+      } catch (error) {
+        console.error(`Error fetching MorphoMidnight account data for address ${address} on market ${market.value}:`, error);
+        positions[address.toLowerCase() as EthAddress].morphoMidnight[market.value] = { error: `Error fetching MorphoMidnight account data for address ${address} on market ${market.value}`, data: null };
+      }
+    })).flat(),
     ...compoundV3Markets.map((market) => addresses.map(async (address) => {
       try {
         const accData = await _getCompoundV3AccountData(client, network, address, ZERO_ADDRESS, { selectedMarket: market, assetsData: compoundV3MarketsData[market.value].assetsData });

package/src/staking/eligibility.ts

@@ -1,5 +1,5 @@
 import Dec from 'decimal.js';
-import { IncentiveEligibilityId, MMUsedAssets } from '../types/common';
+import { IncentiveData, IncentiveEligibilityId, MMUsedAssets } from '../types/common';
 
 type EthenaPairEligibilityConfig = {
   baseSymbol: string;
@@ -113,4 +113,31 @@ export const EligibilityMapping: { [key in IncentiveEligibilityId]: (usedAssets:
   [IncentiveEligibilityId.AaveV3EthenaLiquidLeveragePlasma]: isEligibleForEthenaUSDeRewards,
   [IncentiveEligibilityId.AaveV3EthenaLiquidLeveragePlasmaGHO]: isEligibleForEthenaGHORewards,
   [IncentiveEligibilityId.CompoundV3PufEthWethBorrow]: isEligibleForCompoundV3PufEthWethBorrow,
-};
+};
+
+export type IncentiveEligibilityResult = {
+  isEligible: boolean;
+  eligibleUSDAmount: string;
+};
+
+/**
+ * Resolves an incentive's position-specific eligibility and rewarded USD principal. Incentives
+ * without a curated eligibility rule apply to the full side amount supplied by the caller.
+ */
+export const getIncentiveEligibility = ({
+  incentive,
+  usedAssets,
+  defaultEligibleUSDAmount,
+  optionalData,
+}: {
+  incentive: Pick<IncentiveData, 'eligibilityId'>;
+  usedAssets: MMUsedAssets;
+  defaultEligibleUSDAmount: string;
+  optionalData?: any;
+}): IncentiveEligibilityResult => {
+  const eligibilityCheck = incentive.eligibilityId ? EligibilityMapping[incentive.eligibilityId] : null;
+
+  return eligibilityCheck
+    ? eligibilityCheck(usedAssets, optionalData)
+    : { isEligible: true, eligibleUSDAmount: defaultEligibleUSDAmount };
+};

package/src/staking/staking.ts

@@ -7,7 +7,7 @@ import {
 } from '../types/common';
 import { BLOCKS_IN_A_YEAR } from '../constants';
 import { DEFAULT_TIMEOUT } from '../services/utils';
-import { EligibilityMapping } from './eligibility';
+import { getIncentiveEligibility } from './eligibility';
 
 const getSsrApy = async () => {
   try {
@@ -153,16 +153,15 @@ export const calculateNetApy = ({
 
       if (assetData.supplyIncentives) {
         for (const supplyIncentive of assetData.supplyIncentives) {
-          const { apy, eligibilityId } = supplyIncentive;
-          const eligibilityCheck = eligibilityId ? EligibilityMapping[eligibilityId] : null;
-          if (eligibilityCheck) {
-            const { isEligible, eligibleUSDAmount } = eligibilityCheck(usedAssets, optionalData);
-            const incentiveInterest = isEligible ? calculateInterestEarned(eligibleUSDAmount, apy, 'year', true) : '0';
-            acc.incentiveUsd = new Dec(acc.incentiveUsd).add(incentiveInterest).toString();
-          } else {
-            const incentiveInterest = calculateInterestEarned(amount, apy, 'year', true);
-            acc.incentiveUsd = new Dec(acc.incentiveUsd).add(incentiveInterest).toString();
-          }
+          const { apy } = supplyIncentive;
+          const { isEligible, eligibleUSDAmount } = getIncentiveEligibility({
+            incentive: supplyIncentive,
+            usedAssets,
+            defaultEligibleUSDAmount: amount,
+            optionalData,
+          });
+          const incentiveInterest = isEligible ? calculateInterestEarned(eligibleUSDAmount, apy, 'year', true) : '0';
+          acc.incentiveUsd = new Dec(acc.incentiveUsd).add(incentiveInterest).toString();
         }
       }
     }
@@ -176,16 +175,15 @@ export const calculateNetApy = ({
 
       if (assetData.borrowIncentives) {
         for (const borrowIncentive of assetData.borrowIncentives) {
-          const { apy, eligibilityId } = borrowIncentive;
-          const eligibilityCheck = eligibilityId ? EligibilityMapping[eligibilityId] : null;
-          if (eligibilityCheck) {
-            const { isEligible, eligibleUSDAmount } = eligibilityCheck(usedAssets, optionalData);
-            const incentiveInterest = isEligible ? calculateInterestEarned(eligibleUSDAmount, apy, 'year', true) : '0';
-            acc.incentiveUsd = new Dec(acc.incentiveUsd).add(incentiveInterest).toString();
-          } else {
-            const incentiveInterest = calculateInterestEarned(amount, apy, 'year', true);
-            acc.incentiveUsd = new Dec(acc.incentiveUsd).add(incentiveInterest).toString();
-          }
+          const { apy } = borrowIncentive;
+          const { isEligible, eligibleUSDAmount } = getIncentiveEligibility({
+            incentive: borrowIncentive,
+            usedAssets,
+            defaultEligibleUSDAmount: amount,
+            optionalData,
+          });
+          const incentiveInterest = isEligible ? calculateInterestEarned(eligibleUSDAmount, apy, 'year', true) : '0';
+          acc.incentiveUsd = new Dec(acc.incentiveUsd).add(incentiveInterest).toString();
         }
       }
     }
@@ -204,4 +202,4 @@ export const calculateNetApy = ({
   const netApy = new Dec(totalInterestUsd).div(balance).times(100).toString();
 
   return { netApy, totalInterestUsd, incentiveUsd };
-};
+};

package/src/types/index.ts

@@ -6,6 +6,7 @@ export * from './liquity';
 export * from './liquityV2';
 export * from './maker';
 export * from './morphoBlue';
+export * from './morphoMidnight';
 export * from './llamaLend';
 export * from './fluid';
 export * from './portfolio';