@1delta/margin-fetcher 0.0.403 → 0.0.404

package/dist/index.d.ts

@@ -329,6 +329,76 @@ interface FixedTermProvider {
     /** The single counterparty/venue contract, when there is one (Lista broker, Term servicer). */
     address?: string;
 }
+/**
+ * Origination window for a fixed-term market whose terms are only obtainable
+ * during a bounded round rather than continuously (`provider.kind: 'auction'`
+ * — Term Finance).
+ *
+ * This is the difference between "the rate card is empty right now" and "this
+ * market is dead": between rounds a Term repo still has a maturity, collateral
+ * params and a last-cleared rate, but nothing can be borrowed until the next
+ * round is listed. Without it every closed repo renders as an ordinary
+ * borrowable market whose action silently cannot be built.
+ *
+ * `status` is a snapshot at fetch time; the timestamps are raw so a consumer
+ * can re-derive it live (and drive a countdown) against a cached response.
+ */
+interface FixedTermAuction {
+    /**
+     * Round lifecycle at fetch time:
+     *  - `upcoming`  — listed but not yet accepting submissions (`now < startTime`)
+     *  - `open`      — accepting sealed bids/offers (`startTime ≤ now < revealTime`)
+     *  - `revealing` — submissions closed, prices revealing / clearing pending
+     *                  (`revealTime ≤ now < endTime`)
+     *  - `closed`    — no round is currently listed for this market. Borrowing is
+     *                  unavailable until the next one; lending may still be
+     *                  possible on the secondary repo-token book.
+     */
+    status: 'upcoming' | 'open' | 'revealing' | 'closed';
+    /**
+     * Can a NEW borrow be opened right now? True only inside an open round —
+     * Term borrow origination is a sealed bid, so there is no other entry point.
+     *
+     * Consume this rather than re-deriving from `status`: it is the single flag
+     * a borrow CTA should gate on, and it stays correct if more statuses appear.
+     * It is NOT the same as `canLend` — see below.
+     */
+    canBorrow: boolean;
+    /**
+     * Can a NEW lend position be opened right now? Deliberately decoupled from
+     * `canBorrow`: the primary auction is only one of two lend surfaces, and
+     * buying repo tokens on the secondary book works between rounds. So a closed
+     * round leaves the market lend-only rather than fully inert, and a UI that
+     * greys out the whole market would be wrong.
+     */
+    canLend: boolean;
+    /**
+     * Seconds until submissions close (`revealTime − now`), or undefined when no
+     * round is open. A snapshot — for a live countdown, derive from `revealTime`.
+     */
+    secondsUntilClose?: number;
+    /**
+     * Ready-to-display consequences of this market's origination model, most
+     * important first. Mirrors `params.market.teller.implications`: auction
+     * mechanics are unusual enough that a UI showing only a rate misleads.
+     */
+    implications?: string[];
+    /** Round id. Absent when `status: 'closed'`. */
+    id?: string;
+    /** Submissions open (unix seconds). Absent when `status: 'closed'`. */
+    startTime?: number;
+    /** Submissions CLOSE / reveal begins (unix seconds). Absent when closed. */
+    revealTime?: number;
+    /** Round clears (unix seconds). Absent when closed. */
+    endTime?: number;
+    /**
+     * Minimum submission size in loan-token base units (raw). Term rounds carry a
+     * real floor (e.g. 1000 USDC) — an amount below it cannot be submitted at all,
+     * so it belongs next to the terms rather than surfacing as a failed action.
+     */
+    minBorrowAmount?: string;
+    minLendAmount?: string;
+}
 /**
  * Canonical fixed-term market descriptor, emitted on `params.market.fixedTerm`
  * for EVERY fixed-rate / fixed-maturity market (Lista brokered + Morpho
@@ -367,6 +437,12 @@ interface FixedTermInfo {
     earlyRepay: FixedTermEarlyRepay;
     /** Who offers the term (Lista broker vs Midnight order book). */
     provider?: FixedTermProvider;
