@1delta/margin-fetcher 0.0.3423 → 5.0.1

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 import { PublicClient, Address, Hex } from 'viem';
 import { Lender } from '@1delta/lender-registry';
-export { isAaveType, isAaveV2Type, isAaveV32Type, isAaveV3Type, isCompoundV3, isCompoundV3Type, isInit, isMorphoType, isMultiMarket, isYLDR } from '@1delta/lender-registry';
+export { hasCrossMarginRisk, 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, ResupplyConfigChain, LlamaLendMarketConfig, LlamaLendConfigChain, LlamaLendChainData, UsddMarketConfig, UsddConfigChain, UsddChainData, FrankencoinMarketConfig, FrankencoinConfigChain, FrankencoinChainData, 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,17 +437,40 @@ 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. */
+/**
+ * A single fixed-term loan, attached to its own entry in the positions array.
+ *
+ * Named for Lista (the first producer) but SHARED by every fixed-term lender
+ * that emits per-loan rows — Lista, Exactly, TermMax, Teller. Fields are
+ * therefore mostly optional and several are lender-specific; see
+ * [FIXED_TERM_REPAY_TERMS.md](../../../../FIXED_TERM_REPAY_TERMS.md) for which
+ * lender populates what and for the exact repay economics behind each number.
+ *
+ * `loanId` is the WRITE TARGET and its meaning differs per lender (Lista posId /
+ * Exactly maturity-as-string / TermMax gtId / Teller bidId) — check the lender
+ * before using it. `termId` is the RATE-MENU id and is NOT interchangeable with
+ * it (Exactly is the only lender where the two coincide, both = maturity).
+ */
 interface ListaTermLoan {
     /** loanId — the repay target for the LISTA_BROKER_REPAY composer op. For fixed loans this is the
-     *  posId; for the dynamic (flexible) loan it is the dynamic sentinel (type(uint128).max). */
+     *  posId; for the dynamic (flexible) loan it is the dynamic sentinel (type(uint128).max).
+     *  Other lenders reuse the slot: Exactly = String(maturity), TermMax = gtId, Teller = bidId. */
     loanId: string;
     /** true for the flexible (dynamic / variable-rate) loan; fixed loans omit it */
     isDynamic?: boolean;
     /** best-effort term product id (matched from duration vs the current menu); may be undefined */
     termId?: number;
-    /** outstanding debt in loan-token units (principal + accrued interest) */
+    /** outstanding debt in loan-token units. Lista: principal + accrued interest.
+     *  Static-face-value lenders (Exactly / TermMax / Term): the EXIT-NOW cost —
+     *  for Exactly that is discounted early and penalty-inflated when overdue, so
+     *  compare against `faceValue` rather than assuming it is the face. */
     debt: string;
     /** locked annualised borrow rate in PERCENT (e.g. 3.857 = 3.857% APR) */
     apr?: number;
@@ -386,9 +479,27 @@ interface ListaTermLoan {
     termDays?: number;
     /** outstanding accrued interest in loan-token units */
     accruedInterest?: string;
-    /** early-repayment penalty (loan-token units) to close the loan now; 0 once matured */
+    /** early-repayment penalty (loan-token units) to close the loan now; 0 once matured.
+     *  Lista only — the OPPOSITE sign to Exactly's `earlyRepayDiscount` below. */
     earlyRepayPenalty?: string;
     isMatured?: boolean;
+    /** amount owed AT maturity (principal + fee). Static — no accrual index; it
+     *  grows only via a late penalty where the protocol has one. */
+    faceValue?: string;
+    /** Exactly: rebate for repaying BEFORE maturity (`faceValue − debt`). Exactly
+     *  never charges an early-repay fee, but this is 0 when the fixed pool has no
+     *  unassigned earnings left, so it is not a guaranteed saving. */
+    earlyRepayDiscount?: string;
+    /** Exactly: penalty accrued so far past maturity (`debt − faceValue`). */
+    latePenalty?: string;
+    /** Exactly: further penalty per additional day overdue — LINEAR on face, not
+     *  compounding. */
+    latePenaltyPerDay?: string;
+    /** annualized late-penalty rate in PERCENT (Exactly `penaltyRate`; ~164 %/yr).
+     *  A mutable market parameter, snapshotted per fetch. */
+    latePenaltyApr?: number;
+    /** seconds past maturity; 0 until overdue */
+    secondsLate?: number;
 }
 interface MorphoLendingPositions extends BaseLendingPositions {
     isWhitelisted?: boolean;
@@ -592,6 +703,18 @@ declare const getLenderPublicDataViaApi: (chainId: string, lenders: string[], pr
     [lender: string]: any;
 }>;
 
+/**
+ * Returns true when the lender should ONLY use the API path (no on-chain
+ * fallback). Currently Morpho-type only — the Morpho GraphQL indexer has
+ * been reliable on every chain it supports, so there's no benefit to
+ * double-fetching.
+ *
+ * Exported so the config-consistency test can assert the invariant that makes
+ * the Morpho list safe: a chain routed to the on-chain path MUST have a
+ * `MORPHO_LENS` entry, otherwise `buildMorphoCall` produces a call with an
+ * undefined address and the chain silently yields no markets at all.
+ */
+declare function lenderApiOnly(lender: string, chainId: string): boolean;
 declare const getLenderPublicDataAll: (chainId: string, lenders: string[], prices: {
     [asset: string]: number;
 }, additionalYields: AdditionalYields, multicallRetry: MulticallRetryFunction, tokenList?: () => Promise<GenericTokenList>, includeUnlistedMorphoMarkets?: boolean) => Promise<{
@@ -664,6 +787,38 @@ declare function createRawRpcCalls(preparedCalls: PreparedCall[], batchSize?: nu
 declare function createMulticallRpcCall(preparedCalls: PreparedCall[], multicallAddress: string, batchSize?: number, blockTag?: string, allowFailure?: boolean): MulticallRpcBatch[];
 
 type Call = GeneralCall;
+/**
+ * Sentinel written into the result array for a call that returned NO data —
+ * a revert, an RPC error, or a whole `aggregate3` chunk that was rejected
+ * (rate limit, subrequest cap, dropped connection: viem marks every call in a
+ * rejected chunk as `status: 'failure'`).
+ *
+ * It is NOT a zero value. Parsers must skip these slots — coercing one to `0`
+ * turns a failed read into a phantom "no balance" position and, worse, makes a
+ * real deposit or debt silently disappear from a user's portfolio.
+ */
+declare const MULTICALL_FAILURE = "0x";
+/** True when a multicall slot holds no usable data (see {@link MULTICALL_FAILURE}). */
+declare const isFailedCall: (value: unknown) => boolean;
+/** Reported for each endpoint that failed to serve a batch. */
+interface EndpointFailure {
+    chainId: string;
+    /** Endpoint URL, or `rpc#<id>` when the transport does not expose one. */
+    url: string;
+    rpcId: number;
+    /** `transport` — the request itself died. `slots` — it answered with nothing but failures. */
+    kind: 'transport' | 'slots';
+}
+interface MulticallEndpointOptions {
+    /**
+     * Endpoint URLs already attempted for this call set. Failover consults it so
+     * a retry lands on an endpoint that has NOT already failed — see
+     * {@link resolveEndpoint}.
+     */
+    tried?: Set<string>;
+    /** Invoked for every endpoint that fails, so callers can demote it. */
+    onEndpointFailure?: (info: EndpointFailure) => void;
+}
 declare function prepareMulticallInputs(abi: any[], calls: Call[]): PreparedCall[];
 
 interface PreparedUserDataRpcCalls {
@@ -926,33 +1081,106 @@ type UserData = {
      * not as the user's full position.
      */
     incomplete?: boolean;
+    /**
+     * Set when this entry did NOT come from the current read: the live read failed
+     * and a previously COMPLETE snapshot was served in its place. The position was
+     * accurate as of `staleAgeMs` ago; it is not a partial read (those are
+     * `incomplete`) and it is never served for a lender that read successfully.
+     */
+    stale?: boolean;
+    /** Age of the served snapshot in ms. Only set alongside `stale`. */
+    staleAgeMs?: number;
 };
 
-/** Reported per lender whose multicall slice contained failed reads. */
+/**
+ * How a lender's slice reacts to a failed read.
+ *
+ * Note what this is NOT keyed on: "is the position cross-margin". EVERY position
+ * with debt is corrupted by a lost read — an isolated Morpho market computes its
+ * health from a collateral read and a debt read, so losing either fabricates the
+ * same nonsense a lost Aave reserve does. The question here is narrower and
+ * purely mechanical: **what is the smallest thing we can void?** A failed slot
+ * carries no market label, so the only unit we can void is the lender key.
+ *
+ * - `strict` — void the whole slice on any lost read. Correct when the slice
+ *   resolves to ONE risk computation, which is true both for a single-market
+ *   lender and for a multi-market lender that is nevertheless cross-margin
+ *   (Exactly scores every market under one per-chain Auditor). Nothing smaller
+ *   can be voided, and publishing the remainder would publish a fiction.
+ * - `lenient` — publish, flag `incomplete`, and let per-record invariant
+ *   validation catch the corrupted one. Correct ONLY when the slice fans out to
+ *   many INDEPENDENT isolated positions, where voiding the key would discard
+ *   hundreds of intact markets to hide one — a cure worse than the disease.
+ *
+ * So leniency requires BOTH properties: many independent positions AND no shared
+ * risk computation across them.
+ */
+type ReadFailurePolicy = 'strict' | 'lenient';
+declare const getReadFailurePolicy: (lender: string) => ReadFailurePolicy;
+/** Why a lender's slice did not convert cleanly. */
+type IncompleteReason = 
+/** Every read in the slice failed. */
+'all-reads-failed'
+/** Reads failed on a strict lender — the whole risk set was voided. */
+ | 'partial-read-cross-margin'
+/** Reads failed on a lenient lender — surviving markets were published. */
+ | 'partial-read'
+/** The converter threw. */
+ | 'converter-error'
+/** The converted entry asserted something that cannot be true. */
+ | 'invariant-violation';
+/** Reported per lender whose multicall slice did not convert cleanly. */
 interface IncompleteLenderRead {
     lender: string;
     /** Number of slots in the lender's slice that returned no data. */
     failedCalls: number;
+    /**
+     * Subset of `failedCalls` that could plausibly succeed on a re-read — i.e.
+     * excluding calls known to have reverted. Zero means re-fetching this lender
+     * is pointless: the markets in question always revert for this account.
+     * Equals `failedCalls` when no `permanentFailures` set was supplied.
+     */
+    retryableFailedCalls: number;
     /** Size of the lender's slice. */
     totalCalls: number;
-    /** True when EVERY read failed and the lender was skipped entirely. */
+    /** True when nothing was published for this lender. */
     dropped: boolean;
+    /** What went wrong. */
+    reason: IncompleteReason;
+    /** Extra context for logs (converter message, violation details). */
+    detail?: string;
 }
 interface ConvertLenderUserDataOptions {
-    /** Invoked once per lender with failed reads — for logging / surfacing. */
+    /** Invoked once per lender that did not convert cleanly — for logging / surfacing. */
     onIncomplete?: (info: IncompleteLenderRead) => void;
+    /**
+     * Indices (into `rawResults`) of calls that failed deterministically, as
+     * collected by `getLenderUserDataResult`. Used only to compute
+     * `retryableFailedCalls`.
+     */
+    permanentFailures?: Set<number>;
 }
 /**
  * Converts the raw results into the desired format
  *
  * Slots that hold the multicall failure sentinel are NOT data: a failed read
- * says nothing about the user's position. When every read for a lender failed
- * the lender is skipped outright — converting would emit an all-zero entry that
- * is indistinguishable from "user has no position here", which is how a
- * rate-limited RPC ends up rendering phantom $0 rows (and, when only some calls
- * fail, understated balances). Partial failures still convert — the readable
- * positions are real — but are flagged `incomplete` and reported via
- * `options.onIncomplete`.
+ * says nothing about the user's position. Coercing one to zero is how a
+ * rate-limited RPC ends up rendering phantom $0 rows and understated balances,
+ * so failures are handled explicitly, in three gates:
+ *
+ *  1. **Failure policy** (see {@link ReadFailurePolicy}). Every read failing
+ *     drops the lender under either policy. Beyond that, a `strict`
+ *     (cross-margin) lender drops on ANY failure because its aggregates are only
+ *     meaningful over the complete set, while a `lenient` (multi-market) lender
+ *     publishes the markets that did read and is flagged `incomplete`.
+ *  2. **Converter errors** are reported rather than swallowed — a throwing
+ *     converter used to leave a lender silently absent, indistinguishable from a
+ *     user with no position there.
+ *  3. **Invariant validation** (see `validate.ts`) rejects sub-accounts that
+ *     cannot be true regardless of how the reads went — a `NaN` anywhere in the
+ *     aggregates, or (alongside failed reads) debt with no collateral behind it.
+ *
+ * Anything published after that is either complete or explicitly marked as not.
  *
  * @param chainId - The chain ID
  * @param queriesRaw - The queries to fetch data for
@@ -965,6 +1193,53 @@ declare const convertLenderUserDataResult: (chainId: string, queriesRaw: LenderU
     [lender: string]: UserData;
 };
 
+/**
+ * Why this exists SEPARATELY from the failure sentinels
+ * -----------------------------------------------------
+ * The sentinel path (`isFailedCall`) catches reads that announced themselves as
+ * failures. This catches the ones that did not: a decodable-but-wrong response,
+ * a market whose metadata went missing so its price resolved to `undefined`, a
+ * converter that divided by a zero it should never have seen. Those produce the
+ * SAME user-visible artefact as a dropped read — a debt with no collateral, a
+ * `NaN` health factor — while every slot reports success.
+ *
+ * So this is the last gate before a position is published: it asserts what must
+ * be true of any real lending position, independent of how the data was
+ * obtained.
+ */
+/** One failed assertion about a sub-account's published shape. */
+interface InvariantViolation {
+    /** Sub-account this fired on (`accountId`). */
+    accountId: string;
+    /** Machine-readable check name. */
+    code: 'non-finite' | 'debt-without-collateral' | 'invalid-mode';
+    /** Human-readable detail for logs. */
+    detail: string;
+    /**
+     * `true` when the violation is only conclusive because the read was also
+     * known-incomplete (see {@link validateUserData}).
+     */
+    requiresFailedReads: boolean;
+}
+interface ValidationResult {
+    /** Sub-accounts that passed. Empty means the whole entry must be dropped. */
+    kept: UserDataForSubAccount[];
+    /** Every violation found, including ones on kept sub-accounts. */
+    violations: InvariantViolation[];
+    /** Sub-account ids dropped as corrupt. */
+    dropped: string[];
+}
+/**
+ * Validates a converted entry and drops the sub-accounts that cannot be true.
+ *
+ * `hadFailedReads` gates the checks whose violation is ambiguous on its own:
+ * with a known-incomplete read, `debt-without-collateral` is the signature of a
+ * dropped collateral slot and the sub-account is corrupt; with a clean read it
+ * is a genuine (if grim) position and is kept. Unconditional checks — anything
+ * non-finite — fire either way, because no read produces those legitimately.
+ */
+declare function validateUserData(userData: UserData, hadFailedReads: boolean): ValidationResult;
+
 interface ExposureInfo {
     asset: GenericCurrency;
     collateralFactor: number;
@@ -1004,9 +1279,17 @@ declare function unflattenLenderData(pools: PoolWithMeta[]): LenderData;
  * @param logs - show multicall error logs, default is false
  * @param concurrency - number of distinct RPC endpoints to shard batches
  *   across in parallel; <= 1 keeps the legacy single-endpoint path
+ * @param permanentFailures - optional collector filled with the indices of
+ *   calls that failed DETERMINISTICALLY (revert / no code / unknown selector)
+ *   rather than because of the RPC. Pass it to
+ *   {@link convertLenderUserDataResult} so a caller can tell "this market
+ *   always reverts" from "this read was lost" and only re-fetch the latter.
+ * @param onEndpointFailure - optional hook invoked for every RPC endpoint that
+ *   fails to serve a batch. Only the caller knows where to persist that (KV,
+ *   metrics), and without it every request rediscovers the same bad endpoint.
  * @returns The raw results from the multicall, "0x" for failures
  */
-declare const getLenderUserDataResult: (chainId: string, queriesRaw: LenderUserQuery[], getEvmClient: GetEvmClientFunction, allowFailure?: boolean, batchSize?: number, retries?: number, logs?: boolean, concurrency?: number) => Promise<any[]>;
+declare const getLenderUserDataResult: (chainId: string, queriesRaw: LenderUserQuery[], getEvmClient: GetEvmClientFunction, allowFailure?: boolean, batchSize?: number, retries?: number, logs?: boolean, concurrency?: number, permanentFailures?: Set<number>, onEndpointFailure?: (info: EndpointFailure) => void) => Promise<any[]>;
 /**
  * Prepares the RPC calls for fetching user data without executing them
  * Uses multicall3 aggregate3 to batch all calls into a single RPC call
@@ -1361,6 +1644,21 @@ interface LenderDataEntry extends Omit<LenderSummary, 'subAccounts'> {
     account: string;
     lenderInfo?: LenderInfo;
     data: UserDataForSubAccount[];
+    /**
+     * Set when some of this lender's on-chain reads could not be completed. The
+     * positions listed are real but the set is a LOWER BOUND — anything derived
+     * from the whole picture (NAV, net APR, health factor) is unreliable and must
+     * not be rendered as fact.
+     */
+    incomplete?: boolean;
+    /**
+     * Set when this entry was served from the last COMPLETE snapshot because the
+     * live read failed. Internally consistent — unlike `incomplete` — but as of
+     * `staleAgeMs` ago rather than now.
+     */
+    stale?: boolean;
+    /** Age of the served snapshot in ms. Only set alongside `stale`. */
+    staleAgeMs?: number;
 }
 /**
  * Input type for buildSummaries - user data result from convertLenderUserDataResult
@@ -1472,6 +1770,26 @@ interface MarketBook {
     bids: PublicBookLevel[];
     asks: PublicBookLevel[];
 }
+/**
+ * One entry in a fixed-term rate menu. Lives on `params.market.terms` for
+ * single-borrowable-asset markets, and on `data[*].terms` for cross-margin
+ * multi-asset lenders (Exactly), where each asset has its own fixed pools.
+ *
+ * `termId` semantics are LENDER-SPECIFIC — Exactly/TermMax = the unix maturity,
+ * Teller = duration in seconds, Lista = the broker product id, Midnight/Term =
+ * `0` placeholder. See FIXED_TERM_REPAY_TERMS.md.
+ */
+interface MarketTermEntry {
+    termId: number;
+    durationSecs: number;
+    durationDays: number;
+    /** annualised borrow rate in PERCENT (e.g. 3.857 = 3.857% APR) */
+    apr: number;
+    /** annualised fixed LEND rate in PERCENT at this maturity (Exactly only) */
+    depositApr?: number;
+    /** borrowable liquidity at this maturity, loan-token human units (Exactly only) */
+    available?: number;
+}
 interface MorphoMarket {
     /** the 1delta lender enum */
     lender: string;
@@ -1502,19 +1820,13 @@ interface MorphoMarket {
     /** IRM rate floor */
     rateFloor?: string;
     /** Fixed-term rate menu — available term products (Lista brokered markets,
-     *  Term/Midnight single-maturity markets, Exactly multi-maturity markets —
-     *  for Exactly `termId` = the pool's unix maturity timestamp). */
-    terms?: {
-        termId: number;
-        durationSecs: number;
-        durationDays: number;
-        /** annualised borrow rate in PERCENT (e.g. 3.857 = 3.857% APR) */
-        apr: number;
-        /** annualised fixed LEND rate in PERCENT at this maturity (Exactly only) */
-        depositApr?: number;
-        /** borrowable liquidity at this maturity, loan-token human units (Exactly only) */
-        available?: number;
-    }[];
+     *  Term/Midnight single-maturity markets).
+     *
+     *  MARKET-LEVEL menu, valid only when the lender key has ONE borrowable asset
+     *  (every isolated-market fixed-term lender). CROSS-MARGIN multi-asset
+     *  lenders — Exactly — carry a menu PER ASSET on `data[*].terms` instead,
+     *  since each asset has its own fixed pools. */
+    terms?: MarketTermEntry[];
     /**
      * Canonical cross-protocol fixed-term descriptor (Lista brokered + Morpho
      * Midnight). Present on fixed-rate/fixed-maturity markets only. See
@@ -1565,7 +1877,7 @@ interface MorphoGeneralPublicResponse {
              *  - `'zeroInterest'` — NO ongoing rate at all (River/Satoshi). The borrow
              *                    cost is the one-off `originationFee`, not an APR.
              */
-            rateModel?: 'variable' | 'userSet' | 'fixedTerm' | 'zeroInterest';
+            rateModel?: 'variable' | 'userSet' | 'fixedTerm' | 'zeroInterest' | 'dbr' | 'protocolSet';
             /**
              * One-off fee charged ONCE at borrow time, as a PERCENT of the amount
              * borrowed (e.g. `0.5` = 0.5%). Front-loaded cost that is NOT an APR and
@@ -1575,6 +1887,20 @@ interface MorphoGeneralPublicResponse {
              * only for an effective-cost-since-open view.
              */
             originationFee?: number;
+            /**
+             * PER-ASSET fixed-term rate menu, for CROSS-MARGIN multi-asset fixed-term
+             * lenders (Exactly): one lender key covers every asset, and each asset has
+             * its own fixed pools, so the menu cannot live on `params.market`.
+             * Isolated-market fixed-term lenders (Midnight, Term, Lista broker,
+             * TermMax, Teller) keep using `params.market.terms` — read that as the
+             * fallback when this is absent.
+             */
+            terms?: MarketTermEntry[];
+            /**
+             * PER-ASSET fixed-term descriptor, same rationale as `terms` above
+             * (Exactly). Falls back to `params.market.fixedTerm` when absent.
+             */
+            fixedTerm?: FixedTermInfo;
             rewards?: RewardsList;
             decimals: number;
             config: {
@@ -2065,7 +2391,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
@@ -2074,7 +2400,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
@@ -2105,7 +2431,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
@@ -2222,14 +2548,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;
 }
 
 /**
@@ -2261,7 +2621,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`
@@ -2270,20 +2630,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>;
     /**
@@ -2296,7 +2665,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.
@@ -2390,26 +2759,46 @@ interface ExactlyMarketsRaw {
  */
 declare function fetchExactlyMarkets(chainId: string): Promise<ExactlyMarketsRaw>;
 
-/** Synthesized per-market lender key, e.g. `EXACTLY_<MARKET_ADDRESS_HEX_UPPER>`. */
-declare function exactlyLenderKey(market: string): string;
-/** Recover the Market address from an `EXACTLY_<HEX>` lender key (or undefined). */
-declare function exactlyMarketFromLenderKey(lender: string): string | undefined;
 /**
- * Map the on-chain Previewer batch into the shared `MorphoGeneralPublicResponse`
- * shape (identical to Midnight/Term), keyed by `EXACTLY_<MARKET_ADDRESS>` — one
- * key per asset Market (NOT per maturity; the maturity menu is the market's
- * `params.market.terms[]`, `termId` = maturity timestamp).
+ * The ONE Exactly lender key per chain.
  *
- * Per market:
- *  - the LOAN entry carries the FLOATING rates (`depositRate` /
- *    `variableBorrowRate`) plus the best live fixed borrow APR on
- *    `stableBorrowRate`; its own asset is also collateral (self-pair
- *    adjustFactor²) since Exactly is cross-margin;
- *  - one COLLATERAL entry per SIBLING market (cross-margin: any entered market
- *    collateralizes any borrow) with pairwise LTV = adjF_coll × adjF_borrow
- *    (multiplicative, Dolomite-style) and the Auditor liquidation bonus;
- *  - `params.market.fixedTerm` = `{ model: 'exactly', earlyRepay: 'discount',
- *    fees.latePenaltyApr }` — see the wrapper README for the repay mechanics.
+ * Exactly is a CROSS-MARGIN protocol: a single per-chain `Auditor` (a
+ * Compound-V2-shaped comptroller, NOT a Euler controller) holds one
+ * `enterMarket` bitmap per account, every entered deposit backs debt in ANY
+ * market simultaneously, and health is one global check. The per-asset `Market`
+ * contracts exist because each is the ERC-4626 share token for its asset and
+ * carries that asset's rates / fixed pools — exactly like cUSDC and cETH under
+ * one Comptroller. They are NOT isolated markets.
+ *
+ * So Exactly is modeled like Compound V2: ONE lender key, one entry per asset.
+ * (It was previously split into synthesized `EXACTLY_<MARKET_ADDR>` keys — that
+ * only ever existed because `terms[]` / `fixedTerm` lived on `params.market`,
+ * which assumes one borrowable asset per key. Both now also exist per asset on
+ * `data[*]`, so the split is gone along with the cross-margin collateral
+ * mirroring, the double-count hazard and the optimistic per-key health it
+ * forced. Resolve a Market contract from the ASSET via
+ * `exactlyMarketByAsset(chainId, asset)` — or from the entry's `poolId`.)
+ */
+declare const EXACTLY_LENDER_KEY = "EXACTLY";
+/**
+ * Map the on-chain Previewer batch into the shared `MorphoGeneralPublicResponse`
+ * shape, under the SINGLE cross-margin {@link EXACTLY_LENDER_KEY} — one entry
+ * per ASSET (the Compound V2 shape), never one key per Market.
+ *
+ * Per asset entry:
+ *  - FLOATING rates (`depositRate` / `variableBorrowRate`) plus the best live
+ *    fixed borrow APR on `stableBorrowRate`;
+ *  - its OWN `terms[]` maturity menu (`termId` = the pool's maturity) and its
+ *    OWN `fixedTerm` descriptor pointing at that asset's Market — per-asset
+ *    because each asset has its own fixed pools;
+ *  - risk as `collateralFactor = adjustFactor` + `borrowFactor = 1/adjustFactor`,
+ *    which is the Auditor's own formula (their product = the pairwise LTV);
+ *  - `poolId` / `exactly.market` = the Market contract (the write target).
+ *
+ * Every asset is simultaneously borrowable AND collateral for every other, so
+ * there are no sibling-collateral rows. `params.market` carries only the
+ * pool-wide descriptor (Auditor as `id`, a market-level `fixedTerm` without a
+ * provider address). See the wrapper README for the repay mechanics.
  */
 declare function convertExactlyMarketsToResponse(raw: ExactlyMarketsRaw, chainId: string, prices?: {
     [asset: string]: number;
@@ -2435,7 +2824,15 @@ declare function exactlyPenaltyRateToAprPercent(penaltyRatePerSecond: bigint | u
  */
 declare function exactlyPairLtv(collateralAdjustFactor: bigint | undefined, borrowAdjustFactor: bigint | undefined): number;
 
-/** Per-position fixed-term detail attached to the position row (strings raw). */
+/**
+ * Per-position fixed-term detail attached to the position row (raw strings).
+ *
+ * Carries the FULL exit economics so a repay/withdraw UI needs no second read:
+ * `faceValue` is what is owed/paid at maturity, `previewValue` is what the exit
+ * actually costs/pays RIGHT NOW, and exactly one of `earlyRepayDiscount` /
+ * `earlyExitCost` / `latePenalty` explains the gap. See the "repay terms"
+ * section of the Exactly README for the source-verified formulas.
+ */
 interface ExactlyUserFixedPosition {
     /** unix maturity */
     maturity: number;
@@ -2445,12 +2842,32 @@ interface ExactlyUserFixedPosition {
     principal: string;
     /** face fee locked at trade time (raw asset units) */
     fee: string;
+    /** face value at maturity = principal + fee. Static — Exactly fixed debt does
+     *  NOT accrue an index; it only grows via the late penalty below. */
+    faceValue: string;
     /** live exit value now: withdraw-now / repay-now incl. discount or overdue
      *  penalty (raw asset units) — from the Previewer */
     previewValue: string;
     /** true once maturity passed and the position is still open (borrows accrue
      *  the per-second late penalty until repaid) */
     overdue: boolean;
+    /** seconds past maturity (0 until overdue) */
+    secondsLate: number;
+    /** BORROW before maturity: face − repay-now, the REBATE for repaying early
+     *  (Exactly never charges an early-repay fee). Absent otherwise. */
+    earlyRepayDiscount?: string;
+    /** DEPOSIT before maturity: face − payout-now, the HAIRCUT for exiting a
+     *  fixed deposit early (sold back at the current curve rate). Absent
+     *  otherwise. */
+    earlyExitCost?: string;
+    /** BORROW past maturity: repay-now − face, penalty accrued SO FAR. Absent
+     *  otherwise. */
+    latePenalty?: string;
+    /** BORROW: penalty this position accrues per further day overdue (raw units,
+     *  linear on face — not compounding). Present for borrows only. */
+    latePenaltyPerDay: string;
+    /** market's linear late-penalty rate as an annualized percent (e.g. 164.24) */
+    latePenaltyApr: number;
 }
 
 /**
@@ -2695,6 +3112,682 @@ 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;
+    /**
+     * `Market.replenishmentIncentiveBps` (1000 = 10%) — the replenisher
+     * bot's cut of a force-replenish, per market. It is carved OUT of the
+     * `replenishmentPriceBps` cost and paid in DOLA from the market's own
+     * liquidity; the borrower's debt grows by the FULL cost either way, so
+     * this is a protocol/bot split, not an extra borrower charge.
+     */
+    replenishmentIncentiveBps: 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;
+};
+
+/**
+ * The immutable half of a Resupply pair. Cached across refreshes because none
+ * of it can change: `collateral` and `underlying` are set in the pair's
+ * constructor and there is no setter (`setConvexPool` only moves where the
+ * SHARES are staked, never what the collateral token is).
+ */
+interface ResupplyPairIdentity {
+    pair: string;
+    /** e.g. `Resupply Pair (CurveLend: crvUSD/sfrxUSD) - 1`. */
+    name: string;
+    /** The ERC-4626 share of the WRAPPED market — the accounting unit. */
+    collateral: string;
+    /** What the user actually deposits and withdraws: crvUSD or frxUSD. */
+    underlying: string;
+    collateralDecimals: number;
+    underlyingDecimals: number;
+}
+/**
+ * One Resupply pair after the state batch. Raw bigints; `null` = failed
+ * allowFailure read.
+ */
+interface ResupplyPairRaw {
+    identity: ResupplyPairIdentity;
+    /** 1e5-scaled (95000 = 95%). */
+    maxLTV: bigint | null;
+    /** Debt ceiling. ZERO ⇒ paused/retired — this is the liveness signal. */
+    borrowLimit: bigint | null;
+    /** 1e5-scaled penalty on top of the debt at liquidation. */
+    liquidationFee: bigint | null;
+    /** 1e5-scaled fee added to minted debt (0 on every live pair). */
+    mintFee: bigint | null;
+    /** Hard per-position floor (1,000 reUSD). */
+    minimumBorrowAmount: bigint | null;
+    /** Face reUSD debt, interest previewed. */
+    totalBorrowAmount: bigint | null;
+    totalBorrowShares: bigint | null;
+    /** Collateral SHARES held by the pair. */
+    totalCollateral: bigint | null;
+    /** 1e18-scaled per SECOND, from `currentRateInfo` (last checkpoint). */
+    ratePerSec: bigint | null;
+    /** Same, but recomputed live by the Utilities lens — preferred. */
+    liveRatePerSec: bigint | null;
+    /** The WRAPPED market's supply rate per second, 1e18-scaled. */
+    underlyingSupplyRatePerSec: bigint | null;
+    /** `convertToAssets(1e18)` on the collateral vault — UNDERLYING per share.
+     *  ~1e15 for Curve Lend vaults, ~1e18 for Fraxlend pairs. */
+    collateralPrice: bigint | null;
+    /** Cached `1e36 / collateralPrice` from the pair (stale between writes). */
+    exchangeRate: bigint | null;
+}
+interface ResupplyMarketsRaw {
+    lender: string;
+    config?: ResupplyConfigChain;
+    pairs: ResupplyPairRaw[];
+}
+
+/**
+ * Fetch every Resupply market on a chain — FULLY ON-CHAIN, no API and no
+ * published market roster.
+ *
+ * Discovery is `ResupplyRegistry.getAllPairAddresses()`. That is deliberate:
+ * governance adds pairs (7 appeared between the docs' published list and
+ * 2026-08) and retires them by zeroing `borrowLimit`, so a static file would
+ * both miss new markets and advertise frozen ones as borrowable. The registry
+ * is permissionless to read and is the same source the protocol's own
+ * periphery uses.
+ *
+ * Three rounds cold, two warm:
+ *   1. registry → pair addresses (intersected with `pairAllowlist` if set);
+ *   2. identity (`name`/`collateral`/`underlying` + both tokens' decimals) for
+ *      pairs not already cached — immutable, so this is once per pair ever;
+ *   3. state: terms, accounting, rates and the collateral vault's share price.
+ *
+ * The rate is read from the `Utilities` lens rather than `currentRateInfo`,
+ * which is only a checkpoint from the last write — on a quiet pair that can be
+ * hours stale, and the off-peg amplifier moves with the reUSD price. The
+ * checkpoint is kept as a fallback.
+ */
+declare function fetchResupplyMarkets(lender: string, chainId: string): Promise<ResupplyMarketsRaw>;
+
+/**
+ * The external lending market a Resupply pair wraps.
+ *
+ * Every Resupply pair's collateral IS another lender's supply position, so a
+ * position here carries that market's risk on top of Resupply's own. This
+ * resolves the link where we can: the collateral vault is matched against the
+ * LlamaLend roster by ADDRESS (LlamaLend indexes markets by Controller, so the
+ * lookup goes through `llamaLendMarketByVault`).
+ *
+ * Verified 2026-08-04: 16 of the 21 registered pairs match a LlamaLend market
+ * exactly, and the generation agrees independently — Resupply's own
+ * `CurveLend:` names map to LlamaLend `version: 1` and `CurveLendV2:` to
+ * `version: 2`. The other 5 are Fraxlend pairs, which we do not integrate as a
+ * lender, so they resolve to `provider: 'fraxlend'` with no market key.
+ */
+interface ResupplyWrappedMarket {
+    /** Which protocol the collateral position lives in. */
+    provider: 'llamalend' | 'fraxlend' | 'unknown';
+    /** The ERC-4626 the pair custodies — always known (it IS the collateral). */
+    vault: string;
+    /** `LLAMALEND_<CONTROLLER_ADDR>` when we integrate that market, else absent.
+     *  This is the key to look the wrapped market up in our own data. */
+    lender?: string;
+    /** LlamaLend Controller (the borrow surface of the wrapped market). */
+    controller?: string;
+    /** LlamaLend LLAMMA. Carried because a leverage route through Resupply must
+     *  never touch it — the wrapped Controller asserts its band state. */
+    amm?: string;
+    /** 1 = `oneway`, 2 = `oneway-v2`. Matches Resupply's CurveLend/CurveLendV2. */
+    version?: 1 | 2;
+    /** What the wrapped market lends against, e.g. `sfrxUSD`. */
+    collateralSymbol?: string;
+}
+/**
+ * Synthesized per-pair lender key, e.g. `RESUPPLY_1_C5184CCC…`. The chain id
+ * rides in the key (Fluid/River/Frankencoin convention) even though Resupply
+ * is Ethereum-only today.
+ */
+declare function resupplyLenderKey(lender: string, chainId: string | number, pair: string): string;
+/** Recover `{ lender, chainId, pair }` from a per-pair key. */
+declare function resupplyKeyParts(key: string): {
+    lender: string;
+    chainId: string;
+    pair: string;
+} | undefined;
+/**
+ * Map one Resupply deployment's on-chain batch into the shared
+ * `MorphoGeneralPublicResponse` shape, keyed `RESUPPLY_<chainId>_<PAIR>`.
+ *
+ * Four modelling decisions worth knowing (all from RESUPPLY_PLAN.md):
+ *
+ *  - **The collateral we publish is the UNDERLYING (crvUSD / frxUSD), not the
+ *    ERC-4626 share.** The share is an internal accounting unit that no token
+ *    list carries and no price feed covers, and both user-facing entry points
+ *    (`addCollateral` / `removeCollateral`) are denominated in the underlying.
+ *    Share amounts are converted with the vault's own
+ *    `convertToAssets(1e18)` — the exact number Resupply's oracle uses. NB
+ *    that price is ~**1e15** for Curve Lend vaults, so the share count is
+ *    ~1000x the underlying; a bare 1e18 divide is wrong by three orders of
+ *    magnitude.
+ *  - **The collateral carries the wrapped market's yield.** A Resupply deposit
+ *    is a Curve Lend / Fraxlend supply position, so `getUnderlyingSupplyRate`
+ *    is published as the collateral row's `intrinsicYield`. Without it the
+ *    position looks like it pays nothing, when in fact the whole product is
+ *    the spread between that and the ~half-of-it borrow rate.
+ *  - **`borrowLimit == 0` means PAUSED.** `pause()` zeroes it and there is no
+ *    `isPaused`; 9 of 21 pairs sat at zero at integration. Such a pair is
+ *    reported frozen and non-borrowable, but deposits/withdrawals stay open so
+ *    users can exit.
+ *  - **There is no supply side** — reUSD is minted — so `totalDeposits` on the
+ *    loan row is 0 and `depositRate` is 0. The earn leg is sreUSD, which
+ *    belongs to the savings provider.
+ */
+declare function convertResupplyMarketsToResponse(raw: ResupplyMarketsRaw, chainId: string, prices?: {
+    [asset: string]: number;
+}, _additionalYields?: AdditionalYields, tokens?: GenericTokenList): {
+    [m: string]: MorphoGeneralPublicResponse;
+};
+
+/** Per-position Resupply detail attached to the debt row (raw strings). */
+interface ResupplyPositionInfo {
+    /** Internal borrow shares. NOT an amount — see `debt` for reUSD units. */
+    borrowShares: string;
+    /** Collateral in VAULT SHARES (the pair's own accounting unit). */
+    collateralShares: string;
+    /** `convertToAssets(1e18)` on the collateral vault at read time — the
+     *  factor that turned those shares into the reported underlying. ~1e15 for
+     *  Curve Lend vaults. */
+    collateralSharePrice: string;
+    /** The pair contract — the market id and every write target. */
+    pair: string;
+    /** The collateral vault (Curve Lend / Fraxlend 4626 share token). */
+    collateralVault: string;
+}
+
+/** Test seam — drops the roster + discovery caches. */
+declare function __resetResupplyUserCaches(): void;
+
+/** 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;
+    /** `DBR.debts(user)` (raw DOLA) — debt across ALL FiRM markets, which is
+     *  what burns DBR at 1 per DOLA-year. Chain-wide, repeated on every row. */
+    dbrTotalDebt: string;
+    /** Seconds until `dbrBalance` is exhausted at that burn ('0' if no debt). */
+    dbrRunwaySeconds: string;
+    /** Unix seconds of the projected depletion — past that point anyone can
+     *  force-replenish the account, charging the replenished DBR to its DOLA
+     *  debt at `replenishmentPriceBps`, and withdrawals freeze. Absent when
+     *  there is no debt. */
+    dbrDepletionTimestamp?: string;
+}
+
+/**
+ * Per-market snapshot of a LlamaLend market. Amounts are HUMAN units (the
+ * Curve API serves human numbers; the on-chain fallback normalizes to match).
+ * Rates are DECIMALS (0.0391 = 3.91% APR), nominal — never the compounded
+ * `borrowApy` the API also carries.
+ *
+ * `null` marks a value the active source could not provide; the converter
+ * degrades per field rather than dropping the market.
+ */
+interface LlamaLendMarketRaw {
+    market: LlamaLendMarketConfig;
+    /** Controller.total_debt — borrowed-token units (human). */
+    totalDebt: number | null;
+    /** Vault.totalAssets — borrowed-token units (human). */
+    totalSupplied: number | null;
+    /**
+     * Borrowable right now. v2: `Controller.available_balance()`. v1:
+     * `borrowedToken.balanceOf(controller)`. This is also the withdrawal
+     * ceiling for lenders — the vault cannot pay out what is lent.
+     */
+    availableToBorrow: number | null;
+    /** Nominal borrow APR as a decimal. */
+    borrowApr: number | null;
+    /** Nominal lend APR as a decimal. */
+    lendApr: number | null;
+    /** Collateral price in borrowed-token terms, from the AMM's EMA oracle. */
+    collateralPrice: number | null;
+    /** USD price of the collateral, API only (the chain read has no USD leg). */
+    collateralPriceUsd: number | null;
+    /** USD price of the borrowed token, API only. */
+    borrowedPriceUsd: number | null;
+    /**
+     * Effective collateral factor at the market's `defaultBands`, derived from
+     * `max_borrowable(1 unit, N)` divided by the oracle price.
+     *
+     * There is NO market-constant LTV in LlamaLend — the number moves with the
+     * band count. Measured on sreUSD/crvUSD: 0.991 at N=4 down to 0.886 at
+     * N=50. Reporting the N=4 maximum would flatter every risk comparison
+     * against Aave/Morpho, so the default N is what gets reported and the rest
+     * of the curve travels alongside in `bandLtv`.
+     */
+    collateralFactor: number | null;
+    /** `{ [N]: collateralFactor }` — the trade-off curve for the UI and sizer. */
+    bandLtv: {
+        [bands: string]: number;
+    } | null;
+    /**
+     * v2 borrow cap in borrowed-token units (human). `0` DISABLES borrowing —
+     * a fresh v2 market looks live but is not. `null` on v1 (uncapped).
+     */
+    borrowCap: number | null;
+    /** Whether new borrows are possible at all right now. */
+    borrowingEnabled: boolean;
+    /** Vault.maxDeposit — `0` disables deposits (v2 `max_supply`). */
+    maxDeposit: number | null;
+    /** Number of open loans, for the liquidations surface. */
+    nLoans: number | null;
+    /**
+     * Soft-liquidation state of the market as a whole: the AMM's active band.
+     * Not a per-user value, but it tells the UI whether the market is currently
+     * converting anyone's collateral.
+     */
+    activeBand: number | null;
+}
+/** Raw public-data batch for one LlamaLend chain (both generations together). */
+interface LlamaLendMarketsRaw {
+    /** The bare lender key, `LLAMALEND`. */
+    lender: string;
+    config: LlamaLendConfigChain | undefined;
+    chainData: LlamaLendChainData | undefined;
+    markets: LlamaLendMarketRaw[];
+    /** Which source filled the market rows. */
+    source: 'api' | 'chain' | 'none';
+}
+
+declare function fetchLlamaLendMarkets(lender: string, chainId: string): Promise<LlamaLendMarketsRaw>;
+
+/**
+ * Synthesized per-market lender key, e.g.
+ * `LLAMALEND_4F79FE450A2BAF833E8F50340BD230F5A3ECAFE9` (= the sreUSD/crvUSD
+ * market). Keyed by the CONTROLLER, which is what every write and every user
+ * read targets — the vault is a lookup off it. Address-suffixed
+ * (Teller/Exactly/Inverse convention); the chain id is not part of the key
+ * because chain scoping happens at the marketUid level.
+ *
+ * Both generations share this key space on purpose: to a user they are one
+ * protocol, and the Curve API returns them in one list. The `version` field on
+ * the market row is what encoders branch on.
+ */
+declare function llamaLendLenderKey(lender: string, controller: string): string;
+/** Recover `{ lender, controller }` from a per-market key (or undefined). */
+declare function llamaLendKeyParts(key: string): {
+    lender: string;
+    controller: string;
+} | undefined;
+/**
+ * Map the LlamaLend batch into the shared `MorphoGeneralPublicResponse` shape,
+ * keyed by `LLAMALEND_<CONTROLLER_ADDR>` — one key per market.
+ *
+ * Per market, two entries in the isolated-pair layout:
+ *
+ *  - COLLATERAL entry — deposit-only. `collateralFactor` is the LTV AT THE
+ *    MARKET'S DEFAULT BAND COUNT, because LlamaLend has no market-constant
+ *    LTV: it is a function of `N` and moves 0.886..0.991 on a single market.
+ *    The whole curve rides along in `params.market.llamalend.bandLtv` so the
+ *    UI can show the trade-off and the leverage sizer can use the real number
+ *    for the `N` the user actually picks.
+ *  - LOAN entry — the borrowed token. Supply side is the ERC-4626 vault, so
+ *    unlike Inverse this one HAS `totalDeposits`.
+ *
+ * SOFT LIQUIDATION is the thing this shape cannot express natively, so it is
+ * carried explicitly in the descriptor. `liquidationPenalty` here is the HARD
+ * liquidation bonus only — it applies below the entire band range. Inside the
+ * range a position is converted gradually through the market's own AMM with no
+ * penalty at all, and a consumer that renders `liquidationPenalty` as "what
+ * you lose when the price hits X" is describing the wrong event.
+ */
+declare function convertLlamaLendMarketsToResponse(raw: LlamaLendMarketsRaw, chainId: string, prices?: {
+    [asset: string]: number;
+}, additionalYields?: AdditionalYields, tokens?: GenericTokenList): {
+    [m: string]: MorphoGeneralPublicResponse;
+};
+
+/**
+ * Per-position LlamaLend detail attached to the debt row (raw strings unless
+ * noted).
+ *
+ * The two fields a consumer must not ignore:
+ *
+ *  - `softLiquidating` / `priceUpper` / `priceLower` — a LlamaLend position
+ *    does not have a liquidation price. It has a band RANGE, and it starts
+ *    converting collateral into the borrowed token as soon as the oracle
+ *    enters that range. Rendering a single number here misrepresents the
+ *    protocol.
+ *  - `bandCollateralInBorrowed` — the borrowed-token leg the LLAMMA has
+ *    already produced from the user's collateral. It sits inside the position,
+ *    offsets debt, and is NOT a wallet balance.
+ */
+interface LlamaLendPositionInfo {
+    /** Signed health, WAD. `< 0` ⇒ hard-liquidatable. */
+    health: string;
+    /** Upper bound of the soft-liquidation band range, WAD. */
+    priceUpper: string;
+    /** Lower bound of the soft-liquidation band range, WAD. */
+    priceLower: string;
+    /** Band indices `[n1, n2]` the collateral currently occupies. */
+    bands: [number, number] | undefined;
+    /** Band count `N` chosen at loan creation — IMMUTABLE for the loan's life. */
+    bandCount: number;
+    /**
+     * Borrowed-token amount held inside the user's bands (raw). Non-zero means
+     * the position IS or HAS BEEN in soft liquidation.
+     */
+    bandCollateralInBorrowed: string;
+    /** True when the LLAMMA currently holds a borrowed-token leg for this user. */
+    softLiquidating: boolean;
+    /**
+     * Whether the probed spender holds the Controller's boolean grant for this
+     * market. FAILS CLOSED — older-blueprint controllers have no `approval`
+     * method, the call fails, and this reads `false`, which is correct.
+     */
+    delegated: boolean;
+    /** Whether the market's Controller supports delegation at all. */
+    supportsDelegation: boolean;
+    /** Market generation — the leverage/encoder ABIs differ. */
+    version: 1 | 2;
+}
+
+/**
+ * One USDD market (= one collateral ilk) after the on-chain batch.
+ * Raw bigints; `null` = failed allowFailure read. Maker fixed-point:
+ * wad 1e18 / ray 1e27 / rad 1e45.
+ */
+interface UsddMarketRaw {
+    market: UsddMarketConfig;
+    /** Vat.ilks — total normalised debt (wad). */
+    Art: bigint | null;
+    /** Vat.ilks — debt accumulator (ray); debt = Art × rate (rad). */
+    rate: bigint | null;
+    /** Vat.ilks — liquidation-adjusted price (ray): price / (par × mat). */
+    spot: bigint | null;
+    /** Vat.ilks — ilk debt ceiling (rad). */
+    line: bigint | null;
+    /** Vat.ilks — per-urn debt floor (rad). */
+    dust: bigint | null;
+    /** Jug.ilks — per-second stability fee (ray). */
+    duty: bigint | null;
+    /** Spot.ilks — liquidation ratio (ray). */
+    mat: bigint | null;
+    /** gem.balanceOf(gemJoin) — total collateral custodied by the adapter
+     *  (locked ink + unswept gem), gem-native decimals. */
+    joinBalance: bigint | null;
+}
+interface UsddMarketsRaw {
+    lender: string;
+    config?: UsddConfigChain;
+    chainData?: UsddChainData;
+    markets: UsddMarketRaw[];
+}
+
+/** Ilk string → bytes32 (`'WBTC-A'` → right-padded hex). */
+declare const usddIlkBytes32: (ilk: string) => `0x${string}`;
+/**
+ * Fetch all market data of ONE USDD (Maker-fork) deployment — FULLY ON-CHAIN
+ * via one retrying multicall. The ilk roster comes from lender-metadata
+ * (`usddConfig`/`usddMarkets`, discovered + verified by its `update:usdd`
+ * generator); this fetch reads the LIVE Vat/Jug/Spot params per ilk plus the
+ * gem-join balance (total custodied collateral — the Vat keeps no per-ilk
+ * ink total).
+ *
+ * The roster is EMPTY on both EVM chains today (`cdpi() = 0`, no ilk filed —
+ * see USDD_PLAN.md), so this returns zero markets without issuing a
+ * multicall. The code path stays live so the day metadata fills, data flows
+ * with no code change.
+ */
+declare function fetchUsddMarkets(lender: string, chainId: string): Promise<UsddMarketsRaw>;
+
+/**
+ * Synthesized per-ilk lender key, e.g. `USDD_1_WBTC-A`. The CHAIN ID is part
+ * of the key (Fluid/River convention) because Ethereum and BNB run
+ * INDEPENDENT Maker stacks that could file the same ilk string.
+ */
+declare function usddLenderKey(lender: string, chainId: string | number, ilk: string): string;
+/**
+ * Recover `{ lender, chainId, ilk }` from a per-market key (or undefined).
+ * Ilk strings are Maker `<GEM>-<CLASS>` tokens (`WBTC-A`, `PSM-USDT-A`) —
+ * uppercase alphanumerics + dashes; the leading `\d+_` disambiguates from
+ * the bare `USDD` key.
+ */
+declare function usddKeyParts(key: string): {
+    lender: string;
+    chainId: string;
+    ilk: string;
+} | undefined;
+/**
+ * Map one USDD deployment's on-chain batch into the shared
+ * `MorphoGeneralPublicResponse` shape, keyed `USDD_<chainId>_<ILK>` — one key
+ * per collateral ilk.
+ *
+ * Per market:
+ *  - COLLATERAL entry: totals = the gem-join balance (the Vat keeps no
+ *    per-ilk ink total; the adapter custodies locked + unswept gems);
+ *    LTV = 1/mat; liquidation penalty = chop − 1 (Dog.chop, wad).
+ *  - LOAN entry (USDD): `totalDebt` = Art × rate (rad → human);
+ *    `variableBorrowRate` = the stability fee as a nominal APR percent —
+ *    `(duty − RAY)/RAY × YEAR_SECONDS × 100`, the same annualisation as the
+ *    Pot's dsr in the savings fetcher (never `^ seconds − 1`, which is the
+ *    APY); `borrowLiquidity` = ceiling headroom `(line − Art × rate)/1e45`.
+ *    There is NO protocol supply side (USDD is Vat-minted) — the earn side
+ *    is sUSDD, carried by the savings provider, so `totalDeposits` on the
+ *    loan row is 0 and `depositRate` 0 here.
+ *  - Collateral price: Vat.spot × mat (both ray) recovers the par-adjusted
+ *    OSM price without reading the pip (whitelisted `peek` would revert);
+ *    shared price map as fallback.
+ */
+declare function convertUsddMarketsToResponse(raw: UsddMarketsRaw, chainId: string, prices?: {
+    [asset: string]: number;
+}, _additionalYields?: AdditionalYields, tokens?: GenericTokenList): {
+    [m: string]: MorphoGeneralPublicResponse;
+};
+
+/** Per-CDP position detail attached to the debt row (raw strings). */
+interface UsddPositionInfo {
+    /** DssCdpManager id — the sub-account id and every write op's target. */
+    cdpId: string;
+    /** Urn handle in the Vat. */
+    urn: string;
+    ilk: string;
+}
+
+/**
+ * One Frankencoin market (= one ORIGINAL position) after the on-chain batch.
+ * Raw bigints; `null` = failed allowFailure read.
+ */
+interface FrankencoinMarketRaw {
+    market: FrankencoinMarketConfig;
+    /** Owner-declared liquidation price, 36-dec scaled vs collateral decimals. */
+    price: bigint | null;
+    /** FACE debt on the original itself (clones carry their own). */
+    minted: bigint | null;
+    /** ZCHF the original + its clones may still draw — market borrow capacity. */
+    availableForClones: bigint | null;
+    /** Collateral custodied by the ORIGINAL position contract. */
+    collateralBalance: bigint | null;
+    /** Hub lead rate + risk premium, ppm. */
+    annualInterestPPM: bigint | null;
+    /** Upfront fee for minting now (pro-rata to expiry), ppm. */
+    currentFeePPM: bigint | null;
+    /** Withheld into the equity reserve at mint, ppm. */
+    reserveContribution: bigint | null;
+    /** Non-zero while a Dutch-auction challenge is running. */
+    challengedAmount: bigint | null;
+    expiration: bigint | null;
+    isClosed: boolean | null;
+}
+interface FrankencoinMarketsRaw {
+    lender: string;
+    config?: FrankencoinConfigChain;
+    chainData?: FrankencoinChainData;
+    markets: FrankencoinMarketRaw[];
+}
+
+/**
+ * Fetch all market data of ONE Frankencoin deployment — FULLY ON-CHAIN via
+ * one retrying multicall over the curated ORIGINAL-position roster from
+ * lender-metadata (`frankencoinConfig` / `frankencoinMarkets`, generated by
+ * its `update:frankencoin` job, which filters to V2 + open + a priceable
+ * collateral allowlist).
+ *
+ * Only originals are read here: they carry the terms AND the market-level
+ * borrow capacity (`availableForClones`). Clones are USER positions and are
+ * resolved per-account in the user-data path.
+ *
+ * NB `price` is the owner-DECLARED liquidation price, not an oracle quote —
+ * see the converter for how that is surfaced.
+ */
+declare function fetchFrankencoinMarkets(lender: string, chainId: string): Promise<FrankencoinMarketsRaw>;
+
+/**
+ * Synthesized per-market lender key, e.g.
+ * `FRANKENCOIN_1_5F2C10F7…` — one per ORIGINAL position. The chain id is part
+ * of the key (Fluid/River convention) even though Frankencoin is
+ * Ethereum-only today, so an L2 hub would not collide.
+ */
+declare function frankencoinLenderKey(lender: string, chainId: string | number, position: string): string;
+/** Recover `{ lender, chainId, position }` from a per-market key. */
+declare function frankencoinKeyParts(key: string): {
+    lender: string;
+    chainId: string;
+    position: string;
+} | undefined;
+/**
+ * Map one Frankencoin deployment's on-chain batch into the shared
+ * `MorphoGeneralPublicResponse` shape, keyed `FRANKENCOIN_<chainId>_<ORIGINAL>`.
+ *
+ * Three modelling decisions worth knowing (all from FRANKENCOIN_PLAN.md):
+ *
+ *  - **The liquidation price is owner-DECLARED, not an oracle.** `price` is
+ *    36-dec scaled against the collateral's decimals and is policed by a
+ *    Dutch-auction challenge game. We surface it as the LIQUIDATION price
+ *    (it defines `collateralFactor = 1`, i.e. minting is allowed up to
+ *    `coll × price`) but value collateral with OUR price feeds. The
+ *    divergence between the two is the risk signal, and it is carried
+ *    verbatim in `params.market.frankencoin.declaredPrice` so a consumer can
+ *    compute it. Never present the resulting health as a protocol invariant.
+ *  - **Debt ≠ proceeds.** `minted` is FACE debt including the withheld
+ *    `reserveContribution` (10–40 %) plus the upfront pro-rata fee. Both
+ *    ppm figures ride along in the descriptor so a quote layer can convert.
+ *  - **Positions expire.** `expiration` is surfaced and an expired market is
+ *    reported halted (its collateral is subject to forced sale).
+ *
+ * Per market: a COLLATERAL entry (the original's own collateral) and a LOAN
+ * entry (ZCHF). There is no protocol supply side — ZCHF is minted, and the
+ * earn leg is the separate savings module carried by the savings provider —
+ * so `totalDeposits` on the loan row is 0.
+ */
+declare function convertFrankencoinMarketsToResponse(raw: FrankencoinMarketsRaw, chainId: string, prices?: {
+    [asset: string]: number;
+}, _additionalYields?: AdditionalYields, tokens?: GenericTokenList): {
+    [m: string]: MorphoGeneralPublicResponse;
+};
+
+/** Per-position detail attached to the debt row (raw strings). */
+interface FrankencoinPositionInfo {
+    /** The position contract — the sub-account id and every write op's target. */
+    position: string;
+    /** The ORIGINAL this position was cloned from (its market). */
+    original: string;
+    /** Owner-declared liquidation price (raw, 36-dec scaled). */
+    declaredPrice: string;
+    /** Unix seconds; a position past this is subject to forced sale. */
+    expiration: string;
+    /** Non-zero while a Dutch-auction challenge is running against it. */
+    challengedAmount: string;
+    /** ppm withheld into the equity reserve — needed to quote a close, since
+     *  repaying burns with reserve credit and costs LESS than `minted`. */
+    reserveContributionPPM: 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
@@ -2827,6 +3920,369 @@ 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;
+    /**
+     * False when decimals could not be resolved from the payload and the 18-dec
+     * default was used. Exists because reading the wrong `assetConfigs` field
+     * names once made EVERY 6-dec stablecoin market silently 10^12 out; a
+     * consumer that cares about exactness should treat `false` as suspect.
+     */
+    debtDecimalsResolved?: boolean;
+    collateralDecimalsResolved?: boolean;
+    /** 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
@@ -4015,45 +5471,160 @@ interface EulerEarnVault extends VaultClassificationFields {
     depositRate: number;
     /** Performance fee in percent (e.g. `5.0` = 5 %). */
     fee: number;
-    /** Governance timelock in seconds — the delay before owner/curator config
-     *  changes take effect (Euler Earn `governance.timelock`). Governance-only,
-     *  NOT a per-deposit withdrawal lock. Mirrors `MorphoVault.timelock`. */
+    /** Governance timelock in seconds — the delay before owner/curator config
+     *  changes take effect (Euler Earn `governance.timelock`). Governance-only,
+     *  NOT a per-deposit withdrawal lock. Mirrors `MorphoVault.timelock`. */
+    timelock?: number;
+    /** Owner address, lowercased — may be absent if not set. */
+    owner?: string;
+    /** Curator / fee-recipient address, lowercased. */
+    curator?: string;
+    /** Human-readable curator label for UI, derived best-effort from the
+     *  (curator-branded) vault name — the subgraph exposes only the address.
+     *  Mirrors `MorphoVault.curatorName` so consumers can write generic UI. */
+    curatorName?: string;
+    /** Guardian address, lowercased — may be absent. */
+    guardian?: string;
+    /** Fee recipient, lowercased — may be absent. */
+    feeRecipient?: 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;
+    /** Human-formatted total assets (`totalAssets / 10^assetDecimals`). */
+    totalAssetsFormatted: number;
+    /** Human-formatted total assets in USD. */
+    totalAssetsUsd: number;
+    /** Currently withdrawable underlying, raw integer as string. Computed
+     *  as `idle_cash + Σ min(allocated_i, evk_cash_i)` across the Earn
+     *  vault's strategies — accounts for per-EVK utilization caps. Falls
+     *  back to `totalAssets` (optimistic ceiling) when the EVK index is
+     *  unavailable. Never exceeds `totalAssets`. */
+    liquidity: string;
+    /** Human-formatted immediate withdrawable liquidity. */
+    liquidityFormatted: number;
+    /** Human-formatted immediate withdrawable liquidity in USD. */
+    liquidityUsd: number;
+}
+/** Full parsed payload: per-vault-address map. */
+type EulerEarnVaults = {
+    /** Keyed by lowercased vault address. */
+    [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;
-    /** Owner address, lowercased — may be absent if not set. */
-    owner?: string;
-    /** Curator / fee-recipient address, lowercased. */
+    /** Curator address, lowercased. */
     curator?: string;
-    /** Human-readable curator label for UI, derived best-effort from the
-     *  (curator-branded) vault name — the subgraph exposes only the address.
-     *  Mirrors `MorphoVault.curatorName` so consumers can write generic UI. */
+    /**
+     * 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 — may be absent. */
+    /** Guardian address, lowercased. */
     guardian?: string;
-    /** Fee recipient, lowercased — may be absent. */
-    feeRecipient?: 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;
-    /** Human-formatted total assets (`totalAssets / 10^assetDecimals`). */
+    /** `totalAssets / 10^assetDecimals`. */
     totalAssetsFormatted: number;
-    /** Human-formatted total assets in USD. */
+    /** `totalAssetsFormatted * priceUsd`. */
     totalAssetsUsd: number;
-    /** Currently withdrawable underlying, raw integer as string. Computed
-     *  as `idle_cash + Σ min(allocated_i, evk_cash_i)` across the Earn
-     *  vault's strategies — accounts for per-EVK utilization caps. Falls
-     *  back to `totalAssets` (optimistic ceiling) when the EVK index is
-     *  unavailable. Never exceeds `totalAssets`. */
+    /**
+     * 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;
-    /** Human-formatted immediate withdrawable liquidity. */
     liquidityFormatted: number;
-    /** Human-formatted immediate withdrawable liquidity in USD. */
     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 EulerEarnVaults = {
+type TermMaxVaults = {
     /** Keyed by lowercased vault address. */
-    [vaultAddress: string]: EulerEarnVault;
+    [vaultAddress: string]: TermMaxVault;
 };
 
 /**
@@ -4308,11 +5879,41 @@ interface LstWithdrawalRequest {
      *  ERC-7540 requestId, …). Encoded as a string for cross-protocol
      *  uniformity. */
     requestId: string;
-    /** Raw underlying amount the request will return on claim. Wei-like
-     *  integer string. Some protocols only know this at claim time
-     *  (queue-finalization with floating finalization rate) — those
-     *  surface the **expected** amount at request time. */
+    /** Raw amount the request will return on claim, in the token that
+     *  escrow actually pays out. Wei-like integer string. Some protocols
+     *  only know this at claim time (queue-finalization with a floating
+     *  finalization rate) — those surface the **expected** amount at
+     *  request time.
+     *
+     *  Strata is the one entry where the denomination is not simply the
+     *  vault's underlying, and it is easy to get wrong: the escrow is
+     *  **keyed** by the collateral token (`finalize(sUSDe, user)`) but the
+     *  amount it records is whatever that leg settles in — the tranche's
+     *  `asset()` (USDe) on the UnstakeCooldown, which books Ethena's
+     *  unstake output, and collateral-token shares on the ERC20Cooldown.
+     *  We do not normalize between them; read `withdrawQueue` to tell the
+     *  legs apart. Fork-verified for the UnstakeCooldown leg 2026-08-04
+     *  (10,000 USDe in → 9,997.5 USDe out at a 2.49 bps exit fee, with
+     *  zero sUSDe paid); the ERC20Cooldown denomination is read off the
+     *  strategy source, which escrows `sUSDe.previewWithdraw(baseAssets)`
+     *  shares. */
     amountUnderlying: string;
+    /** Raw share amount of the request, for protocols whose claim call
+     *  takes shares (ERC-7540 `redeem`, sUSD3's plain 4626 `redeem`).
+     *  Passed back verbatim into the claim builder. */
+    shares?: string;
+    /** The escrow contract this request actually lives on, when the
+     *  protocol runs more than one and the registry's default is not
+     *  necessarily the right claim target. Strata gives each market both
+     *  an `UnstakeCooldown` (base-asset leg) and an `ERC20Cooldown`
+     *  (collateral-token leg) — a claim built against the wrong one is a
+     *  no-op — so the reader reports which. Passed back verbatim into
+     *  the claim builder. */
+    withdrawQueue?: string;
+    /** The token the escrow books this request under, when the claim
+     *  call takes it as an argument (Strata's
+     *  `finalize(claimToken, user)`). Passed back verbatim. */
+    claimToken?: string;
     /** Status discriminator. */
     status: LstWithdrawalStatus;
     /** Unix seconds when the request becomes claimable. Set for
@@ -4349,7 +5950,7 @@ type LstWithdrawalStatus =
  | 'expired';
 /** Withdrawal-reader implementation kind — drives which enumeration
  *  function the user is queried against. */
-type LstWithdrawalReaderKind = 'lidoQueue' | 'etherfiNft' | 'yieldNestNft' | 'staderEthxQueue' | 'staderMaticXQueue' | 'renzoQueue' | 'kelpQueue' | 'benqiSavaxQueue' | 'beetsStSQueue' | 'hyperbeatBeHype7540' | 'erc7540' | 'ethenaCooldown' | 'swellNft' | 'stakeWiseSubgraph' | 'mantleCallerSuppliedIds' | 'pufferCallerSuppliedIds' | 'trufinCallerSuppliedIds' | 'lairCallerSuppliedIds' | 'stceloAccountQueue' | 'kinetiqQueue' | 'beHypeQueue' | 'valantisBurnQueue' | 'listaQueue' | 'iberaQueue' | 'primeStakingQueue' | 'berapawRedeemQueue' | 'stellaUnbondQueue' | 'eventsOnly' | 'noQueue' | 'unverified';
+type LstWithdrawalReaderKind = 'lidoQueue' | 'etherfiNft' | 'yieldNestNft' | 'staderEthxQueue' | 'staderMaticXQueue' | 'renzoQueue' | 'kelpQueue' | 'benqiSavaxQueue' | 'beetsStSQueue' | 'hyperbeatBeHype7540' | 'erc7540' | 'ethenaCooldown' | 'susd3Cooldown' | 'strataCooldown' | 'swellNft' | 'stakeWiseSubgraph' | 'mantleCallerSuppliedIds' | 'pufferCallerSuppliedIds' | 'trufinCallerSuppliedIds' | 'lairCallerSuppliedIds' | 'stceloAccountQueue' | 'kinetiqQueue' | 'beHypeQueue' | 'valantisBurnQueue' | 'listaQueue' | 'iberaQueue' | 'primeStakingQueue' | 'berapawRedeemQueue' | 'stellaUnbondQueue' | 'eventsOnly' | 'noQueue' | 'unverified';
 /** Map keyed by lowercased LST share-token address. The orchestrator
  *  fetches all LSTs on a chain in parallel and returns this map
  *  (possibly with empty arrays for LSTs the user has no requests
@@ -4395,6 +5996,17 @@ interface LstWithdrawalRegistryEntry {
     /** Polygon IStakeManager — only for `staderMaticXQueue`. The
      *  finalization check requires `epoch()` + `withdrawalDelay()`. */
     polygonStakeManager?: string;
+    /** Second escrow contract probed with the same reader — only for
+     *  `strataCooldown`, where a market runs both an `UnstakeCooldown`
+     *  (base-asset leg, in `withdrawalContract`) and an `ERC20Cooldown`
+     *  (collateral-token leg). Lowercased. */
+    secondaryWithdrawalContract?: string;
+    /** The token an escrow's requests are booked under — only for
+     *  `strataCooldown` (`balanceOf(escrowToken, user)` /
+     *  `finalize(escrowToken, user)`). The market's staked collateral
+     *  (sUSDe, sNUSD, mHYPER, …), NOT the tranche's `asset()`.
+     *  Lowercased. */
+    escrowToken?: string;
 }
 /** Returns the withdrawal-registry entries for a chain, or `[]`. */
 declare const getLstWithdrawalRegistry: (chainId: string, extraEntries?: LstWithdrawalRegistryEntry[]) => LstWithdrawalRegistryEntry[];
@@ -4529,7 +6141,7 @@ declare const resolveStCeloDepositGroup: (user: Address, requestedGroup?: string
  * kept separate so the two providers can evolve independently without
  * one provider's withdrawal taxonomy creep affecting the other.
  */
-type SavingsWithdrawalMode = 'instant' | 'fixed-cooldown' | 'queued' | 'request-based' | 'fee-or-queued';
+type SavingsWithdrawalMode = 'instant' | 'instant-capped' | 'fixed-cooldown' | 'queued' | 'request-based' | 'fee-or-queued';
 /**
  * Parsed savings-vault entry.
  *
@@ -4560,6 +6172,10 @@ interface SavingsVault extends VaultClassificationFields {
     displayName: string;
     /** Brand label — `Ethena`, `Sky`, `Maker`, `Angle`, `Falcon`, … */
     brand: string;
+    /** Curated user-facing explainer (from the registry): what the
+     *  underlying is, where the yield comes from, and the exit
+     *  mechanics / trust caveat when load-bearing. */
+    description: string;
     /** Alias for `brand` to match `curatorName` on the other providers'
      *  vault types — keeps cross-provider UI code uniform. */
     curatorName: string;
@@ -4591,9 +6207,13 @@ interface SavingsVault extends VaultClassificationFields {
     /** Sum of `supplyRate + rewardsRate` — what a depositor actually
      *  earns. */
     depositRate: number;
-    /** Always true for this provider — every entry is ERC-4626. Kept
-     *  for API parity with `LstShareToken.isErc4626`. */
-    isErc4626: true;
+    /** Whether the share token implements ERC-4626. True for every entry
+     *  except Native's wNLP, which is a bespoke wrapper (`asset()`,
+     *  `totalAssets()` and `convertToAssets()` all revert) — the
+     *  `convertTo*` / `exchangeRate` fields below are still populated for
+     *  it, derived from its own rate getter. Parity with
+     *  `LstShareToken.isErc4626`. */
+    isErc4626: boolean;
     /** Whether the share token itself rebases. False for nearly every
      *  savings vault (they're the non-rebasing wrapper); rebasing
      *  surfaces sit on the underlying (e.g. USDe inside sUSDe). */
@@ -4607,12 +6227,51 @@ interface SavingsVault extends VaultClassificationFields {
     mintContract?: string;
     /** Withdrawal mechanism. */
     withdrawalMode: SavingsWithdrawalMode;
-    /** Fixed cooldown in seconds for `fixed-cooldown` mode. Some
-     *  protocols (Ethena, Avant) expose this on-chain via
-     *  `cooldownDuration()`. Static value here pinned in the registry —
-     *  re-read on-chain if you need the precise governance-current
-     *  value. */
+    /** Waiting period in seconds before a requested redemption can be
+     *  claimed. For `fixed-cooldown` entries (Ethena, Avant) this is the
+     *  registry-pinned value. For `fee-or-queued` entries it is the
+     *  **live** on-chain queue window, which varies per asset (Native
+     *  runs 8 h on some pools and 3 days on most). */
     withdrawalCooldownSeconds?: number;
+    /**
+     * Exit fee in basis points (`10` = 0.10 %) — same units and name as
+     * `GearboxV3Pool.withdrawFeeBps`, so consumers read one field across
+     * providers.
+     *
+     * **How it is charged** (Native): it is *not* a deposit fee, a
+     * management fee, or a skim on yield — `exchangeRate` and `supplyRate`
+     * are already net of everything Native takes on the way in. It is a
+     * one-off haircut on the **instant** exit only, taken out of the
+     * underlying paid to the receiver:
+     *
+     *     received = shares × exchangeRate × (1 − withdrawFeeBps/10_000)
+     *
+     * so redeeming 9,867.98 wNLP-USDC worth 10,000 USDC returns 9,900 USDC
+     * at 100 bps. The shares burn in full — the fee is deducted from the
+     * payout, never charged as a separate transfer, so a caller does not
+     * need to fund it or approve anything extra.
+     *
+     * The **queued** leg (`withdrawQueue`, after
+     * `withdrawalCooldownSeconds`) pays out at par and does not touch this
+     * field. Its cost is implicit instead: the payout is snapshotted when
+     * the request is made, so yield accruing during the wait goes to the
+     * protocol rather than the requester.
+     *
+     * `0` means the instant leg is free. Absent when the vault has no
+     * instant leg at all.
+     */
+    withdrawFeeBps?: number;
+    /** Whether the instant leg is enabled at all — some assets are
+     *  queue-only. When `false`, `liquidity` is `0` regardless of the
+     *  protocol's inventory and `withdrawFeeBps` is unreachable. */
+    instantRedeemEnabled?: boolean;
+    /** Contract the instant leg draws from — Native's per-chain
+     *  `CreditVault`. Its underlying balance is what `liquidity`
+     *  measures. */
+    inventoryContract?: string;
+    /** Contract a delayed redemption is requested from and claimed
+     *  against, when it is not the share token itself. */
+    withdrawQueue?: string;
     /** Hydrated asset metadata from the provided token list, if any. */
     asset?: GenericCurrency;
     /** USD price of one underlying unit, if prices were supplied. */
@@ -4621,18 +6280,60 @@ interface SavingsVault extends VaultClassificationFields {
     totalAssetsFormatted: number;
     /** Human-formatted total assets in USD. */
     totalAssetsUsd: number;
-    /** Instantly-withdrawable underlying right now, raw integer string,
-     *  derived from `withdrawalMode`: `instant` vaults are fully liquid
-     *  (`= totalAssets`); `fixed-cooldown` / `queued` / `request-based` /
-     *  `fee-or-queued` vaults require a waiting period, so their
-     *  instantaneous withdrawable is `0`. (A cooldown vault's underlying
-     *  may still be redeemable after the wait — this field is the *right
-     *  now* figure, matching the cross-provider `liquidity` semantic.) */
+    /** Withdrawable underlying **right now**, raw integer string, per
+     *  `withdrawalMode`:
+     *   - `instant` — fully liquid (`= totalAssets`).
+     *   - `instant-capped` — settles in the same transaction, but only up
+     *     to a live inventory that is smaller than the vault: Spark
+     *     Savings V1 is capped by the PSM3 pocket's underlying balance
+     *     (6–29 % of TVL on the L2 deployments) and Spark Vaults V2 by the
+     *     vault's own idle balance (the rest is lent out through the Spark
+     *     Liquidity Layer). No fee and no cooldown on this leg — the
+     *     difference from `instant` is purely the size cap, and the
+     *     difference from `fee-or-queued` is that exceeding it costs
+     *     nothing extra, it simply cannot be done this block.
+     *   - `fee-or-queued` — the protocol's live instant-exit inventory,
+     *     clamped to `totalAssets`; `0` when the instant leg is disabled.
+     *     This is a **gross** figure: pulling it out instantly nets
+     *     `withdrawFeeBps` less (see that field). The queued leg is not
+     *     inventory-capped and pays at par, so `liquidity` is not a cap on
+     *     what the vault can ultimately return.
+     *   - `fixed-cooldown` / `queued` / `request-based` — `0`; these
+     *     require a waiting period.
+     *  A cooldown vault's underlying may still be redeemable after the
+     *  wait — this field is the *right now* figure, matching the
+     *  cross-provider `liquidity` semantic. */
     liquidity: string;
     /** Human-formatted withdrawable liquidity. */
     liquidityFormatted: number;
     /** Withdrawable liquidity in USD. */
     liquidityUsd: number;
+    /**
+     * `liquidity / totalAssets`, clamped to `0…1` — the share of the vault a
+     * holder could exit **this block**. `1 − instantLiquidityRatio` is the
+     * share that must wait, so this is the vault's **lockup indicator**.
+     *
+     * Deliberately *not* called `utilization`. For a lending vault
+     * utilization is `borrowed / supplied`, read from a debt accumulator;
+     * none of these protocols expose one (Native's CreditVault and NTLP have
+     * no debt getter at all, and the CreditVault commingles market-maker
+     * collateral with pool inventory, so its balance can exceed the pool).
+     * What this measures is exit **coverage**, which is the quantity that
+     * actually predicts lockup — and unlike utilization it stays meaningful
+     * for cooldown vaults that have no borrow side whatsoever.
+     *
+     * Reads per mode:
+     *  - `instant` → always `1` (fully liquid by construction).
+     *  - `fee-or-queued` → the live CreditVault coverage; the observed spread
+     *    across Native pools is the full `0…1` range, so it carries real
+     *    information (BNB `wNLP-T4B` sits near `0`, Ethereum `wNLP-USDC` at
+     *    `1`). Below `1` the remainder is not lost, just queued.
+     *  - `fixed-cooldown` / `queued` / `request-based` → always `0`; nothing
+     *    is redeemable without waiting.
+     *
+     * An empty vault reports `1` — there is nothing to be locked up.
+     */
+    instantLiquidityRatio: number;
 }
 /**
  * Full parsed payload: per-share-token-address map.
@@ -5852,7 +7553,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
@@ -5869,6 +7570,7 @@ interface VaultPublicDataAll {
     lista?: MorphoVaults;
     silo?: SiloVaults;
     'euler-earn'?: EulerEarnVaults;
+    termmax?: TermMaxVaults;
     lst?: LstShareTokens;
     savings?: SavingsVaults;
     lagoon?: LagoonVaults;
@@ -6564,8 +8266,18 @@ declare function parseRawRpcBatchResponses(batches: RawRpcBatch[], batchResponse
  * Parses multicall3 aggregate3 responses
  * The response contains an array of {success, returnData} tuples
  * Each returnData needs to be decoded using the original call's ABI
+ *
+ * `permanentFailures`, when supplied, is filled with the indices of calls that
+ * failed DETERMINISTICALLY. This path can tell them apart with certainty, which
+ * the viem path can only infer: if the batch response itself came back, the
+ * transport worked, so a `success: false` entry inside it is a revert — the
+ * chain's answer, not a lost read. Only a batch-level error is a lost read.
+ *
+ * The distinction matters downstream: a cross-margin lender voids its whole set
+ * on a lost read, and without this a single always-reverting market would void
+ * a perfectly good position on every request.
  */
-declare function parseMulticallRpcResponses(responses: RawRpcResponse[], batches: MulticallRpcBatch[], allowFailure?: boolean): any[];
+declare function parseMulticallRpcResponses(responses: RawRpcResponse[], batches: MulticallRpcBatch[], allowFailure?: boolean, permanentFailures?: Set<number>): any[];
 
 type TokenEntry = {
     chainId: string;
@@ -6658,4 +8370,1189 @@ 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, 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 };
+/**
+ * Term sheets — a structured, per-`marketUid` description of every lend and
+ * borrow offer we serve.
+ *
+ * One shape for pool lenders, fixed-term lenders, CDPs and vaults, so an
+ * integrator reads ONE object instead of ~15 protocol-specific fields plus a
+ * per-lender mental model. See [TERM_SHEET_PLAN.md](../../../../TERM_SHEET_PLAN.md)
+ * for the design rationale and the per-lender coverage matrix.
+ *
+ * ## Conventions that hold everywhere in this file
+ *
+ * - **Rates are nominal APR in PERCENT** (`3.85` = 3.85 %/yr), never a
+ *   fraction and never an APY. This is the package-wide convention.
+ * - **Factors are fractions** (`0.85` = 85 % LTV) — matching `LenderConfigData`.
+ * - **Durations are SECONDS**, timestamps are **unix seconds**.
+ * - **Raw amounts are decimal strings** in base units; human amounts are
+ *   `number`.
+ * - Every string union is deliberately OPEN (`| (string & {})`) so a new
+ *   lender can introduce a member without breaking a consumer's exhaustive
+ *   switch. Consumers MUST have a `default` branch and fall back to
+ *   `info.headline`.
+ */
+/** Nominal APR in percent (`3.85` = 3.85 %/yr). Never a fraction, never APY. */
+type AprPercent = number;
+/**
+ * Open-enum helper. `Open<'a' | 'b'>` keeps autocomplete for the known members
+ * while still accepting any string, so adding a member later is an ADDITIVE
+ * change rather than a breaking one.
+ */
+type Open<T extends string> = T | (string & {});
+/** Compact token reference — enough to render without a second lookup. */
+interface TermAssetRef {
+    chainId: string;
+    /** Lowercased contract address. */
+    address: string;
+    symbol?: string;
+    name?: string;
+    decimals?: number;
+    assetGroup?: string;
+    logoURI?: string;
+}
+/**
+ * Machine tags for filtering/faceting. DERIVED from the structured fields in
+ * `tags.ts` — never hand-written per lender, so they cannot drift from the
+ * numbers they summarize.
+ */
+type TermTag = Open<'fixed-rate' | 'variable-rate' | 'user-set-rate' | 'zero-interest' | 'prepaid-interest' | 'nav-accrual' | 'has-maturity' | 'perpetual' | 'rolling-duration' | 'static-debt' | 'accruing-debt' | 'time-liquidation' | 'price-liquidation' | 'redeemable' | 'no-liquidation' | 'full-collateral-seizure' | 'early-exit-free' | 'early-exit-penalty' | 'early-exit-discount' | 'exit-instant' | 'exit-capped' | 'exit-cooldown' | 'exit-queued' | 'exit-market-sale' | 'exit-may-be-impossible' | 'permissioned' | 'capped' | 'cap-full' | 'first-loss' | 'socialized-loss' | 'physical-delivery' | 'undercollateralized' | 'nav-attested' | 'immutable' | 'no-timelock' | 'eoa-controlled' | 'points-rewards' | 'oracle-flagged' | 'no-oracle'>;
+/** Human-facing copy for one side of a term sheet. */
+interface TermInfo {
+    /**
+     * ≤ ~100 chars, templated from live numbers, ready to render.
+     * `"Fixed 4.12 % until 3 Sep 2026 · repay any time at face value"`.
+     *
+     * ALWAYS populated — it is the graceful-degradation path for a consumer
+     * that does not recognise a newer enum member.
+     */
+    headline: string;
+    /** 1–3 sentences. Invariant prose lives on the profile; this interpolates
+     *  the market's own values. */
+    description: string;
+    /** Ready-to-display consequences, most important first. */
+    implications?: string[];
+    tags: TermTag[];
+}
+type RateKind = Open<
+/** Utilization IRM (Aave, Compound, Morpho, Silo, Euler, Fluid…). */
+'variable-curve'
+/** Governance-set with no curve (USDD stability fee, Spark `vsr`). */
+ | 'variable-managed'
+/** Borrower picks the rate (Liquity family). */
+ | 'user-set'
+/** Locked for a maturity (Exactly, Midnight, Term, TermMax, Teller, Lista). */
+ | 'fixed-term'
+/** Locked, no maturity. Reserved — nothing uses it today. */
+ | 'fixed-open'
+/** No ongoing rate at all (River); cost is a one-off fee. */
+ | 'zero-interest'
+/** Interest prepaid in a separate token (Inverse DBR). */
+ | 'prepaid'
+/** Share price tracks an attested NAV (Re, Apyx, USPC). */
+ | 'nav-accrual'
+/** Pure collateral leg — no yield. */
+ | 'none'>;
+/** One reward program. Identity matters: points are not a bankable APR. */
+interface RewardTerm {
+    /** Absent for points programs — that absence IS the signal. */
+    asset?: TermAssetRef;
+    kind: Open<'token' | 'points' | 'unknown'>;
+    apr: AprPercent;
+    side: 'supply' | 'borrow';
+    /** How it is realized — decides whether the APR is actually bankable. */
+    claim: Open<'accrual' | 'merkl' | 'manual' | 'none'>;
+    /** Program end, where known. An APR with two weeks left is not an APR. */
+    endsAt?: number;
+    /**
+     * `true` ⇒ not priceable (points). MUST be shown separately and is
+     * deliberately EXCLUDED from `RateTerms.aprTotal`.
+     */
+    indicative?: boolean;
+}
+/** One entry in a fixed-term rate menu. Mirrors `MarketTermEntry`. */
+interface RateMenuEntry {
+    /** LENDER-SPECIFIC: Exactly/TermMax = unix maturity, Teller = duration
+     *  seconds, Lista = broker product id, Midnight/Term = `0`. */
+    termId: number;
+    durationSecs: number;
+    durationDays: number;
+    /** Borrow APR at this term. */
+    apr: AprPercent;
+    /** Lend APR at this term, where the lender quotes both sides. */
+    depositApr?: AprPercent;
+    /** Borrowable liquidity at this term, human units. */
+    available?: number;
+}
+interface RateTerms {
+    kind: RateKind;
+    /** Base rate only — no rewards, no intrinsic yield. */
+    apr: AprPercent;
+    components: {
+        base: AprPercent;
+        /** Priceable rewards only. */
+        rewards?: AprPercent;
+        /** Underlying/LST yield the asset earns by itself. */
+        intrinsic?: AprPercent;
+    };
+    /** `base + priceable rewards + intrinsic` — the headline number. */
+    aprTotal: AprPercent;
+    /** Carried explicitly even though it has one value today: a silent
+     *  APR→APY change would be the classic undetectable break. */
+    basis: 'apr-nominal';
+    compounding: Open<'per-second' | 'per-block' | 'none' | 'unknown'>;
+    source: Open<'utilization-curve' | 'orderbook' | 'auction' | 'governance' | 'borrower' | 'oracle' | 'api' | 'derived'>;
+    /** Is the rate locked for the life of the position? */
+    isLocked: boolean;
+    /** Protocol-enforced bounds (Liquity min/max, Morpho rateCap/rateFloor). */
+    minApr?: AprPercent;
+    maxApr?: AprPercent;
+    /**
+     * `kind: 'user-set'` only — the contract a RATE SETTER needs.
+     *
+     * On the Liquity family the borrower picks their own rate at open, and the
+     * choice is not cosmetic: it decides where you sit in the redemption queue,
+     * so the cheapest rate is also the one that gets redeemed first. A borrow UI
+     * that offers no input either cannot build the transaction or silently
+     * accepts a default the user never saw.
+     *
+     * `default` is what the protocol applies when the caller omits a rate (the
+     * branch average), so a UI can pre-fill it and stay consistent with what the
+     * action would have done anyway.
+     */
+    userSet?: {
+        /** Is a rate part of the open call at all? */
+        required: boolean;
+        /** Inclusive bounds, PERCENT. Outside these the open reverts. */
+        min?: AprPercent;
+        max?: AprPercent;
+        /** Applied when the caller omits one — the branch average. */
+        default?: AprPercent;
+        /** Can it be changed after opening (Liquity `set-rate`)? */
+        adjustable: boolean;
+        /**
+         * Changing the rate re-charges the upfront fee — so it is not free, and a
+         * UI that presents it as a slider should say so.
+         */
+        adjustmentCostNote?: string;
+        /** Seconds before the rate may be adjusted again without penalty. */
+        adjustmentCooldownSecs?: number;
+    };
+    /** Per-program reward detail — token identity, claim path, end date. */
+    rewards?: RewardTerm[];
+    /** Rate menu when the market offers several terms at once. */
+    menu?: RateMenuEntry[];
+    /** Size the quote is valid for, when the rate is depth-dependent. */
+    quote?: {
+        assets: number;
+        basis: Open<'marginal' | 'average'>;
+    };
+    lastChangedAt?: number;
+}
+interface MaturityTerms {
+    kind: Open<'perpetual' | 'fixed-date' | 'rolling-duration'>;
+    /** unix seconds; `kind: 'fixed-date'`. */
+    maturity?: number;
+    /** ISO-8601 mirror so consumers need not re-format. */
+    maturityIso?: string;
+    /** Snapshot — derive live from `maturity` for a countdown. */
+    secondsToMaturity?: number;
+    /** `kind: 'rolling-duration'` (Teller, Lista broker). */
+    minDurationSecs?: number;
+    maxDurationSecs?: number;
+    /**
+     * What happens at/after maturity if NOBODY acts. The field that most
+     * surprises users — outcomes range from "interest simply stops" to
+     * "liquidated within five minutes, losing all collateral".
+     */
+    atMaturity?: Open<'stops-earning' | 'penalty-accrues' | 'liquidatable' | 'default-seizure' | 'physical-delivery' | 'refinanced' | 'auto-roll' | 'none'>;
+    /** Grace window before `atMaturity` bites (Teller ~300 s, TermMax 7200 s). */
+    graceSecs?: number;
+}
+type FeeWhen = Open<'entry' | 'ongoing' | 'exit' | 'late' | 'liquidation' | 'performance'>;
+/**
+ * One charge, in a shape general enough that a NEW fee is data rather than a
+ * schema change. Replaces the current scatter: `originationFee`,
+ * `withdrawFeeBps`, `rates.fee`, `fixedTerm.fees.*`, `river.mintFeeRate`,
+ * `liquity.gasCompensation`.
+ */
+interface FeeTerm {
+    /** Stable slug — the join key for UI copy and filtering. */
+    id: Open<'origination' | 'late-penalty' | 'early-repay-penalty' | 'early-repay-discount' | 'continuous' | 'settlement' | 'instant-exit' | 'performance' | 'reserve-factor' | 'gas-compensation' | 'redemption' | 'claim' | 'liquidation-bonus'>;
+    /** Human label — lets an unknown `id` still render correctly. */
+    label: string;
+    when: FeeWhen;
+    unit: Open<'apr-percent' | 'percent' | 'bps' | 'absolute'>;
+    basis: Open<'principal' | 'face-value' | 'yield' | 'collateral' | 'shares' | 'debt-repaid'>;
+    /**
+     * A NEGATIVE value is legal and means a REBATE (Exactly's early-repay
+     * discount). Sign is load-bearing — never take an absolute value.
+     */
+    value: number;
+    payee?: Open<'protocol' | 'lenders' | 'liquidator' | 'curator' | 'gas-refund'>;
+    /** Governance-mutable ⇒ this is a snapshot; re-verify before quoting. */
+    mutable?: boolean;
+    /** Only resolvable at action time (Exactly discount, TermMax curve price). */
+    indicative?: boolean;
+    /** Decaying/scheduled fees (Apyx: 3.40 % → 0 over 20 days). */
+    schedule?: {
+        afterSecs: number;
+        value: number;
+    }[];
+    description?: string;
+}
+/** Superset of `SavingsWithdrawalMode` + `LstWithdrawalMode`, plus the two
+ *  lending-side exits neither covers. */
+type SupplyExitMode = Open<'instant' | 'instant-capped' | 'instant-or-queued' | 'fee-or-queued' | 'fixed-cooldown' | 'queued' | 'request-based'
+/** Sell the instrument on a book (Term, TermMax, Midnight). */
+ | 'market-sale'
+/** No early exit at all. */
+ | 'at-maturity' | 'off-chain' | 'dex-only'>;
+interface SupplyExitTerms {
+    mode: SupplyExitMode;
+    /** Coarse alias — identical semantics to `VaultClassificationFields.redemptionType`. */
+    settlement: Open<'sync' | 'async'>;
+    cooldownSecs?: number;
+    /** Claim-window constraints (Apyx: blocked 3 d, free at 20 d). */
+    claimWindow?: {
+        earliestSecs?: number;
+        freeAfterSecs?: number;
+    };
+    /** What can actually leave right now. */
+    liquidity?: {
+        assets: number;
+        assetsUsd?: number;
+        ratio?: number;
+    };
+    partialAllowed: boolean;
+    /**
+     * Does exiting early cost an UNKNOWN amount?
+     * `none` par · `haircut-formula` deterministic discount ·
+     * `market-price` you sell into a book · `may-be-impossible` the book can be
+     * empty.
+     */
+    priceRisk: Open<'none' | 'haircut-formula' | 'market-price' | 'may-be-impossible'>;
+    cancellable?: boolean;
+    /** The `when: 'exit' | 'performance'` subset of the side's fees. */
+    fees: FeeTerm[];
+}
+interface BorrowExitTerms {
+    /** Three signs exist across our lenders: `discount` is a REBATE (Exactly). */
+    earlyRepay: Open<'free' | 'discount' | 'penalty' | 'market-price' | 'not-allowed'>;
+    atMaturityCost: Open<'face' | 'accrued'>;
+    lateBehaviour: Open<'penalty-accrues' | 'liquidatable' | 'default-seizure' | 'refinanced' | 'none'>;
+    partialAllowed: boolean;
+    /** Dust floor — Liquity `minDebt`, Morpho/Lista `minLoan`. Raw base units. */
+    minDebt?: string;
+    /** Over-repay REVERTS (Midnight `uint128` underflow) — a real footgun. */
+    overRepayReverts?: boolean;
+    fees: FeeTerm[];
+}
+/** One named penalty, for models where a single number is not enough. */
+interface LiquidationPenaltyTerm {
+    /** Stable slug: 'stability-pool' | 'redistribution' | 'hard' | 'protocol-fee'. */
+    id: Open<string>;
+    label: string;
+    /** Fraction of the repaid debt (0.05 = 5 %). */
+    value: number;
+    description?: string;
+}
+interface LiquidationTerms {
+    /**
+     * HOW liquidation happens mechanically — distinct from WHAT triggers it.
+     *
+     * Without this, every market reads as the ordinary "a liquidator repays your
+     * debt and seizes collateral plus a bonus" model, which is wrong for four of
+     * the lenders we serve and materially misleading for one:
+     *
+     *  - `soft-band`      Collateral is converted GRADUALLY inside the market's
+     *                     own AMM as the price enters a band range — with NO
+     *                     penalty and REVERSIBLY (Curve LlamaLend). There is no
+     *                     single liquidation price at all.
+     *  - `stability-pool` A pool absorbs the debt first and only falls back to
+     *                     redistributing it across other borrowers (Liquity,
+     *                     River) — the two paths carry DIFFERENT penalties.
+     *  - `auction`        Price is discovered by a Dutch auction rather than an
+     *                     oracle (Frankencoin challenges).
+     *  - `default-seizure` The whole escrow is forfeit on a missed payment
+     *                     (Teller).
+     *  - `delivery`       Unpaid collateral is delivered to lenders (TermMax).
+     */
+    model?: Open<'repay-seize' | 'soft-band' | 'stability-pool' | 'auction' | 'default-seizure' | 'delivery' | 'none'>;
+    /** Who ends up holding the seized collateral. */
+    absorber?: Open<'liquidator' | 'stability-pool' | 'other-borrowers' | 'lenders' | 'amm'>;
+    /**
+     * Can the position come BACK out of liquidation if the price recovers?
+     * True only for `soft-band`: conversion is continuous and reverses, so
+     * "being liquidated" is not terminal the way it is everywhere else.
+     */
+    reversible?: boolean;
+    /**
+     * Named penalties when `penalty` alone cannot express the model — Liquity
+     * charges a different rate depending on whether the Stability Pool absorbs
+     * the debt or it is redistributed. `penalty` stays the headline (worst or
+     * primary) so a naive consumer is still correct.
+     */
+    penalties?: LiquidationPenaltyTerm[];
+    /** Window between becoming liquidatable and the terminal outcome (TermMax). */
+    windowSecs?: number;
+    /** Only allowlisted keepers may liquidate. Absent/false ⇒ permissionless. */
+    permissioned?: boolean;
+    /** Where a shortfall goes when the collateral does not cover the debt. */
+    badDebt?: Open<'socialized' | 'redistributed' | 'insurance-fund' | 'protocol-absorbed' | 'unknown'>;
+    /**
+     * `soft-band` only: the collateral factor is a FUNCTION of the band count
+     * chosen at open (`{ [N]: ltv }` — 0.991 at N=4 vs 0.886 at N=50). `ltv`
+     * reports the market's default N; a consumer quoting a different N must read
+     * this curve instead.
+     */
+    bandLtv?: Record<string, number>;
+    /** Band count `ltv` / `liquidationLtv` were computed at. */
+    defaultBands?: number;
+    /**
+     * Aave-style escalation: the close factor rises to 1 once health falls below
+     * this. Without it, `closeFactor: 0.5` understates the worst case.
+     */
+    fullCloseBelowHealthFactor?: number;
+    trigger: Open<'price' | 'time' | 'price-and-time' | 'redemption' | 'none'>;
+    /** Max LTV at open. */
+    ltv?: number;
+    /** Threshold at which liquidation becomes possible. */
+    liquidationLtv?: number;
+    /** Fraction of repaid debt paid to the liquidator on top of par. */
+    penalty: number;
+    closeFactor: number;
+    targetHealthFactor?: number;
+    /**
+     * `full-collateral` is the Teller case: the liquidator takes the ENTIRE
+     * escrow, not a proportional slice — ~2× the debt at 50 % LTV.
+     */
+    seizure: Open<'proportional' | 'full-collateral'>;
+    /** Liquity/River: collateral redeemable at par while perfectly healthy. */
+    redeemable?: boolean;
+    gracePeriodSecs?: number;
+}
+interface CounterpartyTerms {
+    kind: Open<'pool' | 'orderbook' | 'auction' | 'broker' | 'cdp' | 'p2p' | 'vault-strategy' | 'off-chain-credit'>;
+    address?: string;
+    /** The trust question, one field. */
+    solvency: Open<'overcollateralized' | 'tranched-senior' | 'tranched-junior' | 'undercollateralized' | 'nav-attested'>;
+    socializedLoss?: boolean;
+    curator?: string;
+}
+/** Origination window for auction-gated markets (Term Finance). */
+interface AuctionWindow {
+    status: Open<'upcoming' | 'open' | 'revealing' | 'closed'>;
+    canBorrow: boolean;
+    canLend: boolean;
+    secondsUntilClose?: number;
+    id?: string;
+    startTime?: number;
+    revealTime?: number;
+    endTime?: number;
+    minBorrowAmount?: string;
+    minLendAmount?: string;
+}
+/** What must be granted BEFORE an action can even be built. */
+type PermissionKind = Open<'token-approval' | 'lender-delegation' | 'manager-authorization' | 'eip712-permit' | 'nft-approval' | 'operator-set'
+/** Contract callers must be governance-approved (Inverse, Fraxlend). */
+ | 'caller-allowlist'>;
+interface AvailabilityTerms {
+    /** Gate CTAs on THIS and nothing else — it already folds in caps, freezes,
+     *  auction windows and gating. */
+    canOpen: boolean;
+    canClose: boolean;
+    /** Machine-readable reason when `canOpen` is false. */
+    blockedBy?: Open<'frozen' | 'paused' | 'cap-full' | 'auction-closed' | 'no-liquidity' | 'not-whitelisted' | 'shutdown' | 'disabled'>;
+    gating: Open<'permissionless' | 'whitelist' | 'attestation' | 'kyc' | 'allowlist-contract'>;
+    /** Absent ⇒ no window applies. NOT the same as `closed`. */
+    window?: AuctionWindow;
+    /**
+     * Minimum position size to OPEN, in RAW base units of THIS side's asset.
+     *
+     * On the borrow side this is a minimum DEBT (Comet `baseBorrowMin`, Liquity
+     * `minDebt`, Maker-fork `dust`). On the supply/collateral side it is a
+     * minimum COLLATERAL — a genuinely different gate, and the only one some
+     * lenders have: Frankencoin caps nothing on the debt but refuses a position
+     * below `minimumCollateral`, and dropping under it closes the position
+     * permanently.
+     */
+    minSize?: string;
+    cap?: string;
+    /** 0..1 — how full the cap is. */
+    capUtilization?: number;
+    requires?: PermissionKind[];
+}
+interface PositionConstraints {
+    /** Aave isolation mode: capped debt, no collateral mixing. */
+    isolation?: {
+        enabled: boolean;
+        debtCeiling?: string;
+        ceilingUtilization?: number;
+    };
+    /** Borrowing this asset forbids borrowing any other in the same account. */
+    siloedBorrowing?: boolean;
+    crossMargin: boolean;
+    /**
+     * How a position is ADDRESSED. `loanId` already means five different things
+     * across our lenders and `termId` six — making the model explicit is
+     * cheaper than making every integrator rediscover it.
+     */
+    positionModel: Open<'account' | 'sub-account' | 'nft' | 'cdp-id' | 'loan-id' | 'escrow'>;
+    /** One line saying what the id in `loanId`/`posId` actually IS here. */
+    positionIdMeaning?: string;
+    maxPositions?: number;
+    /**
+     * What this fetch actually SAW, as opposed to what the lender family
+     * implies. Kept separate from `crossMargin` / `positionModel` on purpose:
+     * those are family-level truths from the registry, these are per-fetch
+     * observations, and collapsing the two would let a thin chain (a lender
+     * listing one asset today) masquerade as a structural property.
+     *
+     * Useful precisely where they DISAGREE — e.g. Fluid is registered isolated
+     * because its T1 vaults dominate, but its T2–T4 "smart" vaults genuinely
+     * pool two collaterals; a `collateralAssetCount > 1` on a Fluid row is the
+     * signal that this particular vault is one of them.
+     */
+    observed?: {
+        /** Distinct collateral assets this market actually accepts, this fetch. */
+        collateralAssetCount: number;
+        /** Markets seen under this lender key on this chain, this fetch. */
+        marketCount: number;
+        /** Does the lender key fan out to many markets (registry answer)? */
+        multiMarketKey: boolean;
+    };
+}
+type AdminKind = Open<'EOA' | 'SAFE' | 'TIMELOCK' | 'GOVERNOR' | 'GOVERNANCE' | 'CUSTOM' | 'UNKNOWN'>;
+type GovernancePower = Open<'pause-deposits' | 'pause-withdrawals' | 'pause-borrows' | 'freeze-market' | 'change-ltv' | 'change-rate' | 'change-fees' | 'set-caps' | 'add-collateral' | 'swap-oracle' | 'upgrade-implementation' | 'blacklist' | 'seize-funds' | 'reprice-pending-redemptions'>;
+interface GovernanceTerms {
+    mutability: Open<'immutable' | 'governed' | 'unknown'>;
+    /** The governance root, after hopping proxy admins / timelock admins. */
+    controller?: string;
+    controllerKind?: AdminKind;
+    safe?: {
+        threshold: number;
+        owners: number;
+    };
+    /**
+     * Enforced delay in SECONDS between a parameter change being queued and it
+     * taking effect — the holder's NOTICE PERIOD. `0`, or any `controllerKind`
+     * that is not `TIMELOCK`, means a parameter can change in the very next
+     * block with no warning.
+     *
+     * **This is NOT a withdrawal lock.** `SupplyExitTerms.cooldownSecs` is how
+     * long YOUR money is stuck; this is how long you have to react to someone
+     * else changing the deal. Never merge or sum the two.
+     */
+    timelockSecs?: number;
+    timelockSource?: Open<'on-chain' | 'screened' | 'metadata'>;
+    /**
+     * The controller IS a timelock but its delay could not be read. Distinct
+     * from `timelockSecs: undefined` on a non-timelock root, which genuinely
+     * means "no notice period" — conflating the two would raise a false alarm
+     * on the safest governance shape.
+     */
+    timelockUnknown?: boolean;
+    tier?: Open<'low' | 'medium' | 'high' | 'unknown'>;
+    score?: number;
+    powers?: GovernancePower[];
+    roles?: {
+        owner?: string;
+        curator?: string;
+        guardian?: string;
+        feeRecipient?: string;
+    };
+    /** Governance screens refresh far slower than rates — own timestamp. */
+    asOfScreen?: number;
+}
+type OracleBand = Open<'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL'>;
+interface OracleTerms {
+    /**
+     * `none` is MEANINGFUL, not missing data: Teller liquidates on TIME and has
+     * no oracle and no health factor anywhere in its trigger.
+     */
+    kind: Open<'price-feed' | 'nav-attested' | 'none'>;
+    /**
+     * THE oracle for this `marketUid` — SINGULAR, lowercased. Verified across
+     * the full oracle classification: 8,993 marketUids, 0 with more than one
+     * address. Singularity holds because `marketUid` granularity is already
+     * per-asset; the array in the legacy `oracleInfo.feeds[]` is an artifact of
+     * hanging off the lender/params level instead.
+     *
+     * For a composite/cross adapter this is the ADAPTER — the address whose
+     * failure or replacement moves this market's price.
+     */
+    address?: string;
+    /** Underlying feeds when the adapter composes several and the classifier
+     *  decomposed them. `address` stays the single source of truth. */
+    components?: string[];
+    provider?: string;
+    /** Decoded reported pair, e.g. `"ETH / USD"`. */
+    priceDescription?: string;
+    /** What it SHOULD report, e.g. `"WETH / USD"`. */
+    intendedPair?: string;
+    correctAsset?: boolean | null;
+    correctNumeraire?: boolean | null;
+    fixedRate?: boolean;
+    score?: number;
+    band?: OracleBand;
+    flags?: string[];
+    /** Can the oracle be swapped/upgraded, and by whom. On an otherwise
+     *  IMMUTABLE market this is the ONLY mutable trust vector. */
+    mutability?: {
+        mutable: boolean;
+        kind: Open<'IMMUTABLE' | 'PROXY' | 'AUTHORITY' | 'UNKNOWN'>;
+        controller?: string;
+        controllerKind?: AdminKind;
+        timelockSecs?: number;
+    };
+    heartbeatSecs?: number;
+    lastUpdateAt?: number;
+}
+interface AssetQuality {
+    /** 1 (best) … 5 (worst). */
+    riskScore?: number;
+    source?: Open<'whitelist' | 'default' | 'curated'>;
+    /** On-chain USD liquidity available to absorb a liquidation — the number
+     *  that decides whether the LLTV is actually enforceable. */
+    liquidityUsd?: number;
+    /** The TOKEN CONTRACT's own governance, distinct from the market's. An
+     *  upgradeable, pausable collateral is a supplier risk even on an
+     *  immutable market. */
+    governanceScore?: number;
+    governanceLevel?: Open<'green' | 'amber' | 'red'>;
+    upgradeable?: boolean;
+    canPause?: boolean;
+    adminKind?: AdminKind;
+}
+interface ExposureEntry {
+    asset: TermAssetRef;
+    /** That asset's OWN row in this lender — join key to its full term sheet. */
+    marketUid?: string;
+    via: Open<'collateral' | 'vault-allocation' | 'strategy' | 'idle'>;
+    assets?: number;
+    assetsUsd?: number;
+    /** 0..100. ABSENT when `weightBasis === 'unweighted'`. */
+    weightPct?: number;
+    ltv?: number;
+    liquidationLtv?: number;
+    liquidationPenalty?: number;
+    /** The collateral's OWN oracle. Your deposit's safety depends on the oracle
+     *  pricing SOMEONE ELSE'S collateral. */
+    oracle?: OracleTerms;
+    quality?: AssetQuality;
+}
+interface ExposureTerms {
+    count: number;
+    /**
+     * How `weightPct` was obtained, and therefore how much to trust it.
+     * `unweighted` = POOLED lenders: Aave/Compound do not record which
+     * collateral backs which borrow on-chain, so the list is the ACCEPTED SET,
+     * not a measured split. Do not render a pie chart from it.
+     */
+    weightBasis: Open<'debt' | 'allocation' | 'unweighted'>;
+    worstRiskScore?: number;
+    worstOracleBand?: OracleBand;
+    /** Largest single exposure's `weightPct` — the concentration signal. Only
+     *  meaningful when `weightBasis !== 'unweighted'`. */
+    topWeightPct?: number;
+    items: ExposureEntry[];
+}
+interface UtilizationTerms {
+    /** borrowed / supplied, 0..1 — the IRM input for this market. */
+    utilization: number;
+    /**
+     * The basis the ratio is computed over. NOT always this row: rates for
+     * shared-liquidity protocols are set on a larger pool, and a simulation
+     * must shift THAT, not the row totals.
+     */
+    basis: Open<'market' | 'hub' | 'liquidity-layer' | 'pool'>;
+    irmTotalDeposits?: number;
+    irmTotalDebt?: number;
+    /** Where the curve steepens — headroom before the rate jumps. */
+    targetUtilization?: number;
+    kinkUtilization?: number;
+    /** 0..1. `1` = cap full and the side is closed. */
+    supplyCapUtilization?: number;
+    borrowCapUtilization?: number;
+    /** Fluid: share of collateral locked below the withdrawal limit. */
+    lockupRatio?: number;
+}
+/**
+ * A non-default risk category, expressed as a DELTA against the resolved
+ * default. `config` is a MAP keyed by category (Aave e-modes, Dolomite
+ * categories, Euler configs, Silo) — a single flat LTV silently reports the
+ * default and hides the rest, which on an Aave ETH-correlated e-mode is the
+ * difference between 80 % and 93 %.
+ */
+interface ModeVariant {
+    /** The `config` map key. `'0'` is the default on every lender. */
+    modeId: string;
+    label?: string;
+    isDefault: boolean;
+    entry?: Open<'automatic' | 'user-selected' | 'per-position'>;
+    liquidation?: Partial<LiquidationTerms>;
+    /**
+     * Mode-scoped and usually RESTRICTED: an e-mode typically narrows the
+     * accepted collateral to a correlated basket. Omitting it would make the
+     * headline LTV look obtainable against collateral the mode forbids.
+     */
+    acceptedCollateral?: ExposureTerms;
+    rate?: Partial<RateTerms>;
+    availability?: Partial<AvailabilityTerms>;
+}
+interface SupplyTermSheet {
+    /** Is this position earning, or is it just collateral? */
+    role: Open<'yield' | 'collateral' | 'both'>;
+    rate: RateTerms;
+    maturity: MaturityTerms;
+    exit: SupplyExitTerms;
+    /** ALL fees on this side, including the exit subset. */
+    fees: FeeTerm[];
+    /** What secures the debt drawn against this deposit. */
+    backedBy?: ExposureTerms;
+    modes?: ModeVariant[];
+    counterparty: CounterpartyTerms;
+    availability: AvailabilityTerms;
+    /** Is the supplied principal at risk beyond ordinary credit risk? */
+    principal: {
+        protected: boolean;
+        risks: Open<'bad-debt' | 'physical-delivery' | 'nav-drawdown' | 'first-loss' | 'depeg'>[];
+    };
+    info: TermInfo;
+    /** Namespaced escape hatch — see the promotion rule in TERM_SHEET_PLAN §13.5. */
+    ext?: Record<string, unknown>;
+}
+interface BorrowTermSheet {
+    rate: RateTerms;
+    maturity: MaturityTerms;
+    /**
+     * Does the amount owed GROW, or is it a static face value fixed at trade
+     * time? The single biggest departure from variable-rate intuition — four of
+     * six fixed-term lenders are static.
+     */
+    debtShape: Open<'accruing' | 'static-face' | 'prepaid'>;
+    exit: BorrowExitTerms;
+    /** Fully resolved for the DEFAULT mode. `modes[]` carries the rest. */
+    liquidation: LiquidationTerms;
+    /** What you may post, each with its own LTV, oracle and quality. */
+    acceptedCollateral?: ExposureTerms;
+    modes?: ModeVariant[];
+    fees: FeeTerm[];
+    counterparty: CounterpartyTerms;
+    availability: AvailabilityTerms;
+    info: TermInfo;
+    ext?: Record<string, unknown>;
+}
+/**
+ * Distinguishes "not applicable" from "not implemented yet" — the affordance
+ * that lets phases ship incrementally without lying. A missing `oracle` must
+ * never read as "this market has no oracle" when the truth is "we have not
+ * classified it".
+ */
+interface CoverageInfo {
+    /** Blocks genuinely computed for this market. */
+    present: string[];
+    /** Blocks that do NOT APPLY here — a positive fact. */
+    notApplicable?: Record<string, string>;
+    /** Blocks that WOULD apply but are not wired yet. */
+    pending?: Record<string, string>;
+}
+/** Current schema version. Bumped ONLY for removals/semantic/unit changes;
+ *  new optional fields and new enum members are additive. */
+declare const TERM_SHEET_SCHEMA_VERSION = 1;
+interface TermSheet {
+    schemaVersion: number;
+    /** unix seconds at fetch — everything here is a snapshot. */
+    asOf: number;
+    /** `<family>.<variant>@v<n>`, e.g. `aave-v3.pool@v1`. Points at the prose
+     *  catalogue so the per-market payload stays small. */
+    profileId: string;
+    /** The anchor this sheet describes. */
+    marketUid?: string;
+    lender?: string;
+    chainId?: string;
+    /**
+     * The market's own underlying asset.
+     *
+     * Load-bearing, not decoration: `availability.minSize`, `availability.cap`
+     * and `exit.minDebt` are all RAW base units, and without decimals + symbol a
+     * consumer cannot render any of them. The sheet described a market without
+     * ever saying which asset it was about.
+     */
+    asset?: TermAssetRef;
+    supply?: SupplyTermSheet;
+    borrow?: BorrowTermSheet;
+    /** Shared — these describe the MARKET, not a side. */
+    governance?: GovernanceTerms;
+    oracle?: OracleTerms;
+    utilization?: UtilizationTerms;
+    constraints?: PositionConstraints;
+    coverage?: CoverageInfo;
+    ext?: Record<string, unknown>;
+}
+/** Compact form for list endpoints — `?terms=digest`. */
+interface TermSheetDigest {
+    schemaVersion: number;
+    profileId: string;
+    marketUid?: string;
+    supply?: {
+        rateKind: RateKind;
+        aprTotal: AprPercent;
+        maturityKind: MaturityTerms['kind'];
+        maturity?: number;
+        exitMode: SupplyExitMode;
+        settlement: SupplyExitTerms['settlement'];
+        canOpen: boolean;
+        headline: string;
+        tags: TermTag[];
+        backedBy?: Omit<ExposureTerms, 'items'>;
+    };
+    borrow?: {
+        rateKind: RateKind;
+        apr: AprPercent;
+        maturityKind: MaturityTerms['kind'];
+        maturity?: number;
+        debtShape: BorrowTermSheet['debtShape'];
+        earlyRepay: BorrowExitTerms['earlyRepay'];
+        liquidationTrigger: LiquidationTerms['trigger'];
+        canOpen: boolean;
+        headline: string;
+        tags: TermTag[];
+        acceptedCollateral?: Omit<ExposureTerms, 'items'>;
+    };
+    oracle?: Pick<OracleTerms, 'kind' | 'address' | 'provider' | 'band'>;
+    governance?: Pick<GovernanceTerms, 'mutability' | 'controllerKind' | 'timelockSecs' | 'tier'>;
+    utilization?: number;
+}
+/** A term profile — the invariant prose, one per lender family × variant. */
+interface TermProfile {
+    id: string;
+    /** Display name, e.g. `Aave V3 pool market`. */
+    name: string;
+    /** Which lender family this covers. */
+    family: string;
+    supply?: {
+        description: string;
+        implications?: string[];
+    };
+    borrow?: {
+        description: string;
+        implications?: string[];
+    };
+    docsUrl?: string;
+}
+/** Deep-partial, for adapters that return only what they override. */
+type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends (infer U)[] ? U[] : T[K] extends object | undefined ? DeepPartial<NonNullable<T[K]>> : T[K];
+};
+
+/**
+ * The normalized input the builder reads.
+ *
+ * Deliberately NOT `PoolData` directly: the same market travels through this
+ * codebase in two casings — the in-package shape (`totalDepositsUSD`,
+ * `variableBorrowRate`) and the API-serialized shape (`totalDepositsUsd`,
+ * nested `caps`/`flags`/`config`). The builder must work on both, because it
+ * runs in-package during a fetch AND at the worker while proxying an origin
+ * response.
+ *
+ * So: one tolerant reader (`toTermSheetInput`) normalizes either shape into
+ * this interface, and the builder itself is pure over the normalized form.
+ */
+interface TermConfigEntry {
+    category: number | string;
+    label?: string;
+    borrowCollateralFactor?: number;
+    collateralFactor?: number;
+    borrowFactor?: number;
+    liquidationPenalty?: number;
+    closeFactor?: number;
+    targetHealthFactor?: number;
+    collateralDisabled?: boolean;
+    debtDisabled?: boolean;
+}
+interface TermRewardInput {
+    asset?: string;
+    depositRate?: number;
+    variableBorrowRate?: number;
+    stableBorrowRate?: number;
+    /** Merkl / points programs mark themselves; absent ⇒ a normal token. */
+    kind?: string;
+    endsAt?: number;
+    claim?: string;
+}
+interface TermMenuInput {
+    termId: number;
+    durationSecs: number;
+    durationDays: number;
+    apr: number;
+    depositApr?: number;
+    available?: number;
+}
+/** Normalized market facts the generic builder needs. */
+interface TermSheetInput {
+    marketUid: string;
+    lender: string;
+    chainId: string;
+    /** Underlying asset of THIS row. */
+    asset?: {
+        chainId?: string;
+        address?: string;
+        symbol?: string;
+        name?: string;
+        decimals?: number;
+        assetGroup?: string;
+        logoURI?: string;
+    };
+    underlying?: string;
+    decimals?: number;
+    depositRate?: number;
+    variableBorrowRate?: number;
+    stableBorrowRate?: number;
+    intrinsicYield?: number;
+    rewards?: TermRewardInput[];
+    rateModel?: string;
+    originationFee?: number;
+    totalDeposits?: number;
+    totalDebt?: number;
+    totalDebtStable?: number;
+    totalLiquidity?: number;
+    borrowLiquidity?: number;
+    totalDepositsUsd?: number;
+    totalDebtUsd?: number;
+    totalLiquidityUsd?: number;
+    utilization?: number;
+    irmTotalDeposits?: number;
+    irmTotalDebt?: number;
+    lockupRatio?: number;
+    supplyCap?: number;
+    borrowCap?: number;
+    debtCeiling?: string | number;
+    /** Minimum borrow in RAW base units (Compound V3 `baseBorrowMin`). */
+    minBorrow?: string;
+    isActive?: boolean;
+    isFrozen?: boolean;
+    borrowingEnabled?: boolean;
+    depositsEnabled?: boolean;
+    collateralActive?: boolean;
+    hasStable?: boolean;
+    variableBorrowDisabled?: boolean;
+    config?: Record<string, TermConfigEntry>;
+    closeFactor?: number;
+    targetHealthFactor?: number;
+    fixedTerm?: {
+        model?: string;
+        maturity?: number;
+        fees?: {
+            continuousFeeApr?: number;
+            settlementFee?: number;
+            latePenaltyApr?: number;
+            originationFeePercent?: number;
+        };
+        earlyRepay?: {
+            kind?: string;
+        };
+        provider?: {
+            kind?: string;
+            address?: string;
+        };
+        auction?: Record<string, unknown>;
+    };
+    terms?: TermMenuInput[];
+    /** Market-level params (`params.market`) when the lender has them. */
+    market?: Record<string, unknown>;
+}
+/**
+ * Normalize either the in-package `PoolData`-ish row or an API `LendingMarket`
+ * item into {@link TermSheetInput}. Tolerant by design: a field missing under
+ * one casing is looked up under the other, and nested `caps`/`flags` bundles
+ * are unwrapped.
+ */
+declare function toTermSheetInput(row: Record<string, any>, ctx?: {
+    marketUid?: string;
+    lender?: string;
+    chainId?: string;
+    market?: Record<string, any>;
+    /**
+     * Item-level fixed-term descriptor. `/lending/latest` attaches `fixedTerm`
+     * to the LENDER item, not to each market row, so without this every
+     * fixed-term market would silently lose its maturity, its fees and its
+     * auction window. A row-level `fixedTerm` (how `/pools/latest` serializes
+     * it) is more specific and wins.
+     */
+    fixedTerm?: Record<string, any>;
+}): TermSheetInput;
+
+/**
+ * Accepted-collateral / backing set from the SIBLING rows of the same lender.
+ *
+ * Pooled lenders (Aave, Compound) do NOT record on-chain which collateral
+ * backs which borrow, so the result is the ACCEPTED SET with
+ * `weightBasis: 'unweighted'` and NO `weightPct` on any item. Inventing a
+ * TVL-proxy weight would look authoritative and be false — a large idle
+ * collateral market is not a large exposure.
+ */
+declare function buildExposures(input: TermSheetInput, siblings: TermSheetInput[], direction: 'backing' | 'accepted'): ExposureTerms | undefined;
+/** Deep merge an adapter's partial over the generic result. Arrays REPLACE. */
+declare function mergeDeep<T>(base: T, patch: DeepPartial<T> | undefined): T;
+/**
+ * Fill `info` (headline / description / tags) LAST, after adapters have run,
+ * so the prose always describes the final values rather than the generic
+ * guess. This is the mechanism that stops copy drifting from numbers.
+ */
+declare function finalizeInfo(sheet: TermSheet): TermSheet;
+interface BuildTermSheetOptions {
+    /** Unix seconds; injected so tests are deterministic. */
+    now?: number;
+    /** Other rows of the SAME lender+chain — used to derive the exposure set. */
+    siblings?: TermSheetInput[];
+    /** Adapter output, merged over the generic result. */
+    patch?: DeepPartial<TermSheet>;
+    profileId?: string;
+}
+/** Build one complete term sheet for one market row. */
+declare function buildTermSheet(input: TermSheetInput, opts?: BuildTermSheetOptions): TermSheet;
+
+/** Supply-side tags. Market-level tags are folded in by the caller. */
+declare function deriveSupplyTags(supply: SupplyTermSheet, market?: Pick<TermSheet, 'governance' | 'oracle'>): TermTag[];
+/** Borrow-side tags. */
+declare function deriveBorrowTags(borrow: BorrowTermSheet, market?: Pick<TermSheet, 'governance' | 'oracle'>): TermTag[];
+
+/**
+ * Severity model — PURE, derived only from structured fields.
+ *
+ * Space is the binding constraint at every display depth, so ranking has to be
+ * principled rather than per-lender taste. There is deliberately NO
+ * hand-maintained list of "scary markets": a newly integrated lender is
+ * classified correctly the moment its adapter sets the right fields.
+ *
+ * - `critical` — you can lose MORE than the amount at stake, or lose it
+ *   without doing anything wrong. This is the only tier that should gate a
+ *   signature.
+ * - `warn` — it costs money, or blocks you.
+ * - `info` — everything else.
+ */
+type Severity = 'critical' | 'warn' | 'info';
+interface SeverityFinding {
+    severity: Severity;
+    /** Stable slug — the join key for UI copy and for tests. */
+    id: string;
+    /** Ready-to-render sentence. */
+    message: string;
+    side: 'supply' | 'borrow' | 'market';
+}
+/** Sort findings most-severe-first, stable within a tier. */
+declare function rankFindings(findings: SeverityFinding[]): SeverityFinding[];
+declare function supplyFindings(supply: SupplyTermSheet): SeverityFinding[];
+declare function borrowFindings(borrow: BorrowTermSheet): SeverityFinding[];
+/**
+ * All findings for one side of a sheet, ranked most-severe-first. Pass
+ * `side: 'supply' | 'borrow'` — market-level findings are always included
+ * because governance and oracle affect both sides.
+ */
+declare function findingsFor(sheet: TermSheet, side: 'supply' | 'borrow'): SeverityFinding[];
+/** Does this side carry anything that should gate a signature? */
+declare function hasCritical(sheet: TermSheet, side: 'supply' | 'borrow'): boolean;
+
+/** `4.1234` → `"4.12 %"`; trims to 2dp, drops a trailing `.00`. */
+/**
+ * Format an already-PERCENT value (`49.88` → `"49.88%"`).
+ *
+ * Never pass a fraction. The convention across the term sheet is **rates are
+ * percent, factors/ratios are fractions**, so `liquidationLtv`, `penalty`,
+ * `utilization` and every `*Ratio` must be multiplied by 100 at the call site.
+ *
+ * Trailing zeros are trimmed only inside the FRACTIONAL part: a naive
+ * `/\.?0+$/` strip eats integer zeros whenever `dp = 0` leaves no decimal
+ * point, turning `100` into `"1"` and `1000` into `"1"`.
+ *
+ * No space before the `%` — the portal formats the same numbers without one,
+ * and a headline reading "49.88 %" next to a table cell reading "49.88%" looks
+ * like two different figures.
+ */
+declare function pct(value: number | undefined, dp?: number): string;
+/** Duration in seconds → the coarsest human unit that stays honest. */
+declare function duration(secs: number | undefined): string;
+/** Unix seconds → `"3 Sep 2026"`. Locale-independent so snapshots are stable. */
+declare function shortDate(unixSecs: number | undefined): string;
+/** One fee → a self-contained phrase, correct even for an unrecognised `id`. */
+declare function feePhrase(fee: FeeTerm): string;
+/** Supply-side headline: ≤ ~100 chars, always populated. */
+declare function supplyHeadline(s: SupplyTermSheet): string;
+/** Borrow-side headline. */
+declare function borrowHeadline(b: BorrowTermSheet): string;
+/** Supply-side description — 1–3 sentences, market values interpolated. */
+declare function supplyDescription(s: SupplyTermSheet, sheet?: Pick<TermSheet, 'utilization'>): string;
+/** Borrow-side description. */
+declare function borrowDescription(b: BorrowTermSheet): string;
+
+declare const TERM_PROFILES: TermProfile[];
+declare function getTermProfile(id: string): TermProfile | undefined;
+/** Fallback used when a family has no dedicated profile yet. */
+declare const DEFAULT_PROFILE_ID = "pool.variable@v1";
+
+/**
+ * Stamping — the single place term sheets are attached.
+ *
+ * Runs ONCE at the end of the public-data pipeline rather than inside each
+ * lender's converter. That is the whole architecture: ~200 Aave/Compound forks
+ * get correct sheets from the generic builder with zero per-fork work, and
+ * only the ~13 exotic families need an adapter.
+ */
+interface StampOptions {
+    /** Unix seconds; injected so tests are deterministic. */
+    now?: number;
+    /** Attach ranked `implications[]` from the severity model. Default true. */
+    withImplications?: boolean;
+    /**
+     * Derive `governance` / `oracle` / exposure quality from the rows' own
+     * `oracleInfo` + `risk.breakdown`. Default true — set `false` only to test
+     * the un-enriched builder in isolation.
+     */
+    enrich?: boolean;
+}
+/**
+ * Build sheets for one lender's rows on one chain.
+ *
+ * Siblings matter: the exposure set (`backedBy` / `acceptedCollateral`) is
+ * derived by cross-referencing the OTHER rows of the same lender, so the whole
+ * group has to be built together.
+ */
+declare function buildTermSheetsForGroup(rows: Record<string, any>[], ctx?: {
+    lender?: string;
+    chainId?: string;
+    market?: Record<string, any>;
+    /** Item-level `fixedTerm` from `/lending/latest` — see `toTermSheetInput`. */
+    fixedTerm?: Record<string, any>;
+}, opts?: StampOptions): Map<string, TermSheet>;
+/**
+ * Fill `info.implications[]` from the severity model, most severe first.
+ *
+ * Derived rather than hand-written, so a newly integrated lender gets correct
+ * warnings the moment its adapter sets the right structured fields — and a
+ * warning can never contradict the numbers next to it.
+ */
+declare function attachImplications(sheet: TermSheet): TermSheet;
+/**
+ * Build an {@link EnrichmentIndex} from the market rows themselves.
+ *
+ * The governance and oracle screens are NOT a separate fetch: the origin
+ * already ships both on every row — `oracleInfo.feeds[]` (the oracle-risk
+ * classification) and `risk.breakdown[]` (the governance screen under
+ * `category: 'governance'`, the asset screen under `category: 'token'`). So
+ * the join is local to the group being stamped, with no extra round-trip and
+ * no cross-service dependency.
+ *
+ * The per-exposure enrichment falls out of the same data: an exposure item
+ * points at a SIBLING row's `marketUid`, and that sibling is already in this
+ * group — so its oracle and its asset quality are right there.
+ */
+declare function enrichmentIndexFromRows(rows: Record<string, any>[]): EnrichmentIndex;
+/**
+ * Collapse a sheet to its digest form (`?terms=digest`).
+ *
+ * Drops `items[]` from the exposure sets and the long prose — an Aave market
+ * with 30 accepted collaterals is several kB on its own, and it is the SAME
+ * accepted set repeated on every row of that lender. Every dropped item is
+ * still reachable: each carries a `marketUid` for the bulk endpoint.
+ */
+declare function toDigest(sheet: TermSheet): TermSheetDigest;
+/** Row shape of `~/risk-data/data/oracles/oracle-risk-flat.json`. */
+interface OracleRiskRow {
+    marketUid: string;
+    oracle?: string;
+    provider?: string;
+    priceDescription?: string;
+    intendedPair?: string;
+    correctOracle?: boolean | null;
+    denominatorMatch?: boolean | null;
+    fixedRate?: boolean;
+    score?: number;
+    band?: string;
+    flags?: string[];
+    /** Underlying feeds when an adapter composes several. `oracle` stays the
+     *  single source of truth — this is for auditability only. */
+    components?: string[];
+}
+/** Row shape of `~/risk-data/data/lending/market-governance-flat.json`. */
+interface GovernanceRow {
+    marketUid: string;
+    tier?: string;
+    score?: number;
+    ownerKind?: string;
+    signerThreshold?: number | null;
+    signerCount?: number | null;
+    mode?: string;
+    /** Present once the flat builder carries it through (see TERM_SHEET_PLAN §5.4.1). */
+    delaySeconds?: number | null;
+}
+/** Per-asset quality, keyed `chainId → lowercased address`. */
+type AssetRiskIndex = Record<string, Record<string, {
+    riskScore?: number;
+    source?: string;
+    liquidityUsd?: number;
+    governanceScore?: number;
+    governanceLevel?: string;
+    upgradeable?: boolean;
+    canPause?: boolean;
+    adminKind?: string;
+}>>;
+interface EnrichmentIndex {
+    oracleByMarketUid?: Map<string, OracleRiskRow>;
+    governanceByMarketUid?: Map<string, GovernanceRow>;
+    assetRisk?: AssetRiskIndex;
+}
+/**
+ * Merge governance / oracle / asset-quality onto a sheet at the SERVING layer.
+ *
+ * These cannot be computed in-package — they come from the risk-data
+ * screeners, which key on the same `marketUid` grammar (a dictionary lookup,
+ * not a fuzzy match). `margin-fetcher` emits the sheet with these blocks
+ * absent; the worker fills them in, exactly as it already does for
+ * `oracleInfo`.
+ */
+declare function enrichTermSheet(sheet: TermSheet, index: EnrichmentIndex): TermSheet;
+
+/**
+ * Invariant checker — pure, and the mechanism that turns a derivation bug into
+ * a loud failure instead of a plausible-looking wrong answer.
+ *
+ * Run over live fetched data in CI for every lender key and vault provider.
+ * Every rule here encodes something that WOULD otherwise ship silently.
+ */
+interface TermSheetViolation {
+    /** Stable slug, so a test can assert on the specific rule. */
+    rule: string;
+    message: string;
+    marketUid?: string;
+}
+declare function validateTermSheet(sheet: TermSheet): TermSheetViolation[];
+/** Validate a batch; returns every violation found, flattened. */
+declare function validateTermSheets(sheets: TermSheet[]): TermSheetViolation[];
+
+/**
+ * A term-sheet adapter: returns ONLY what the generic builder cannot derive,
+ * as a `DeepPartial<TermSheet>` merged over the generic result.
+ *
+ * Adding a lender is one adapter plus one profile entry — no core edits. The
+ * completeness test fails when a lender family reaches production without a
+ * profile, so the extension point cannot be silently skipped.
+ */
+interface TermAdapter {
+    /** Stable id, for tests and debugging. */
+    id: string;
+    /** Does this adapter handle the given lender key? */
+    matches: (lender: string) => boolean;
+    /** The profile whose prose this market points at. */
+    profileId: (input: TermSheetInput) => string;
+    build: (input: TermSheetInput) => DeepPartial<TermSheet>;
+}
+/**
+ * Order matters only where predicates could overlap; today they are disjoint.
+ * The list is walked front-to-back and the first match wins.
+ */
+declare const TERM_ADAPTERS: TermAdapter[];
+declare function resolveAdapter(lender: string): TermAdapter | undefined;
+
+export { type AaveMetadata, type AaveV2Public, type AaveV2UserReserveResponse, type AaveV3Public, type AaveV3UserReserveResponse, type AdditionalYields, type AdminKind, ApiBookSource, type AprData, type AprPercent, type AssetQuality, type AssetRiskIndex, type AuctionWindow, type AvailabilityTerms, type BalanceData, type BaseLendingPosition, type BasicReserveResponse, type BorrowExitTerms, type BorrowTermSheet, type BuildTermSheetOptions, type ChainDiagnostic, type ChainLinkResponse, type ChainQuery, type ChainSummary, type CompoundV2Metadata, type CompoundV3Public, type CompoundV3UserReserveResponse, type ConfigEntry, type ConvertLenderUserDataOptions, type CoreValidators, type CounterpartyTerms, type CoverageInfo, DEFAULT_MIDNIGHT_API, DEFAULT_OUTLIER_GUARD, DEFAULT_PROFILE_ID, DEFAULT_STALE_REJECT_SECONDS, DEFAULT_TERMMAX_API, type DeepPartial, type Denomination, type DepthMap, EMPTY_BALANCE, type EModeAssets, type EModeData, type EModeResult, EXACTLY_LENDER_KEY, type EndpointFailure, type EnrichmentIndex, type EulerEarnVault, type EulerEarnVaults, type EulerV2Metadata, type ExactlyFixedPool, type ExactlyFixedPosition, type ExactlyMarketAccount, type ExactlyMarketsRaw, type ExactlyUserFixedPosition, type ExposureEntry, type ExposureTerms, type ExtraValidationCall, type FeeTerm, type FeeWhen, type FeedObservation, type FeedStat, type FeedStatsMap, type FeedTimestampMap, type FetchListaVaultsFromChainOptions, type FetchMorphoVaultsFromChainOptions, type FetchOraclePricesOptions, type FetchTokenBalancesOptions, type FlattenPriorityConfig, type FluidFToken, type FluidFTokens, type FrankencoinMarketRaw, type FrankencoinMarketsRaw, type FrankencoinPositionInfo, 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 GovernancePower, type GovernanceRow, type GovernanceTerms, 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 IncompleteLenderRead, type IncompleteReason, type InitMetadata, type InitPublic, type InitUserReserveResponse, type InterfaceKind, type InvariantViolation, 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 LiquidationPenaltyTerm, type LiquidationTerms, type LiquityBranchRaw, type LiquityDiscoveredTrove, type LiquityDiscovery, type LiquityMarketsRaw, type LiquitySpInfo, type LiquityTroveInfo, type ListaMarketOverrides, type LlamaLendMarketRaw, type LlamaLendMarketsRaw, type LlamaLendPositionInfo, type LoopPostTradeMetrics, type LstDelegation, type LstDelegationKind, type LstValidator, type LstWithdrawalFetchOptions, type LstWithdrawalRegistryEntry, type LstWithdrawalRequest, type LstWithdrawalRequestsByLst, type LstWithdrawalStatus, MORPHO_LENS, MULTICALL_FAILURE, type MaturityTerms, MaxParamThresholds, type MergedUserData, type MidnightBook, type MidnightBookLevel, type MidnightBookSource, type ModeBase, type ModeVariant, type MorphoMarketOverrides, type MorphoSubgraphProxyConfig, type MorphoUserMarketBalance, type MorphoUserReserveResponse, type MorphoVault, type MorphoVaults, type MulticallEndpointOptions, type MulticallRpcBatch, type NumberMap, type Open, type OracleBand, type OracleDiagnostics, type OraclePriceEntry, type OraclePricesResult, type OracleRiskRow, type OracleTerms, type OutlierGuardConfig, type ParsedBalanceData, type ParsedResponse, type ParsedUserBalance, type PermissionKind, type PermissionParams, type PoolData, type PoolWithMeta, type PortfolioSummary, type PortfolioTotals, type PositionConstraints, type PostTradeMetrics, type PreparedCall, type PreparedMergedMulticallParams, type PreparedMergedRpcCalls, type PreparedTokenBalanceRpcCalls, type PreparedUserDataRpcCalls, type PriceDerivation, type PriceSelection, type ProtocolParams, type ProviderOptions, type RateKind, type RateMenuEntry, type RateTerms, type RawRpcBatch, type RawRpcCall, type RawRpcResponse, type ReadFailurePolicy, type ResupplyMarketsRaw, type ResupplyPairIdentity, type ResupplyPairRaw, type ResupplyPositionInfo, type ResupplyWrappedMarket, type RewardTerm, type RiverMarketRaw, type RiverMarketsRaw, type RiverPositionInfo, STABLECOIN_SYMBOLS, STCELO_MANAGER_ADDRESS, type SelectPricesOptions, type Severity, type SeverityFinding, type SiloVault, type SiloVaults, type StCeloValidatorGroup, type StaleFeedEntry, type StampOptions, type StructuredOraclePrices, type SubAccountSummary, type SumerPositionInput, type SummaryAprData, type SummaryBalanceData, type SupplyExitMode, type SupplyExitTerms, type SupplyTermSheet, 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, TERM_ADAPTERS, TERM_PROFILES, TERM_SHEET_SCHEMA_VERSION, type TellerDiscoveredBid, type TellerDiscovery, type TellerMarketsRaw, type TellerPoolRaw, type TermAdapter, type TermAssetRef, type TermAuctionOrder, type TermAuctionOrders, type TermBookSource, type TermBookTop, type TermInfo, type TermListing, type TermMarketRaw, TermMaxApiSource, type TermMaxBookTop, type TermMaxCurveSegment, type TermMaxDataSource, type TermMaxDiscovery, type TermMaxFeeConfig, type TermMaxMarketConfig, type TermMaxMarketRaw, type TermMaxOrderState, type TermProfile, type TermSheet, type TermSheetDigest, type TermSheetInput, type TermSheetViolation, TermSubgraphSource, type TermTag, 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 UsddMarketRaw, type UsddMarketsRaw, type UsddPositionInfo, type UserApr, type UserConfig, type UserData, type UserDataResult, type UserLendingPosition, type UtilizationTerms, VAULT_SHARE_PRICE_PROBE, VOLATILE_VAULT_OVERRIDES, type ValidationResult, 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, __resetResupplyUserCaches, accountDepositListKey, accountWithdrawalListKey, appendSnapshot, applyPositionDelta, attachImplications, attachPricesToFlashLiquidity, borrowDescription, borrowFindings, borrowHeadline, buildExposures, buildFluidFTokensCall, buildLiquityUserCall, buildLoopResult, buildMorphoTypeCall, buildMorphoTypeUserCallWithLens, buildPortfolioTotals, buildSumerAccumulators, buildSummaries, buildTellerUserCall, buildTermMaxUserCall, buildTermSheet, buildTermSheetsForGroup, 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, convertFrankencoinMarketsToResponse, convertInverseMarketsToResponse, convertLenderUserDataResult, convertLiquityMarketsToResponse, convertLlamaLendMarketsToResponse, convertResupplyMarketsToResponse, convertRiverMarketsToResponse, convertTellerMarketsToResponse, convertTermMarketsToResponse, convertTermMaxMarketsToResponse, convertUsddMarketsToResponse, createMarketUid, createMidnightBookSource, createMulticallRpcCall, createRawRpcCalls, createTermBookSource, createTermMaxDataSource, decodeListaMarkets, decodeMarkets, decodePackedListaUserDataset, decodePackedMorphoUserDataset, deriveBorrowTags, deriveSupplyTags, detectInterfaceKinds, duration, encodeBalanceFetcherCalldata, enrichTermSheet, enrichmentIndexFromRows, exactlyPairLtv, exactlyPenaltyRateToAprPercent, exactlyWadRateToPercent, feePhrase, feedKeyOf, feedStatKey, fetchDolomiteAccountNumbers, fetchEulerEarnVaults, fetchEulerEarnVaultsFromSubgraph, fetchEulerSubAccountIndexes, fetchExactlyMarkets, fetchFlashLiquidityForChain, fetchFluidFTokens, fetchFrankencoinMarkets, fetchGeneralYields, fetchGeneralYieldsByMarketUid, fetchGmxExecutionFees, fetchGmxTickerPrices, fetchGmxVaults, fetchHypercoreVaults, fetchInverseMarkets, fetchLagoonApiVaults, fetchLagoonVaults, fetchLiquityMarkets, fetchListaVaultsFromChain, fetchLlamaLendMarkets, fetchMorphoUserBalances, fetchMorphoUserPositionMarkets, fetchMorphoVaults, fetchMorphoVaultsFromApi, fetchMorphoVaultsFromChain, fetchOraclePrices, fetchPendlePrices, fetchResupplyMarkets, fetchRiverMarkets, fetchSiloVaults, fetchTellerMarkets, fetchTermMarkets, fetchTermMaxMarkets, fetchTokenBalances, fetchTokenMetadata, fetchUpshiftApiVaults, fetchUpshiftVaults, fetchUsddMarkets, fetchYearnApiVaults, fetchYearnVaults, filterActiveLenders, filterLendersByProtocol, finalizeInfo, findingsFor, frankencoinKeyParts, frankencoinLenderKey, 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, getReadFailurePolicy, getResolvedDolomiteAccountNumbers, getStCeloValidatorGroups, getSubAccountAddress, getSubAccountIndex, getTermProfile, getVaultPublicDataAll, getVaultWithdrawalRequests, hasCritical, hasEulerEarnVaultSubgraph, hasLagoonVaults, hasMorphoPositionIndex, hasMorphoUserApi, hasMorphoUserSubgraph, hasUpshiftVaults, hasYearnVaults, inverseKeyParts, inverseLenderKey, isFailedCall, isStablecoinSymbol, isYearnV3, keysFromMaps, lenderApiOnly, lenderFamily, liquityCandidateTroveIds, liquityKeyParts, liquityLenderKey, llamaLendKeyParts, llamaLendLenderKey, mergeDeep, multicall3Abi, nanTo, needsLenderApproval, needsTokenApproval, noOpResult, normalizeToBytes, parseBalanceFetcherResult, parseMergedResult, parseMulticallRpcResponses, parseRawRpcBatchResponses, parseRawRpcResponses, parseTermMaxLtv, parseTokenBalanceResult, pct, positivePart, predictInverseEscrow, prepareLenderUserDataRpcCalls, prepareMergedMulticallParams, prepareMergedRpcCalls, prepareMulticallInputs, prepareTokenBalanceRpcCalls, priceGlvVaults, priceGmMarkets, probeAaveFeedTimestamps, pruneFeedStats, rankFindings, readVaultSharePrices, rejectOutliers as rejectPriceOutliers, resolveAdapter, resolveDerivation, resolveStCeloDepositGroup, resupplyKeyParts, resupplyLenderKey, riverKeyParts, riverLenderKey, selectAssetGroupPrices, shortDate, stampVaultClassification, supplyDescription, supplyFindings, supplyHeadline, 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, toDigest, toTermSheetInput, unflattenLenderData, updateFeedStats, usddIlkBytes32, usddKeyParts, usddLenderKey, validateTermSheet, validateTermSheets, validateUserData };