@1delta/margin-fetcher 0.0.319 → 0.0.321

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

@@ -13447,7 +13447,18 @@ function getListaMarketDataConverter(lender, chainId, prices, additionalYields =
               rateCap: rateCap?.toString() ?? "0",
               rateFloor: rateFloor?.toString() ?? "0",
               // term menu for brokered markets (warm via fetchListaFixedTerms)
-              terms: fixedTermsForMarket
+              terms: fixedTermsForMarket,
+              // Canonical cross-protocol fixed-term descriptor (Lista + Midnight
+              // share this shape). Lista: rolling-duration menu (no single
+              // maturity), no market-level fees, and a per-loan early-repay
+              // penalty (the concrete amount is position-level, on the loan's
+              // `term.earlyRepayPenalty`).
+              fixedTerm: {
+                model: "lista",
+                maturity: void 0,
+                fees: {},
+                earlyRepay: { kind: "penalty" }
+              }
             }
           };
           data[m].chainId = chainId;
@@ -20885,9 +20896,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 +20981,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 +20998,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] = {
@@ -20984,7 +21062,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 +21127,23 @@ function convertMidnightMarketsToResponse(raw, chainId, prices = {}, _additional
         // Midnight-specific extras (consumed by calldata / worker-api resolvers)
         maturity: config.maturity,
         rcfThreshold: config.rcfThreshold,
+        // Raw on-chain-snapshotted fees — authoritative for downstream ingest
+        // (yield-tracer reads these verbatim).
+        settlementFeeCbp: config.settlementFeeCbp,
+        continuousFee: config.continuousFee,
+        // Canonical cross-protocol fixed-term descriptor (Lista + Midnight share
+        // this shape). Midnight: single calendar maturity, continuous +
+        // settlement fees, and NO early-repay penalty (exit = buy debt units
+        // back on the book at market price).
+        fixedTerm: {
+          model: "midnight",
+          maturity: Number(config.maturity),
+          fees: {
+            continuousFeeApr: continuousFeeAprPct,
+            settlementFee
+          },
+          earlyRepay: { kind: "none" }
+        },
         enterGate: config.enterGate,
         liquidatorGate: config.liquidatorGate,
         collateralParams: config.collateralParams
@@ -22548,7 +22644,7 @@ var buildDolomiteUserCall = async (chainId, _lender, account, accountNumbers) =>
     params: [{ owner: account, number }]
   }));
 };
-var midnightMarketCallCount = (collateralCount) => 1 + collateralCount;
+var midnightMarketCallCount = (collateralCount) => 2 + collateralCount;
 var buildMidnightUserCall = (chainId, _lender, account) => {
   const midnight = midnightConfig()?.[chainId]?.midnight;
   const markets = midnightMarketsByChain(chainId);
@@ -22560,6 +22656,29 @@ var buildMidnightUserCall = (chainId, _lender, account) => {
       name: "position",
       params: [market.marketId, account]
     });