+    /**
+     * Origination window, for `provider.kind: 'auction'` markets only (Term
+     * Finance). Absent for lenders whose terms are continuously available — a
+     * missing `auction` means "no window applies", NOT "closed".
+     */
+    auction?: FixedTermAuction;
 }
 /** A Lista loan, attached to its own entry in the positions array. */
 interface ListaTermLoan {
@@ -2234,14 +2310,48 @@ interface TermBookSource {
     getTopAndBook?(config: TermMarketConfig, maxLevels?: number): Promise<{
         top: TermBookTop;
         book: TermBook;
+        /** Live/upcoming auction round; null when none is listed. */
+        auction: TermAuctionWindow | null;
     } | null>;
 }
+/**
+ * The repo's CURRENT primary auction round, when one is listed.
+ *
+ * Term borrow origination is a periodic sealed-bid auction, not a continuous
+ * book: outside the submission window there is nothing to bid on, so a repo
+ * whose auction has cleared is lend-only (buy repo tokens on the secondary
+ * book) until the next round is listed. Timestamps are raw so consumers can
+ * derive a live countdown; `status` is a snapshot at fetch time.
+ */
+interface TermAuctionWindow {
+    /** Auction round id (the TermAuction entity id). */
+    id: string;
+    /** Submissions open (unix seconds). */
+    startTime: number;
+    /** Submissions CLOSE and the sealed prices start revealing (unix seconds). */
+    revealTime: number;
+    /** Auction clears (unix seconds). Equal to `revealTime` on current deployments. */
+    endTime: number;
+    /** Minimum bid (borrow) size, loan-token base units (raw string; '0' when unset). */
+    minBidAmount: string;
+    /** Minimum offer (lend) size, loan-token base units (raw string; '0' when unset). */
+    minOfferAmount: string;
+    /** Highest accepted bid rate, WAD (raw string; '0' when unset). */
+    maxBidPriceWad: string;
+    /** Highest accepted offer rate, WAD (raw string; '0' when unset). */
+    maxOfferPriceWad: string;
+}
 /** A Term repo paired with its current top-of-book (null when the fetch failed). */
 interface TermMarketRaw {
     config: TermMarketConfig;
     top: TermBookTop | null;
     /** Bounded book slice (top-N levels/side); null/absent when unavailable. */
     book?: TermBook | null;
+    /**
+     * The live/upcoming auction round, or null when no round is currently listed
+     * (the common case between auctions — the repo is then lend-only).
+     */
+    auction?: TermAuctionWindow | null;
 }
 
 /**
@@ -2287,15 +2397,24 @@ declare class TermSubgraphSource implements TermBookSource {
     getBookTop(config: TermMarketConfig): Promise<TermBookTop | null>;
     /**
      * ONE query → the aggregate top (best APR + FULL depth) PLUS a bounded book
-     * slice (top `maxLevels` open orders per side). `asks` = orders selling repo
-     * tokens (the secondary LEND book); `bids` = the rest (borrow side, usually
-     * empty — Term borrow is sealed-bid auction, not a continuous book). Term
-     * secondary orders carry no per-order rate, so every level shares the market's
-     * clearing APR; the levels expose per-order SIZE for filtering.
+     * slice (top `maxLevels` open orders per side) PLUS the repo's current
+     * auction round. `asks` = orders selling repo tokens (the secondary LEND
+     * book); `bids` = the rest (borrow side, usually empty — Term borrow is
+     * sealed-bid auction, not a continuous book). Term secondary orders carry no
+     * per-order rate, so every level shares the market's clearing APR; the levels
+     * expose per-order SIZE for filtering.
+     *
+     * Two auction reads, deliberately distinct:
+     *  - `cleared` — the latest COMPLETE round, whose clearing price IS the
+     *    market's fixed APR (and stays the reference rate between auctions).
+     *  - `pending` — rounds not yet complete/cancelled. Only one of these is a
+     *    real, actionable round; the rest are abandoned listings the subgraph
+     *    never marked complete, filtered out below.
      */
     getTopAndBook(config: TermMarketConfig, maxLevels?: number): Promise<{
         top: TermBookTop;
         book: TermBook;
+        auction: TermAuctionWindow | null;
     } | null>;
     getListings(config: TermMarketConfig): Promise<TermListing[] | null>;
     /**

package/dist/index.js

@@ -21470,6 +21470,20 @@ var toBig3 = (v) => {
     return 0n;
   }
 };
+function pickAuction(rows, nowSec7 = Math.floor(Date.now() / 1e3)) {
+  if (!Array.isArray(rows) || rows.length === 0) return null;
+  const live = rows.filter((a) => a && !a.delisted && !a.nonViableAuction).map((a) => ({
+    id: String(a.id ?? ""),
+    startTime: toNum(a.auctionStartTime),
+    revealTime: toNum(a.revealTime),
+    endTime: toNum(a.auctionEndTime),
+    minBidAmount: String(a.auctionMinBidAmount ?? "0"),
+    minOfferAmount: String(a.auctionMinOfferAmount ?? "0"),
+    maxBidPriceWad: String(a.auctionMaxBidPrice ?? "0"),
+    maxOfferPriceWad: String(a.auctionMaxOfferPrice ?? "0")
+  })).filter((a) => a.endTime > nowSec7).sort((a, b) => a.endTime - b.endTime);
+  return live[0] ?? null;
+}
 var TermSubgraphSource = class {
   url;
   fetchImpl;
@@ -21504,29 +21518,54 @@ var TermSubgraphSource = class {
   }
   /**
    * ONE query → the aggregate top (best APR + FULL depth) PLUS a bounded book
-   * slice (top `maxLevels` open orders per side). `asks` = orders selling repo
-   * tokens (the secondary LEND book); `bids` = the rest (borrow side, usually
-   * empty — Term borrow is sealed-bid auction, not a continuous book). Term
-   * secondary orders carry no per-order rate, so every level shares the market's
-   * clearing APR; the levels expose per-order SIZE for filtering.
+   * slice (top `maxLevels` open orders per side) PLUS the repo's current
+   * auction round. `asks` = orders selling repo tokens (the secondary LEND
+   * book); `bids` = the rest (borrow side, usually empty — Term borrow is
+   * sealed-bid auction, not a continuous book). Term secondary orders carry no
+   * per-order rate, so every level shares the market's clearing APR; the levels
+   * expose per-order SIZE for filtering.
+   *
+   * Two auction reads, deliberately distinct:
+   *  - `cleared` — the latest COMPLETE round, whose clearing price IS the
+   *    market's fixed APR (and stays the reference rate between auctions).
+   *  - `pending` — rounds not yet complete/cancelled. Only one of these is a
+   *    real, actionable round; the rest are abandoned listings the subgraph
+   *    never marked complete, filtered out below.
    */
   async getTopAndBook(config, maxLevels = 20) {
     const id = config.termRepoId.toLowerCase();
     const repoToken = config.repoToken.toLowerCase();
     const data = await this.gql(
-      `query Top($id: ID!, $repoId: Bytes!) {
+      `query Top($id: ID!, $termId: String!, $repoId: Bytes!) {
         termRepo(id: $id) { termRepoTokenRedemptionRatio }
         termAuctions(where: { term: $id, auctionComplete: true }, orderBy: auctionEndTime, orderDirection: desc, first: 1) {
           auctionClearingPrice
           dayCountFractionMantissa
         }
+        pending: termAuctions(
+          where: { term: $termId, auctionComplete: false, auctionCancelled: false }
+          orderBy: auctionEndTime
+          orderDirection: desc
+          first: 5
+        ) {
+          id
+          auctionStartTime
+          revealTime
+          auctionEndTime
+          delisted
+          nonViableAuction
+          auctionMinBidAmount
+          auctionMinOfferAmount
+          auctionMaxBidPrice
+          auctionMaxOfferPrice
+        }
         termOrders(where: { termRepoId: $repoId, orderCancelled: false }, first: 500) {
           makerToken
           originalOrderAmount
           filledAmount
         }
       }`,
-      { id, repoId: id }
+      { id, termId: id, repoId: id }
     );
     if (!data) return null;
     const redemptionRatio = toBig3(data.termRepo?.termRepoTokenRedemptionRatio) || BigInt(WAD3);
@@ -21563,7 +21602,7 @@ var TermSubgraphSource = class {
       supplyLiquidity: toLoan(supplyUnits),
       borrowLiquidity: toLoan(borrowUnits)
     };
-    return { top, book: { bids, asks } };
+    return { top, book: { bids, asks }, auction: pickAuction(data.pending) };
   }
   async getListings(config) {
     const id = config.termRepoId.toLowerCase();
@@ -21672,17 +21711,23 @@ async function fetchTopAndBookWithFallback2(source, chainId, config, nowSec7) {
     fresh = await source.getTopAndBook(config, TERM_BOOK_LEVELS).catch(() => null);
   } else {
     const top = await source.getBookTop(config).catch(() => null);
-    if (top) fresh = { top, book: { bids: [], asks: [] } };
+    if (top) fresh = { top, book: { bids: [], asks: [] }, auction: null };
   }
   if (fresh) {
-    lastGood2.set(key, { top: fresh.top, book: fresh.book, at: nowSec7 });
-    return { top: fresh.top, book: fresh.book };
+    lastGood2.set(key, {
+      top: fresh.top,
+      book: fresh.book,
+      auction: fresh.auction ?? null,
+      at: nowSec7
+    });
+    return { top: fresh.top, book: fresh.book, auction: fresh.auction ?? null };
   }
   const cached = lastGood2.get(key);
   if (cached && nowSec7 - cached.at <= LKG_TTL_SEC2) {
-    return { top: cached.top, book: cached.book };
+    const stillOpen = cached.auction && cached.auction.endTime > nowSec7 ? cached.auction : null;
+    return { top: cached.top, book: cached.book, auction: stillOpen };
   }
-  return { top: null, book: null };
+  return { top: null, book: null, auction: null };
 }
 async function fetchTermMarkets(chainId, source = createTermBookSource(chainId)) {
   const markets = termMarketsByChain(chainId);
@@ -21691,15 +21736,15 @@ async function fetchTermMarkets(chainId, source = createTermBookSource(chainId))
   return Promise.all(
     markets.map(async (config) => {
       if (Number(config.maturity) <= nowSec7) {
-        return { config, top: null, book: null };
+        return { config, top: null, book: null, auction: null };
       }
-      const { top, book } = await fetchTopAndBookWithFallback2(
+      const { top, book, auction } = await fetchTopAndBookWithFallback2(
         source,
         chainId,
         config,
         nowSec7
       );
-      return { config, top, book };
+      return { config, top, book, auction };
     })
   );
 }
@@ -21733,6 +21778,76 @@ function termLenderKey(termRepoId) {
   const body = termRepoId.startsWith("0x") ? termRepoId.slice(2) : termRepoId;
   return "TERM_FINANCE_" + body.toUpperCase();
 }
+function fmtDuration(secs) {
+  if (secs >= 2 * 86400) return `${Math.round(secs / 86400)} days`;
+  if (secs >= 2 * 3600) return `${Math.round(secs / 3600)} hours`;
+  return `${Math.max(1, Math.round(secs / 60))} minutes`;
+}
+function auctionImplications(status, matured, secondsUntilClose) {
+  const out = [];
+  if (matured) {
+    out.push(
+      "This term has MATURED \u2014 it can no longer be borrowed or lent. Existing positions settle through the repurchase/redemption window."
+    );
+    return out;
+  }
+  if (status === "open") {
+    out.push(
+      `\u26A0 Borrowing is a SEALED BID into an auction, not an instant loan. Submissions close in ${secondsUntilClose != null ? fmtDuration(secondsUntilClose) : "a limited window"}; after that nothing can be borrowed until the next round is listed.`
+    );
+    out.push(
+      "Your rate is NOT the rate shown \u2014 the shown figure is the last round\u2019s clearing rate. Your actual rate is set when this round clears, and a bid above the clearing rate may not be filled at all."
+    );
+  } else if (status === "revealing") {
+    out.push(
+      "\u26A0 Bidding has CLOSED for this round \u2014 sealed prices are being revealed and the auction is clearing. No new borrows until the next round is listed."
+    );
+  } else if (status === "upcoming") {
+    out.push(
+      "An auction round is scheduled but not yet accepting bids. Borrowing becomes possible when it opens."
+    );
+  } else {
+    out.push(
+      "\u26A0 NO auction is open, so this market CANNOT be borrowed right now. Term originates loans only during scheduled sealed-bid auctions."
+    );
+    out.push(
+      "Any borrow rate shown is the last round\u2019s clearing rate \u2014 historical, not obtainable."
+    );
+  }
+  out.push(
+    "Lending is still possible between rounds by buying repo tokens on the secondary market; only borrowing depends on the auction window."
+  );
+  out.push(
+    "Fixed maturity: the debt is a static face value with no interest accrual, repayable up to the end of the repurchase window."
+  );
+  return out;
+}
+function toFixedTermAuction(auction, now, matured = false) {
+  const base = { canBorrow: false, canLend: !matured };
+  if (!auction || auction.endTime <= now) {
+    return {
+      status: "closed",
+      ...base,
+      implications: auctionImplications("closed", matured)
+    };
+  }
+  const status = now < auction.startTime ? "upcoming" : now < auction.revealTime ? "open" : "revealing";
+  const secondsUntilClose = status === "open" ? Math.max(0, auction.revealTime - now) : void 0;
+  return {
+    status,
+    ...base,
+    // A matured repo is never borrowable, whatever the round says.
+    canBorrow: status === "open" && !matured,
+    secondsUntilClose,
+    implications: auctionImplications(status, matured, secondsUntilClose),
+    id: auction.id,
+    startTime: auction.startTime,
+    revealTime: auction.revealTime,
+    endTime: auction.endTime,
+    minBorrowAmount: auction.minBidAmount,
+    minLendAmount: auction.minOfferAmount
+  };
+}
 function currencyFor2(address, decimals, tokens) {
   const lower = address.toLowerCase();
   return tokens[lower] ?? { address: lower, symbol: "", name: "", decimals };
@@ -21744,7 +21859,7 @@ function convertTermMarketsToResponse(raw, chainId, prices = {}, _additionalYiel
 }, tokens = {}) {
   const out = {};
   const now = nowSec2();
-  for (const { config, top, book } of raw) {
+  for (const { config, top, book, auction } of raw) {
     if (!config?.termRepoId || !config.purchaseToken) continue;
     const m = termLenderKey(config.termRepoId);
     const maturity = Number(config.maturity);
@@ -21752,7 +21867,9 @@ function convertTermMarketsToResponse(raw, chainId, prices = {}, _additionalYiel
     const matured = ttm <= 0;
     const supplyAprPct = !matured ? top?.supplyAprPct ?? 0 : 0;
     const borrowAprPct = !matured ? top?.borrowAprPct ?? 0 : 0;
-    const terms = borrowAprPct > 0 && !matured ? [
+    const auctionInfo = toFixedTermAuction(auction, now, matured);
+    const auctionOpen = auctionInfo.canBorrow;
+    const terms = borrowAprPct > 0 && auctionOpen ? [
       {
         termId: 0,
         durationSecs: Math.max(0, ttm),
@@ -21807,10 +21924,15 @@ function convertTermMarketsToResponse(raw, chainId, prices = {}, _additionalYiel
       },
       closeFactor: 1,
       collateralActive: false,
-      borrowingEnabled: !matured,
-      depositsEnabled: !matured,
+      // Borrow needs a LIVE auction round, not just an unmatured repo.
+      // `depositsEnabled` stays on the maturity alone: lending is also possible
+      // between rounds by buying repo tokens on the secondary book.
+      borrowingEnabled: auctionOpen,
+      depositsEnabled: auctionInfo.canLend,
       hasStable: false,
-      variableBorrowDisabled: false,
+      // Term has no variable rate at all; between auctions there is no
+      // borrowable rate either, so flag it rather than let a 0 read as free.
+      variableBorrowDisabled: true,
       isActive: true,
       isFrozen: false
     };
@@ -21893,7 +22015,11 @@ function convertTermMarketsToResponse(raw, chainId, prices = {}, _additionalYiel
           earlyRepay: { kind: "none" },
           // Fixed rate is discovered by the periodic sealed-bid auction; the
           // per-repo servicer is the market-level venue reference.
-          provider: { kind: "auction", address: config.servicer }
+          provider: { kind: "auction", address: config.servicer },
+          // The origination window. `closed` (the common state between rounds)
+          // is what tells a consumer that this market is display-only right
+          // now, rather than an ordinary market with an empty rate card.
+          auction: auctionInfo
         },
         collateralParams: config.collateralParams,
         // Bounded book slice (top-N open orders/side) for later filtering. Term
@@ -22883,7 +23009,7 @@ function currencyFor6(address, decimals, symbol, tokens) {
   const lower = address.toLowerCase();
   return tokens[lower] ?? { address: lower, symbol, name: symbol, decimals };
 }
-function fmtDuration(sec) {
+function fmtDuration2(sec) {
   if (sec == null || sec <= 0) return "a short window";
   if (sec < 3600) return `${Math.round(sec / 60)} minute${sec < 120 ? "" : "s"}`;
   if (sec < 86400) return `${Math.round(sec / 3600)} hour${sec < 7200 ? "" : "s"}`;
@@ -23049,7 +23175,7 @@ function convertTellerMarketsToResponse(raw, chainId, prices = {}, _additionalYi
     const originationFeeBps = marketFeeBps + protocolFeeBps;
     const originationFeePercent = originationFeeBps / 100;
     const graceSec = p.paymentDefaultDuration;
-    const graceHuman = fmtDuration(graceSec);
+    const graceHuman = fmtDuration2(graceSec);
     const ltvPct = ltv > 0 ? Math.round(ltv * 100) : void 0;
     const lossX = ltv > 0 ? (1 / ltv).toFixed(1) : void 0;
     const implications = [];