@1delta/margin-fetcher 0.0.319 → 0.0.320

package/README.md

@@ -1,6 +1,6 @@
 # @1delta/margin-fetcher
 
-Multi-protocol lending data fetcher supporting Morpho Blue, Aave V2/V3, Compound V2/V3, Euler, Init, and Lista DAO. Provides public market data (rates, TVL, configs) and per-user position data (balances, shares, collateral) in a unified format.
+Multi-protocol lending data fetcher supporting Morpho Blue, Aave V2/V3, Compound V2/V3, Euler, Init, Lista DAO, and Morpho Midnight. Provides public market data (rates, TVL, configs) and per-user position data (balances, shares, collateral) in a unified format.
 
 ## How Morpho Blue Works
 
@@ -299,3 +299,36 @@ Brokered markets emit **no variable debt** — the position's `debt` is `0`, the
 
 > **Note:** `terms[]` currently itemizes only fixed loans. The dynamic position (post-refinance) is
 > included in the `debtStable` total but not yet surfaced as its own repayable term.
+
+## Morpho Midnight extension
+
+Morpho Midnight is a Base-only, **fixed-rate / fixed-maturity** lending protocol built on an
+**order book of off-chain signed offers** (zero-coupon credit/debt units) — it is **NOT a Morpho
+Blue fork**, so it is modeled as its own `'midnight'` provider (`Lender.MORPHO_MIDNIGHT`,
+`isMidnight`), not `isMorphoType`. There is no pool and no utilization curve: rates are derived
+from each offer's `tick` → price and its time-to-maturity, knowable only via the API. Each
+maturity is its own isolated market, keyed `MORPHO_MIDNIGHT_<marketId>`.
+
+### API-first fetching
+
+Unlike Morpho Blue's GraphQL-then-on-chain hybrid, Midnight public data is **API-only** — there
+is no on-chain public fallback in `fetchLenderAll`. The fetcher lives in
+[`lending/public-data/midnight/`](src/lending/public-data/midnight/):
+
+- **`apiClient` / `fetchPublic`** — an `ApiBookSource` reads the order book per market
+  (`GET /books/{id}`) from the Midnight API. The base URL resolves override → config → hosted
+  default (`https://api.morpho.org/v0/midnight`); the worker can point it at a dev API via
+  `MIDNIGHT_API_BASE` (see `data-sdk` `setMidnightApiBase`).
+- **`math.ts`** — ported `TickLib` (`tickToApr` etc.), bit-verified against `@morpho-org/midnight-sdk`.
+- **`convertPublic`** — normalizes the book into a `MorphoGeneralPublicResponse` keyed by
+  `MORPHO_MIDNIGHT_<id>`, emitting the fixed borrow/supply APR and a single-term
+  `params.market.terms[]` (`{termId, durationSecs, durationDays, apr}`) carrying the maturity — so
+  the maturity flows through the same generic `terms[]` path as Lista's fixed loans. Units are in
+  the **loan token's decimals** (not 18): `assets = units × price / WAD`, so `units ≈ assets`.
+
+User positions (`{credit, debt, collateral[128], collateralBitmap}`) are read via multicall in
+[`lending/user-data/midnight/`](src/lending/user-data/midnight/), one `UserData` per market.
+
+> **Scope:** the fetcher and direct spot actions (supply collateral / borrow-via-`take` / repay /
+> withdraw) are wired. Composer-routed leverage and native ETH are deferred — see
+> [`calldata-sdk/src/evm/generic/midnight/COMPOSER_PLAN.md`](../calldata-sdk/src/evm/generic/midnight/COMPOSER_PLAN.md).

package/dist/index.js

