@1delta/margin-fetcher 0.0.403 → 0.0.405

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import { Lender } from '@1delta/lender-registry';
 export { isAaveType, isAaveV2Type, isAaveV32Type, isAaveV3Type, isCompoundV3, isCompoundV3Type, isInit, isMorphoType, isMultiMarket, isYLDR } from '@1delta/lender-registry';
 import { DebitData, LenderDebitData, LstAcceptedInput } from '@1delta/calldata-sdk';
 import { RelayProxyConfig } from '@1delta/proxy-fetch';
-import { TermMarketConfig, LiquityBranchConfig, LiquityConfigChain, RiverMarketConfig, RiverConfigChain, RiverChainData, TellerPoolConfig, MorphoTypeVaultEntry } from '@1delta/data-sdk';
+import { TermMarketConfig, LiquityBranchConfig, LiquityConfigChain, RiverMarketConfig, RiverConfigChain, RiverChainData, InverseMarketConfig, InverseConfigChain, InverseChainData, TellerPoolConfig, MorphoTypeVaultEntry } from '@1delta/data-sdk';
 export { MorphoLensAbi } from '@1delta/abis';
 
 interface GenericCurrency {
@@ -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
@@ -338,7 +408,7 @@ interface FixedTermProvider {
  */
 interface FixedTermInfo {
     /** Underlying fixed-term protocol shape. */
-    model: 'lista' | 'midnight' | 'term' | 'exactly' | 'teller';
+    model: 'lista' | 'midnight' | 'term' | 'exactly' | 'teller' | 'termmax';
     /**
      * Single fixed calendar maturity (unix secs). Undefined for rolling-duration
      * menus (Lista) and multi-maturity markets (Exactly — the maturity menu lives
@@ -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 {
@@ -2077,7 +2153,7 @@ interface MidnightBookSource {
 
 /** Default hosted Midnight API (see @morpho-org/midnight-sdk MidnightApi). */
 declare const DEFAULT_MIDNIGHT_API = "https://api.morpho.org/v0/midnight";
-type FetchLike$1 = typeof fetch;
+type FetchLike$2 = typeof fetch;
 /**
  * Hosted-API book source. Reads `GET {base}/books/{marketId}` and reduces the
  * `asks`/`bids` price levels to a {@link MidnightBookTop}. This is the swappable
@@ -2086,7 +2162,7 @@ type FetchLike$1 = typeof fetch;
 declare class ApiBookSource implements MidnightBookSource {
     private readonly baseUrl;
     private readonly fetchImpl;
-    constructor(baseUrl: string, fetchImpl?: FetchLike$1);
+    constructor(baseUrl: string, fetchImpl?: FetchLike$2);
     getBookTop(marketId: string): Promise<MidnightBookTop | null>;
     /**
      * Full ladder for a market — every level per side, best-first (unlike
@@ -2117,7 +2193,7 @@ declare class ApiBookSource implements MidnightBookSource {
     getOfferMakers(marketId: string, side: 'bids' | 'asks', assets: bigint): Promise<Record<string, string[]>>;
 }
 /** Build the default (hosted-API) book source for a chain. */
-declare function createMidnightBookSource(chainId: string, fetchImpl?: FetchLike$1): MidnightBookSource;
+declare function createMidnightBookSource(chainId: string, fetchImpl?: FetchLike$2): MidnightBookSource;
 
 /**
  * Top-of-book snapshot for a single Term repo, already reduced to best
@@ -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;
 }
 
 /**
@@ -2273,7 +2383,7 @@ declare function convertTermMarketsToResponse(raw: TermMarketRaw[], chainId: str
     [m: string]: MorphoGeneralPublicResponse;
 };
 
-type FetchLike = typeof fetch;
+type FetchLike$1 = typeof fetch;
 /**
  * GraphQL subgraph source. `getBookTop` derives the fixed APR from the repo's
  * latest completed auction clearing price and open-order depth; `getListings`
@@ -2282,20 +2392,29 @@ type FetchLike = typeof fetch;
 declare class TermSubgraphSource implements TermBookSource {
     private readonly url;
     private readonly fetchImpl;
-    constructor(url: string, fetchImpl?: FetchLike);
+    constructor(url: string, fetchImpl?: FetchLike$1);
     private gql;
     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>;
     /**
@@ -2308,7 +2427,7 @@ declare class TermSubgraphSource implements TermBookSource {
     getAuctionOrders(config: TermMarketConfig, account: string): Promise<TermAuctionOrders | null>;
 }
 /** Default Term public-data source for a chain (subgraph via resolved URL). */
-declare function createTermBookSource(chainId: string, fetchImpl?: FetchLike): TermBookSource;
+declare function createTermBookSource(chainId: string, fetchImpl?: FetchLike$1): TermBookSource;
 
 /**
  * Decoded shapes of the Exactly `Previewer.exactly(account)` aggregate view.
@@ -2707,6 +2826,107 @@ interface RiverPositionInfo {
     collateralSurplus: string;
 }
 
+/**
+ * Per-market snapshot of a FiRM market. Numbers are HUMAN units (the
+ * Inverse API serves human numbers; the on-chain fallback normalizes to
+ * match). `null` marks a value the active source could not provide —
+ * the converter degrades gracefully per field.
+ */
+interface InverseMarketRaw {
+    market: InverseMarketConfig;
+    /** Market.totalDebt — DOLA units (human). */
+    totalDebt: number | null;
+    /** DOLA sitting in the Market = instant borrowable ceiling (human). */
+    dolaLiquidity: number | null;
+    /** min(dolaLiquidity, dailyLimit − dailyBorrows) — API only. */
+    leftToBorrow: number | null;
+    /** Collateral price in USD (pessimistic-oracle based). */
+    price: number | null;
+    /** Live borrowPaused (falls back to the metadata snapshot). */
+    borrowPaused: boolean | null;
+    /** Borrows already taken today against `dailyLimit` — API only. */
+    dailyBorrows: number | null;
+}
+/** Raw public-data batch for the FiRM deployment (one chain). */
+interface InverseMarketsRaw {
+    /** The bare lender key, `INVERSE`. */
+    lender: string;
+    config: InverseConfigChain | undefined;
+    chainData: InverseChainData | undefined;
+    /**
+     * DBR price in DOLA — THE fixed borrow APR as a decimal (0.041 =
+     * 4.1%). API-first, metadata snapshot as fallback, `null` if neither
+     * resolves.
+     */
+    dbrPriceDola: number | null;
+    /** Force-replenish penalty APR in bps (54.75% = 5475) — static read. */
+    replenishmentPriceBps: number | null;
+    markets: InverseMarketRaw[];
+    /** Which source filled the market rows. */
+    source: 'api' | 'chain' | 'none';
+}
+
+declare function fetchInverseMarkets(lender: string, chainId: string): Promise<InverseMarketsRaw>;
+
+/**
+ * Synthesized per-market lender key, e.g.
+ * `INVERSE_63DF5E23DB45A2066508318F172BA45B9CD37035` (= the WETH
+ * market). Address-suffixed (Teller/Exactly convention) — FiRM is
+ * Ethereum-only so the chain id is not part of the key.
+ */
+declare function inverseLenderKey(lender: string, market: string): string;
+/** Recover `{ lender, market }` from a per-market key (or undefined). */
+declare function inverseKeyParts(key: string): {
+    lender: string;
+    market: string;
+} | undefined;
+/**
+ * Map the FiRM batch into the shared `MorphoGeneralPublicResponse`
+ * shape, keyed by `INVERSE_<MARKET_ADDR>` — one key per Market
+ * (collateral).
+ *
+ * Per market:
+ *  - COLLATERAL entry: deposit-only; LTV = `collateralFactorBps`;
+ *    liquidation penalty = `liquidationIncentiveBps`; the close factor
+ *    is `liquidationFactorBps` (a liquidation may only close that
+ *    share of the position).
+ *  - LOAN entry (DOLA): `totalDebt` = market debt; the borrow rate is
+ *    the DBR price (FIXED APR — interest is prepaid in DBR, not
+ *    accrued on principal, `rateModel: 'dbr'`); `borrowLiquidity` =
+ *    `leftToBorrow` (API: min(dailyLimit headroom, DOLA in market)) or
+ *    `dolaLiquidity` in the on-chain fallback. There is NO supply side
+ *    — `totalDeposits` on the loan row is always 0 (DOLA is Fed-minted
+ *    into markets, not user-deposited).
+ *
+ * The full FiRM descriptor (minDebt, dailyLimit, escrow implementation,
+ * DBR addresses, replenishment penalty) rides in
+ * `params.market.inverse` for the calldata builders + worker-api
+ * resolvers.
+ */
+declare function convertInverseMarketsToResponse(raw: InverseMarketsRaw, chainId: string, prices?: {
+    [asset: string]: number;
+}, _additionalYields?: AdditionalYields, tokens?: GenericTokenList): {
+    [m: string]: MorphoGeneralPublicResponse;
+};
+
+/** Off-chain `Market.predictEscrow(user)`. */
+declare function predictInverseEscrow(market: Address, escrowImplementation: Address, user: Address): Address;
+
+/** Per-position FiRM detail attached to the debt row (raw strings). */
+interface InversePositionInfo {
+    /** Pessimistic-oracle borrow ceiling for the CURRENT collateral (DOLA raw). */
+    creditLimit: string;
+    /** Max collateral withdrawable right now (collateral raw). */
+    withdrawalLimit: string;
+    /** DBR wallet balance (raw) — the prepaid-interest runway. */
+    dbrBalance: string;
+    /** DBR deficit (raw). > 0 ⇒ force-replenishable at 54.75% APR AND
+     *  withdrawals are FROZEN until the user buys DBR. */
+    dbrDeficit: string;
+    /** DBR signed balance (raw, may be negative). */
+    dbrSignedBalance: string;
+}
+
 /**
  * Raw on-chain read for ONE Teller `LenderCommitmentGroup` pool. All amounts are
  * raw token base units; `minRateBps` is the pool's min borrow APR in BASIS
@@ -2839,6 +3059,361 @@ interface TellerDiscovery {
 declare const getCachedTellerBids: (chainId: string, account: string) => TellerDiscovery | undefined;
 declare const buildTellerUserCall: (chainId: string, _lender: string, account: string) => Promise<Call[]>;
 
+/**
+ * TermMax public-data types.
+ *
+ * ─── SIDE SEMANTICS, READ THIS FIRST ───────────────────────────────────────
+ * TermMax names its two curves from the MAKER's perspective, and they cross
+ * over relative to what a taker (our user) is doing:
+ *
+ *   maker's `lendCurveCuts`   → consumed by a taker who BORROWS
+ *   maker's `borrowCurveCuts` → consumed by a taker who LENDS
+ *
+ * `ITermMaxOrder.apr()` inherits that naming, so its `lendApr` is our user's
+ * BORROW rate and its `borrowApr` is our user's LEND rate — and the API's
+ * `priceInfo.term.lcft` / `bcft` follow the same convention.
+ *
+ * Every field in this file is named for the TAKER action. The crossing happens
+ * exactly once, at the adapter boundary in `apiClient.ts` / `onchain.ts`, and
+ * nowhere else. If a value ever produces lend > borrow on the same order, the
+ * mapping has been applied twice.
+ * ───────────────────────────────────────────────────────────────────────────
+ */
+/**
+ * One segment of an order's piecewise pricing curve (TermMax `CurveCut`).
+ *
+ * `xtReserve` is the LEFT EDGE of the segment's validity interval, not a
+ * quantity. Within a segment the swap solves a constant product over
+ * `(xtReserve + offset, liqSquare_eff / (xtReserve + offset))` where
+ * `liqSquare_eff = liqSquare · daysToMaturity · nif / (365 · 1e8)`.
+ *
+ * This is the TermMax analogue of a Midnight book LEVEL, but continuous rather
+ * than discrete — which is why it cannot reuse `MidnightBookLevel`.
+ */
+interface TermMaxCurveSegment {
+    xtReserve: bigint;
+    liqSquare: bigint;
+    /** Signed — shifts the virtual reserve. */
+    offset: bigint;
+}
+/** Per-order fee ratios, 1e8-scaled (`0.02e8` = 2%). Fees apply to the INTEREST, not principal. */
+interface TermMaxFeeConfig {
+    lendTakerFeeRatio: bigint;
+    lendMakerFeeRatio: bigint;
+    borrowTakerFeeRatio: bigint;
+    borrowMakerFeeRatio: bigint;
+    mintGtFeeRatio: bigint;
+    mintGtFeeRef: bigint;
+}
+/**
+ * Live state of one maker order, already mapped to taker-side semantics.
+ *
+ * An order can source liquidity beyond its own token balance (from an ERC-4626
+ * `pool`, or by minting fresh FT against the maker's own `gtId`), so
+ * balance-derived depth UNDERSTATES what is actually executable. Prefer the
+ * capacity fields on {@link TermMaxBookTop}, or quote.
+ */
+interface TermMaxOrderState {
+    orderAddress: string;
+    marketAddress: string;
+    /** The maker; `makerIsVault` when it is a curated ERC-4626 vault. */
+    makerAddress?: string;
+    makerIsVault?: boolean;
+    /** THE pricing state in V2 (V1 used the real XT balance). */
+    virtualXtReserve: bigint;
+    ftReserve: bigint;
+    xtReserve: bigint;
+    maxXtReserve: bigint;
+    /** Maker's own GT, used to mint FT on demand. 0 = none (it is a sentinel). */
+    gtId: bigint;
+    /** Curve a TAKER LENDS against (TermMax's `borrowCurveCuts`). */
+    takerLendCuts: TermMaxCurveSegment[];
+    /** Curve a TAKER BORROWS against (TermMax's `lendCurveCuts`). */
+    takerBorrowCuts: TermMaxCurveSegment[];
+    feeConfig?: TermMaxFeeConfig;
+    /** Optional ERC-4626 base-yield sink; absent/zero when unset. */
+    pool?: string;
+    /** Executable size caps in USD, as reported upstream. */
+    lendCapacityUsd: number;
+    borrowCapacityUsd: number;
+    /** Executable size caps in debt-token units (human, not raw). */
+    lendCapacityAmount: number;
+    borrowCapacityAmount: number;
+    /** Fee-free mid APRs as fractions (0.055 = 5.5%), taker-side. Display only. */
+    takerLendApr?: number;
+    takerBorrowApr?: number;
+}
+/**
+ * Best executable rate per side plus aggregate depth for one market — the
+ * direct analogue of `MidnightBookTop`, collapsed across every order.
+ *
+ * "Best" is order-agnostic (we scan all orders): best LEND = highest taker-lend
+ * APR, best BORROW = lowest taker-borrow APR.
+ */
+interface TermMaxBookTop {
+    /** Highest taker LEND APR available, as a fraction. Undefined when no order quotes the side. */
+    bestLendApr?: number;
+    /** Lowest taker BORROW APR available, as a fraction. */
+    bestBorrowApr?: number;
+    /** Aggregate executable depth, USD. */
+    lendDepthUsd: number;
+    borrowDepthUsd: number;
+    /** Aggregate executable depth in debt-token units (human). */
+    lendDepthAmount: number;
+    borrowDepthAmount: number;
+}
+/**
+ * A TermMax market, i.e. one (debtToken, collateral, maturity) tuple.
+ *
+ * Discovered DYNAMICALLY — never read from a static registry. Matured markets
+ * disappear from upstream entirely rather than lingering with a flag, and ~15%
+ * of the book can roll on a single maturity date.
+ */
+interface TermMaxMarketConfig {
+    /** Market contract — also the per-market lender-key body. */
+    market: string;
+    /** FT: the zero-coupon bond ERC-20. THE LEND POSITION. */
+    ft: string;
+    /** XT: the complement (`FT + XT = 1` debt token). */
+    xt: string;
+    /** GT: the ERC-721 loan. THE BORROW POSITION (sub-accounts). */
+    gt: string;
+    /** Debt / loan token. */
+    debtToken: string;
+    debtDecimals: number;
+    collateral: string;
+    collateralDecimals: number;
+    /** Display symbol, e.g. `USDC/PT-sUSDE-13AUG2026@16AUG2026`. */
+    symbol?: string;
+    /** Unix seconds. */
+    maturity: number;
+    /** 1e8-scaled, as strings (as upstream reports them). */
+    maxLtv: string;
+    liquidationLtv: string;
+    /** false ⇒ NO liquidation at all, only post-maturity physical delivery. */
+    liquidatable: boolean;
+    /** Post-maturity liquidation window, seconds (7200 on every live market). */
+    liquidationWindowSeconds?: number;
+    /** Contract `getVersion()`: `v2` = "2.0.0", `v2_01` = "2.0.1". Both are V2. */
+    version?: string;
+    /** Market-level fee config (1e8-scaled). */
+    feeConfig?: TermMaxFeeConfig;
+    /** Oracle the protocol itself prices LTV/liquidation against. */
+    oracle?: string;
+    isMatured?: boolean;
+    isEnabled?: boolean;
+}
+/** A market paired with its live book state. `top` is null when the fetch failed. */
+interface TermMaxMarketRaw {
+    config: TermMaxMarketConfig;
+    top: TermMaxBookTop | null;
+    /** Per-order state, best-first by taker rate. Empty when the market has no live orders. */
+    orders: TermMaxOrderState[];
+}
+/**
+ * Pluggable TermMax data source — the hosted API today, a self-hosted indexer
+ * or a pure on-chain reader later. Mirrors `MidnightBookSource`.
+ */
+interface TermMaxDataSource {
+    /**
+     * Every live market on a chain with its orders, or null when unavailable.
+     * One upstream call per chain on the happy path.
+     */
+    getChainMarkets(chainId: string): Promise<TermMaxMarketRaw[] | null>;
+}
+
+/**
+ * Resolve a TermMax market from the discovery cache, or undefined when it was
+ * never fetched / has gone stale. Callers that need a guaranteed answer should
+ * `await fetchTermMaxMarkets(chainId)` first (or read the market on-chain).
+ */
+declare function getCachedTermMaxMarket(chainId: string | number, market: string): TermMaxMarketConfig | undefined;
+/** All markets cached for a chain (may be empty before the first fetch). */
+declare function getCachedTermMaxMarkets(chainId: string | number): TermMaxMarketConfig[];
+/**
+ * Fetch every live TermMax market on a chain, with its order book collapsed to
+ * a best-rate + depth snapshot.
+ *
+ * Returns `[]` (not an error) when the chain has no TermMax deployment
+ * configured, so callers can fan out across chains unconditionally.
+ *
+ * Markets are DISCOVERED, never read from a static list: matured markets vanish
+ * from upstream entirely rather than lingering with a flag, and ~15% of the
+ * book can roll on a single maturity date.
+ */
+declare function fetchTermMaxMarkets(chainId: string, source?: TermMaxDataSource): Promise<TermMaxMarketRaw[]>;
+
+/**
+ * Map fetched TermMax markets into the shared `MorphoGeneralPublicResponse`
+ * shape, keyed by the synthesized `TERMMAX_<MARKET_ADDR>` lender key.
+ *
+ * Each TermMax market is ONE (debt, collateral, maturity) tuple, so it emits
+ * exactly two entries — unlike Midnight, which has several collateral legs per
+ * market:
+ *   - LOAN entry: `depositRate` = best taker LEND APR, `variableBorrowRate` =
+ *     best taker BORROW APR (already crossed from TermMax's maker-side names in
+ *     `apiClient.parseOrder`), plus order-book depth as the liquidity proxy.
+ *   - COLLATERAL entry: maxLtv → collateralFactor, liquidationLtv →
+ *     borrowCollateralFactor, fixed 10% liquidation penalty.
+ *
+ * Rates are DISPLAY values from the fee-free mid quote. Anything that actually
+ * executes must price off a live quote at build time.
+ */
+declare function convertTermMaxMarketsToResponse(raw: TermMaxMarketRaw[], chainId: string, prices?: {
+    [asset: string]: number;
+}, _additionalYields?: AdditionalYields, tokens?: GenericTokenList): {
+    [m: string]: MorphoGeneralPublicResponse;
+};
+
+/** Hosted TermMax data API (Swagger at `/api-docs`, spec at `/api-docs-json`). */
+declare const DEFAULT_TERMMAX_API = "https://api.termmax.ts.finance";
+type FetchLike = typeof fetch;
+/** Resolve a chain's TermMax API base (config override → hosted default). */
+declare function termMaxApiBase(chainId: string): string;
+/**
+ * Hosted-API data source. ONE call per chain — `GET /market/data?chainId=`
+ * returns global config, asset configs, markets, order configs and live order
+ * state together (~240KB on Ethereum).
+ *
+ * This is the swappable seam: a self-hosted indexer or a pure on-chain reader
+ * can implement {@link TermMaxDataSource} later without touching callers.
+ *
+ * Reliability posture: the endpoint is an undocumented app backend (no
+ * versioning or rate-limit statement, `/admin/*` routes on the same host), so
+ * treat it exactly like the Morpho GraphQL API — primary, but the caller keeps
+ * a last-known-good snapshot (see fetchPublic.ts).
+ */
+declare class TermMaxApiSource implements TermMaxDataSource {
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    constructor(baseUrl: string, fetchImpl?: FetchLike);
+    getChainMarkets(chainId: string): Promise<TermMaxMarketRaw[] | null>;
+}
+/** Default data source for a chain (hosted API, resolved per chain). */
+declare function createTermMaxDataSource(chainId: string, fetchImpl?: FetchLike): TermMaxDataSource;
+
+/** TermMax ratio base: `0.01e8` = 1%. */
+declare const DECIMAL_BASE = 100000000n;
+/**
+ * Days to maturity, **ceilinged to whole days** — exactly as
+ * `TermMaxOrderV2._daysToMaturity` does it:
+ *
+ *   `(maturity - now + SECONDS_IN_DAY - 1) / SECONDS_IN_DAY`
+ *
+ * Reproduce the ceiling or an off-chain quote drifts by up to a full day of
+ * interest against the contract. Returns 0 at/after maturity.
+ */
+declare function daysToMaturity(maturity: number, nowSec: number): bigint;
+/**
+ * Marginal (fee-free) APR implied by a curve at a given reserve, 1e8-scaled —
+ * the same formula `TermMaxOrderV2.apr()` uses:
+ *
+ *   `apr = vFt · 1e8 · 365 / (vXt · daysToMaturity)`
+ *
+ * Returns 0n for an empty curve or a matured market. This is a MID PRICE at the
+ * current reserve: it ignores both the taker fee and trade size, so it is for
+ * display and sorting only — never quote against it.
+ */
+declare function curveApr(cuts: TermMaxCurveSegment[], virtualXtReserve: bigint, days: bigint): bigint;
+/** 1e8-scaled ratio → plain fraction (`5_500_000n` → `0.055`). */
+declare function ratioToNumber(v: bigint): number;
+/** 1e8-scaled ratio → percent (`5_500_000n` → `5.5`). */
+declare function ratioToPercent(v: bigint): number;
+/**
+ * Marginal APR as a fraction for one side, taker-side by construction.
+ *
+ * Pass `takerLendCuts` for the lend rate and `takerBorrowCuts` for the borrow
+ * rate — the maker/taker crossing has already been applied when those fields
+ * were built (see types.ts).
+ */
+declare function curveAprNumber(cuts: TermMaxCurveSegment[], virtualXtReserve: bigint, days: bigint): number;
+/**
+ * Net-interest factor for a taker LEND (`1e8 - lendTakerFeeRatio`).
+ * Guarded so a malformed fee config cannot produce a non-positive factor.
+ */
+declare function lendNif(fee?: TermMaxFeeConfig): bigint;
+/** Net-interest factor for a taker BORROW (`1e8 + borrowTakerFeeRatio`). */
+declare function borrowNif(fee?: TermMaxFeeConfig): bigint;
+/**
+ * The GT-mint fee ratio at a given time to maturity, 1e8-scaled — mirrors
+ * `TermMaxMarketV2.mintGtFeeRatio()`:
+ *
+ *   `days · feeRatio · feeRef / (365·1e8 + feeRef·days)`
+ *
+ * This is a genuine percentage OF PRINCIPAL charged once at borrow time
+ * (`issueFee = debt · ratio / 1e8`), so it maps onto the cross-protocol
+ * `FixedTermInfo.fees.originationFeePercent`. It is NOT the raw
+ * `feeConfig.mintGtFeeRatio` — prefer reading the contract when you can.
+ */
+declare function mintGtFeeRatio(fee: TermMaxFeeConfig | undefined, days: bigint): bigint;
+/**
+ * TermMax liquidation penalty as a fraction of the repaid debt.
+ *
+ * Protocol constants, not per-market: the liquidator is paid 5% and the
+ * protocol reserve takes 5%, so the borrower loses 10% of the liquidated debt
+ * value. (Loans over $10k can only be liquidated 50% at a time; that is a size
+ * cap, not a penalty, and is modeled as `closeFactor`.)
+ */
+declare const TERMMAX_LIQUIDATION_PENALTY = 0.1;
+declare const TERMMAX_LIQUIDATOR_BONUS = 0.05;
+/** Partial-liquidation threshold, USD: above it a single call can take at most 50%. */
+declare const TERMMAX_PARTIAL_LIQUIDATION_THRESHOLD_USD = 10000;
+declare const TERMMAX_PARTIAL_CLOSE_FACTOR = 0.5;
+/** Post-maturity liquidation window before physical delivery (`Constants.LIQUIDATION_WINDOW`). */
+declare const TERMMAX_LIQUIDATION_WINDOW_SECS = 7200;
+/**
+ * Parse a 1e8-scaled LTV string into a plain fraction (`87500000` → `0.875`).
+ * Returns 0 for missing/garbage input rather than NaN, so a bad config row
+ * degrades to "no collateral value" instead of poisoning the optimizer.
+ */
+declare function parseTermMaxLtv(v: string | number | bigint | undefined): number;
+
+/**
+ * TermMax user data is a DISCOVERY-first, async build — the Teller/Liquity
+ * shape, not the Midnight one.
+ *
+ * Midnight can build synchronously because its positions are keyed
+ * `(marketId, user)`: one fixed slot per user per market, with the market list
+ * coming from a static registry. TermMax has neither property:
+ *
+ *  1. the market list is DYNAMIC (markets churn on every maturity roll and
+ *     matured ones vanish upstream), so it must be resolved at call time; and
+ *  2. borrow positions are GT ERC-721 sub-accounts — a user can hold N per
+ *     market and the ids are not derivable.
+ *
+ * But it is cheaper than Teller: `TermMaxViewer.getPositionDetails(markets[],
+ * owner)` returns FT/XT/collateral balances AND every GT with its debt and
+ * collateral in ONE call, so discovery and data collapse into a single
+ * multicall entry — no two-phase discovery round-trip. The viewer `try`-guards
+ * each position internally, so one bad loan cannot poison the batch.
+ *
+ * Health is NOT read per GT (`getLiquidationInfo`): it is computed downstream
+ * from LTVs + oracle prices in `createMultiAccountTypeUserState`, exactly as
+ * Midnight does. That keeps this to one call.
+ */
+/** Every TermMax market read consumes exactly one viewer call (batched). */
+declare const TERMMAX_CALLS_PER_ACCOUNT = 1;
+interface TermMaxDiscovery {
+    /** Markets passed to the viewer, IN ORDER — the parser slices results by index. */
+    markets: TermMaxMarketConfig[];
+    at: number;
+}
+/**
+ * The market layout used for the last build on this (chain, account).
+ *
+ * The parser runs as a separate phase, fed only the multicall results, so it
+ * needs the layout the builder chose — the same trick the Teller / Liquity /
+ * Lista-broker caches use.
+ */
+declare const getCachedTermMaxDiscovery: (chainId: string, account: string) => TermMaxDiscovery | undefined;
+/**
+ * Build the user-data call for every live TermMax market on a chain.
+ *
+ * Returns `[]` when the chain has no TermMax deployment, no viewer configured,
+ * or no live markets — callers can fan out unconditionally.
+ */
+declare const buildTermMaxUserCall: (chainId: string, _lender: string, account: string) => Promise<Call[]>;
+
 type PendleAssetTypes = 'PT' | 'YT' | 'SY' | 'PENDLE_LP';
 /**
  * Main function to fetch Pendle prices
@@ -4068,6 +4643,121 @@ type EulerEarnVaults = {
     [vaultAddress: string]: EulerEarnVault;
 };
 
+/**
+ * Parsed TermMax curated vault entry.
+ *
+ * TermMax vaults are the CONTINUOUS earn side of a fixed-maturity protocol.
+ * The per-market lend position (buying FT) expires; a vault holds a rolling
+ * book of orders across many maturities and rolls them for the depositor, so
+ * from the outside it behaves like an ordinary ERC-4626 yield vault. Same
+ * relationship Fluid has between its per-vault borrow markets and its fTokens.
+ *
+ * Multiple vaults exist per underlying with different curators (Keyrock, MEV
+ * Capital, Origami and TermMax itself all curate), so the map is keyed by
+ * VAULT ADDRESS —
+ * the `MorphoVaults` / `SiloVaults` / `EulerEarnVaults` convention, not the
+ * key-by-underlying convention Fluid and Gearbox use.
+ *
+ * IMPORTANT — vault assets and lender-side depth are the SAME capital. A
+ * vault's deposits are what appear as lend-side order depth in the TermMax
+ * lender data, so summing "TermMax lender TVL + TermMax vault TVL" double
+ * counts.
+ */
+interface TermMaxVault extends VaultClassificationFields {
+    /** Vault (share-token) contract address, lowercased. */
+    address: string;
+    /** Lowercased underlying ERC-20 address (the markets' debt token). */
+    underlying: string;
+    /** Vault share-token symbol, e.g. `TMKR-RLUSD`. */
+    symbol: string;
+    /** Vault share-token name, e.g. `Coinshift rlUSD vault`. */
+    name: string;
+    /** Share-token decimals. */
+    decimals: number;
+    /** Underlying asset decimals — read on-chain, may differ from `decimals`. */
+    assetDecimals: number;
+    /** Total underlying assets held, raw integer as string. */
+    totalAssets: string;
+    /** Total shares minted, raw integer as string. */
+    totalSupply: string;
+    /** Raw `convertToAssets(10**shareDecimals)` — 1 share → X underlying. */
+    convertToAssets: string;
+    /**
+     * Supply APR in percent, **net of the performance fee**.
+     *
+     * TermMax's own formula (`OrderManagerV2`):
+     *   `annualizedInterest · (1e8 − performanceFeeRate) / accretingPrincipal`
+     * `annualizedInterest` is GROSS — the fee is taken out of it on accrual
+     * (`_accretingPrincipal += interest − performanceFeeToCurator`), so it must
+     * be netted here to match the README's "net of performance fee" convention.
+     *
+     * Served directly by the API. The on-chain fallback derives it, because
+     * `apr()` AND `accretingPrincipal()` both revert on the deployed 2.0.0
+     * vaults — it substitutes `totalAssets` as the denominator, which is larger
+     * and so understates rather than overstates. The derivation was validated
+     * against the API on both funded Ethereum vaults: 2.579% and 1.449%,
+     * matching to 3 decimals.
+     */
+    supplyRate: number;
+    /** Extra rewards APR (TMX emissions). 0 on the on-chain fallback, which
+     *  cannot see them. */
+    rewardsRate: number;
+    /** `supplyRate + rewardsRate` — what a depositor actually earns. */
+    depositRate: number;
+    /** Performance fee in percent (e.g. `10` = 10%). */
+    fee: number;
+    /** Governance timelock in seconds for curator/guardian config changes. */
+    timelock?: number;
+    /** Curator address, lowercased. */
+    curator?: string;
+    /**
+     * Human-readable curator label.
+     *
+     * ONLY the API carries this — the on-chain surface exposes an address and
+     * nothing else. Do NOT derive it from `name`: the vault literally called
+     * "Coinshift rlUSD vault" is curated by **Keyrock**.
+     */
+    curatorName?: string;
+    /** Guardian address, lowercased. */
+    guardian?: string;
+    /** Hydrated asset metadata from the provided token list, if any. */
+    asset?: GenericCurrency;
+    /** USD price of one underlying unit, if prices were supplied. */
+    priceUsd?: number;
+    /** `totalAssets / 10^assetDecimals`. */
+    totalAssetsFormatted: number;
+    /** `totalAssetsFormatted * priceUsd`. */
+    totalAssetsUsd: number;
+    /**
+     * Immediately withdrawable underlying, raw integer as string.
+     *
+     * A TermMax vault's capital is committed to maker orders until each order's
+     * maturity, so only part is instantly exitable — the rest needs the curator
+     * to unwind or a maturity to roll. Sourced from the API's `redeemableAmt`
+     * (falling back to `idleFunds`), or the vault's own underlying balance
+     * on-chain. Deliberately NOT `totalAssets`.
+     */
+    liquidity: string;
+    liquidityFormatted: number;
+    liquidityUsd: number;
+    /** Contract `getVersion()` / API `version`, e.g. `"2.0.0"` / `"v2"`. */
+    version?: string;
+    /** Vault is paused — deposits blocked, existing funds still visible. */
+    isPaused?: boolean;
+    /** Deposit cap in underlying base units (API `capacity`). */
+    supplyCap?: string;
+    /**
+     * The vault's ERC-4626 base-yield pool for idle funds (v2_01 "composable
+     * base yield"). Idle capital earns here instead of sitting dead.
+     */
+    basePool?: string;
+}
+/** Full parsed payload: per-vault-address map. */
+type TermMaxVaults = {
+    /** Keyed by lowercased vault address. */
+    [vaultAddress: string]: TermMaxVault;
+};
+
 /**
  * Validator / delegation dataset for LST deposits.
  *
@@ -5949,7 +6639,7 @@ interface VaultLookupEntry {
 declare function buildVaultLookup(data: VaultPublicDataAll): Map<string, VaultLookupEntry>;
 
 /** Supported ERC-4626 vault providers. */
-type VaultProvider = 'fluid' | 'gearbox' | 'morpho' | 'lista' | 'silo' | 'euler-earn' | 'lst' | 'savings' | 'lagoon' | 'aave-earn' | 'upshift' | 'yearn' | 'hypercore' | 'gmx';
+type VaultProvider = 'fluid' | 'gearbox' | 'morpho' | 'lista' | 'silo' | 'euler-earn' | 'termmax' | 'lst' | 'savings' | 'lagoon' | 'aave-earn' | 'upshift' | 'yearn' | 'hypercore' | 'gmx';
 /**
  * Per-provider payload returned by `getVaultPublicDataAll`. Each entry is
  * present only when the matching provider was requested AND its fetch
@@ -5966,6 +6656,7 @@ interface VaultPublicDataAll {
     lista?: MorphoVaults;
     silo?: SiloVaults;
     'euler-earn'?: EulerEarnVaults;
+    termmax?: TermMaxVaults;
     lst?: LstShareTokens;
     savings?: SavingsVaults;
     lagoon?: LagoonVaults;
@@ -6755,4 +7446,4 @@ interface FetchTokenBalancesOptions {
  */
 declare function fetchTokenBalances(chainId: string, account: string, tokens: string[], options?: FetchTokenBalancesOptions): Promise<TokenBalanceResult>;
 
-export { type AaveMetadata, type AaveV2Public, type AaveV2UserReserveResponse, type AaveV3Public, type AaveV3UserReserveResponse, type AdditionalYields, ApiBookSource, type AprData, type BalanceData, type BaseLendingPosition, type BasicReserveResponse, type ChainDiagnostic, type ChainLinkResponse, type ChainQuery, type ChainSummary, type CompoundV2Metadata, type CompoundV3Public, type CompoundV3UserReserveResponse, type ConfigEntry, type CoreValidators, DEFAULT_MIDNIGHT_API, DEFAULT_OUTLIER_GUARD, DEFAULT_STALE_REJECT_SECONDS, type Denomination, type DepthMap, EMPTY_BALANCE, type EModeAssets, type EModeData, type EModeResult, type EulerEarnVault, type EulerEarnVaults, type EulerV2Metadata, type ExactlyFixedPool, type ExactlyFixedPosition, type ExactlyMarketAccount, type ExactlyMarketsRaw, type ExactlyUserFixedPosition, type ExtraValidationCall, type FeedObservation, type FeedStat, type FeedStatsMap, type FeedTimestampMap, type FetchListaVaultsFromChainOptions, type FetchMorphoVaultsFromChainOptions, type FetchOraclePricesOptions, type FetchTokenBalancesOptions, type FlattenPriorityConfig, type FluidFToken, type FluidFTokens, type FullLenderRewardsMap, GMX_API_HOSTS, GMX_READ_CONTRACTS, GMX_SUPPORTED_CHAINS, type GenericCurrency, type GenericTokenList, type GetVaultPublicDataAllOptions, type GmxExecutionFees, type GmxPendingDeposit, type GmxPendingWithdrawal, type GmxReadContracts, type GmxUserBalance, type GmxUserPositions, type GmxUserPositionsOptions, type GmxVault, type GmxVaultKind, type GmxVaults, type GmxVaultsFetchOptions, type GroupAccumulator, HYPERCORE_VAULT_REGISTRY, type HypercoreLockStatus, type HypercoreUserPositionsOptions, type HypercoreVault, type HypercoreVaultPosition, type HypercoreVaultRegistryEntry, type HypercoreVaults, type HypercoreVaultsFetchOptions, IDLE_MARKET_ID, INTERFACE_IDS, type InitMetadata, type InitPublic, type InitUserReserveResponse, type InterfaceKind, LAGOON_API_URL, LAGOON_CHAIN_IDS, type LagoonApiVault, type LagoonSyncMode, type LagoonVault, type LagoonVaults, type LenderConfigData, type LenderConfigMap, type LenderCrossPoolMeta, type LenderData, type LenderDataEntry, type LenderInfo, type LenderInfoMap, type LenderPublicBase, type LenderRewardsMap, type LenderSummary, type LenderToLenderCrossPoolMeta, type LenderTotalAmounts, type LenderUserQuery, type LenderUserResponse, type LenderYieldComplete, type LenderYields$1 as LenderYields, LendingMode, type LiquityBranchRaw, type LiquityDiscoveredTrove, type LiquityDiscovery, type LiquityMarketsRaw, type LiquitySpInfo, type LiquityTroveInfo, type ListaMarketOverrides, type LoopPostTradeMetrics, type LstDelegation, type LstDelegationKind, type LstValidator, type LstWithdrawalFetchOptions, type LstWithdrawalRegistryEntry, type LstWithdrawalRequest, type LstWithdrawalRequestsByLst, type LstWithdrawalStatus, MORPHO_LENS, MaxParamThresholds, type MergedUserData, type MidnightBook, type MidnightBookLevel, type MidnightBookSource, type ModeBase, type MorphoMarketOverrides, type MorphoSubgraphProxyConfig, type MorphoUserMarketBalance, type MorphoUserReserveResponse, type MorphoVault, type MorphoVaults, type MulticallRpcBatch, type NumberMap, type OracleDiagnostics, type OraclePriceEntry, type OraclePricesResult, type OutlierGuardConfig, type ParsedBalanceData, type ParsedResponse, type ParsedUserBalance, type PermissionParams, type PoolData, type PoolWithMeta, type PortfolioSummary, type PortfolioTotals, type PostTradeMetrics, type PreparedCall, type PreparedMergedMulticallParams, type PreparedMergedRpcCalls, type PreparedTokenBalanceRpcCalls, type PreparedUserDataRpcCalls, type PriceDerivation, type PriceSelection, type ProtocolParams, type ProviderOptions, type RawRpcBatch, type RawRpcCall, type RawRpcResponse, type RiverMarketRaw, type RiverMarketsRaw, type RiverPositionInfo, STABLECOIN_SYMBOLS, STCELO_MANAGER_ADDRESS, type SelectPricesOptions, type SiloVault, type SiloVaults, type StCeloValidatorGroup, type StaleFeedEntry, type StructuredOraclePrices, type SubAccountSummary, type SumerPositionInput, type SummaryAprData, type SummaryBalanceData, TELLER_CALLS_PER_BID, type TellerDiscoveredBid, type TellerDiscovery, type TellerMarketsRaw, type TellerPoolRaw, type TermAuctionOrder, type TermAuctionOrders, type TermBookSource, type TermBookTop, type TermListing, type TermMarketRaw, TermSubgraphSource, type TokenApprovalMeta, type TokenApprovalParams, type TokenBalanceEntry, type TokenBalanceQuery, type TokenBalanceResult, type TokenEntry, type TokenList, type TokenListInput, type TrackerDiagnostic, UPSHIFT_CHAIN_IDS, UPSHIFT_VAULTS_URL, type USDPriceMap, type UpshiftApiAsset, type UpshiftApiVault, type UpshiftVault, type UpshiftVaults, type UserApr, type UserConfig, type UserData, type UserDataResult, type UserLendingPosition, VAULT_SHARE_PRICE_PROBE, VOLATILE_VAULT_OVERRIDES, type VaultAprResult, type VaultClassification, type VaultClassificationFields, type VaultLookupEntry, type VaultMarketExposure, type VaultProvider, type VaultPublicDataAll, type VaultPublicDataResult, type VaultYieldSeries, type VaultYieldSnapshot, type YDaemonVault, YEARN_CHAIN_IDS, YEARN_YDAEMON_BASE, type YearnVault, type YearnVaultKind, type YearnVaults, type YieldProfile, accountDepositListKey, accountWithdrawalListKey, appendSnapshot, applyPositionDelta, attachPricesToFlashLiquidity, buildFluidFTokensCall, buildLiquityUserCall, buildLoopResult, buildMorphoTypeCall, buildMorphoTypeUserCallWithLens, buildPortfolioTotals, buildSumerAccumulators, buildSummaries, buildTellerUserCall, buildVaultLookup, calculateLeverage, calculateNetApr, calculateOverallNetApr, calculateWeightedAverage, classifyFreshness, classifyReliability, classifyVault, collectFeedObservations, computeBorrowDelta, computeCloseTradeDeltas, computeCollateralSwapDeltas, computeDebtSwapDeltas, computeDepositDelta, computeEModeAnalysis, computeOpenTradeDeltas, computePostTradeMetrics, computeRepayDelta, computeSumerBorrowDelta, computeSumerDepositDelta, computeSumerRepayDelta, computeSumerWaterfall, computeSumerWithdrawDelta, computeVaultApr, computeWithdrawDelta, computeZapTradeDeltas, consensusReference, convertExactlyMarketsToResponse, convertLenderUserDataResult, convertLiquityMarketsToResponse, convertRiverMarketsToResponse, convertTellerMarketsToResponse, convertTermMarketsToResponse, createMarketUid, createMidnightBookSource, createMulticallRpcCall, createRawRpcCalls, createTermBookSource, decodeListaMarkets, decodeMarkets, decodePackedListaUserDataset, decodePackedMorphoUserDataset, detectInterfaceKinds, encodeBalanceFetcherCalldata, exactlyLenderKey, exactlyMarketFromLenderKey, exactlyPairLtv, exactlyPenaltyRateToAprPercent, exactlyWadRateToPercent, feedKeyOf, feedStatKey, fetchDolomiteAccountNumbers, fetchEulerEarnVaults, fetchEulerEarnVaultsFromSubgraph, fetchEulerSubAccountIndexes, fetchExactlyMarkets, fetchFlashLiquidityForChain, fetchFluidFTokens, fetchGeneralYields, fetchGeneralYieldsByMarketUid, fetchGmxExecutionFees, fetchGmxTickerPrices, fetchGmxVaults, fetchHypercoreVaults, fetchLagoonApiVaults, fetchLagoonVaults, fetchLiquityMarkets, fetchListaVaultsFromChain, fetchMorphoUserBalances, fetchMorphoUserPositionMarkets, fetchMorphoVaults, fetchMorphoVaultsFromApi, fetchMorphoVaultsFromChain, fetchOraclePrices, fetchPendlePrices, fetchRiverMarkets, fetchSiloVaults, fetchTellerMarkets, fetchTermMarkets, fetchTokenBalances, fetchTokenMetadata, fetchUpshiftApiVaults, fetchUpshiftVaults, fetchYearnApiVaults, fetchYearnVaults, filterActiveLenders, filterLendersByProtocol, fuseLenderData, generateLendingPools, getAavesForChain, getAssetConfig, getBalanceForMarketUid, getBorrowCapacity, getCachedLiquityTroves, getCachedTellerBids, getCoreValidators, getFluidFTokensConverter, getGmxApiHost, getGmxReadContracts, getGmxUserPositions, getHealthFactor, getHypercoreUserPositions, getHypercoreVaultRegistry, getLenderAssets, getLenderPublicData, getLenderPublicDataAll, getLenderPublicDataViaApi, getLenderUserDataMulti, getLenderUserDataResult, getLendersForChain, getLstDelegation, getLstValidators, getLstWithdrawalRegistry, getLstWithdrawalRequests, getMaxAmountClose, getMaxAmountCollateralSwap, getMaxAmountDebtSwap, getMaxAmountOpen, getMergedUserData, getMorphoTypeMarketConverter, getResolvedDolomiteAccountNumbers, getStCeloValidatorGroups, getSubAccountAddress, getSubAccountIndex, getVaultPublicDataAll, getVaultWithdrawalRequests, hasEulerEarnVaultSubgraph, hasLagoonVaults, hasMorphoPositionIndex, hasMorphoUserApi, hasMorphoUserSubgraph, hasUpshiftVaults, hasYearnVaults, isStablecoinSymbol, isYearnV3, keysFromMaps, lenderApiOnly, lenderFamily, liquityCandidateTroveIds, liquityKeyParts, liquityLenderKey, multicall3Abi, nanTo, needsLenderApproval, needsTokenApproval, noOpResult, normalizeToBytes, parseBalanceFetcherResult, parseMergedResult, parseMulticallRpcResponses, parseRawRpcBatchResponses, parseRawRpcResponses, parseTokenBalanceResult, positivePart, prepareLenderUserDataRpcCalls, prepareMergedMulticallParams, prepareMergedRpcCalls, prepareMulticallInputs, prepareTokenBalanceRpcCalls, priceGlvVaults, priceGmMarkets, probeAaveFeedTimestamps, pruneFeedStats, readVaultSharePrices, rejectOutliers as rejectPriceOutliers, resolveDerivation, resolveStCeloDepositGroup, riverKeyParts, riverLenderKey, selectAssetGroupPrices, stampVaultClassification, tellerBpsToPercent, tellerImpliedLtv, tellerLenderKey, tellerPoolFromLenderKey, termLenderKey, tickToAprNumber, tickToPrice, unflattenLenderData, updateFeedStats };
+export { type AaveMetadata, type AaveV2Public, type AaveV2UserReserveResponse, type AaveV3Public, type AaveV3UserReserveResponse, type AdditionalYields, ApiBookSource, type AprData, type BalanceData, type BaseLendingPosition, type BasicReserveResponse, type ChainDiagnostic, type ChainLinkResponse, type ChainQuery, type ChainSummary, type CompoundV2Metadata, type CompoundV3Public, type CompoundV3UserReserveResponse, type ConfigEntry, type CoreValidators, DEFAULT_MIDNIGHT_API, DEFAULT_OUTLIER_GUARD, DEFAULT_STALE_REJECT_SECONDS, DEFAULT_TERMMAX_API, type Denomination, type DepthMap, EMPTY_BALANCE, type EModeAssets, type EModeData, type EModeResult, type EulerEarnVault, type EulerEarnVaults, type EulerV2Metadata, type ExactlyFixedPool, type ExactlyFixedPosition, type ExactlyMarketAccount, type ExactlyMarketsRaw, type ExactlyUserFixedPosition, type ExtraValidationCall, type FeedObservation, type FeedStat, type FeedStatsMap, type FeedTimestampMap, type FetchListaVaultsFromChainOptions, type FetchMorphoVaultsFromChainOptions, type FetchOraclePricesOptions, type FetchTokenBalancesOptions, type FlattenPriorityConfig, type FluidFToken, type FluidFTokens, type FullLenderRewardsMap, GMX_API_HOSTS, GMX_READ_CONTRACTS, GMX_SUPPORTED_CHAINS, type GenericCurrency, type GenericTokenList, type GetVaultPublicDataAllOptions, type GmxExecutionFees, type GmxPendingDeposit, type GmxPendingWithdrawal, type GmxReadContracts, type GmxUserBalance, type GmxUserPositions, type GmxUserPositionsOptions, type GmxVault, type GmxVaultKind, type GmxVaults, type GmxVaultsFetchOptions, type GroupAccumulator, HYPERCORE_VAULT_REGISTRY, type HypercoreLockStatus, type HypercoreUserPositionsOptions, type HypercoreVault, type HypercoreVaultPosition, type HypercoreVaultRegistryEntry, type HypercoreVaults, type HypercoreVaultsFetchOptions, IDLE_MARKET_ID, INTERFACE_IDS, type InitMetadata, type InitPublic, type InitUserReserveResponse, type InterfaceKind, type InverseMarketRaw, type InverseMarketsRaw, type InversePositionInfo, LAGOON_API_URL, LAGOON_CHAIN_IDS, type LagoonApiVault, type LagoonSyncMode, type LagoonVault, type LagoonVaults, type LenderConfigData, type LenderConfigMap, type LenderCrossPoolMeta, type LenderData, type LenderDataEntry, type LenderInfo, type LenderInfoMap, type LenderPublicBase, type LenderRewardsMap, type LenderSummary, type LenderToLenderCrossPoolMeta, type LenderTotalAmounts, type LenderUserQuery, type LenderUserResponse, type LenderYieldComplete, type LenderYields$1 as LenderYields, LendingMode, type LiquityBranchRaw, type LiquityDiscoveredTrove, type LiquityDiscovery, type LiquityMarketsRaw, type LiquitySpInfo, type LiquityTroveInfo, type ListaMarketOverrides, type LoopPostTradeMetrics, type LstDelegation, type LstDelegationKind, type LstValidator, type LstWithdrawalFetchOptions, type LstWithdrawalRegistryEntry, type LstWithdrawalRequest, type LstWithdrawalRequestsByLst, type LstWithdrawalStatus, MORPHO_LENS, MaxParamThresholds, type MergedUserData, type MidnightBook, type MidnightBookLevel, type MidnightBookSource, type ModeBase, type MorphoMarketOverrides, type MorphoSubgraphProxyConfig, type MorphoUserMarketBalance, type MorphoUserReserveResponse, type MorphoVault, type MorphoVaults, type MulticallRpcBatch, type NumberMap, type OracleDiagnostics, type OraclePriceEntry, type OraclePricesResult, type OutlierGuardConfig, type ParsedBalanceData, type ParsedResponse, type ParsedUserBalance, type PermissionParams, type PoolData, type PoolWithMeta, type PortfolioSummary, type PortfolioTotals, type PostTradeMetrics, type PreparedCall, type PreparedMergedMulticallParams, type PreparedMergedRpcCalls, type PreparedTokenBalanceRpcCalls, type PreparedUserDataRpcCalls, type PriceDerivation, type PriceSelection, type ProtocolParams, type ProviderOptions, type RawRpcBatch, type RawRpcCall, type RawRpcResponse, type RiverMarketRaw, type RiverMarketsRaw, type RiverPositionInfo, STABLECOIN_SYMBOLS, STCELO_MANAGER_ADDRESS, type SelectPricesOptions, type SiloVault, type SiloVaults, type StCeloValidatorGroup, type StaleFeedEntry, type StructuredOraclePrices, type SubAccountSummary, type SumerPositionInput, type SummaryAprData, type SummaryBalanceData, TELLER_CALLS_PER_BID, TERMMAX_CALLS_PER_ACCOUNT, DECIMAL_BASE as TERMMAX_DECIMAL_BASE, TERMMAX_LIQUIDATION_PENALTY, TERMMAX_LIQUIDATION_WINDOW_SECS, TERMMAX_LIQUIDATOR_BONUS, TERMMAX_PARTIAL_CLOSE_FACTOR, TERMMAX_PARTIAL_LIQUIDATION_THRESHOLD_USD, type TellerDiscoveredBid, type TellerDiscovery, type TellerMarketsRaw, type TellerPoolRaw, type TermAuctionOrder, type TermAuctionOrders, type TermBookSource, type TermBookTop, type TermListing, type TermMarketRaw, TermMaxApiSource, type TermMaxBookTop, type TermMaxCurveSegment, type TermMaxDataSource, type TermMaxDiscovery, type TermMaxFeeConfig, type TermMaxMarketConfig, type TermMaxMarketRaw, type TermMaxOrderState, TermSubgraphSource, type TokenApprovalMeta, type TokenApprovalParams, type TokenBalanceEntry, type TokenBalanceQuery, type TokenBalanceResult, type TokenEntry, type TokenList, type TokenListInput, type TrackerDiagnostic, UPSHIFT_CHAIN_IDS, UPSHIFT_VAULTS_URL, type USDPriceMap, type UpshiftApiAsset, type UpshiftApiVault, type UpshiftVault, type UpshiftVaults, type UserApr, type UserConfig, type UserData, type UserDataResult, type UserLendingPosition, VAULT_SHARE_PRICE_PROBE, VOLATILE_VAULT_OVERRIDES, type VaultAprResult, type VaultClassification, type VaultClassificationFields, type VaultLookupEntry, type VaultMarketExposure, type VaultProvider, type VaultPublicDataAll, type VaultPublicDataResult, type VaultYieldSeries, type VaultYieldSnapshot, type YDaemonVault, YEARN_CHAIN_IDS, YEARN_YDAEMON_BASE, type YearnVault, type YearnVaultKind, type YearnVaults, type YieldProfile, accountDepositListKey, accountWithdrawalListKey, appendSnapshot, applyPositionDelta, attachPricesToFlashLiquidity, buildFluidFTokensCall, buildLiquityUserCall, buildLoopResult, buildMorphoTypeCall, buildMorphoTypeUserCallWithLens, buildPortfolioTotals, buildSumerAccumulators, buildSummaries, buildTellerUserCall, buildTermMaxUserCall, buildVaultLookup, calculateLeverage, calculateNetApr, calculateOverallNetApr, calculateWeightedAverage, classifyFreshness, classifyReliability, classifyVault, collectFeedObservations, computeBorrowDelta, computeCloseTradeDeltas, computeCollateralSwapDeltas, computeDebtSwapDeltas, computeDepositDelta, computeEModeAnalysis, computeOpenTradeDeltas, computePostTradeMetrics, computeRepayDelta, computeSumerBorrowDelta, computeSumerDepositDelta, computeSumerRepayDelta, computeSumerWaterfall, computeSumerWithdrawDelta, computeVaultApr, computeWithdrawDelta, computeZapTradeDeltas, consensusReference, convertExactlyMarketsToResponse, convertInverseMarketsToResponse, convertLenderUserDataResult, convertLiquityMarketsToResponse, convertRiverMarketsToResponse, convertTellerMarketsToResponse, convertTermMarketsToResponse, convertTermMaxMarketsToResponse, createMarketUid, createMidnightBookSource, createMulticallRpcCall, createRawRpcCalls, createTermBookSource, createTermMaxDataSource, decodeListaMarkets, decodeMarkets, decodePackedListaUserDataset, decodePackedMorphoUserDataset, detectInterfaceKinds, encodeBalanceFetcherCalldata, exactlyLenderKey, exactlyMarketFromLenderKey, exactlyPairLtv, exactlyPenaltyRateToAprPercent, exactlyWadRateToPercent, feedKeyOf, feedStatKey, fetchDolomiteAccountNumbers, fetchEulerEarnVaults, fetchEulerEarnVaultsFromSubgraph, fetchEulerSubAccountIndexes, fetchExactlyMarkets, fetchFlashLiquidityForChain, fetchFluidFTokens, fetchGeneralYields, fetchGeneralYieldsByMarketUid, fetchGmxExecutionFees, fetchGmxTickerPrices, fetchGmxVaults, fetchHypercoreVaults, fetchInverseMarkets, fetchLagoonApiVaults, fetchLagoonVaults, fetchLiquityMarkets, fetchListaVaultsFromChain, fetchMorphoUserBalances, fetchMorphoUserPositionMarkets, fetchMorphoVaults, fetchMorphoVaultsFromApi, fetchMorphoVaultsFromChain, fetchOraclePrices, fetchPendlePrices, fetchRiverMarkets, fetchSiloVaults, fetchTellerMarkets, fetchTermMarkets, fetchTermMaxMarkets, fetchTokenBalances, fetchTokenMetadata, fetchUpshiftApiVaults, fetchUpshiftVaults, fetchYearnApiVaults, fetchYearnVaults, filterActiveLenders, filterLendersByProtocol, fuseLenderData, generateLendingPools, getAavesForChain, getAssetConfig, getBalanceForMarketUid, getBorrowCapacity, getCachedLiquityTroves, getCachedTellerBids, getCachedTermMaxDiscovery, getCachedTermMaxMarket, getCachedTermMaxMarkets, getCoreValidators, getFluidFTokensConverter, getGmxApiHost, getGmxReadContracts, getGmxUserPositions, getHealthFactor, getHypercoreUserPositions, getHypercoreVaultRegistry, getLenderAssets, getLenderPublicData, getLenderPublicDataAll, getLenderPublicDataViaApi, getLenderUserDataMulti, getLenderUserDataResult, getLendersForChain, getLstDelegation, getLstValidators, getLstWithdrawalRegistry, getLstWithdrawalRequests, getMaxAmountClose, getMaxAmountCollateralSwap, getMaxAmountDebtSwap, getMaxAmountOpen, getMergedUserData, getMorphoTypeMarketConverter, getResolvedDolomiteAccountNumbers, getStCeloValidatorGroups, getSubAccountAddress, getSubAccountIndex, getVaultPublicDataAll, getVaultWithdrawalRequests, hasEulerEarnVaultSubgraph, hasLagoonVaults, hasMorphoPositionIndex, hasMorphoUserApi, hasMorphoUserSubgraph, hasUpshiftVaults, hasYearnVaults, inverseKeyParts, inverseLenderKey, isStablecoinSymbol, isYearnV3, keysFromMaps, lenderApiOnly, lenderFamily, liquityCandidateTroveIds, liquityKeyParts, liquityLenderKey, multicall3Abi, nanTo, needsLenderApproval, needsTokenApproval, noOpResult, normalizeToBytes, parseBalanceFetcherResult, parseMergedResult, parseMulticallRpcResponses, parseRawRpcBatchResponses, parseRawRpcResponses, parseTermMaxLtv, parseTokenBalanceResult, positivePart, predictInverseEscrow, prepareLenderUserDataRpcCalls, prepareMergedMulticallParams, prepareMergedRpcCalls, prepareMulticallInputs, prepareTokenBalanceRpcCalls, priceGlvVaults, priceGmMarkets, probeAaveFeedTimestamps, pruneFeedStats, readVaultSharePrices, rejectOutliers as rejectPriceOutliers, resolveDerivation, resolveStCeloDepositGroup, riverKeyParts, riverLenderKey, selectAssetGroupPrices, stampVaultClassification, tellerBpsToPercent, tellerImpliedLtv, tellerLenderKey, tellerPoolFromLenderKey, termLenderKey, termMaxApiBase, borrowNif as termMaxBorrowNif, curveApr as termMaxCurveApr, curveAprNumber as termMaxCurveAprNumber, daysToMaturity as termMaxDaysToMaturity, lendNif as termMaxLendNif, mintGtFeeRatio as termMaxMintGtFeeRatio, ratioToNumber as termMaxRatioToNumber, ratioToPercent as termMaxRatioToPercent, tickToAprNumber, tickToPrice, unflattenLenderData, updateFeedStats };