+    calls.push({
+      address: midnight,
+      name: "updatePositionView",
+      params: [
+        {
+          chainId: BigInt(chainId),
+          midnight,
+          loanToken: market.loanToken,
+          collateralParams: market.collateralParams.map((c) => ({
+            token: c.token,
+            lltv: BigInt(c.lltv),
+            liquidationCursor: BigInt(c.liquidationCursor),
+            oracle: c.oracle
+          })),
+          maturity: BigInt(market.maturity),
+          rcfThreshold: BigInt(market.rcfThreshold),
+          enterGate: market.enterGate,
+          liquidatorGate: market.liquidatorGate
+        },
+        market.marketId,
+        account
+      ]
+    });
     for (let index = 0; index < market.collateralParams.length; index++) {
       calls.push({
         address: midnight,
@@ -24829,6 +24948,21 @@ function readDebtUnits(positionResult) {
     return toBigInt10(positionResult.debt);
   return 0n;
 }
+function readUpdatedLender(updateResult) {
+  if (Array.isArray(updateResult)) {
+    return {
+      credit: toBigInt10(updateResult[0]),
+      pendingFee: toBigInt10(updateResult[1])
+    };
+  }
+  if (updateResult && typeof updateResult === "object") {
+    return {
+      credit: toBigInt10(updateResult.newCredit),
+      pendingFee: toBigInt10(updateResult.newPendingFee)
+    };
+  }
+  return { credit: 0n, pendingFee: 0n };
+}
 var getMidnightUserDataConverter = (_lender, chainId, account, meta) => {
   const markets = midnightMarketsByChain(chainId);
   const totalCalls = markets.reduce(
@@ -24842,8 +24976,9 @@ var getMidnightUserDataConverter = (_lender, chainId, account, meta) => {
       let cursor = 0;
       for (const market of markets) {
         const positionResult = data[cursor];
+        const updateResult = data[cursor + 1];
         const collateralResults = market.collateralParams.map(
-          (_c, i) => data[cursor + 1 + i]
+          (_c, i) => data[cursor + 2 + i]
         );
         cursor += midnightMarketCallCount(market.collateralParams.length);
         const lenderKey = midnightLenderKey(market.marketId);
@@ -24858,24 +24993,40 @@ var getMidnightUserDataConverter = (_lender, chainId, account, meta) => {
         const debtUnits = readDebtUnits(positionResult);
         const debtStr = parseRawAmount(debtUnits.toString(), market.loanDecimals);
         const debtNum = Number(debtStr);
+        const { credit, pendingFee } = readUpdatedLender(updateResult);
+        const netCreditUnits = credit > pendingFee ? credit - pendingFee : 0n;
+        const depositsStr = parseRawAmount(
+          netCreditUnits.toString(),
+          market.loanDecimals
+        );
+        const depositsNum = Number(depositsStr);
+        const pendingFeeStr = parseRawAmount(
+          pendingFee.toString(),
+          market.loanDecimals
+        );
         const posData = {};
-        let anyBalance = debtUnits > 0n;
-        let depositsUSD24h = 0;
+        let anyBalance = debtUnits > 0n || netCreditUnits > 0n;
+        let depositsUSD24h = depositsNum * loanPriceHist;
         posData[loanUid] = {
           marketUid: loanUid,
           underlying: loanAddr,
-          deposits: "0",
+          deposits: depositsStr,
           debt: debtStr,
           debtStable: "0",
-          depositsUSD: 0,
+          depositsUSD: depositsNum * loanDisplayPrice,
           debtUSD: debtNum * loanDisplayPrice,
           debtStableUSD: 0,
-          depositsUSDOracle: 0,
+          depositsUSDOracle: depositsNum * loanOraclePrice,
           debtUSDOracle: debtNum * loanOraclePrice,
           debtStableUSDOracle: 0,
           stableBorrowRate: "0",
+          // Supply on Midnight is a lend position, not collateral for a borrow.
           collateralEnabled: false,
-          claimableRewards: 0
+          claimableRewards: 0,
+          // Midnight-specific: accrued continuous fee owed by the lender (loan
+          // units), already netted out of `deposits`. 0 on markets with no
+          // continuous fee (the current live default).
+          pendingFee: pendingFeeStr
         };
         market.collateralParams.forEach((c, i) => {
           const collAmt = toBigInt10(collateralResults[i]);
@@ -24888,19 +25039,19 @@ var getMidnightUserDataConverter = (_lender, chainId, account, meta) => {
           const collDisplayPrice = collMeta ? getDisplayPrice(collMeta) : 0;
           const collOraclePrice = collMeta ? getOraclePrice(collMeta) : 0;
           const collPriceHist = collMeta?.price?.priceUsd24h ?? collDisplayPrice;
-          const depositsStr = parseRawAmount(collAmt.toString(), collDec);
-          const depositsNum = Number(depositsStr);
-          depositsUSD24h += depositsNum * collPriceHist;
+          const depositsStr2 = parseRawAmount(collAmt.toString(), collDec);
+          const depositsNum2 = Number(depositsStr2);
+          depositsUSD24h += depositsNum2 * collPriceHist;
           posData[collUid] = {
             marketUid: collUid,
             underlying: collAddr,
-            deposits: depositsStr,
+            deposits: depositsStr2,
             debt: "0",
             debtStable: "0",
-            depositsUSD: depositsNum * collDisplayPrice,
+            depositsUSD: depositsNum2 * collDisplayPrice,
             debtUSD: 0,
             debtStableUSD: 0,
-            depositsUSDOracle: depositsNum * collOraclePrice,
+            depositsUSDOracle: depositsNum2 * collOraclePrice,
             debtUSDOracle: 0,
             debtStableUSDOracle: 0,
             stableBorrowRate: "0",