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

package/src/markets/morphoMidnight/index.ts

@@ -0,0 +1,161 @@
+import { MorphoMidnightMarketData, MorphoMidnightVersions, NetworkNumber } from '../../types';
+
+// Morpho Midnight core contract on Base (same for every market).
+const MIDNIGHT_BASE = '0xAdedD8ab6dE832766Fedf0FaC4992E5C4D3EA18A';
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+
+// Curated Morpho Midnight markets. Each market is fixed-term: it is uniquely identified on-chain by
+// `marketId` (bytes32), derived from the static struct below via MidnightView.toId. Because markets
+// churn as maturities roll, this list is hand-maintained for the pairs/maturities the app supports.
+// Sourced from the official listing at https://markets.morpho.org/fixed/base (see its sitemap.xml) —
+// currently a single USDC/cbBTC pair offered on a monthly maturity ladder; new maturities are added
+// there progressively. Every `marketId` here is verified against MidnightView.toId(marketStruct) in
+// tests/morphoMidnight.ts.
+
+// BASE — USDC/cbBTC, 86% LLTV, monthly maturity ladder
+
+export const MORPHO_MIDNIGHT_CBBTC_USDC_860_20260731 = (networkId = NetworkNumber.Base): MorphoMidnightMarketData => ({
+  chainIds: [NetworkNumber.Base],
+  label: 'Morpho Midnight cbBTC/USDC',
+  shortLabel: 'cbBTC/USDC',
+  url: 'cbbtc-usdc-20260731',
+  value: MorphoMidnightVersions.MorphoMidnightCbBTCUSDC_860_20260731_Base,
+  midnight: MIDNIGHT_BASE,
+  loanToken: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC
+  collaterals: [{
+    token: '0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf', // cbBTC
+    lltv: 0.86,
+    liquidationCursor: '300000000000000000',
+    oracle: '0x663BECd10daE6C4A3Dcd89F1d76c1174199639B9',
+  }],
+  maturity: 1785510000, // 2026-07-31T15:00:00Z
+  rcfThreshold: '3000000000',
+  enterGate: ZERO_ADDRESS,
+  liquidatorGate: ZERO_ADDRESS,
+  marketId: '0x168e31250e0008b50d2255a5ab85e0265acd6c12e4f9a1336134b36a65a47937',
+  protocolName: 'morpho-midnight',
+});
+
+export const MORPHO_MIDNIGHT_CBBTC_USDC_860_20260828 = (networkId = NetworkNumber.Base): MorphoMidnightMarketData => ({
+  chainIds: [NetworkNumber.Base],
+  label: 'Morpho Midnight cbBTC/USDC',
+  shortLabel: 'cbBTC/USDC',
+  url: 'cbbtc-usdc-20260828',
+  value: MorphoMidnightVersions.MorphoMidnightCbBTCUSDC_860_20260828_Base,
+  midnight: MIDNIGHT_BASE,
+  loanToken: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC
+  collaterals: [{
+    token: '0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf', // cbBTC
+    lltv: 0.86,
+    liquidationCursor: '300000000000000000',
+    oracle: '0x663BECd10daE6C4A3Dcd89F1d76c1174199639B9',
+  }],
+  maturity: 1787929200, // 2026-08-28T15:00:00Z
+  rcfThreshold: '3000000000',
+  enterGate: ZERO_ADDRESS,
+  liquidatorGate: ZERO_ADDRESS,
+  marketId: '0x05959752fdeff325962b9d263edb421efc6e2186a49360dba6c32e86ebf6c84c',
+  protocolName: 'morpho-midnight',
+});
+
+export const MORPHO_MIDNIGHT_CBBTC_USDC_860_20260925 = (networkId = NetworkNumber.Base): MorphoMidnightMarketData => ({
+  chainIds: [NetworkNumber.Base],
+  label: 'Morpho Midnight cbBTC/USDC',
+  shortLabel: 'cbBTC/USDC',
+  url: 'cbbtc-usdc-20260925',
+  value: MorphoMidnightVersions.MorphoMidnightCbBTCUSDC_860_20260925_Base,
+  midnight: MIDNIGHT_BASE,
+  loanToken: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC
+  collaterals: [{
+    token: '0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf', // cbBTC
+    lltv: 0.86,
+    liquidationCursor: '300000000000000000',
+    oracle: '0x663BECd10daE6C4A3Dcd89F1d76c1174199639B9',
+  }],
+  maturity: 1790348400, // 2026-09-25T15:00:00Z
+  rcfThreshold: '3000000000',
+  enterGate: ZERO_ADDRESS,
+  liquidatorGate: ZERO_ADDRESS,
+  marketId: '0x549cd072daf99328554f3a6d2d4d6f4a07f1c59369e891e6391946f9cf75f221',
+  protocolName: 'morpho-midnight',
+});
+
+export const MORPHO_MIDNIGHT_CBBTC_USDC_860_20261030 = (networkId = NetworkNumber.Base): MorphoMidnightMarketData => ({
+  chainIds: [NetworkNumber.Base],
+  label: 'Morpho Midnight cbBTC/USDC',
+  shortLabel: 'cbBTC/USDC',
+  url: 'cbbtc-usdc-20261030',
+  value: MorphoMidnightVersions.MorphoMidnightCbBTCUSDC_860_20261030_Base,
+  midnight: MIDNIGHT_BASE,
+  loanToken: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC
+  collaterals: [{
+    token: '0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf', // cbBTC
+    lltv: 0.86,
+    liquidationCursor: '300000000000000000',
+    oracle: '0x663BECd10daE6C4A3Dcd89F1d76c1174199639B9',
+  }],
+  maturity: 1793372400, // 2026-10-30T15:00:00Z
+  rcfThreshold: '3000000000',
+  enterGate: ZERO_ADDRESS,
+  liquidatorGate: ZERO_ADDRESS,
+  marketId: '0x43d6120738c57b2bc5835901f8250fdf7fc8054efbb006c6ccba61ec898e5ed9',
+  protocolName: 'morpho-midnight',
+});
+
+export const MORPHO_MIDNIGHT_CBBTC_USDC_860_20261127 = (networkId = NetworkNumber.Base): MorphoMidnightMarketData => ({
+  chainIds: [NetworkNumber.Base],
+  label: 'Morpho Midnight cbBTC/USDC',
+  shortLabel: 'cbBTC/USDC',
+  url: 'cbbtc-usdc-20261127',
+  value: MorphoMidnightVersions.MorphoMidnightCbBTCUSDC_860_20261127_Base,
+  midnight: MIDNIGHT_BASE,
+  loanToken: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC
+  collaterals: [{
+    token: '0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf', // cbBTC
+    lltv: 0.86,
+    liquidationCursor: '300000000000000000',
+    oracle: '0x663BECd10daE6C4A3Dcd89F1d76c1174199639B9',
+  }],
+  maturity: 1795791600, // 2026-11-27T15:00:00Z
+  rcfThreshold: '3000000000',
+  enterGate: ZERO_ADDRESS,
+  liquidatorGate: ZERO_ADDRESS,
+  marketId: '0xe1878eec035b601f301484e63a49a428f8e008e2bf57a2fd88a3fc3a4c1b1acd',
+  protocolName: 'morpho-midnight',
+});
+
+export const MORPHO_MIDNIGHT_CBBTC_USDC_860_20261225 = (networkId = NetworkNumber.Base): MorphoMidnightMarketData => ({
+  chainIds: [NetworkNumber.Base],
+  label: 'Morpho Midnight cbBTC/USDC',
+  shortLabel: 'cbBTC/USDC',
+  url: 'cbbtc-usdc-20261225',
+  value: MorphoMidnightVersions.MorphoMidnightCbBTCUSDC_860_20261225_Base,
+  midnight: MIDNIGHT_BASE,
+  loanToken: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC
+  collaterals: [{
+    token: '0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf', // cbBTC
+    lltv: 0.86,
+    liquidationCursor: '300000000000000000',
+    oracle: '0x663BECd10daE6C4A3Dcd89F1d76c1174199639B9',
+  }],
+  maturity: 1798210800, // 2026-12-25T15:00:00Z
+  rcfThreshold: '3000000000',
+  enterGate: ZERO_ADDRESS,
+  liquidatorGate: ZERO_ADDRESS,
+  marketId: '0x9593c3a6dba45b6106af8dc8b45ba8c505d90d3d68a3d33f7c278dd921b637da',
+  protocolName: 'morpho-midnight',
+});
+
+export const MorphoMidnightMarkets = (networkId: NetworkNumber) => ({
+  // BASE
+  [MorphoMidnightVersions.MorphoMidnightCbBTCUSDC_860_20260731_Base]: MORPHO_MIDNIGHT_CBBTC_USDC_860_20260731(networkId),
+  [MorphoMidnightVersions.MorphoMidnightCbBTCUSDC_860_20260828_Base]: MORPHO_MIDNIGHT_CBBTC_USDC_860_20260828(networkId),
+  [MorphoMidnightVersions.MorphoMidnightCbBTCUSDC_860_20260925_Base]: MORPHO_MIDNIGHT_CBBTC_USDC_860_20260925(networkId),
+  [MorphoMidnightVersions.MorphoMidnightCbBTCUSDC_860_20261030_Base]: MORPHO_MIDNIGHT_CBBTC_USDC_860_20261030(networkId),
+  [MorphoMidnightVersions.MorphoMidnightCbBTCUSDC_860_20261127_Base]: MORPHO_MIDNIGHT_CBBTC_USDC_860_20261127(networkId),
+  [MorphoMidnightVersions.MorphoMidnightCbBTCUSDC_860_20261225_Base]: MORPHO_MIDNIGHT_CBBTC_USDC_860_20261225(networkId),
+}) as const;
+
+export const findMorphoMidnightMarket = (marketId: string, network: NetworkNumber = NetworkNumber.Base): MorphoMidnightMarketData | undefined => Object.values(MorphoMidnightMarkets(network)).find(
+  (market) => market.marketId.toLowerCase() === marketId.toLowerCase(),
+);