@@ -20885,9 +20885,63 @@ function tickToApr(tick, timeToMaturity) {
 function tickToAprNumber(tick, timeToMaturity) {
   return Number(tickToApr(tick, timeToMaturity)) / 1e18;
 }
+function midnightMaxLif(lltv, liquidationCursor) {
+  const denom = WAD2 - liquidationCursor * (WAD2 - lltv) / WAD2;
+  if (denom <= 0n) return 0n;
+  return WAD2 * WAD2 / denom;
+}
+function midnightLiquidationPenaltyNumber(lltv, liquidationCursor) {
+  if (lltv <= 0n || liquidationCursor <= 0n) return 0;
+  const lif = midnightMaxLif(lltv, liquidationCursor);
+  if (lif <= WAD2) return 0;
+  return Number(lif - WAD2) / 1e18;
+}
+var SETTLEMENT_FEE_BREAKPOINTS_SECS = [
+  0,
+  86400,
+  604800,
+  2592e3,
+  7776e3,
+  15552e3,
+  31104e3
+];
+var CBP_TO_FRACTION = 1e-6;
+function midnightSettlementFeeForTtm(settlementFeeCbp, ttmSecs) {
+  const cbp = settlementFeeCbp;
+  if (!cbp || cbp.length < 7) return 0;
+  const bps = SETTLEMENT_FEE_BREAKPOINTS_SECS;
+  if (ttmSecs <= 0) return cbp[0] * CBP_TO_FRACTION;
+  if (ttmSecs >= bps[6]) return cbp[6] * CBP_TO_FRACTION;
+  let i = 0;
+  while (i < 6 && ttmSecs > bps[i + 1]) i++;
+  const spanLo = bps[i];
+  const spanHi = bps[i + 1];
+  const t = (ttmSecs - spanLo) / (spanHi - spanLo);
+  const feeCbp = cbp[i] + (cbp[i + 1] - cbp[i]) * t;
+  return feeCbp * CBP_TO_FRACTION;
+}
+function midnightContinuousFeeAprPercent(continuousFeeRaw) {
+  if (continuousFeeRaw == null) return 0;
+  let raw;
+  try {
+    raw = typeof continuousFeeRaw === "bigint" ? continuousFeeRaw : BigInt(continuousFeeRaw);
+  } catch {
+    return 0;
+  }
+  if (raw <= 0n) return 0;
+  return Number(raw * SECONDS_PER_YEAR7) / 1e18 * 100;
+}
 
 // src/lending/public-data/midnight/convertPublic.ts
 var nowSec = () => Math.floor(Date.now() / 1e3);
+function toBigIntOr0(v) {
+  if (v === void 0 || v === null || v === "") return 0n;
+  try {
+    return typeof v === "bigint" ? v : BigInt(v);
+  } catch {
+    return 0n;
+  }
+}
 function midnightLenderKey(marketId) {
   return "MORPHO_MIDNIGHT_" + marketId.slice(2).toUpperCase();
 }
@@ -20916,6 +20970,13 @@ function convertMidnightMarketsToResponse(raw, chainId, prices = {}, _additional
     const ttmBig = BigInt(Math.max(0, ttm));
     const supplyAprPct = top?.bestSupplyTick != null && !matured ? tickToAprNumber(top.bestSupplyTick, ttmBig) * 100 : 0;
     const borrowAprPct = top?.bestBorrowTick != null && !matured ? tickToAprNumber(top.bestBorrowTick, ttmBig) * 100 : 0;
+    const settlementFee = midnightSettlementFeeForTtm(
+      config.settlementFeeCbp,
+      ttm
+    );
+    const continuousFeeAprPct = midnightContinuousFeeAprPercent(
+      config.continuousFee
+    );
     const terms = borrowAprPct > 0 && !matured ? [
       {
         termId: 0,
@@ -20926,10 +20987,16 @@ function convertMidnightMarketsToResponse(raw, chainId, prices = {}, _additional
     ] : void 0;
     const loanAddr = config.loanToken.toLowerCase();
     const loanAsset = tokens[loanAddr];
-    const loanKey = toOracleKey(loanAsset?.assetGroup) ?? toGenericPriceKey(loanAsset?.address ?? config.loanToken, chainId);
+    const loanKey = toOracleKey(loanAsset?.assetGroup) || toGenericPriceKey(loanAddr, chainId);
     const loanPrice = prices[loanKey] ?? 0;
-    const supplyLiquidity = formatNr(top?.supplyDepthAssets ?? 0n, config.loanDecimals);
-    const borrowLiquidity = formatNr(top?.borrowDepthAssets ?? 0n, config.loanDecimals);
+    const supplyLiquidity = formatNr(
+      top?.supplyDepthAssets ?? 0n,
+      config.loanDecimals
+    );
+    const borrowLiquidity = formatNr(
+      top?.borrowDepthAssets ?? 0n,
+      config.loanDecimals
+    );
     const entry = { data: {} };
     const loanUid = createMarketUid(chainId, m, loanAddr);
     entry.data[loanUid] = {
@@ -20954,6 +21021,11 @@ function convertMidnightMarketsToResponse(raw, chainId, prices = {}, _additional
       // Midnight is fixed-rate: expose the fixed borrow APR on stableBorrowRate
       // too, so fixed-rate consumers pick it up like a term product.
       stableBorrowRate: borrowAprPct,
+      // Mutable per-market fees (display convenience; authoritative raw values
+      // live on params.market). continuousFeeApr is a %/yr lender-side haircut;
+      // settlementFee is the effective fraction at the current TTM.
+      continuousFeeApr: continuousFeeAprPct,
+      settlementFee,
       intrinsicYield: 0,
       rewards: void 0,
       decimals: config.loanDecimals,
@@ -20984,7 +21056,8 @@ function convertMidnightMarketsToResponse(raw, chainId, prices = {}, _additional
     config.collateralParams.forEach((c) => {
       const collAddr = c.token.toLowerCase();
       const ltv = parseLtv(c.lltv);
-      const liquidationPenalty = liquidationPenaltyFromLltv(ltv);
+      const cursor = toBigIntOr0(c.liquidationCursor);
+      const liquidationPenalty = cursor > 0n ? midnightLiquidationPenaltyNumber(toBigIntOr0(c.lltv), cursor) : liquidationPenaltyFromLltv(ltv);
       const collUid = createMarketUid(chainId, m, collAddr);
       entry.data[collUid] = {
         marketUid: collUid,
@@ -21048,6 +21121,13 @@ function convertMidnightMarketsToResponse(raw, chainId, prices = {}, _additional
         // Midnight-specific extras (consumed by calldata / worker-api resolvers)
         maturity: config.maturity,
         rcfThreshold: config.rcfThreshold,
+        // Mutable, on-chain-snapshotted fees. Raw values are authoritative for
+        // downstream ingest (yield-tracer); the derived `continuousFeeApr` (%)
+        // and `settlementFee` (fraction at current TTM) are convenience fields.
+        settlementFeeCbp: config.settlementFeeCbp,
+        continuousFee: config.continuousFee,
+        continuousFeeApr: continuousFeeAprPct,
+        settlementFee,
         enterGate: config.enterGate,
         liquidatorGate: config.liquidatorGate,
         collateralParams: config.collateralParams