@defisaver/positions-sdk 2.1.127-dev → 2.1.127-midnight-1-dev

package/src/morphoBlue/index.ts

@@ -8,7 +8,7 @@ import {
   DFSFeedRegistryContractViem, FeedRegistryContractViem, MorphoBlueViewContractViem,
 } from '../contracts';
 import {
-  MorphoBlueAssetsData, MorphoBlueEarnData, MorphoBlueMarketData, MorphoBlueMarketInfo, MorphoBlueMarketRewards, MorphoBluePositionData,
+  MorphoBlueAssetsData, MorphoBlueMarketData, MorphoBlueMarketInfo, MorphoBluePositionData,
 } from '../types';
 import { USD_QUOTE, WAD } from '../constants';
 import { calculateNetApy, getStakingApy, STAKING_ASSETS } from '../staking';
@@ -21,39 +21,7 @@ import { getViemProvider, setViemBlockNumber } from '../services/viem';
 
 const HARDCODED_USD_STABLE_PRICE = '100000000'; // $1 with 8 decimals
 
-const getMorphoRewardIncentives = (apy: string) => [{
-  token: 'MORPHO',
-  apy,
-  incentiveKind: IncentiveKind.Reward,
-  description: 'Eligible for protocol-level MORPHO incentives.',
-}];
-
-export const addMorphoBlueRewardsToMarketInfo = (
-  marketInfo: MorphoBlueMarketInfo,
-  rewards: MorphoBlueMarketRewards,
-): MorphoBlueMarketInfo => ({
-  ...marketInfo,
-  assetsData: {
-    ...marketInfo.assetsData,
-    [marketInfo.loanToken]: {
-      ...marketInfo.assetsData[marketInfo.loanToken],
-      supplyIncentives: [
-        ...marketInfo.assetsData[marketInfo.loanToken].supplyIncentives.filter(({ token }) => token !== 'MORPHO'),
-        ...getMorphoRewardIncentives(rewards.supplyApy),
-      ],
-      borrowIncentives: [
-        ...marketInfo.assetsData[marketInfo.loanToken].borrowIncentives.filter(({ token }) => token !== 'MORPHO'),
-        ...getMorphoRewardIncentives(rewards.borrowApy),
-      ],
-    },
-  },
-});
-
-async function getMorphoBlueMarketDataInternal(
-  provider: Client,
-  network: NetworkNumber,
-  selectedMarket: MorphoBlueMarketData,
-): Promise<MorphoBlueMarketInfo> {
+export async function _getMorphoBlueMarketData(provider: Client, network: NetworkNumber, selectedMarket: MorphoBlueMarketData): Promise<MorphoBlueMarketInfo> {
   const {
     loanToken, collateralToken, oracle, irm, lltv, oracleType,
   } = selectedMarket;
@@ -91,6 +59,16 @@ async function getMorphoBlueMarketDataInternal(
     loanTokenPrice = loanTokenPriceRound[1].toString();
   }
 
+  let morphoSupplyApy = '0';
+  let morphoBorrowApy = '0';
+  try {
+    const { supplyApy: _morphoSupplyApy, borrowApy: _morphoBorrowApy } = await getRewardsForMarket(selectedMarket.marketId, network);
+    morphoSupplyApy = _morphoSupplyApy;
+    morphoBorrowApy = _morphoBorrowApy;
+  } catch (e) {
+    console.error(e);
+  }
+
   const supplyRate = getSupplyRate(marketInfo.totalSupplyAssets.toString(), marketInfo.totalBorrowAssets.toString(), marketInfo.borrowRate.toString(), marketInfo.fee.toString());
   const compoundedBorrowRate = getBorrowRate(marketInfo.borrowRate.toString(), marketInfo.totalBorrowShares.toString());
   const utillization = new Dec(marketInfo.totalBorrowAssets.toString()).div(marketInfo.totalSupplyAssets.toString()).mul(100).toString();
@@ -112,8 +90,18 @@ async function getMorphoBlueMarketDataInternal(
     totalBorrow: new Dec(marketInfo.totalBorrowAssets.toString()).div(scale).toString(),
     canBeSupplied: true,
     canBeBorrowed: true,
-    supplyIncentives: [],
-    borrowIncentives: [],
+    supplyIncentives: [{
+      token: 'MORPHO',
+      apy: morphoSupplyApy,
+      incentiveKind: IncentiveKind.Reward,
+      description: 'Eligible for protocol-level MORPHO incentives.',
+    }],
+    borrowIncentives: [{
+      token: 'MORPHO',
+      apy: morphoBorrowApy,
+      incentiveKind: IncentiveKind.Reward,
+      description: 'Eligible for protocol-level MORPHO incentives.',
+    }],
   };
 
   assetsData[wethToEth(collateralTokenInfo.symbol)] = {
@@ -150,70 +138,10 @@ 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' });
-  }
-}
-
-export function _getMorphoBluePortfolioMarketData(provider: Client, network: NetworkNumber, selectedMarket: MorphoBlueMarketData): Promise<MorphoBlueMarketInfo> {
-  return getMorphoBlueMarketDataInternal(provider, network, selectedMarket);
-}
-
 export async function getMorphoBlueMarketData(provider: EthereumProvider, network: NetworkNumber, selectedMarket: MorphoBlueMarketData): Promise<MorphoBlueMarketInfo> {
   return _getMorphoBlueMarketData(getViemProvider(provider, network), network, selectedMarket);
 }
 
-export function getMorphoBluePortfolioMarketData(provider: EthereumProvider, network: NetworkNumber, selectedMarket: MorphoBlueMarketData): Promise<MorphoBlueMarketInfo> {
-  return _getMorphoBluePortfolioMarketData(getViemProvider(provider, network), network, selectedMarket);
-}
-
-export const getMorphoBluePositionDataWithMarketInfo = (
-  data: MorphoBluePositionData,
-  marketInfo: MorphoBlueMarketInfo,
-): MorphoBluePositionData => ({
-  ...data,
-  ...getMorphoBlueAggregatedPositionData({
-    usedAssets: data.usedAssets,
-    assetsData: marketInfo.assetsData,
-    marketInfo,
-  }),
-});
-
-export const getMorphoEarnDataWithMarketInfo = (data: MorphoBlueEarnData, marketInfo: MorphoBlueMarketInfo): MorphoBlueEarnData => {
-  const loanTokenInfo = marketInfo.assetsData[marketInfo.loanToken];
-  const usedAssets: MMUsedAssets = {
-    [marketInfo.loanToken]: {
-      symbol: loanTokenInfo.symbol,
-      supplied: data.amount,
-      borrowed: '0',
-      isSupplied: new Dec(data.amount).gt(0),
-      isBorrowed: false,
-      collateral: false,
-      suppliedUsd: data.amountUsd,
-      borrowedUsd: '0',
-    },
-  };
-
-  return {
-    ...data,
-    apy: calculateNetApy({ usedAssets, assetsData: marketInfo.assetsData as unknown as MMAssetsData }).netApy,
-  };
-};
-
-export function getMorphoBlueMarketRewards(
-  network: NetworkNumber,
-  selectedMarket: MorphoBlueMarketData,
-): Promise<MorphoBlueMarketRewards> {
-  return getRewardsForMarket(selectedMarket.marketId, network);
-}
-
 export const _getMorphoBlueAccountBalances = async (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, selectedMarket: MorphoBlueMarketData): Promise<PositionBalances> => {
   let balances: PositionBalances = {
     collateral: {},
@@ -310,7 +238,7 @@ export async function getMorphoBlueAccountData(provider: EthereumProvider, netwo
   return _getMorphoBlueAccountData(getViemProvider(provider, network), network, account, selectedMarket, marketInfo);
 }
 
-export async function getMorphoEarn(provider: Client, network: NetworkNumber, account: EthAddress, selectedMarket: MorphoBlueMarketData, marketInfo: MorphoBlueMarketInfo): Promise<MorphoBlueEarnData> {
+export async function getMorphoEarn(provider: Client, network: NetworkNumber, account: EthAddress, selectedMarket: MorphoBlueMarketData, marketInfo: MorphoBlueMarketInfo): Promise<{ apy: string, amount: string, amountUsd: string }> {
   const {
     loanToken, collateralToken, oracle, irm, lltv,
   } = selectedMarket;
@@ -326,9 +254,24 @@ export async function getMorphoEarn(provider: Client, network: NetworkNumber, ac
   const loanTokenInfo = marketInfo.assetsData[marketInfo.loanToken];
   const loanTokenSupplied = assetAmountInEth(loanInfo.suppliedInAssets.toString(), marketInfo.loanToken);
   const loanTokenSuppliedUsd = new Dec(loanTokenSupplied).mul(loanTokenInfo.price).toString();
-  return getMorphoEarnDataWithMarketInfo({
-    apy: '0',
+  const usedAssets: MMUsedAssets = {
+    [marketInfo.loanToken]: {
+      symbol: loanTokenInfo.symbol,
+      supplied: loanTokenSupplied,
+      borrowed: '0',
+      isSupplied: new Dec(loanInfo.suppliedInAssets.toString()).gt(0),
+      isBorrowed: false,
+      collateral: false,
+      suppliedUsd: loanTokenSuppliedUsd,
+      borrowedUsd: '0',
+    },
+  };
+
+  const { netApy } = calculateNetApy({ usedAssets, assetsData: marketInfo.assetsData as unknown as MMAssetsData });
+
+  return {
+    apy: netApy,
     amount: loanTokenSupplied,
     amountUsd: loanTokenSuppliedUsd,
-  }, marketInfo);
-}
+  };
+}

package/src/morphoMidnight/index.ts

@@ -0,0 +1,261 @@
+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, 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: true,
+    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 assetsDataForApy = marketInfo.assetsData;
+  if (new Dec(positionInfo.debt.toString()).gt(0)) {
+    try {
+      const borrowInfo = await getMorphoMidnightUserBorrowInfo(account, marketId, marketInfo.maturity, marketInfo.loanToken);
+      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 },
+      };
+    } catch (err) {
+      // Orderbook API unavailable — keep the on-chain-only fallback above.
+    }
+  }
+
+  return {
+    usedAssets,
+    credit,
+    debt,
+    borrowRate,
+    debtBase,
+    debtInterest,
+    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

@@ -9,9 +9,11 @@ import {
   LiquityV2Markets,
   LlamaLendMarkets,
   MorphoBlueMarkets,
+  MorphoMidnightMarkets,
   SparkMarkets,
 } from '../markets';
-import { _getMorphoBlueAccountData, _getMorphoBluePortfolioMarketData, getMorphoEarn } from '../morphoBlue';
+import { _getMorphoBlueAccountData, _getMorphoBlueMarketData, getMorphoEarn } from '../morphoBlue';
+import { _getMorphoMidnightAccountData, _getMorphoMidnightMarketData, getMorphoMidnightEarn } from '../morphoMidnight';
 import {
   AaveV2MarketData,
   AaveV3MarketData,
@@ -26,6 +28,7 @@ import {
   LiquityV2MarketData,
   LlamaLendGlobalMarketData,
   MorphoBlueMarketInfo,
+  MorphoMidnightMarketInfo,
   PortfolioPositionsData,
   SparkMarketsData,
 } from '../types';
@@ -62,6 +65,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 eulerV2Markets = Object.values(EulerV2Markets(network)).filter((market) => market.chainIds.includes(network));
@@ -79,6 +83,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 eulerV2MarketsData: Record<string, EulerV2FullMarketData> = {};
@@ -93,6 +98,7 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
 
   const markets = {
     morphoMarketsData,
+    morphoMidnightMarketsData,
     compoundV3MarketsData,
     sparkMarketsData,
     eulerV2MarketsData,
@@ -115,6 +121,7 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
       aaveV3: {},
       aaveV4: {},
       morphoBlue: {},
+      morphoMidnight: {},
       compoundV3: {},
       spark: {},
       eulerV2: {},
@@ -136,6 +143,7 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
     stakingPositions[address.toLowerCase() as EthAddress] = {
       aaveV3: {},
       morphoBlue: {},
+      morphoMidnight: {},
       compoundV3: {},
       spark: {},
       aaveV2: {},
@@ -162,9 +170,13 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
   await Promise.allSettled([
     // === MARKET DATA (needs to be fetched first) ===
     ...morphoMarkets.map(async (market) => {
-      const marketData = await _getMorphoBluePortfolioMarketData(client, network, market);
+      const marketData = await _getMorphoBlueMarketData(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;
@@ -456,6 +468,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/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 './euler';
 export * from './fluid';

package/src/types/morphoBlue.ts

@@ -235,17 +235,6 @@ export interface MorphoBluePositionData {
   exposure: string,
 }
 
-export interface MorphoBlueEarnData {
-  apy: string,
-  amount: string,
-  amountUsd: string,
-}
-
-export interface MorphoBlueMarketRewards {
-  supplyApy: string,
-  borrowApy: string,
-}
-
 export interface MorphoBlueVault {
   address: string,
 }