@defisaver/positions-sdk 2.1.127-midnight-4-dev → 2.1.127-midnight-6-dev

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.
@@ -173,34 +193,19 @@ export interface MorphoMidnightPaybackQuote {
   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();
-};
+// Payback quoted the other way round: the caller names the debt units to retire, and the quote prices
+// what buying them costs. Same rate guard as the assets-target quote, expressed as a spend ceiling.
+export interface MorphoMidnightPaybackUnitsQuote {
+  bestPrice: string, // average_best_price, loan-per-unit — the cheapest units on the ask side
+  worstPrice: string, // average_worst_price, slippage-adjusted (ABOVE best: a dearer unit)
+  estPaybackRate: string, // APY the repayment retires debt at, as a percent
+  minRate: string, // APY the on-chain ceiling permits, i.e. `maxAssets` annualized (display only)
+  newAssets: string, // assets the target units cost at best price, raw loan-token base units
+  maxAssets: string, // ceiling on assets spent (on-chain guard), raw loan-token base units
+  availableAssets: string,
+  availableUnits: string,
+  takeableOffers: any[], // opaque orderbook offers, forwarded verbatim to on-chain execution
+}
 
 /**
  * Coerce a slippage into what the quote endpoint accepts: 0.1–100 with at most one decimal place. The
@@ -261,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());
 
-  if (offers.length === 0) return null;
+  const offers: MorphoMidnightBookOffer[] = (json?.data?.[side] || []).map((offer) => ({
+    rate: midnightApyFromPrice(new Dec(offer.price).div(WAD), ttmDays),
+    liquidity: assetAmountInEth(offer.assets, loanSymbol),
+  }));
 
-  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
@@ -302,14 +302,22 @@ interface MidnightParsedQuote {
   takeableOffers: any[],
 }
 
+/**
+ * How much of the book to quote. The endpoint takes exactly one of the two — it rejects a request with
+ * neither ("Either assets or units must be provided") — and answers the same `takeable_offers` list either
+ * way, since that list is the whole in-band depth rather than the slice this size consumes.
+ */
+type MidnightQuoteSize = { assets: string } | { units: string };
+
 // The raw quote both sides share: prices descaled from WAD, everything else forwarded verbatim.
 const fetchMorphoMidnightQuote = async (
   marketId: string,
   side: MorphoMidnightBookSide,
-  assetsRaw: string,
+  size: MidnightQuoteSize,
   slippagePercent: Dec.Value,
 ): Promise<MidnightParsedQuote> => {
-  const url = `${MIDNIGHT_API_BASE}/books/${marketId}/${side}/quote?assets=${assetsRaw}&slippage=${midnightSlippageParam(slippagePercent)}`;
+  const [sizeParam, sizeValue] = 'assets' in size ? ['assets', size.assets] : ['units', size.units];
+  const url = `${MIDNIGHT_API_BASE}/books/${marketId}/${side}/quote?${sizeParam}=${sizeValue}&slippage=${midnightSlippageParam(slippagePercent)}`;
   const res = await fetch(url, { signal: AbortSignal.timeout(LONGER_TIMEOUT) });
   const json: { data?: MidnightQuoteResponse, error?: MidnightApiError } = await res.json();
   const d = json?.data;
@@ -340,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,
@@ -347,8 +358,13 @@ export const getMorphoMidnightBorrowQuote = async (
   slippagePercent: Dec.Value,
   maturity: number,
   maxBorrowRate?: Dec.Value,
+  taker?: string,
 ): Promise<MorphoMidnightBorrowQuote> => {
-  const quote = await fetchMorphoMidnightQuote(marketId, 'bids', assetsRaw, slippagePercent);
+  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);
   const estBorrowRate = midnightApyFromPrice(bestPrice, ttmDays);
@@ -395,8 +411,13 @@ export const getMorphoMidnightPaybackQuote = async (
   slippagePercent: Dec.Value,
   maturity: number,
   minPaybackRate?: Dec.Value,
+  taker?: string,
 ): Promise<MorphoMidnightPaybackQuote> => {
-  const quote = await fetchMorphoMidnightQuote(marketId, 'asks', assetsRaw, slippagePercent);
+  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);
   const estPaybackRate = midnightApyFromPrice(bestPrice, ttmDays);
@@ -418,3 +439,54 @@ export const getMorphoMidnightPaybackQuote = async (
     minUnits,
   };
 };
+
+/**
+ * Payback quoted against a **units** target instead of a spend: "retire exactly these debt units, and tell
+ * me what that costs". The sibling of `getMorphoMidnightPaybackQuote` in every other respect — same ask
+ * side, same rate floor, same offer list — but with the two amounts swapped, so the on-chain guard becomes
+ * a ceiling on assets spent rather than a floor on units bought.
+ *
+ * This is what a **full close** must be sized with. Retiring N units costs less than N loan tokens before
+ * maturity, so quoting the close as a spend of the debt's face value asks the book for more depth than the
+ * close needs (and can be refused for liquidity that is in fact there), and caps the taker's spend at more
+ * than the position is worth. Callers that cannot refund an overspend — a taker calling the bundler
+ * directly, rather than through an action contract that sweeps the remainder back — need this quote.
+ *
+ * A `minPaybackRate` above `estPaybackRate` yields `maxAssets < newAssets`: the ceiling is under what the
+ * buy costs and it would revert on-chain, the mirror of the assets-target quote's `minUnits > newUnits`.
+ */
+export const getMorphoMidnightPaybackUnitsQuote = async (
+  marketId: string,
+  unitsRaw: string,
+  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);
+  const estPaybackRate = midnightApyFromPrice(bestPrice, ttmDays);
+
+  const capPrice = minPaybackRate !== undefined && new Dec(minPaybackRate).gt(0)
+    ? midnightPriceFromApy(minPaybackRate, ttmDays)
+    : worstPrice;
+  const minRate = midnightApyFromPrice(capPrice, ttmDays);
+  // Rounded UP on both counts — the mirror of the assets-target quote's ROUND_DOWN. Here the figures are
+  // what the taker SPENDS, so a value rounded down understates the cost by a base unit and would leave the
+  // buy short of the units it was asked for.
+  const newAssets = new Dec(unitsRaw).mul(bestPrice).toFixed(0, Dec.ROUND_UP);
+  const maxAssets = new Dec(unitsRaw).mul(capPrice).toFixed(0, Dec.ROUND_UP);
+
+  return {
+    ...quote,
+    estPaybackRate,
+    minRate,
+    newAssets,
+    maxAssets,
+  };
+};

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,
+  };
+};