@1delta/margin-fetcher 5.0.7 → 5.0.8

package/dist/index.d.ts

@@ -8808,8 +8808,17 @@ interface LiquidationTerms {
     ltv?: number;
     /** Threshold at which liquidation becomes possible. */
     liquidationLtv?: number;
-    /** Fraction of repaid debt paid to the liquidator on top of par. */
-    penalty: number;
+    /**
+     * Fraction of repaid debt paid to the liquidator on top of par.
+     *
+     * OPTIONAL, and the distinction is load-bearing: `0` means "the liquidator
+     * gets no bonus", `undefined` means "we do not know it". The first cut
+     * defaulted the unknown case to `0` and every market on `/lending/latest`
+     * rendered a confident "Liquidator takes debt repaid + 0%" — the origin's
+     * `market_config` had no penalty column at all, so NOTHING was known. A row
+     * we cannot fill must be absent, not zero.
+     */
+    penalty?: number;
     closeFactor: number;
     targetHealthFactor?: number;
     /**

package/dist/index.js

@@ -62540,8 +62540,9 @@ function borrowDescription(b) {
       "Liquidation here is triggered by TIME, not price \u2014 being late is the trigger, and being over-collateralised does not protect you."
     );
   } else if (b.liquidation.liquidationLtv != null) {
+    const pen = b.liquidation.penalty;
     parts.push(
-      `Liquidation starts at ${pct(b.liquidation.liquidationLtv * 100)} LTV, with a ${pct(b.liquidation.penalty * 100)} penalty.`
+      `Liquidation starts at ${pct(b.liquidation.liquidationLtv * 100)} LTV` + (pen != null ? `, with a ${pct(pen * 100)} penalty` : "") + "."
     );
   }
   return parts.join(" ");
@@ -63167,7 +63168,20 @@ function buildConstraints(input, siblings, acceptedCollateral) {
     }
   };
 }
-function liquidationFrom(cfg, input) {
+function marketLltv(input) {
+  const raw = input.market?.lltv;
+  if (raw == null) return void 0;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n <= 0) return void 0;
+  return n / 1e18;
+}
+function liquidationFrom(cfg, input, acceptedCollateral) {
+  const lltv = marketLltv(input);
+  const soleCollateral = acceptedCollateral?.count === 1 ? acceptedCollateral.items[0] : void 0;
+  const isolated = lltv != null || !hasCrossMarginRisk(input.lender) && soleCollateral != null;
+  const ownLtv = cfg?.borrowCollateralFactor;
+  const ownLiqLtv = cfg?.collateralFactor;
+  const ownPenalty = cfg?.liquidationPenalty;
   return {
     // The ordinary model: a liquidator repays part of the debt and takes
     // collateral plus a bonus. Adapters override for the four lenders where
@@ -63175,9 +63189,11 @@ function liquidationFrom(cfg, input) {
     model: "repay-seize",
     absorber: "liquidator",
     trigger: "price",
-    ltv: cfg?.borrowCollateralFactor,
-    liquidationLtv: cfg?.collateralFactor,
-    penalty: cfg?.liquidationPenalty ?? 0,
+    ltv: ownLtv || (isolated ? soleCollateral?.ltv ?? lltv : void 0) || ownLtv,
+    liquidationLtv: ownLiqLtv || (isolated ? soleCollateral?.liquidationLtv ?? lltv : void 0) || ownLiqLtv,
+    // No `?? 0` — see `LiquidationTerms.penalty`. An unknown penalty is
+    // undefined so the row is omitted rather than rendered as "+0%".
+    penalty: ownPenalty || (isolated ? soleCollateral?.liquidationPenalty : void 0) || ownPenalty,
     closeFactor: cfg?.closeFactor ?? input.closeFactor ?? 1,
     targetHealthFactor: cfg?.targetHealthFactor ?? input.targetHealthFactor,
     seizure: "proportional",
@@ -63204,7 +63220,8 @@ function buildModes(input) {
       liquidation: {
         ltv: c.borrowCollateralFactor,
         liquidationLtv: c.collateralFactor,
-        penalty: c.liquidationPenalty ?? 0,
+        // Same rule as the top-level penalty: unknown stays unknown.
+        penalty: c.liquidationPenalty,
         closeFactor: c.closeFactor ?? input.closeFactor ?? 1,
         targetHealthFactor: c.targetHealthFactor ?? input.targetHealthFactor
       },
@@ -63299,6 +63316,7 @@ function buildBorrow(input, now, siblings) {
   const rate = buildRate(input, "borrow");
   const maturity = buildMaturity(input, now);
   const fees = buildFees(input, "borrow");
+  const acceptedCollateral = buildExposures2(input, siblings, "accepted");
   const borrow = {
     rate,
     maturity,
@@ -63313,8 +63331,8 @@ function buildBorrow(input, now, siblings) {
       minDebt: resolveMinDebt(input),
       fees: fees.filter((f) => f.when === "exit" || f.when === "late")
     },
-    liquidation: liquidationFrom(cfg, input),
-    acceptedCollateral: buildExposures2(input, siblings, "accepted"),
+    liquidation: liquidationFrom(cfg, input, acceptedCollateral),
+    acceptedCollateral,
     modes: buildModes(input),
     fees,
     counterparty: { kind: "pool", solvency: "overcollateralized" },
@@ -64939,7 +64957,7 @@ function validateTermSheet(sheet) {
           "full-collateral seizure must surface a tag or an implication"
         );
     }
-    if (l.penalty < 0 || l.penalty > 1)
+    if (l.penalty != null && (l.penalty < 0 || l.penalty > 1))
       fail("penalty-range", `liquidation.penalty ${l.penalty} outside 0..1`);
     if (l.closeFactor <= 0 || l.closeFactor > 1)
       fail(