@defisaver/positions-sdk 2.1.127-midnight-5-dev → 2.1.127-midnight-7-dev

package/esm/types/morphoMidnight.js

@@ -9,4 +9,20 @@ export var MorphoMidnightVersions;
     MorphoMidnightVersions["MorphoMidnightCbBTCUSDC_860_20261030_Base"] = "morphomidnightcbbtcusdc_860_20261030_base";
     MorphoMidnightVersions["MorphoMidnightCbBTCUSDC_860_20261127_Base"] = "morphomidnightcbbtcusdc_860_20261127_base";
     MorphoMidnightVersions["MorphoMidnightCbBTCUSDC_860_20261225_Base"] = "morphomidnightcbbtcusdc_860_20261225_base";
+    // Tenor-hosted Midnight markets (same core, different order book)
+    MorphoMidnightVersions["MorphoMidnightTenorCbBTCUSDC_20260827_Base"] = "morphomidnighttenorcbbtcusdc_20260827_base";
+    MorphoMidnightVersions["MorphoMidnightTenorCbBTCUSDC_20260924_Base"] = "morphomidnighttenorcbbtcusdc_20260924_base";
+    MorphoMidnightVersions["MorphoMidnightTenorCbBTCUSDC_20261022_Base"] = "morphomidnighttenorcbbtcusdc_20261022_base";
+    MorphoMidnightVersions["MorphoMidnightTenorCbBTCUSDC_20261119_Base"] = "morphomidnighttenorcbbtcusdc_20261119_base";
+    MorphoMidnightVersions["MorphoMidnightTenorCbBTCUSDC_20261217_Base"] = "morphomidnighttenorcbbtcusdc_20261217_base";
+    MorphoMidnightVersions["MorphoMidnightTenorWETHUSDC_20260827_Base"] = "morphomidnighttenorwethusdc_20260827_base";
+    MorphoMidnightVersions["MorphoMidnightTenorWETHUSDC_20260924_Base"] = "morphomidnighttenorwethusdc_20260924_base";
+    MorphoMidnightVersions["MorphoMidnightTenorWETHUSDC_20261022_Base"] = "morphomidnighttenorwethusdc_20261022_base";
+    MorphoMidnightVersions["MorphoMidnightTenorWETHUSDC_20261119_Base"] = "morphomidnighttenorwethusdc_20261119_base";
+    MorphoMidnightVersions["MorphoMidnightTenorWETHUSDC_20261217_Base"] = "morphomidnighttenorwethusdc_20261217_base";
+    MorphoMidnightVersions["MorphoMidnightTenorCbETHWETH_20260827_Base"] = "morphomidnighttenorcbethweth_20260827_base";
+    MorphoMidnightVersions["MorphoMidnightTenorCbETHWETH_20260924_Base"] = "morphomidnighttenorcbethweth_20260924_base";
+    MorphoMidnightVersions["MorphoMidnightTenorCbETHWETH_20261022_Base"] = "morphomidnighttenorcbethweth_20261022_base";
+    MorphoMidnightVersions["MorphoMidnightTenorCbETHWETH_20261119_Base"] = "morphomidnighttenorcbethweth_20261119_base";
+    MorphoMidnightVersions["MorphoMidnightTenorCbETHWETH_20261217_Base"] = "morphomidnighttenorcbethweth_20261217_base";
 })(MorphoMidnightVersions || (MorphoMidnightVersions = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defisaver/positions-sdk",
-  "version": "2.1.127-midnight-5-dev",
+  "version": "2.1.127-midnight-7-dev",
   "description": "",
   "main": "./cjs/index.js",
   "module": "./esm/index.js",

package/src/constants/index.ts

@@ -6,6 +6,7 @@ export const SECONDS_PER_WEEK = 7 * SECONDS_PER_DAY;
 export const AVG_BLOCK_TIME = 12;
 export const BLOCKS_IN_A_YEAR = SECONDS_PER_YEAR / AVG_BLOCK_TIME;
 export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+export const ZERO_BYTES32 = '0x0000000000000000000000000000000000000000000000000000000000000000';
 export const WAD = 1e18;
 export const USD_QUOTE = '0x0000000000000000000000000000000000000348';
 export const borrowOperations = ['borrow', 'payback'];

package/src/helpers/morphoMidnightHelpers/index.ts

@@ -16,8 +16,29 @@ import {
   MorphoMidnightMarketInfo,
   MorphoMidnightParsedBook,
 } from '../../types';
-import { SECONDS_PER_DAY, WAD } from '../../constants';
+import { WAD } from '../../constants';
 import { LONGER_TIMEOUT } from '../../services/utils';
+import { isTenorMidnightMarket } from '../../markets/morphoMidnight';
+import {
+  buildMidnightParsedBook, midnightApyFromPrice, midnightPriceFromApy, midnightTimeToMaturityDays,
+} from './rate';
+import {
+  getTenorBorrowQuote, getTenorMarketBook, getTenorPaybackQuote, getTenorPaybackUnitsQuote,
+} from './tenor';
+
+export {
+  buildMidnightParsedBook,
+  midnightApyFromPrice,
+  midnightBookBestFirst,
+  midnightPriceFromApy,
+  midnightTimeToMaturityDays,
+} from './rate';
+export {
+  tenorBookKeyFor,
+  tenorBookRateToApyPercent,
+  tenorOfferFillToApiFill,
+  tenorOfferToApiOffer,
+} from './tenor';
 
 /**
  * Aggregate a Morpho Midnight position. Midnight markets are multi-collateral, so the borrow limit is
@@ -104,7 +125,6 @@ export const getMorphoMidnightAggregatedPositionData = ({
 // loan-per-unit ratios (< 1 for a discounted fixed-term borrow); annualizing them yields the borrow APY.
 
 const MIDNIGHT_API_BASE = 'https://api.morpho.org/v0/midnight';
-const nowInSeconds = () => Math.floor(Date.now() / 1000);
 
 // The book endpoint is markedly slower than the rest of the API — `LONGER_TIMEOUT` (5s) aborts it often
 // enough that markets drop out of the list for no reason.
@@ -187,35 +207,6 @@ export interface MorphoMidnightPaybackUnitsQuote {
   takeableOffers: any[], // opaque orderbook offers, forwarded verbatim to on-chain execution
 }
 
-// Days remaining until maturity, optionally measured at a past timestamp (for historical fills).
-export const midnightTimeToMaturityDays = (maturity: number, atSeconds: number = nowInSeconds()): number => new Dec(maturity).sub(atSeconds).div(SECONDS_PER_DAY).toNumber();
-
-// Annualize a fixed-term discount price into an APY percent: (1 / price)^(365 / ttmDays) − 1.
-// `price` is loan-per-unit (assets received / units owed), so 1/price ≥ 1.
-export const midnightApyFromPrice = (price: Dec.Value, ttmDays: Dec.Value): string => {
-  const p = new Dec(price);
-  const ttm = new Dec(ttmDays);
-  if (p.lte(0) || ttm.lte(0)) return '0';
-  return new Dec(1).div(p).pow(new Dec(365).div(ttm)).sub(1)
-    .mul(100)
-    .toString();
-};
-
-/**
- * Inverse of `midnightApyFromPrice`: the loan-per-unit price a borrow APY implies,
- * price = (1 + rate)^(−ttmDays / 365).
- *
- * This is what turns an absolute rate ceiling into an on-chain `maxUnits` cap (units = assets / price),
- * and equally the principal a unit of borrow power is worth — Midnight debt is recorded at its maturity
- * face value, so borrowing the full limit as principal would overshoot it by the interest.
- */
-export const midnightPriceFromApy = (ratePercent: Dec.Value, ttmDays: Dec.Value): string => {
-  const rate = new Dec(ratePercent);
-  const ttm = new Dec(ttmDays);
-  if (rate.lte(0) || ttm.lte(0)) return '1';
-  return new Dec(1).div(new Dec(1).add(rate.div(100)).pow(ttm.div(365))).toString();
-};
-
 /**
  * Coerce a slippage into what the quote endpoint accepts: 0.1–100 with at most one decimal place. The
  * validation is lexical, so a computed value (`4.15066671050631467`) is rejected outright — without this
@@ -275,28 +266,23 @@ export const getMorphoMidnightMarketBook = async (
   network: NetworkNumber,
   side: MorphoMidnightBookSide = 'bids',
 ): Promise<MorphoMidnightParsedBook | null> => {
+  if (isTenorMidnightMarket(market)) {
+    return getTenorMarketBook(market, network, side);
+  }
+
   const loanSymbol = getAssetInfoByAddress(market.loanToken, network).symbol;
   const res = await fetch(`${MIDNIGHT_API_BASE}/books/${market.marketId}`, { signal: AbortSignal.timeout(MIDNIGHT_BOOK_TIMEOUT) });
   if (!res.ok) throw new Error(`Midnight book request failed for ${market.value} (${res.status})`);
 
   const json: { data?: Partial<Record<MorphoMidnightBookSide, MidnightRawOffer[]>> } = await res.json();
   const ttmDays = midnightTimeToMaturityDays(market.maturity);
-  const bestFirst = side === 'asks' ? -1 : 1;
 
-  const offers: MorphoMidnightBookOffer[] = (json?.data?.[side] || [])
-    .map((offer) => ({
-      rate: midnightApyFromPrice(new Dec(offer.price).div(WAD), ttmDays),
-      liquidity: assetAmountInEth(offer.assets, loanSymbol),
-    }))
-    .sort((a, b) => new Dec(a.rate).minus(b.rate).mul(bestFirst).toNumber());
+  const offers: MorphoMidnightBookOffer[] = (json?.data?.[side] || []).map((offer) => ({
+    rate: midnightApyFromPrice(new Dec(offer.price).div(WAD), ttmDays),
+    liquidity: assetAmountInEth(offer.assets, loanSymbol),
+  }));
 
-  if (offers.length === 0) return null;
-
-  return {
-    bestRate: offers[0].rate,
-    totalLiquidity: offers.reduce((sum, offer) => sum.add(offer.liquidity), new Dec(0)).toString(),
-    offers,
-  };
+  return buildMidnightParsedBook(offers, side);
 };
 
 // The API says why a quote failed — NOT_FOUND (market matured or not open yet), INSUFFICIENT_LIQUIDITY
@@ -362,6 +348,9 @@ const fetchMorphoMidnightQuote = async (
  *
  * A `maxBorrowRate` below `estBorrowRate` yields `maxUnits < newUnits` — the borrow would revert on-chain.
  * Compare the two before submitting and tell the user their ceiling is under the market rate.
+ *
+ * Tenor-hosted markets (see `isTenorMidnightMarket`) are quoted against Tenor's router instead of Morpho's
+ * book API. Slippage is applied locally to `maxUnits`; `taker` is the position owner (the smart wallet).
  */
 export const getMorphoMidnightBorrowQuote = async (
   marketId: string,
@@ -369,7 +358,12 @@ export const getMorphoMidnightBorrowQuote = async (
   slippagePercent: Dec.Value,
   maturity: number,
   maxBorrowRate?: Dec.Value,
+  taker?: string,
 ): Promise<MorphoMidnightBorrowQuote> => {
+  if (isTenorMidnightMarket(marketId)) {
+    return getTenorBorrowQuote(marketId, assetsRaw, slippagePercent, maturity, maxBorrowRate, taker);
+  }
+
   const quote = await fetchMorphoMidnightQuote(marketId, 'bids', { assets: assetsRaw }, slippagePercent);
   const { bestPrice, worstPrice } = quote;
   const ttmDays = midnightTimeToMaturityDays(maturity);
@@ -417,7 +411,12 @@ export const getMorphoMidnightPaybackQuote = async (
   slippagePercent: Dec.Value,
   maturity: number,
   minPaybackRate?: Dec.Value,
+  taker?: string,
 ): Promise<MorphoMidnightPaybackQuote> => {
+  if (isTenorMidnightMarket(marketId)) {
+    return getTenorPaybackQuote(marketId, assetsRaw, slippagePercent, maturity, minPaybackRate, taker);
+  }
+
   const quote = await fetchMorphoMidnightQuote(marketId, 'asks', { assets: assetsRaw }, slippagePercent);
   const { bestPrice, worstPrice } = quote;
   const ttmDays = midnightTimeToMaturityDays(maturity);
@@ -462,7 +461,12 @@ export const getMorphoMidnightPaybackUnitsQuote = async (
   slippagePercent: Dec.Value,
   maturity: number,
   minPaybackRate?: Dec.Value,
+  taker?: string,
 ): Promise<MorphoMidnightPaybackUnitsQuote> => {
+  if (isTenorMidnightMarket(marketId)) {
+    return getTenorPaybackUnitsQuote(marketId, unitsRaw, slippagePercent, maturity, minPaybackRate, taker);
+  }
+
   const quote = await fetchMorphoMidnightQuote(marketId, 'asks', { units: unitsRaw }, slippagePercent);
   const { bestPrice, worstPrice } = quote;
   const ttmDays = midnightTimeToMaturityDays(maturity);

package/src/helpers/morphoMidnightHelpers/rate.ts

@@ -0,0 +1,46 @@
+import Dec from 'decimal.js';
+import { SECONDS_PER_DAY } from '../../constants';
+import { MorphoMidnightBookOffer, MorphoMidnightBookSide, MorphoMidnightParsedBook } from '../../types';
+
+const nowInSeconds = () => Math.floor(Date.now() / 1000);
+
+// Days remaining until maturity, optionally measured at a past timestamp (for historical fills).
+export const midnightTimeToMaturityDays = (maturity: number, atSeconds: number = nowInSeconds()): number => new Dec(maturity).sub(atSeconds).div(SECONDS_PER_DAY).toNumber();
+
+// Annualize a fixed-term discount price into an APY percent: (1 / price)^(365 / ttmDays) − 1.
+// `price` is loan-per-unit (assets received / units owed), so 1/price ≥ 1.
+export const midnightApyFromPrice = (price: Dec.Value, ttmDays: Dec.Value): string => {
+  const p = new Dec(price);
+  const ttm = new Dec(ttmDays);
+  if (p.lte(0) || ttm.lte(0)) return '0';
+  return new Dec(1).div(p).pow(new Dec(365).div(ttm)).sub(1)
+    .mul(100)
+    .toString();
+};
+
+/**
+ * Inverse of `midnightApyFromPrice`: the loan-per-unit price a borrow APY implies,
+ * price = (1 + rate)^(−ttmDays / 365).
+ */
+export const midnightPriceFromApy = (ratePercent: Dec.Value, ttmDays: Dec.Value): string => {
+  const rate = new Dec(ratePercent);
+  const ttm = new Dec(ttmDays);
+  if (rate.lte(0) || ttm.lte(0)) return '1';
+  return new Dec(1).div(new Dec(1).add(rate.div(100)).pow(ttm.div(365))).toString();
+};
+
+export const midnightBookBestFirst = (side: MorphoMidnightBookSide): 1 | -1 => (side === 'asks' ? -1 : 1);
+
+export const buildMidnightParsedBook = (
+  offers: MorphoMidnightBookOffer[],
+  side: MorphoMidnightBookSide,
+): MorphoMidnightParsedBook | null => {
+  const bestFirst = [...offers].sort((a, b) => new Dec(a.rate).minus(b.rate).mul(midnightBookBestFirst(side)).toNumber());
+  if (bestFirst.length === 0) return null;
+
+  return {
+    bestRate: bestFirst[0].rate,
+    totalLiquidity: bestFirst.reduce((sum, offer) => sum.add(offer.liquidity), new Dec(0)).toString(),
+    offers: bestFirst,
+  };
+};

package/src/helpers/morphoMidnightHelpers/tenor.ts

@@ -0,0 +1,411 @@
+import Dec from 'decimal.js';
+import { assetAmountInEth, getAssetInfoByAddress } from '@defisaver/tokens';
+import { ZERO_ADDRESS, ZERO_BYTES32 } from '../../constants';
+import {
+  MorphoMidnightBookOffer,
+  MorphoMidnightBookSide,
+  MorphoMidnightMarketData,
+  MorphoMidnightParsedBook,
+  NetworkNumber,
+} from '../../types';
+import { isTenorMidnightMarket, MIDNIGHT_BASE } from '../../markets/morphoMidnight';
+import type {
+  MorphoMidnightBorrowQuote,
+  MorphoMidnightPaybackQuote,
+  MorphoMidnightPaybackUnitsQuote,
+} from './index';
+import {
+  buildMidnightParsedBook,
+  midnightApyFromPrice,
+  midnightPriceFromApy,
+  midnightTimeToMaturityDays,
+} from './rate';
+
+
+// Notion doc by Rajko: https://app.notion.com/p/defisaver/Tenor-API-3ba0be682adc80dfad35c81a9a4cb442
+
+const TENOR_QUOTES_URL = 'https://router.tenor.finance/v1/quotes';
+const TENOR_ORDERBOOK_URL = 'https://router.tenor.finance/v1/orderbook';
+const TENOR_TIMEOUT_MS = 15000;
+const TENOR_ALGORITHM = 'branch_and_bound';
+
+const tenorQuoteError = (reason?: string): string => (
+  reason ? `Morpho Midnight quote unavailable: ${reason}` : 'Morpho Midnight quote unavailable'
+);
+
+type TenorBookKey = 'asks' | 'bids';
+export const tenorBookKeyFor = (side: MorphoMidnightBookSide): TenorBookKey => (side === 'bids' ? 'asks' : 'bids');
+
+// Tenor order-book levels are annualized APR in basis points: 25 → 0.25%, 700 → 7%.
+export const tenorBookRateToApyPercent = (rate: Dec.Value): string => new Dec(rate || 0).div(100).toString();
+
+const tenorFillPrice = (assets: Dec.Value, units: Dec.Value): string => (
+  new Dec(units).lte(0) ? '0' : new Dec(assets).div(units).toString()
+);
+
+export const tenorCapPrice = (
+  bestPrice: string,
+  slippagePercent: Dec.Value,
+  direction: 1 | -1,
+  ttmDays: Dec.Value,
+  boundRate?: Dec.Value,
+): string => {
+  if (boundRate !== undefined && new Dec(boundRate).gt(0)) return midnightPriceFromApy(boundRate, ttmDays);
+  const band = new Dec(1).add(new Dec(slippagePercent || 0).div(100).mul(direction));
+  return Dec.max(0, new Dec(bestPrice).mul(band)).toString();
+};
+
+interface TenorOfferCollateral {
+  token: string;
+  lltv: string | number;
+  liquidation_cursor: string | number;
+  oracle: string;
+}
+
+interface TenorOffer {
+  start: string | number;
+  group?: string;
+  callback?: string;
+  tick: string | number;
+  chain_id: string | number;
+  maturity: string | number;
+  buy: boolean;
+  maker: string;
+  loan_token_address: string;
+  callback_data?: string;
+  expiry: string | number;
+  ratifier?: string;
+  collaterals: TenorOfferCollateral[];
+  continuous_fee_cap: string | number;
+  enter_gate: string;
+  liquidator_gate: string;
+  max_assets: string | number;
+  max_units: string | number;
+  ratifier_data?: string;
+  rcf_threshold: string | number;
+  receiver_if_maker_is_seller?: string;
+  reduce_only: boolean;
+}
+
+interface TenorOfferFill {
+  units: string | number;
+  offer: TenorOffer;
+}
+
+/**
+ * Tenor's offer JSON is flat (market fields live on the offer). Morpho's is nested, and that nested
+ * shape is what the app encodes for `Midnight.take`. Map Tenor into that shape so recipes stay on one encoder.
+ */
+export const tenorOfferToApiOffer = (offer: TenorOffer) => ({
+  market: {
+    chain_id: offer.chain_id,
+    midnight: MIDNIGHT_BASE,
+    loan_token: offer.loan_token_address,
+    collaterals: offer.collaterals || [],
+    maturity: offer.maturity,
+    rcf_threshold: offer.rcf_threshold,
+    enter_gate: offer.enter_gate,
+    liquidator_gate: offer.liquidator_gate,
+  },
+  buy: offer.buy,
+  maker: offer.maker,
+  start: offer.start,
+  expiry: offer.expiry,
+  tick: offer.tick,
+  group: offer.group || ZERO_BYTES32,
+  callback: offer.callback || ZERO_ADDRESS,
+  callback_data: offer.callback_data || '0x',
+  receiver_if_maker_is_seller: offer.receiver_if_maker_is_seller || ZERO_ADDRESS,
+  ratifier: offer.ratifier || ZERO_ADDRESS,
+  reduce_only: offer.reduce_only,
+  max_units: offer.max_units,
+  max_assets: offer.max_assets,
+  continuous_fee_cap: offer.continuous_fee_cap,
+});
+
+export const tenorOfferFillToApiFill = (fill: TenorOfferFill) => ({
+  units: fill.units,
+  offer: tenorOfferToApiOffer(fill.offer),
+  ratifier_data: fill.offer.ratifier_data || '0x',
+  market_id: '',
+});
+
+interface TenorBookBucket {
+  rate: number | string;
+  liquidity: number | string;
+  cumulative_liquidity?: number | string;
+}
+
+interface TenorBookSidePayload {
+  buckets?: TenorBookBucket[];
+}
+
+interface TenorBookResponse {
+  asks?: TenorBookSidePayload | TenorBookBucket[];
+  bids?: TenorBookSidePayload | TenorBookBucket[];
+}
+
+const tenorBookBuckets = (side?: TenorBookSidePayload | TenorBookBucket[]): TenorBookBucket[] => {
+  if (!side) return [];
+  if (Array.isArray(side)) return side;
+  return side.buckets || [];
+};
+
+/** The levels resting on the Tenor side a taker of `side` fills, in raw loan-token base units. */
+export const parseTenorBookSide = (
+  json: TenorBookResponse,
+  side: MorphoMidnightBookSide,
+) => tenorBookBuckets(json[tenorBookKeyFor(side)])
+  .map((bucket) => ({
+    rate: tenorBookRateToApyPercent(bucket.rate),
+    liquidityRaw: new Dec(bucket.liquidity || 0).toFixed(0),
+  }))
+  .filter((offer) => new Dec(offer.liquidityRaw).gt(0));
+
+export const parseTenorOrderBook = (
+  json: TenorBookResponse,
+  side: MorphoMidnightBookSide,
+  loanSymbol: string,
+): MorphoMidnightParsedBook | null => {
+  const offers: MorphoMidnightBookOffer[] = parseTenorBookSide(json, side).map((offer) => ({
+    rate: offer.rate,
+    liquidity: assetAmountInEth(offer.liquidityRaw, loanSymbol),
+  }));
+
+  return buildMidnightParsedBook(offers, side);
+};
+
+const fetchTenorBook = async (marketId: string, network: NetworkNumber): Promise<TenorBookResponse> => {
+  const res = await fetch(
+    `${TENOR_ORDERBOOK_URL}/${marketId}?chain_id=${network}`,
+    { signal: AbortSignal.timeout(TENOR_TIMEOUT_MS) },
+  );
+  if (!res.ok) throw new Error(`Midnight book request failed for ${marketId} (${res.status})`);
+  return res.json();
+};
+
+export const getTenorMarketBook = async (
+  market: MorphoMidnightMarketData,
+  network: NetworkNumber,
+  side: MorphoMidnightBookSide = 'bids',
+): Promise<MorphoMidnightParsedBook | null> => {
+  const loanSymbol = getAssetInfoByAddress(market.loanToken, network).symbol;
+  return parseTenorOrderBook(await fetchTenorBook(market.marketId, network), side, loanSymbol);
+};
+
+const tenorBookAvailableAssetsRaw = async (
+  marketId: string,
+  network: NetworkNumber,
+  side: MorphoMidnightBookSide,
+): Promise<string> => {
+  try {
+    const json = await fetchTenorBook(marketId, network);
+    return parseTenorBookSide(json, side).reduce((sum, offer) => sum.add(offer.liquidityRaw), new Dec(0)).toFixed(0);
+  } catch {
+    return '0';
+  }
+};
+
+interface TenorQuotePayload {
+  units?: string;
+  rate?: string;
+  buyer_assets?: string;
+  seller_assets?: string;
+  offers?: TenorOfferFill[];
+}
+
+interface TenorQuoteResponse extends TenorQuotePayload {
+  quotes?: TenorQuotePayload[];
+  error?: string;
+  message?: string;
+}
+
+const fetchTenorQuote = async ({
+  marketId,
+  side,
+  assets,
+  units,
+  taker,
+  network = NetworkNumber.Base,
+}: {
+  marketId: string,
+  side: MorphoMidnightBookSide,
+  assets?: string,
+  units?: string,
+  taker?: string,
+  network?: NetworkNumber,
+}) => {
+  const hasAssets = assets !== undefined && assets !== null;
+  const hasUnits = units !== undefined && units !== null;
+  if (hasAssets === hasUnits) {
+    throw new Error(tenorQuoteError('Either assets or units must be provided'));
+  }
+  if (side !== 'asks' && side !== 'bids') {
+    throw new Error(tenorQuoteError(`Unsupported Tenor quote side: ${side}`));
+  }
+
+  const isBuy = side === 'asks';
+  const amount = (hasAssets ? assets : units) as string;
+  const res = await fetch(TENOR_QUOTES_URL, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      market_hashes: [marketId],
+      amount,
+      chain_id: network,
+      is_buy: isBuy,
+      is_exact_in: hasAssets ? isBuy : !isBuy,
+      limit_rate: null,
+      valid_for: null,
+      algorithm: TENOR_ALGORITHM,
+      allow_partial: false,
+      taker: taker || ZERO_ADDRESS,
+    }),
+    signal: AbortSignal.timeout(TENOR_TIMEOUT_MS),
+  });
+
+  const result: TenorQuoteResponse = await res.json().catch(() => ({} as TenorQuoteResponse));
+  if (!res.ok) {
+    throw new Error(tenorQuoteError(result.error || result.message || `Tenor quote request failed with status ${res.status}`));
+  }
+
+  const payload: TenorQuotePayload = result.quotes?.[0] || result;
+  const quotedUnits = new Dec(payload.units || result.units || 0);
+  const offers = payload.offers || result.offers || [];
+  // A book that can't fill the size comes back 200 with everything zeroed rather than as an error.
+  if (quotedUnits.lte(0) || offers.length === 0) {
+    throw new Error(tenorQuoteError('INSUFFICIENT_LIQUIDITY'));
+  }
+
+  return {
+    units: quotedUnits.toFixed(0),
+    buyerAssets: (payload.buyer_assets || result.buyer_assets || '0').toString(),
+    offerFills: offers.map(tenorOfferFillToApiFill),
+  };
+};
+
+const TENOR_NO_AVAILABLE_UNITS = '0';
+
+export const getTenorBorrowQuote = async (
+  marketId: string,
+  assetsRaw: string,
+  slippagePercent: Dec.Value,
+  maturity: number,
+  maxBorrowRate?: Dec.Value,
+  taker?: string,
+  network: NetworkNumber = NetworkNumber.Base,
+): Promise<MorphoMidnightBorrowQuote> => {
+  if (!isTenorMidnightMarket(marketId)) {
+    throw new Error(tenorQuoteError(`Not a Tenor Midnight market: ${marketId}`));
+  }
+
+  const [quote, availableAssets] = await Promise.all([
+    fetchTenorQuote({
+      marketId, side: 'bids', assets: assetsRaw, taker, network,
+    }),
+    tenorBookAvailableAssetsRaw(marketId, network, 'bids'),
+  ]);
+
+  const ttmDays = midnightTimeToMaturityDays(maturity);
+  const bestPrice = tenorFillPrice(assetsRaw, quote.units);
+  const estBorrowRate = midnightApyFromPrice(bestPrice, ttmDays);
+
+  const capPrice = tenorCapPrice(bestPrice, slippagePercent, -1, ttmDays, maxBorrowRate);
+  const maxRate = midnightApyFromPrice(capPrice, ttmDays);
+  const maxUnits = new Dec(capPrice).lte(0) ? '0' : new Dec(assetsRaw).div(capPrice).toFixed(0);
+
+  return {
+    bestPrice,
+    worstPrice: capPrice,
+    estBorrowRate,
+    maxRate,
+    newUnits: quote.units,
+    maxUnits,
+    availableAssets,
+    availableUnits: TENOR_NO_AVAILABLE_UNITS,
+    takeableOffers: quote.offerFills,
+  };
+};
+
+export const getTenorPaybackQuote = async (
+  marketId: string,
+  assetsRaw: string,
+  slippagePercent: Dec.Value,
+  maturity: number,
+  minPaybackRate?: Dec.Value,
+  taker?: string,
+  network: NetworkNumber = NetworkNumber.Base,
+): Promise<MorphoMidnightPaybackQuote> => {
+  if (!isTenorMidnightMarket(marketId)) {
+    throw new Error(tenorQuoteError(`Not a Tenor Midnight market: ${marketId}`));
+  }
+
+  const [quote, availableAssets] = await Promise.all([
+    fetchTenorQuote({
+      marketId, side: 'asks', assets: assetsRaw, taker, network,
+    }),
+    tenorBookAvailableAssetsRaw(marketId, network, 'asks'),
+  ]);
+
+  const ttmDays = midnightTimeToMaturityDays(maturity);
+  const bestPrice = tenorFillPrice(assetsRaw, quote.units);
+  const estPaybackRate = midnightApyFromPrice(bestPrice, ttmDays);
+
+  const capPrice = tenorCapPrice(bestPrice, slippagePercent, 1, ttmDays, minPaybackRate);
+  const minRate = midnightApyFromPrice(capPrice, ttmDays);
+  const minUnits = new Dec(capPrice).lte(0) ? '0' : new Dec(assetsRaw).div(capPrice).toFixed(0, Dec.ROUND_DOWN);
+
+  return {
+    bestPrice,
+    worstPrice: capPrice,
+    estPaybackRate,
+    minRate,
+    newUnits: quote.units,
+    minUnits,
+    availableAssets,
+    availableUnits: TENOR_NO_AVAILABLE_UNITS,
+    takeableOffers: quote.offerFills,
+  };
+};
+
+export const getTenorPaybackUnitsQuote = async (
+  marketId: string,
+  unitsRaw: string,
+  slippagePercent: Dec.Value,
+  maturity: number,
+  minPaybackRate?: Dec.Value,
+  taker?: string,
+  network: NetworkNumber = NetworkNumber.Base,
+): Promise<MorphoMidnightPaybackUnitsQuote> => {
+  if (!isTenorMidnightMarket(marketId)) {
+    throw new Error(tenorQuoteError(`Not a Tenor Midnight market: ${marketId}`));
+  }
+
+  const [quote, availableAssets] = await Promise.all([
+    fetchTenorQuote({
+      marketId, side: 'asks', units: unitsRaw, taker, network,
+    }),
+    tenorBookAvailableAssetsRaw(marketId, network, 'asks'),
+  ]);
+
+  const ttmDays = midnightTimeToMaturityDays(maturity);
+  const newAssets = quote.buyerAssets;
+  const bestPrice = tenorFillPrice(newAssets, unitsRaw);
+  const estPaybackRate = midnightApyFromPrice(bestPrice, ttmDays);
+
+  const capPrice = tenorCapPrice(bestPrice, slippagePercent, 1, ttmDays, minPaybackRate);
+  const minRate = midnightApyFromPrice(capPrice, ttmDays);
+  const maxAssets = new Dec(unitsRaw).mul(capPrice).toFixed(0, Dec.ROUND_UP);
+
+  return {
+    bestPrice,
+    worstPrice: capPrice,
+    estPaybackRate,
+    minRate,
+    newAssets,
+    maxAssets,
+    availableAssets,
+    availableUnits: TENOR_NO_AVAILABLE_UNITS,
+    takeableOffers: quote.offerFills,
+  };
+};

package/src/markets/index.ts

@@ -17,7 +17,9 @@ export {
 export { SparkMarkets } from './spark';
 export { CrvUsdMarkets } from './curveUsd';
 export { MorphoBlueMarkets, findMorphoBlueMarket } from './morphoBlue';
-export { MorphoMidnightMarkets, findMorphoMidnightMarket } from './morphoMidnight';
+export {
+  MorphoMidnightMarkets, findMorphoMidnightMarket, isTenorMidnightMarket, morphoMidnightMarketCollateralParams,
+} from './morphoMidnight';
 export { LlamaLendMarkets } from './llamaLend';
 export { LiquityV2Markets, findLiquityV2MarketByAddress } from './liquityV2';
 export { EulerV2Markets } from './euler';