@1delta/margin-fetcher 0.0.410 → 0.0.412

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import { Lender } from '@1delta/lender-registry';
 export { isAaveType, isAaveV2Type, isAaveV32Type, isAaveV3Type, isCompoundV3, isCompoundV3Type, isInit, isMorphoType, isMultiMarket, isYLDR } from '@1delta/lender-registry';
 import { DebitData, LenderDebitData, LstAcceptedInput } from '@1delta/calldata-sdk';
 import { RelayProxyConfig } from '@1delta/proxy-fetch';
-import { TermMarketConfig, LiquityBranchConfig, LiquityConfigChain, RiverMarketConfig, RiverConfigChain, RiverChainData, InverseMarketConfig, InverseConfigChain, InverseChainData, UsddMarketConfig, UsddConfigChain, UsddChainData, 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 {
@@ -444,16 +444,33 @@ interface FixedTermInfo {
      */
     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;
@@ -462,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;
@@ -1560,6 +1595,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;
@@ -1590,19 +1645,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
@@ -1663,6 +1712,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: {
@@ -2521,26 +2584,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;
@@ -2874,6 +2957,14 @@ interface InverseMarketRaw {
     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 {
@@ -2937,6 +3028,184 @@ declare function convertInverseMarketsToResponse(raw: InverseMarketsRaw, chainId
     [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;
 
@@ -2953,6 +3222,184 @@ interface InversePositionInfo {
     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;
 }
 
 /**
@@ -3057,6 +3504,115 @@ interface UsddPositionInfo {
     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
@@ -7629,4 +8185,4 @@ interface FetchTokenBalancesOptions {
  */
 declare function fetchTokenBalances(chainId: string, account: string, tokens: string[], options?: FetchTokenBalancesOptions): Promise<TokenBalanceResult>;
 
-export { type AaveMetadata, type AaveV2Public, type AaveV2UserReserveResponse, type AaveV3Public, type AaveV3UserReserveResponse, type AdditionalYields, ApiBookSource, type AprData, type BalanceData, type BaseLendingPosition, type BasicReserveResponse, type ChainDiagnostic, type ChainLinkResponse, type ChainQuery, type ChainSummary, type CompoundV2Metadata, type CompoundV3Public, type CompoundV3UserReserveResponse, type ConfigEntry, type CoreValidators, DEFAULT_MIDNIGHT_API, DEFAULT_OUTLIER_GUARD, DEFAULT_STALE_REJECT_SECONDS, DEFAULT_TERMMAX_API, type Denomination, type DepthMap, EMPTY_BALANCE, type EModeAssets, type EModeData, type EModeResult, type EulerEarnVault, type EulerEarnVaults, type EulerV2Metadata, type ExactlyFixedPool, type ExactlyFixedPosition, type ExactlyMarketAccount, type ExactlyMarketsRaw, type ExactlyUserFixedPosition, type ExtraValidationCall, type FeedObservation, type FeedStat, type FeedStatsMap, type FeedTimestampMap, type FetchListaVaultsFromChainOptions, type FetchMorphoVaultsFromChainOptions, type FetchOraclePricesOptions, type FetchTokenBalancesOptions, type FlattenPriorityConfig, type FluidFToken, type FluidFTokens, type FullLenderRewardsMap, GMX_API_HOSTS, GMX_READ_CONTRACTS, GMX_SUPPORTED_CHAINS, type GenericCurrency, type GenericTokenList, type GetVaultPublicDataAllOptions, type GmxExecutionFees, type GmxPendingDeposit, type GmxPendingWithdrawal, type GmxReadContracts, type GmxUserBalance, type GmxUserPositions, type GmxUserPositionsOptions, type GmxVault, type GmxVaultKind, type GmxVaults, type GmxVaultsFetchOptions, type GroupAccumulator, HYPERCORE_VAULT_REGISTRY, type HypercoreLockStatus, type HypercoreUserPositionsOptions, type HypercoreVault, type HypercoreVaultPosition, type HypercoreVaultRegistryEntry, type HypercoreVaults, type HypercoreVaultsFetchOptions, IDLE_MARKET_ID, INTERFACE_IDS, type InitMetadata, type InitPublic, type InitUserReserveResponse, type InterfaceKind, type InverseMarketRaw, type InverseMarketsRaw, type InversePositionInfo, LAGOON_API_URL, LAGOON_CHAIN_IDS, type LagoonApiVault, type LagoonSyncMode, type LagoonVault, type LagoonVaults, type LenderConfigData, type LenderConfigMap, type LenderCrossPoolMeta, type LenderData, type LenderDataEntry, type LenderInfo, type LenderInfoMap, type LenderPublicBase, type LenderRewardsMap, type LenderSummary, type LenderToLenderCrossPoolMeta, type LenderTotalAmounts, type LenderUserQuery, type LenderUserResponse, type LenderYieldComplete, type LenderYields$1 as LenderYields, LendingMode, type LiquityBranchRaw, type LiquityDiscoveredTrove, type LiquityDiscovery, type LiquityMarketsRaw, type LiquitySpInfo, type LiquityTroveInfo, type ListaMarketOverrides, type LoopPostTradeMetrics, type LstDelegation, type LstDelegationKind, type LstValidator, type LstWithdrawalFetchOptions, type LstWithdrawalRegistryEntry, type LstWithdrawalRequest, type LstWithdrawalRequestsByLst, type LstWithdrawalStatus, MORPHO_LENS, MaxParamThresholds, type MergedUserData, type MidnightBook, type MidnightBookLevel, type MidnightBookSource, type ModeBase, type MorphoMarketOverrides, type MorphoSubgraphProxyConfig, type MorphoUserMarketBalance, type MorphoUserReserveResponse, type MorphoVault, type MorphoVaults, type MulticallRpcBatch, type NumberMap, type OracleDiagnostics, type OraclePriceEntry, type OraclePricesResult, type OutlierGuardConfig, type ParsedBalanceData, type ParsedResponse, type ParsedUserBalance, type PermissionParams, type PoolData, type PoolWithMeta, type PortfolioSummary, type PortfolioTotals, type PostTradeMetrics, type PreparedCall, type PreparedMergedMulticallParams, type PreparedMergedRpcCalls, type PreparedTokenBalanceRpcCalls, type PreparedUserDataRpcCalls, type PriceDerivation, type PriceSelection, type ProtocolParams, type ProviderOptions, type RawRpcBatch, type RawRpcCall, type RawRpcResponse, type RiverMarketRaw, type RiverMarketsRaw, type RiverPositionInfo, STABLECOIN_SYMBOLS, STCELO_MANAGER_ADDRESS, type SelectPricesOptions, type SiloVault, type SiloVaults, type StCeloValidatorGroup, type StaleFeedEntry, type StructuredOraclePrices, type SubAccountSummary, type SumerPositionInput, type SummaryAprData, type SummaryBalanceData, TELLER_CALLS_PER_BID, TERMMAX_CALLS_PER_ACCOUNT, DECIMAL_BASE as TERMMAX_DECIMAL_BASE, TERMMAX_LIQUIDATION_PENALTY, TERMMAX_LIQUIDATION_WINDOW_SECS, TERMMAX_LIQUIDATOR_BONUS, TERMMAX_PARTIAL_CLOSE_FACTOR, TERMMAX_PARTIAL_LIQUIDATION_THRESHOLD_USD, type TellerDiscoveredBid, type TellerDiscovery, type TellerMarketsRaw, type TellerPoolRaw, type TermAuctionOrder, type TermAuctionOrders, type TermBookSource, type TermBookTop, type TermListing, type TermMarketRaw, TermMaxApiSource, type TermMaxBookTop, type TermMaxCurveSegment, type TermMaxDataSource, type TermMaxDiscovery, type TermMaxFeeConfig, type TermMaxMarketConfig, type TermMaxMarketRaw, type TermMaxOrderState, TermSubgraphSource, type TokenApprovalMeta, type TokenApprovalParams, type TokenBalanceEntry, type TokenBalanceQuery, type TokenBalanceResult, type TokenEntry, type TokenList, type TokenListInput, type TrackerDiagnostic, UPSHIFT_CHAIN_IDS, UPSHIFT_VAULTS_URL, type USDPriceMap, type UpshiftApiAsset, type UpshiftApiVault, type UpshiftVault, type UpshiftVaults, type UsddMarketRaw, type UsddMarketsRaw, type UsddPositionInfo, type UserApr, type UserConfig, type UserData, type UserDataResult, type UserLendingPosition, VAULT_SHARE_PRICE_PROBE, VOLATILE_VAULT_OVERRIDES, type VaultAprResult, type VaultClassification, type VaultClassificationFields, type VaultLookupEntry, type VaultMarketExposure, type VaultProvider, type VaultPublicDataAll, type VaultPublicDataResult, type VaultYieldSeries, type VaultYieldSnapshot, type YDaemonVault, YEARN_CHAIN_IDS, YEARN_YDAEMON_BASE, type YearnVault, type YearnVaultKind, type YearnVaults, type YieldProfile, accountDepositListKey, accountWithdrawalListKey, appendSnapshot, applyPositionDelta, attachPricesToFlashLiquidity, buildFluidFTokensCall, buildLiquityUserCall, buildLoopResult, buildMorphoTypeCall, buildMorphoTypeUserCallWithLens, buildPortfolioTotals, buildSumerAccumulators, buildSummaries, buildTellerUserCall, buildTermMaxUserCall, buildVaultLookup, calculateLeverage, calculateNetApr, calculateOverallNetApr, calculateWeightedAverage, classifyFreshness, classifyReliability, classifyVault, collectFeedObservations, computeBorrowDelta, computeCloseTradeDeltas, computeCollateralSwapDeltas, computeDebtSwapDeltas, computeDepositDelta, computeEModeAnalysis, computeOpenTradeDeltas, computePostTradeMetrics, computeRepayDelta, computeSumerBorrowDelta, computeSumerDepositDelta, computeSumerRepayDelta, computeSumerWaterfall, computeSumerWithdrawDelta, computeVaultApr, computeWithdrawDelta, computeZapTradeDeltas, consensusReference, convertExactlyMarketsToResponse, convertInverseMarketsToResponse, convertLenderUserDataResult, convertLiquityMarketsToResponse, convertRiverMarketsToResponse, convertTellerMarketsToResponse, convertTermMarketsToResponse, convertTermMaxMarketsToResponse, convertUsddMarketsToResponse, createMarketUid, createMidnightBookSource, createMulticallRpcCall, createRawRpcCalls, createTermBookSource, createTermMaxDataSource, decodeListaMarkets, decodeMarkets, decodePackedListaUserDataset, decodePackedMorphoUserDataset, detectInterfaceKinds, encodeBalanceFetcherCalldata, exactlyLenderKey, exactlyMarketFromLenderKey, exactlyPairLtv, exactlyPenaltyRateToAprPercent, exactlyWadRateToPercent, feedKeyOf, feedStatKey, fetchDolomiteAccountNumbers, fetchEulerEarnVaults, fetchEulerEarnVaultsFromSubgraph, fetchEulerSubAccountIndexes, fetchExactlyMarkets, fetchFlashLiquidityForChain, fetchFluidFTokens, fetchGeneralYields, fetchGeneralYieldsByMarketUid, fetchGmxExecutionFees, fetchGmxTickerPrices, fetchGmxVaults, fetchHypercoreVaults, fetchInverseMarkets, fetchLagoonApiVaults, fetchLagoonVaults, fetchLiquityMarkets, fetchListaVaultsFromChain, fetchMorphoUserBalances, fetchMorphoUserPositionMarkets, fetchMorphoVaults, fetchMorphoVaultsFromApi, fetchMorphoVaultsFromChain, fetchOraclePrices, fetchPendlePrices, fetchRiverMarkets, fetchSiloVaults, fetchTellerMarkets, fetchTermMarkets, fetchTermMaxMarkets, fetchTokenBalances, fetchTokenMetadata, fetchUpshiftApiVaults, fetchUpshiftVaults, fetchUsddMarkets, fetchYearnApiVaults, fetchYearnVaults, filterActiveLenders, filterLendersByProtocol, fuseLenderData, generateLendingPools, getAavesForChain, getAssetConfig, getBalanceForMarketUid, getBorrowCapacity, getCachedLiquityTroves, getCachedTellerBids, getCachedTermMaxDiscovery, getCachedTermMaxMarket, getCachedTermMaxMarkets, getCoreValidators, getFluidFTokensConverter, getGmxApiHost, getGmxReadContracts, getGmxUserPositions, getHealthFactor, getHypercoreUserPositions, getHypercoreVaultRegistry, getLenderAssets, getLenderPublicData, getLenderPublicDataAll, getLenderPublicDataViaApi, getLenderUserDataMulti, getLenderUserDataResult, getLendersForChain, getLstDelegation, getLstValidators, getLstWithdrawalRegistry, getLstWithdrawalRequests, getMaxAmountClose, getMaxAmountCollateralSwap, getMaxAmountDebtSwap, getMaxAmountOpen, getMergedUserData, getMorphoTypeMarketConverter, getResolvedDolomiteAccountNumbers, getStCeloValidatorGroups, getSubAccountAddress, getSubAccountIndex, getVaultPublicDataAll, getVaultWithdrawalRequests, hasEulerEarnVaultSubgraph, hasLagoonVaults, hasMorphoPositionIndex, hasMorphoUserApi, hasMorphoUserSubgraph, hasUpshiftVaults, hasYearnVaults, inverseKeyParts, inverseLenderKey, isStablecoinSymbol, isYearnV3, keysFromMaps, lenderApiOnly, lenderFamily, liquityCandidateTroveIds, liquityKeyParts, liquityLenderKey, multicall3Abi, nanTo, needsLenderApproval, needsTokenApproval, noOpResult, normalizeToBytes, parseBalanceFetcherResult, parseMergedResult, parseMulticallRpcResponses, parseRawRpcBatchResponses, parseRawRpcResponses, parseTermMaxLtv, parseTokenBalanceResult, positivePart, predictInverseEscrow, prepareLenderUserDataRpcCalls, prepareMergedMulticallParams, prepareMergedRpcCalls, prepareMulticallInputs, prepareTokenBalanceRpcCalls, priceGlvVaults, priceGmMarkets, probeAaveFeedTimestamps, pruneFeedStats, readVaultSharePrices, rejectOutliers as rejectPriceOutliers, resolveDerivation, resolveStCeloDepositGroup, riverKeyParts, riverLenderKey, selectAssetGroupPrices, stampVaultClassification, tellerBpsToPercent, tellerImpliedLtv, tellerLenderKey, tellerPoolFromLenderKey, termLenderKey, termMaxApiBase, borrowNif as termMaxBorrowNif, curveApr as termMaxCurveApr, curveAprNumber as termMaxCurveAprNumber, daysToMaturity as termMaxDaysToMaturity, lendNif as termMaxLendNif, mintGtFeeRatio as termMaxMintGtFeeRatio, ratioToNumber as termMaxRatioToNumber, ratioToPercent as termMaxRatioToPercent, tickToAprNumber, tickToPrice, unflattenLenderData, updateFeedStats, usddIlkBytes32, usddKeyParts, usddLenderKey };
+export { type AaveMetadata, type AaveV2Public, type AaveV2UserReserveResponse, type AaveV3Public, type AaveV3UserReserveResponse, type AdditionalYields, ApiBookSource, type AprData, type BalanceData, type BaseLendingPosition, type BasicReserveResponse, type ChainDiagnostic, type ChainLinkResponse, type ChainQuery, type ChainSummary, type CompoundV2Metadata, type CompoundV3Public, type CompoundV3UserReserveResponse, type ConfigEntry, type CoreValidators, DEFAULT_MIDNIGHT_API, DEFAULT_OUTLIER_GUARD, DEFAULT_STALE_REJECT_SECONDS, DEFAULT_TERMMAX_API, type Denomination, type DepthMap, EMPTY_BALANCE, type EModeAssets, type EModeData, type EModeResult, EXACTLY_LENDER_KEY, 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 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 GroupAccumulator, HYPERCORE_VAULT_REGISTRY, type HypercoreLockStatus, type HypercoreUserPositionsOptions, type HypercoreVault, type HypercoreVaultPosition, type HypercoreVaultRegistryEntry, type HypercoreVaults, type HypercoreVaultsFetchOptions, IDLE_MARKET_ID, INTERFACE_IDS, type InitMetadata, type InitPublic, type InitUserReserveResponse, type InterfaceKind, type InverseMarketRaw, type InverseMarketsRaw, type InversePositionInfo, LAGOON_API_URL, LAGOON_CHAIN_IDS, type LagoonApiVault, type LagoonSyncMode, type LagoonVault, type LagoonVaults, type LenderConfigData, type LenderConfigMap, type LenderCrossPoolMeta, type LenderData, type LenderDataEntry, type LenderInfo, type LenderInfoMap, type LenderPublicBase, type LenderRewardsMap, type LenderSummary, type LenderToLenderCrossPoolMeta, type LenderTotalAmounts, type LenderUserQuery, type LenderUserResponse, type LenderYieldComplete, type LenderYields$1 as LenderYields, LendingMode, type LiquityBranchRaw, type LiquityDiscoveredTrove, type LiquityDiscovery, type LiquityMarketsRaw, type LiquitySpInfo, type LiquityTroveInfo, type ListaMarketOverrides, type 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, 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 ResupplyMarketsRaw, type ResupplyPairIdentity, type ResupplyPairRaw, type ResupplyPositionInfo, type ResupplyWrappedMarket, type RiverMarketRaw, type RiverMarketsRaw, type RiverPositionInfo, STABLECOIN_SYMBOLS, STCELO_MANAGER_ADDRESS, type SelectPricesOptions, type SiloVault, type SiloVaults, type StCeloValidatorGroup, type StaleFeedEntry, type StructuredOraclePrices, type SubAccountSummary, type SumerPositionInput, type SummaryAprData, type SummaryBalanceData, TELLER_CALLS_PER_BID, TERMMAX_CALLS_PER_ACCOUNT, DECIMAL_BASE as TERMMAX_DECIMAL_BASE, TERMMAX_LIQUIDATION_PENALTY, TERMMAX_LIQUIDATION_WINDOW_SECS, TERMMAX_LIQUIDATOR_BONUS, TERMMAX_PARTIAL_CLOSE_FACTOR, TERMMAX_PARTIAL_LIQUIDATION_THRESHOLD_USD, type TellerDiscoveredBid, type TellerDiscovery, type TellerMarketsRaw, type TellerPoolRaw, type TermAuctionOrder, type TermAuctionOrders, type TermBookSource, type TermBookTop, type TermListing, type TermMarketRaw, TermMaxApiSource, type TermMaxBookTop, type TermMaxCurveSegment, type TermMaxDataSource, type TermMaxDiscovery, type TermMaxFeeConfig, type TermMaxMarketConfig, type TermMaxMarketRaw, type TermMaxOrderState, TermSubgraphSource, type TokenApprovalMeta, type TokenApprovalParams, type TokenBalanceEntry, type TokenBalanceQuery, type TokenBalanceResult, type TokenEntry, type TokenList, type TokenListInput, type TrackerDiagnostic, UPSHIFT_CHAIN_IDS, UPSHIFT_VAULTS_URL, type USDPriceMap, type UpshiftApiAsset, type UpshiftApiVault, type UpshiftVault, type UpshiftVaults, type UsddMarketRaw, type UsddMarketsRaw, type UsddPositionInfo, 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, __resetResupplyUserCaches, accountDepositListKey, accountWithdrawalListKey, appendSnapshot, applyPositionDelta, attachPricesToFlashLiquidity, buildFluidFTokensCall, buildLiquityUserCall, buildLoopResult, buildMorphoTypeCall, buildMorphoTypeUserCallWithLens, buildPortfolioTotals, buildSumerAccumulators, buildSummaries, buildTellerUserCall, buildTermMaxUserCall, buildVaultLookup, calculateLeverage, calculateNetApr, calculateOverallNetApr, calculateWeightedAverage, classifyFreshness, classifyReliability, classifyVault, collectFeedObservations, computeBorrowDelta, computeCloseTradeDeltas, computeCollateralSwapDeltas, computeDebtSwapDeltas, computeDepositDelta, computeEModeAnalysis, computeOpenTradeDeltas, computePostTradeMetrics, computeRepayDelta, computeSumerBorrowDelta, computeSumerDepositDelta, computeSumerRepayDelta, computeSumerWaterfall, computeSumerWithdrawDelta, computeVaultApr, computeWithdrawDelta, computeZapTradeDeltas, consensusReference, convertExactlyMarketsToResponse, convertFrankencoinMarketsToResponse, convertInverseMarketsToResponse, convertLenderUserDataResult, convertLiquityMarketsToResponse, convertLlamaLendMarketsToResponse, convertResupplyMarketsToResponse, convertRiverMarketsToResponse, convertTellerMarketsToResponse, convertTermMarketsToResponse, convertTermMaxMarketsToResponse, convertUsddMarketsToResponse, createMarketUid, createMidnightBookSource, createMulticallRpcCall, createRawRpcCalls, createTermBookSource, createTermMaxDataSource, decodeListaMarkets, decodeMarkets, decodePackedListaUserDataset, decodePackedMorphoUserDataset, detectInterfaceKinds, encodeBalanceFetcherCalldata, exactlyPairLtv, exactlyPenaltyRateToAprPercent, exactlyWadRateToPercent, 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, 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, getResolvedDolomiteAccountNumbers, getStCeloValidatorGroups, getSubAccountAddress, getSubAccountIndex, getVaultPublicDataAll, getVaultWithdrawalRequests, hasEulerEarnVaultSubgraph, hasLagoonVaults, hasMorphoPositionIndex, hasMorphoUserApi, hasMorphoUserSubgraph, hasUpshiftVaults, hasYearnVaults, inverseKeyParts, inverseLenderKey, isStablecoinSymbol, isYearnV3, keysFromMaps, lenderApiOnly, lenderFamily, liquityCandidateTroveIds, liquityKeyParts, liquityLenderKey, llamaLendKeyParts, llamaLendLenderKey, multicall3Abi, nanTo, needsLenderApproval, needsTokenApproval, noOpResult, normalizeToBytes, parseBalanceFetcherResult, parseMergedResult, parseMulticallRpcResponses, parseRawRpcBatchResponses, parseRawRpcResponses, parseTermMaxLtv, parseTokenBalanceResult, positivePart, predictInverseEscrow, prepareLenderUserDataRpcCalls, prepareMergedMulticallParams, prepareMergedRpcCalls, prepareMulticallInputs, prepareTokenBalanceRpcCalls, priceGlvVaults, priceGmMarkets, probeAaveFeedTimestamps, pruneFeedStats, readVaultSharePrices, rejectOutliers as rejectPriceOutliers, resolveDerivation, resolveStCeloDepositGroup, resupplyKeyParts, resupplyLenderKey, riverKeyParts, riverLenderKey, selectAssetGroupPrices, stampVaultClassification, tellerBpsToPercent, tellerImpliedLtv, tellerLenderKey, tellerPoolFromLenderKey, termLenderKey, termMaxApiBase, borrowNif as termMaxBorrowNif, curveApr as termMaxCurveApr, curveAprNumber as termMaxCurveAprNumber, daysToMaturity as termMaxDaysToMaturity, lendNif as termMaxLendNif, mintGtFeeRatio as termMaxMintGtFeeRatio, ratioToNumber as termMaxRatioToNumber, ratioToPercent as termMaxRatioToPercent, tickToAprNumber, tickToPrice, unflattenLenderData, updateFeedStats, usddIlkBytes32, usddKeyParts, usddLenderKey };