package/src/morphoMidnight/index.ts

@@ -0,0 +1,234 @@
+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 } 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',
+    };
+  });
+
+  return {
+    usedAssets,
+    credit,
+    debt,
+    maturity: marketInfo.maturity,
+    isMatured: marketInfo.isMatured,
+    ...getMorphoMidnightAggregatedPositionData({ usedAssets, assetsData: marketInfo.assetsData, 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, _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: {},
@@ -165,6 +173,10 @@ export async function getPortfolioData(provider: EthereumProvider, network: Netw
       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/morphoMidnight.ts

@@ -0,0 +1,104 @@
+import {
+  EthAddress, IncentiveData, LeverageType, MMUsedAssets, NetworkNumber,
+} from './common';
+
+export enum MorphoMidnightVersions {
+  // BASE
+  // Fixed-term markets are disambiguated by maturity (YYYYMMDD), so the same pair recurs across dates.
+  // Sourced from the official listing at https://markets.morpho.org/fixed/base (see sitemap.xml).
+  MorphoMidnightCbBTCUSDC_860_20260731_Base = 'morphomidnightcbbtcusdc_860_20260731_base',
+  MorphoMidnightCbBTCUSDC_860_20260828_Base = 'morphomidnightcbbtcusdc_860_20260828_base',
+  MorphoMidnightCbBTCUSDC_860_20260925_Base = 'morphomidnightcbbtcusdc_860_20260925_base',
+  MorphoMidnightCbBTCUSDC_860_20261030_Base = 'morphomidnightcbbtcusdc_860_20261030_base',
+  MorphoMidnightCbBTCUSDC_860_20261127_Base = 'morphomidnightcbbtcusdc_860_20261127_base',
+  MorphoMidnightCbBTCUSDC_860_20261225_Base = 'morphomidnightcbbtcusdc_860_20261225_base',
+}
+
+export interface MorphoMidnightCollateralParams {
+  token: EthAddress,
+  lltv: number | string,
+  liquidationCursor: number | string,
+  oracle: EthAddress,
+}
+
+export interface MorphoMidnightMarketData {
+  chainIds: NetworkNumber[],
+  label: string,
+  shortLabel: string,
+  url: string,
+  value: MorphoMidnightVersions,
+  midnight: EthAddress,
+  loanToken: EthAddress,
+  collaterals: MorphoMidnightCollateralParams[],
+  maturity: number, // unix timestamp (seconds)
+  rcfThreshold: number | string,
+  enterGate: EthAddress,
+  liquidatorGate: EthAddress,
+  marketId: string, // bytes32, precomputed off-chain (verify with MidnightView.toId)
+  protocolName: string,
+}
+
+export interface MorphoMidnightAssetData {
+  symbol: string,
+  address: string,
+  price: string,
+  supplyRate: string,
+  borrowRate: string,
+  supplyIncentives: IncentiveData[],
+  borrowIncentives: IncentiveData[],
+  totalSupply?: string,
+  totalBorrow?: string,
+  canBeSupplied?: boolean,
+  canBeBorrowed?: boolean,
+  lltv?: string,
+}
+
+export type MorphoMidnightAssetsData = { [key: string]: MorphoMidnightAssetData };
+
+export interface MorphoMidnightMarketInfo {
+  id: string,
+  loanToken: string,
+  collaterals: string[], // collateral symbols, index-aligned with the market's collateral set
+  maturity: number, // unix timestamp (seconds)
+  isMatured: boolean, // true once now >= maturity; no new debt can be opened
+  totalUnits: string, // face-value units on the market (= totalDebt + withdrawable)
+  withdrawable: string, // loan-token liquidity available for withdraw
+  totalDebt: string,
+  lossFactor: string, // bad-debt socialization factor applied to lender credit
+  tickSpacing: number, // orderbook price granularity (relevant to phase-2 rate math)
+  utillization: string,
+  assetsData: MorphoMidnightAssetsData,
+}
+
+export interface MorphoMidnightAggregatedPositionData {
+  suppliedUsd: string,
+  suppliedCollateralUsd: string,
+  borrowedUsd: string,
+  borrowLimitUsd: string,
+  liquidationLimitUsd: string,
+  leftToBorrowUsd: string,
+  leftToBorrow: string,
+  netApy: string,
+  incentiveUsd: string,
+  totalInterestUsd: string,
+  ltv: string,
+  ratio: string, // health ratio as a percentage (from MidnightView.ratio, 1e18-scaled)
+  healthRatio: string, // liquidationLimitUsd / borrowedUsd
+  leveragedType: LeverageType,
+  leveragedAsset?: string,
+  currentVolatilePairRatio?: string,
+  liquidationPrice?: string,
+  minCollRatio?: string,
+  collLiquidationRatio?: string,
+  exposure: string,
+}
+
+// Fixed-rate/YTM (derived from entry price + orderbook) is intentionally absent in MVP:
+// MidnightView exposes no per-position rate, so a variable-MM-style APY would be misleading.
+export interface MorphoMidnightPositionData extends MorphoMidnightAggregatedPositionData {
+  usedAssets: MMUsedAssets,
+  credit: string, // lender credit units, face value at maturity (with interest); 0 for borrowers
+  debt: string, // borrower debt, face value at maturity (with interest); 0 for lenders
+  maturity: number,
+  isMatured: boolean,
+}

package/src/types/portfolio.ts

@@ -10,6 +10,7 @@ import { LiquityV2TroveData, LiquityV2Versions } from './liquityV2';
 import { LlamaLendUserData, LlamaLendVersionsType } from './llamaLend';
 import { CdpData } from './maker';
 import { MorphoBluePositionData, MorphoBlueVersions } from './morphoBlue';
+import { MorphoMidnightPositionData, MorphoMidnightVersions } from './morphoMidnight';
 import { SparkPositionData, SparkVersions } from './spark';
 
 export interface PortfolioProtocolData<T> {
@@ -24,6 +25,9 @@ export interface PortfolioPositionsDataForAddress {
   morphoBlue: {
     [key in MorphoBlueVersions]?: PortfolioProtocolData<MorphoBluePositionData>;
   };
+  morphoMidnight: {
+    [key in MorphoMidnightVersions]?: PortfolioProtocolData<MorphoMidnightPositionData>;
+  };
   compoundV3: {
     [key in CompoundVersions]?: PortfolioProtocolData<CompoundV3PositionData>;
   };