@1delta/margin-fetcher-sol 0.0.1 → 0.0.3

package/dist/index.d.ts

@@ -800,6 +800,14 @@ interface KlendReserveChain extends KlendReserveFlash {
     /** `config.disableUsageAsCollOutsideEmode` — outside a group, an obligation holding this deposit cannot borrow. */
     disableUsageAsCollOutsideEmode: boolean;
     utilizationLimitBlockBorrowingAbovePct: number;
+    /**
+     * `config.borrowRateCurve` — the reserve's 11 knots as `[utilization,
+     * borrowRate]` FRACTIONS (bps / 1e4), padding included: unused knots repeat
+     * the last one. The rate is on the reserve's `interestRateBasis` (a `legacy`
+     * reserve quotes per slot on the 0.5 s slot-year). Matches the API's
+     * deduplicated `borrowCurve` as a function (irm-sdk `solana.test.ts`).
+     */
+    borrowRateCurve: [number, number][];
     /** Cap on debt of THIS reserve taken outside any group, raw units of this reserve. */
     borrowLimitOutsideElevationGroup: bigint;
     /** Per group (index = id − 1): cap on debt this reserve may BACK as collateral in the group, raw units of the group's DEBT reserve. */
@@ -1105,6 +1113,8 @@ interface KaminoMarketInputs {
     collateralReserves?: KaminoCollateralReserve[];
     /** Kamino's Multiply/Leverage pair book for the market. */
     leveragePairs?: KaminoLeveragePair[];
+    /** Measured wall-clock seconds per slot (svm-kit `measureSlotSeconds`) — stamped on `legacy` reserves' `kamino.slotSeconds`. */
+    slotSeconds?: number;
     /** Optional curated currency for `asset` (name/symbol/assetGroup); falls back to the API's symbol and `solana-<mint>`. */
     tokenList?: {
         [mint: string]: GenericCurrency;
@@ -1126,7 +1136,23 @@ interface KaminoReserveExt {
     interestRateBasis: KaminoReserveStats['interestRateBasis'];
     protocolTakeRatePct: number;
     hostFixedInterestRateBps: number;
+    /**
+     * `[utilization, borrowRate]` FRACTIONS on the reserve's own
+     * `interestRateBasis`, first knot at 0, last at 1. From the chain's
+     * `borrowRateCurve` when the reserve was read (padding knots dropped),
+     * else the API's — the same function (irm-sdk `solana.test.ts`).
+     */
     borrowCurve: [number, number][];
+    borrowCurveSource: 'chain' | 'api';
+    /**
+     * `legacy` reserves only: the measured seconds per slot the curve must be
+     * scaled by (`× 0.5 / slotSeconds` — per-slot accrual on the nominal 0.5 s
+     * slot-year). Absent when not measured: a consumer then has no basis and
+     * must not evaluate the curve.
+     */
+    slotSeconds?: number;
+    /** `config.utilizationLimitBlockBorrowingAbovePct` — borrows refused above it; 0 = no limit. `undefined` = not read. */
+    utilizationLimitBlockBorrowingAbovePct?: number;
     autoDeleverage: KaminoReserveStats['autoDeleverage'];
     /** Where the config / limits / indices came from. */
     source: 'chain' | 'api';
@@ -1252,6 +1278,7 @@ declare function convertKaminoReserve(inp: KaminoReserveInputs, ctx: {
     closeFactor: number;
     chainMarket?: KlendMarketChain;
     slot?: number;
+    slotSeconds?: number;
     tokenList?: KaminoMarketInputs['tokenList'];
 }): KaminoPoolData;
 /** Risk inputs for every reserve of the market (chain when read, else API). */
@@ -1314,6 +1341,12 @@ interface FetchKaminoPublicOptions extends KaminoApiOptions, ListServedMarketsOp
      * market and never invents a group.
      */
     rpc?: SvmRpc;
+    /**
+     * Wall-clock seconds per slot for the `legacy` reserves' curves. Absent
+     * with an `rpc`: measured once (`measureSlotSeconds`); absent without one:
+     * not stamped, and those curves are unusable downstream (never guessed).
+     */
+    slotSeconds?: number;
 }
 /**
  * Public market data for every served Kamino market: one bundle per market
@@ -1564,6 +1597,263 @@ declare function createJupiterLendApi(opts?: JupiterLendApiOptions): {
 };
 type JupiterLendApi = ReturnType<typeof createJupiterLendApi>;
 
+/**
+ * Jupiter Lend vaults read straight from the VAULTS program — for the ids
+ * `lite-api.jup.ag/lend/v1/borrow/vaults` does not list (on 2026-10-02 it
+ * served 82 of main's 104: ids 65–67, 74–76, 85–87, 89–99 were missing,
+ * and users transact on 91 / 96 / 97). The program numbers vaults
+ * contiguously from 1 (`VaultAdmin.next_vault_id`), so enumeration is PDA
+ * derivation, no `getProgramAccounts`.
+ *
+ * The arithmetic is `@jup-ag/lend-read` 0.0.14's `getVaultEntireDataV2`,
+ * ported to bigint (liquidity exchange prices → the vault's, the layer's
+ * supply / borrow rate, the vault's limits). Verified against the API's own
+ * numbers for the vaults it does list (`test/jupiterLend.onchain.live.test.ts`).
+ *
+ * Scales, measured: vault-internal amounts (`VaultState.total_supply` /
+ * `total_borrow`) are normalised to 9 DECIMALS whatever the mint
+ * (`× 10^(decimals − 9)` gives base units — vault 1's USDC debt reads 1000×
+ * the API otherwise); the liquidity layer's amounts are mint base units.
+ *
+ * SMART vaults (type 2 = smart collateral, 3 = smart debt, 4 = both — the
+ * Fluid T2/T3/T4) put a DEX where the mint would be: `supply_token` /
+ * `borrow_token` is the DEX account, and that side's amounts are DEX SHARES
+ * (9 decimals), not tokens. The smart side is served as a leg keyed by the
+ * DEX address (the key pos-indexer's decoder uses, since it reads the same
+ * account off the instruction), denominated in shares, UNPRICED (price
+ * `'0'`): a share's token value needs the DEX's reserve math, which is not
+ * ported. `params.jupiterLendVault.smart` says which side it is.
+ *
+ * Not read: the vault ORACLE price (the oracle program combines its sources;
+ * `oraclePrice*` are left `''`, which the converter turns into an absent
+ * Fluid oracle price, never a 0), rewards, and `metadata` flags (UI-only).
+ */
+declare const JL_VAULTS_ACCOUNTS_IDL: Idl;
+/** The vaults program per market (`@jup-ag/lend`'s `PROGRAM_IDS`). */
+declare const JUP_VAULTS_PROGRAMS: Record<JupiterLendMarket, string>;
+/** The Jupiter Lend DEX (smart-vault AMM) program — owner of a smart side's `Dex`. */
+declare const JUP_DEX_PROGRAM = "jupZ4m2GqUCJ5iueMfzQf8khFfH31d4XAQt3RzCT9Vd";
+declare const JL_EXCHANGE_PRICES_PRECISION: bigint;
+/** Vault-internal amounts are 9-decimal normalised. */
+declare const JL_VAULT_AMOUNT_DECIMALS = 9;
+/** Fluid's vault types; 0 is the legacy spelling of 1. */
+declare const isJlSmartCol: (t: number) => t is 2 | 4;
+declare const isJlSmartDebt: (t: number) => t is 3 | 4;
+declare const jlVaultConfigPda: (vaultId: number, market?: JupiterLendMarket) => Promise<string>;
+declare const jlVaultStatePda: (vaultId: number, market?: JupiterLendMarket) => Promise<string>;
+declare const jlVaultAdminPda: (market?: JupiterLendMarket) => Promise<string>;
+interface RawVaultConfig {
+    vault_id: number;
+    supply_rate_magnifier: number;
+    borrow_rate_magnifier: number;
+    collateral_factor: number;
+    liquidation_threshold: number;
+    liquidation_max_limit: number;
+    withdraw_gap: number;
+    liquidation_penalty: number;
+    borrow_fee: number;
+    vault_type: number;
+    oracle: string;
+    supply_token: string;
+    borrow_token: string;
+}
+interface RawVaultState {
+    vault_id: number;
+    topmost_tick: number;
+    total_supply: bigint;
+    total_borrow: bigint;
+    total_positions: number;
+    absorbed_debt_amount: bigint;
+    absorbed_col_amount: bigint;
+    liquidity_supply_exchange_price: bigint;
+    liquidity_borrow_exchange_price: bigint;
+    vault_supply_exchange_price: bigint;
+    vault_borrow_exchange_price: bigint;
+    last_update_timestamp: bigint;
+}
+interface RawTokenReserve {
+    mint: string;
+    /** The layer's token account for the mint — its balance is what can leave now. */
+    vault: string;
+    borrow_rate: number;
+    fee_on_interest: number;
+    last_utilization: number;
+    last_update_timestamp: bigint;
+    supply_exchange_price: bigint;
+    borrow_exchange_price: bigint;
+    max_utilization: number;
+    total_supply_with_interest: bigint;
+    total_supply_interest_free: bigint;
+    total_borrow_with_interest: bigint;
+    total_borrow_interest_free: bigint;
+}
+interface RawUserSupply {
+    with_interest: number;
+    amount: bigint;
+    withdrawal_limit: bigint;
+    decay_amount: bigint;
+    last_update: bigint;
+    expand_pct: number;
+    expand_duration: number;
+    decay_duration: number;
+    base_withdrawal_limit: bigint;
+}
+interface RawUserBorrow {
+    with_interest: number;
+    amount: bigint;
+    debt_ceiling: bigint;
+    last_update: bigint;
+    expand_pct: number;
+    expand_duration: number;
+    base_debt_ceiling: bigint;
+    max_debt_ceiling: bigint;
+}
+/** The layer's exchange prices advanced to `now` (`calculateExchangePrice`). */
+declare function jlLiquidityExchangePrices(r: RawTokenReserve, now: bigint): {
+    supplyEx: bigint;
+    borrowEx: bigint;
+};
+/** The layer's per-token totals + supply rate (bps) (`processOverallTokenData`). */
+declare function jlOverallTokenData(r: RawTokenReserve, now: bigint): {
+    supplyEx: bigint;
+    borrowEx: bigint;
+    totalSupply: bigint;
+    totalBorrow: bigint;
+    supplyRate: bigint;
+    borrowRate: bigint;
+    maxUtilization: bigint;
+};
+type Overall = ReturnType<typeof jlOverallTokenData>;
+/** A protocol's supply position on the layer (`processUserSupplyData`). */
+declare function jlUserSupplyData(u: RawUserSupply | undefined, o: Overall, balance: bigint, now: bigint): {
+    modeWithInterest: boolean;
+    supply: bigint;
+    withdrawalLimit: bigint;
+    lastUpdateTimestamp: bigint;
+    expandPercent: bigint;
+    expandDuration: bigint;
+    baseWithdrawalLimit: bigint;
+    withdrawableUntilLimit: bigint;
+    withdrawable: bigint;
+    decayAmount: bigint;
+    decayEndTimestamp: bigint;
+};
+/** A protocol's borrow position on the layer (`processUserBorrowData`). */
+declare function jlUserBorrowData(u: RawUserBorrow | undefined, o: Overall, balance: bigint, now: bigint): {
+    modeWithInterest: boolean;
+    borrow: bigint;
+    borrowLimit: bigint;
+    lastUpdateTimestamp: bigint;
+    expandPercent: bigint;
+    expandDuration: bigint;
+    baseBorrowLimit: bigint;
+    maxBorrowLimit: bigint;
+    borrowLimitUtilization: bigint;
+    borrowableUntilLimit: bigint;
+    borrowable: bigint;
+};
+/** The vault's exchange prices advanced with the layer's (`updateExchangePrices`). */
+declare function jlVaultExchangePrices(s: RawVaultState, c: RawVaultConfig, liqSupplyEx: bigint, liqBorrowEx: bigint, now: bigint): {
+    supplyEx: bigint;
+    borrowEx: bigint;
+};
+/** Vault-internal (9-dec normalised) → base units of a `decimals` mint. */
+declare const jlVaultToRaw: (v: bigint, decimals: number) => bigint;
+interface JlOnchainVault {
+    vault: JupiterLendVault;
+    smartCol: boolean;
+    smartDebt: boolean;
+    /** The DEX behind a smart side, decoded (`token_0` / `token_1`). */
+    supplyDex?: {
+        address: string;
+        token0: string;
+        token1: string;
+    };
+    borrowDex?: {
+        address: string;
+        token0: string;
+        token1: string;
+    };
+    slot: number;
+}
+interface ReadJlVaultsOptions {
+    /** Known token facts by mint (the API's own `supplyToken` / `borrowToken` / earn `asset`) — symbol, logo and the USD price. */
+    tokens?: {
+        [mint: string]: JupiterLendToken;
+    };
+    /** Symbols / decimals for mints the API does not name. */
+    tokenList?: {
+        [mint: string]: {
+            symbol?: string;
+            name?: string;
+            decimals?: number;
+            logoURI?: unknown;
+        };
+    };
+    /** Unix seconds "now" for the accrual (default: the clock). */
+    now?: number;
+}
+/** `VaultAdmin.next_vault_id` — ids run 1 … next − 1. `undefined` when the admin cannot be read. */
+declare function readJlNextVaultId(rpc: SvmRpc, market?: JupiterLendMarket): Promise<number | undefined>;
+/**
+ * Read `vaultIds` of `market` from the chain and shape each as the API's
+ * `JupiterLendVault`, so the API path's converter serves it unchanged.
+ * Three batched reads: config + state, then the layer accounts (reserves,
+ * the vault's positions on the layer, mints, DEXes, the oracle), then the
+ * reserves' token accounts (what can leave the layer now). An id with no config / state account is skipped.
+ */
+declare function readJupiterLendVaultsOnchain(rpc: SvmRpc, market: JupiterLendMarket, vaultIds: number[], opts?: ReadJlVaultsOptions): Promise<JlOnchainVault[]>;
+/**
+ * One mint's Liquidity-layer IRM, as irm-sdk's `jupiter_lend` model takes it
+ * (`JupiterLendIRMParams`, the magnifiers added per row). Every rate / kink /
+ * fee is on the 1e2 scale the accounts use (10000 = 100 %).
+ */
+interface JlLayerIrm {
+    version: 1 | 2;
+    rateAtZero: number;
+    kink1: number;
+    rateAtKink1: number;
+    /** v2 only — a v1 model keeps stale values in these fields. */
+    kink2?: number;
+    rateAtKink2?: number;
+    rateAtMax: number;
+    /** `TokenReserve.fee_on_interest`. */
+    feeOnInterest: number;
+    /** `TokenReserve.max_utilization` (0 read as the program's default 100 %). */
+    maxUtilization: number;
+    /** `(B_wi / S_wi) / u` over the layer's live totals — 1 when nothing is interest-free. */
+    supplyWithInterestRatio: number;
+    /** The program's own last evaluation — `borrow_rate` at `last_utilization` (1e2). */
+    lastUtilization: number;
+    borrowRate: number;
+}
+/**
+ * `RateModel` (PDA `['rate_model', mint]` on the Liquidity program),
+ * bytemuck-packed after the 8-byte discriminator: mint (32) · version u8 ·
+ * rate_at_zero · kink1_utilization · rate_at_kink1 · rate_at_max ·
+ * kink2_utilization · rate_at_kink2 (u16 LE each) = 53 bytes. Layout from
+ * `@jup-ag/lend` 0.4.0's liquidity IDL (the program publishes no on-chain
+ * IDL); `rate_at_max` sits BEFORE `kink2`. Verified 2026-10-03: the curve
+ * at `TokenReserve.last_utilization` reproduces `borrow_rate` to the unit
+ * on every live mint (irm-sdk `solana.test.ts`).
+ */
+declare function decodeJlRateModel(data: Uint8Array): {
+    kink2?: number | undefined;
+    rateAtKink2?: number | undefined;
+    version: 1 | 2;
+    rateAtZero: number;
+    kink1: number;
+    rateAtKink1: number;
+    rateAtMax: number;
+};
+/**
+ * Every listed mint's layer IRM for a market: one batched read of the
+ * `RateModel` + `TokenReserve` PDAs. A mint whose either account is missing
+ * or undecodable is absent from the map (its rows then carry no curve),
+ * never defaulted.
+ */
+declare function readJlLayerIrms(rpc: SvmRpc, market: JupiterLendMarket, mints: string[], now?: bigint): Promise<Map<string, JlLayerIrm>>;
+
 /**
  * Scales — JUPITER_LEND.md §2, verified against the program source
  * (UNIFIED_API_AUDIT.md §9): factors 1e3 (`vault_config.rs`), penalty and
@@ -1634,10 +1924,11 @@ interface JupiterLendFluidVault {
     /** Raw debt per raw collateral × 1e27 — EVM Fluid's scale (`jlOracleToFluidRaw`). */
     oraclePriceOperate?: string;
     oraclePriceLiquidate?: string;
-    isSmartCol: false;
-    isSmartDebt: false;
-    /** Both JL types (0 legacy, 1) are plain T1. */
-    vaultType: typeof FLUID_VAULT_TYPE_T1;
+    /** True on a smart side (JL type 2 / 4 col, 3 / 4 debt — chain-enumerated vaults only; the API lists T1 only). The smart side's `dex` stays `null`: the DEX is on `params.jupiterLendVault.smart`. */
+    isSmartCol: boolean;
+    isSmartDebt: boolean;
+    /** Fluid's `TYPE()`: 10000 T1 (JL 0 / 1), 20000 T2, 30000 T3, 40000 T4. */
+    vaultType: number;
     collateral: JupiterLendFluidSide;
     loan: JupiterLendFluidSide;
 }
@@ -1710,6 +2001,29 @@ interface JupiterLendVaultMeta {
         supplyFlashable: boolean;
         borrowFlashable: boolean;
     };
+    /** `api` = Jupiter's listing; `chain` = read from the vaults program because the listing omits the id (`onchain.ts`). */
+    source?: 'api' | 'chain';
+    /** The slot of a chain read. */
+    slot?: number;
+    /**
+     * A smart side's DEX (chain-enumerated vaults): that side's leg is keyed
+     * by the DEX address, denominated in DEX SHARES (9 decimals) and UNPRICED
+     * (USD 0 — the share's token value needs the DEX math, not ported).
+     */
+    smart?: {
+        col?: {
+            dex: string;
+            token0?: string;
+            token1?: string;
+        };
+        debt?: {
+            dex: string;
+            token0?: string;
+            token1?: string;
+        };
+    };
+    /** Mints whose USD the read could not source (the leg's USD reads 0 because the price is unknown, not because the leg is empty). */
+    unpriced?: string[];
 }
 /** Both params slots of one vault bundle. */
 interface JupiterLendBundleParams {
@@ -1758,6 +2072,18 @@ type JupiterLendPoolData = Omit<PoolData, 'borrowCap' | 'supplyCap' | 'config'>
     config: {
         [mode: string]: JupiterLendConfigEntry;
     };
+    /**
+     * The row's interest-rate model: its token's Liquidity-layer `RateModel`
+     * plus THIS vault's ADDITIVE magnifiers (bps) — irm-sdk's `jupiter_lend`
+     * model takes it verbatim. Absent when the layer was not read (no `rpc`)
+     * or on a smart side (its token is a DEX share, not a layer token).
+     */
+    jupiterLend?: {
+        irm: JlLayerIrm & {
+            supplyMagnifier: number;
+            borrowMagnifier: number;
+        };
+    };
 };
 interface ConvertJupiterLendOptions {
     tokenList?: {
@@ -1841,8 +2167,14 @@ interface FetchJupiterLendPublicOptions extends JupiterLendApiOptions {
     intrinsicYields?: {
         [assetGroup: string]: number;
     };
-    /** With an RPC: the market's flashloan admin (fee, activation) and the flash-able set, on `params.vault.flashloan` and the term sheet. */
+    /** With an RPC: the market's flashloan admin (fee, activation) and the flash-able set, on `params.vault.flashloan` and the term sheet; and the vaults the listing omits, read from the chain (`enumerateOnchain`). */
     rpc?: SvmRpc;
+    /**
+     * With an `rpc`: enumerate the vaults program (`VaultAdmin.next_vault_id`)
+     * and read every id the API does not list (`onchain.ts`). API rows are
+     * kept as they are; the chain only fills the gaps. Default true.
+     */
+    enumerateOnchain?: boolean;
 }
 /**
  * Every Jupiter Lend vault in the margin-fetcher return shape — one lender
@@ -1855,6 +2187,13 @@ interface FetchJupiterLendPublicOptions extends JupiterLendApiOptions {
  * token needs the jl token's supply, JUPITER_LEND.md §3). Both markets = 4
  * GETs, ~0.5 s. A market whose read fails fails the fetch — a partial
  * roster is not served.
+ *
+ * With an `rpc`, the ids the listing omits are read from the chain (3
+ * batched account reads per market; on 2026-10-02 main served 82 of 104 —
+ * the gaps include the smart-debt / smart-collateral vaults 90–98, which
+ * users transact on). A failed chain read keeps the API rows and warns: the
+ * enumeration only ever ADDS bundles. Chain bundles carry
+ * `params.jupiterLendVault.source = 'chain'`.
  */
 declare function fetchJupiterLendPublic(opts?: FetchJupiterLendPublicOptions): Promise<{
     [lender: string]: JupiterLendPublicResponse;
@@ -2103,12 +2442,21 @@ declare const SAVE_WAD: bigint;
 declare const SAVE_U64_MAX = "18446744073709551615";
 /**
  * The program's slot-year: interest compounds `rate / 63,072,000` PER SLOT,
- * i.e. it assumes a 0.5 s slot. Mainnet runs ~0.39–0.40 s, so the curve
- * under-states the wall-clock rate by ~25 % (SAVE_FINANCE.md §3.2).
+ * i.e. it assumes a 0.5 s slot. The wall-clock rate is `curve × 0.5 /
+ * slotSeconds`, and the slot time MOVES: ~0.39–0.40 s through 2025 (×1.25),
+ * 0.2665 s on 2026-10-03 (×1.88) — SAVE_FINANCE.md §3.2.
  */
 declare const SAVE_SLOTS_PER_YEAR = 63072000;
-/** Default wall-clock slot time used to scale the curve; measured 0.393 s over 441 days to 2026-09-16. */
-declare const SAVE_DEFAULT_AVG_SLOT_SECONDS = 0.4;
+/**
+ * FALLBACK wall-clock slot time, used only when no measurement is passed
+ * (`avgSlotSeconds`; `getLenderPublicDataAll` measures it with svm-kit
+ * `measureSlotSeconds` whenever it has an rpc). 0.2665 s = the mean of 327
+ * one-minute `getRecentPerformanceSamples` on 2026-10-03 (266.3–266.5 ms over
+ * every sub-window). It was 0.4 until then — measured 0.393 s over the 441
+ * days to 2026-09-16 — and that stale constant understated every Save rate by
+ * a third once the chain sped up. Re-measure before trusting it.
+ */
+declare const SAVE_DEFAULT_AVG_SLOT_SECONDS = 0.2665;
 /** Program constants (sdk/src/state/reserve.rs). */
 declare const SAVE_LIQUIDATION_CLOSE_FACTOR = 0.2;
 declare const SAVE_MAX_LIQUIDATABLE_VALUE_USD = 500000;
@@ -2168,8 +2516,9 @@ type SaveApi = ReturnType<typeof createSaveApi>;
  * with `opt == 0 ⇒ min`. Supply = u × borrow × (1 − protocolTakeRate).
  *
  * Save's own SDK (`calculateBorrowInterest`) agrees to the digit on live
- * state; the hosted API's `rates` field does NOT (×1.61, unexplained), which
- * is why the row recomputes.
+ * state; the hosted API's `rates` field does NOT (×1.61 on 2026-09-16, mostly
+ * a fresher slot time and APY quoting — SAVE_FINANCE.md §2), which is why the
+ * row recomputes.
  */
 declare function saveBorrowCurvePercent(c: Pick<SaveReserveConfigState, 'optimalUtilizationRate' | 'maxUtilizationRate' | 'minBorrowRate' | 'optimalBorrowRate' | 'maxBorrowRate' | 'superMaxBorrowRate'>, utilization: number): number;
 /** `borrowedAmountWads / 1e18` in RAW token units (a bigint-exact division, then float). */
@@ -2195,7 +2544,8 @@ declare const wadsToFloat: (wads: bigint) => number;
  */
 declare function saveUtilization(liquidity: SaveReserveAccount['liquidity']): number;
 /**
- * The curve is denominated in a 0.5 s slot-year; the chain runs ~0.4 s slots,
+ * The curve is denominated in a 0.5 s slot-year; the chain runs faster slots
+ * (~0.27 s in 2026-10, ~0.4 s through 2025),
  * so one wall-clock year contains `31,536,000 / avgSlot` slots and the rate a
  * depositor actually sees is `curve × (that / 63,072,000)` = `curve × 0.5 / avgSlot`.
  */
@@ -2506,7 +2856,7 @@ interface FetchSavePublicOptions extends SaveApiOptions, SaveRosterOptions {
     tokenList?: {
         [mint: string]: GenericCurrency;
     };
-    /** Wall-clock slot time the curve is scaled by (default 0.4 s). */
+    /** Wall-clock seconds per slot the curve is scaled by — pass a MEASURED value (svm-kit `measureSlotSeconds`); the default is a dated constant. */
     avgSlotSeconds?: number;
     dropUnrealizable?: boolean;
     /** Already-fetched configs (the user-data path and the action builders share them). */
@@ -3086,7 +3436,12 @@ interface LoopscaleOfferingVault {
     vault: string;
     strategy: string;
     name: string;
+    /** `vaultMetadata.managerName` — the curator's display name ('' when the venue names none). */
     curator: string;
+    /** The vault's `manager` — the curator's ADDRESS, base58 verbatim. */
+    manager: string;
+    /** `vaultMetadata.managerImage`, verbatim; absent when none. */
+    managerImage?: string;
     /** CBPS of interest earned, the vault's take. */
     interestFee: number;
     /** CBPS of principal at origination. */
@@ -3638,13 +3993,28 @@ type LoopscaleConfigEntry = Omit<ConfigEntry, 'collateralDisabled' | 'debtDisabl
     debtDisabled: boolean;
     openParameter?: LoopscaleOpenParameter;
 };
-/** One `market_terms` row (yield-tracer reads `termId`, `durationDays`, `apr`). */
+/** One `market_terms` row (yield-tracer reads `termId`, `durationDays`, `apr`, `ladder`). */
 interface LoopscaleMarketTerm {
     termId: string;
     durationDays: number;
     durationSecs: number;
     /** Best offer, percent APR. */
     apr: number;
+    /**
+     * The tenor's OWN borrow ladder, cheapest first, in yield-tracer's
+     * `market_terms.ladder` shape: `apr` percent, `assets` = what ONE strategy
+     * can lend at that level, TOKEN units. `fill: 'single'` is the order-book
+     * rule this venue has and Midnight does not: one ledger fills ONE
+     * strategy, and a level's `sum` is that strategy's idle balance repeated on
+     * every pair and tenor it quotes — so the rate at size S is the cheapest
+     * level whose `assets ≥ S`, never a VWAP across levels, and depth is the
+     * MAX, never the total.
+     */
+    ladder: {
+        apr: number;
+        assets: number;
+        fill: 'single';
+    }[];
 }
 /**
  * Structurally margin-fetcher's `FixedTermInfo` with `model: 'loopscale'`
@@ -4655,7 +5025,7 @@ declare const P0_EMODE_BASE_LABEL = "No emode";
 interface P0BankPrice {
     priceUsd: number;
     /** Where the number came from. */
-    source: 'pyth-push' | 'pyth-push×multiplier' | 'fixed' | 'bank-cache' | 'none';
+    source: 'pyth-push' | 'pyth-push×multiplier' | 'scope' | 'fixed' | 'bank-cache' | 'none';
     /** Unix seconds of the reading (the oracle's publish time or the cache's timestamp). */
     updatedAt?: number;
     multiplier: number;
@@ -5122,7 +5492,11 @@ roster: {
  *    underlying), the price is the underlying's; Drift's shares are
  *    9-decimal scaled balances whatever the mint, so its multiplier is
  *    rescaled to the mint;
- *  - `PythPushOracle` — the price, multiplier 1; `Fixed*` — `fixed_price`.
+ *  - `PythPushOracle` — the price, multiplier 1; `Fixed*` — `fixed_price`;
+ *  - `PythMSOL` — live = Pyth SOL × Marinade's `State.msol_price`
+ *    (`oracle_keys[1]`), read here (the venue variants stay on the cache);
+ *  - `Scope` — live = the Scope `OraclePrices` entry at
+ *    `config.scopeEntryIndex` (`oracle_keys[0]`), with its own timestamp.
  * A cached venue multiplier moves at the venue's YIELD rate (bps per day),
  * so a day-old one on a fresh SOL price is the right number to a few bps.
  */
@@ -7145,6 +7519,10 @@ interface LoopscaleEarnVault {
     name: string;
     displayName: string;
     curatorName: string;
+    /** The vault's `manager` — the curator's ADDRESS, base58 verbatim (the chain-role arm of a curator identity). */
+    manager: string;
+    /** The venue's curator logo (`vaultMetadata.managerImage`), verbatim; absent when the venue names none. */
+    managerImage?: string;
     decimals: number;
     assetDecimals: number;
     /** TVL, raw principal units (the guide's four-term sum). */
@@ -7246,6 +7624,254 @@ interface FetchLoopscaleEarnVaultsOptions extends LoopscaleApiOptions {
 /** Every curated Loopscale vault as an earn row — one paged route, zero RPC. A principal with no known decimals is skipped and named. */
 declare function fetchLoopscaleEarnVaults(opts?: FetchLoopscaleEarnVaultsOptions): Promise<LoopscaleEarnVault[]>;
 
+/**
+ * Kamino kvaults (`KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd`) — curated
+ * earn vaults that allocate one token across K-Lend reserves. Two public
+ * routes carry everything, read off live responses 2026-10-02:
+ *
+ * | route                         | rows | what it is the only source of                                    |
+ * | ----------------------------- | ---- | ---------------------------------------------------------------- |
+ * | `/kvaults/vaults`             | 183  | the ROSTER + the decoded `VaultState` (admins, mints, fees, name) |
+ * | `/kvaults/vaults/metrics`     | 186  | per-vault APY, tokens per share, AUM split, USD prices, holders  |
+ *
+ * `/kvaults/vaults/metrics` is PAGED (100 rows, `paginationToken`) and
+ * carries 3 vaults the roster omits (closed / not listed); the roster is the
+ * join's left side. `/kvaults/<vault>/metrics` is the per-vault twin — not
+ * needed when the batch answers.
+ *
+ * Scales: every `state` amount is RAW base units of its mint (u64 as a
+ * decimal string; `prevAum` / `pendingFees` carry a Fraction's decimals);
+ * every `metrics` amount is HUMAN units; APYs are FRACTIONS.
+ */
+interface KaminoKvaultAllocation {
+    reserve: string;
+    ctokenVault: string;
+    targetAllocationWeight: number;
+    tokenAllocationCap: string;
+    ctokenVaultBump: number;
+    ctokenAllocation: string;
+    lastInvestSlot: string;
+    tokenTargetAllocation: string;
+}
+interface KaminoKvaultState {
+    /** The vault's admin — the curator's ADDRESS (sets allocations, fees, the allocation admin). */
+    vaultAdminAuthority: string;
+    baseVaultAuthority: string;
+    baseVaultAuthorityBump: number;
+    tokenMint: string;
+    tokenMintDecimals: number;
+    tokenVault: string;
+    tokenProgram: string;
+    sharesMint: string;
+    sharesMintDecimals: number;
+    /** Raw underlying held idle by the vault. */
+    tokenAvailable: string;
+    /** Raw shares outstanding. */
+    sharesIssued: string;
+    availableCrankFunds: string;
+    performanceFeeBps: number;
+    managementFeeBps: number;
+    lastFeeChargeTimestamp: number;
+    prevAum: string;
+    /** Raw underlying owed to the admin, decimal fraction — deducted from AUM. */
+    pendingFees: string;
+    vaultAllocationStrategy: KaminoKvaultAllocation[];
+    minDepositAmount: string;
+    minWithdrawAmount: string;
+    minInvestAmount: string;
+    minInvestDelaySlots: number;
+    crankFundFeePerReserve: string;
+    pendingAdmin: string;
+    cumulativeEarnedInterest: string;
+    cumulativeMgmtFees: string;
+    cumulativePerfFees: string;
+    /** Empty on a handful of vaults. */
+    name: string;
+    vaultLookupTable: string;
+    vaultFarm: string;
+    creationTimestamp: number;
+    /** The key allowed to move allocations (a bot or the curator's own key). */
+    allocationAdmin: string;
+}
+/** One row of `/kvaults/vaults`. `address` is the VaultState account. */
+interface KaminoKvault {
+    address: string;
+    state: KaminoKvaultState;
+    programId: string;
+}
+/** One row of `/kvaults/vaults/metrics` (and `/kvaults/<vault>/metrics`, without `kvault`). */
+interface KaminoKvaultMetrics {
+    kvault?: string;
+    /** Fractions. `apy` = `apyTheoretical` — the current allocation's rate, net of the vault's fees. */
+    apy: string;
+    apyTheoretical: string;
+    apyActual: string;
+    apy24h: string;
+    apy7d: string;
+    apy30d: string;
+    apy90d: string;
+    apy180d: string;
+    apy365d: string;
+    apyFarmRewards: string;
+    apyIncentives: string;
+    apyReservesIncentives: string;
+    /** USD per whole underlying. */
+    tokenPrice: string;
+    solPrice: string;
+    /** Human underlying. */
+    tokensAvailable: string;
+    tokensAvailableUsd: string;
+    tokensInvested: string;
+    tokensInvestedUsd: string;
+    /** USD per whole SHARE (= tokensPerShare × tokenPrice). */
+    sharePrice: string;
+    /** Whole underlying per whole share — the 4626 `convertToAssets(1)`. */
+    tokensPerShare: string;
+    numberOfHolders: number;
+    sharesIssued: string;
+    cumulativeInterestEarned: string;
+    cumulativeInterestEarnedUsd: string;
+    interestEarnedPerSecond: string;
+    cumulativePerformanceFees: string;
+    cumulativeManagementFees: string;
+    [k: string]: unknown;
+}
+/**
+ * A kvault as an EARN VAULT row, the 4626 shape the other Solana families
+ * emit (`LoopscaleEarnVault`, `JupiterLendEarnVault`).
+ *
+ * `address` is the VAULT STATE account, NOT the share mint: it is the
+ * account every kvault instruction names (`vaultState`) and the one
+ * pos-indexer's decoder keys a row by — market uid
+ * `vault.kamino-kvault:solana:<vault state>`. The share a holder owns is
+ * `shareMint`.
+ */
+interface KaminoKvaultEarnVault {
+    provider: 'kamino-kvault';
+    originProvider: 'kamino-kvault';
+    chainId: string;
+    /** The VaultState account (the decoder's key). */
+    address: string;
+    /** The share token a depositor holds. */
+    shareMint: string;
+    underlying: string;
+    symbol: string;
+    name: string;
+    displayName: string;
+    /** The admin address, base58 verbatim — kvaults publish no curator name; a label layer keyed by this address names it. */
+    curatorName: string;
+    /** `vaultAdminAuthority` — the curator's address (the chain-role arm). */
+    manager: string;
+    /** `allocationAdmin` — the key that moves allocations. */
+    allocationAdmin: string;
+    decimals: number;
+    assetDecimals: number;
+    /** Raw underlying: `tokensPerShare × sharesIssued` (idle + invested − pending fees). */
+    totalAssets: string;
+    /** Raw shares. */
+    totalSupply: string;
+    /** Raw underlying per 10^decimals shares. */
+    convertToAssets: string;
+    convertToShares: string;
+    /** percent APR (`ln(1 + apy)`), net of the vault's fees. */
+    supplyRate: number;
+    /** percent APR from the vault farm + incentives. */
+    rewardsRate: number;
+    depositRate: number;
+    asset?: GenericCurrency;
+    priceUsd?: number;
+    totalAssetsFormatted: number;
+    totalAssetsUsd: number;
+    /** Idle underlying (`tokenAvailable`), raw — what `withdrawFromAvailable` pays without touching a reserve. */
+    liquidity: string;
+    liquidityFormatted: number;
+    liquidityUsd: number;
+    sharePrice: number;
+    sharePriceUsd: number;
+    yieldProfile: 'yield-bearing';
+    denomination: Denomination;
+    logoURI?: string;
+    /** Performance fee, PERCENT. */
+    fee: number;
+    managementFeePct: number;
+    withdrawalMode: Extract<OriginWithdrawalMode, 'instant-capped'>;
+    /** `liquidity / totalAssets` — the idle share; a withdraw also disinvests from reserves with cash. */
+    instantLiquidityRatio: number;
+    /** The venue's APY figures, FRACTIONS, verbatim. */
+    apy: {
+        current: number;
+        actual: number;
+        d1: number;
+        d7: number;
+        d30: number;
+        d90: number;
+        farmRewards: number;
+        incentives: number;
+        /** Reserve incentives — not added to `rewardsRate` (whether `apy` already counts them is not documented). */
+        reservesIncentives: number;
+    };
+    holders: number;
+    vaultFarm?: string;
+    /** The K-Lend reserves it allocates to, with the target weight. */
+    allocations: {
+        reserve: string;
+        weight: number;
+        ctokenAllocation: string;
+    }[];
+    createdAt: number;
+    minDepositAmount: string;
+}
+
+/** The kvault program, mainnet. */
+declare const KVAULT_PROGRAM_ID = "KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd";
+interface KaminoKvaultApiOptions extends HttpOptions {
+    baseUrl?: string;
+    maxInFlight?: number;
+    /** Page cap for `/kvaults/vaults/metrics` (100 rows a page; 2 pages on 2026-10-02). Default 20. */
+    maxPages?: number;
+}
+/** The two kvault routes: the roster (one GET) and the batch metrics (paged by `paginationToken`). */
+declare function createKaminoKvaultApi(opts?: KaminoKvaultApiOptions): {
+    vaults: () => Promise<KaminoKvault[]>;
+    /** Every page of the batch metrics. A page that fails fails the call — a partial metrics set would read as vaults with no APY. */
+    metrics: () => Promise<KaminoKvaultMetrics[]>;
+    vaultMetrics: (vault: string) => Promise<KaminoKvaultMetrics>;
+};
+type KaminoKvaultApi = ReturnType<typeof createKaminoKvaultApi>;
+
+/**
+ * A HUMAN decimal string × 10^decimals → raw bigint, exact (truncates digits
+ * past `decimals`). `undefined` for anything that is not a plain decimal.
+ */
+declare function decimalStringToRaw(s: string | number | undefined | null, decimals: number): bigint | undefined;
+/**
+ * One kvault + its metrics → an earn row. `undefined` when the metrics row
+ * is missing (no share price, no APY: the row would be numbers we do not
+ * have). USD is the venue's `tokenPrice` — Kamino's oracle view of the
+ * underlying — and is left absent when it reads ≤ 0.
+ */
+declare function convertKaminoKvault(v: KaminoKvault, m: KaminoKvaultMetrics | undefined, opts?: {
+    tokenList?: {
+        [mint: string]: GenericCurrency;
+    };
+}): KaminoKvaultEarnVault | undefined;
+interface FetchKaminoKvaultsOptions extends KaminoKvaultApiOptions {
+    tokenList?: {
+        [mint: string]: GenericCurrency;
+    };
+    /** Pre-fetched responses (tests, or a caller that already holds them). */
+    vaults?: KaminoKvault[];
+    metrics?: KaminoKvaultMetrics[];
+    /** Serve vaults with no shares outstanding. Default false. */
+    includeEmpty?: boolean;
+}
+/**
+ * Every Kamino kvault as an earn row: 2–3 GETs (roster + paged metrics),
+ * zero RPC. A roster vault with no metrics row is skipped and named; the
+ * metrics' extra vaults (not in the roster) are ignored.
+ */
+declare function fetchKaminoKvaults(opts?: FetchKaminoKvaultsOptions): Promise<KaminoKvaultEarnVault[]>;
+
 /**
  * Liquid-staking tokens (LSTs) as EARN VAULT rows — the 4626
  * (`FluidFToken`) shape `JupiterLendEarnVault` and `SolsticeVault` share, so
@@ -7593,7 +8219,7 @@ declare function fetchLstVaults(opts?: FetchLstVaultsOptions): Promise<LstEarnVa
  */
 
 /** The origin's `vaults_latest.provider` keys a Solana row takes. */
-type OriginVaultProvider = 'savings' | 'lst' | 'jupiter-lend' | 'loopscale';
+type OriginVaultProvider = 'savings' | 'lst' | 'jupiter-lend' | 'loopscale' | 'kamino-kvault';
 /** yield-tracer `CommonVaultFields` — one `vaults_latest` row (and its snapshot). */
 interface OriginVaultCommon {
     chainId: string;
@@ -7696,6 +8322,12 @@ interface OriginJupiterLendMeta {
 interface OriginLoopscaleMeta {
     vaultAccount: string;
     strategy: string;
+    /** The curator's ADDRESS (the vault's `manager`), base58 verbatim — `vault_loopscale_meta.curator`. */
+    manager: string;
+    /** The curator's display name as the venue publishes it (also the common `curatorName`). */
+    managerName?: string;
+    /** The curator's logo, verbatim. */
+    managerImage?: string;
     grossRate: number;
     venueApy?: number;
     interestFee: number;
@@ -7718,6 +8350,31 @@ interface OriginLoopscaleMeta {
     rewardsSchedules: LoopscaleEarnVault['rewardsSchedules'];
     description?: string;
 }
+/**
+ * `vault_kamino_kvault_meta` (NEW — yield-tracer needs the table and the
+ * provider key). The row's `vaultAddress` is the VAULT STATE account (what
+ * every kvault instruction and pos-indexer's decoder name), so the share
+ * mint rides here.
+ */
+interface OriginKaminoKvaultMeta {
+    shareMint: string;
+    /** `vaultAdminAuthority` — the curator's address, base58 verbatim. */
+    manager: string;
+    allocationAdmin: string;
+    /** Percent. The PERFORMANCE fee is the common `fee`. */
+    managementFeePct: number;
+    convertToAssets: string;
+    convertToShares: string;
+    withdrawalMode: OriginWithdrawalMode;
+    instantLiquidityRatio: number;
+    /** FRACTIONS, verbatim from `/kvaults/vaults/metrics`. */
+    apy: KaminoKvaultEarnVault['apy'];
+    holders: number;
+    vaultFarm?: string;
+    allocations: KaminoKvaultEarnVault['allocations'];
+    createdAt: number;
+    minDepositAmount: string;
+}
 type OriginSavingsRow = OriginVaultCommon & {
     provider: 'savings';
     metaTable: 'vault_savings_meta';
@@ -7738,8 +8395,13 @@ type OriginLoopscaleRow = OriginVaultCommon & {
     metaTable: 'vault_loopscale_meta';
     meta: OriginLoopscaleMeta;
 };
+type OriginKaminoKvaultRow = OriginVaultCommon & {
+    provider: 'kamino-kvault';
+    metaTable: 'vault_kamino_kvault_meta';
+    meta: OriginKaminoKvaultMeta;
+};
 /** One `vaults_latest` row + its meta — structurally a yield-tracer `VaultIngestRow` (`metaTable` is extra and ignored by it). */
-type OriginVaultRow = OriginSavingsRow | OriginLstRow | OriginJupiterLendRow | OriginLoopscaleRow;
+type OriginVaultRow = OriginSavingsRow | OriginLstRow | OriginJupiterLendRow | OriginLoopscaleRow | OriginKaminoKvaultRow;
 /**
  * The `exponent_vaults_latest` row — yield-tracer's `PendleVaultRow`
  * (`buildPendleRow`'s output) plus the three Exponent columns. Every column
@@ -7795,10 +8457,17 @@ declare function lstOriginRow(r: LstEarnVault): OriginLstRow;
 declare function jupiterLendOriginRow(r: JupiterLendEarnVault): OriginJupiterLendRow;
 /** A curated Loopscale Vault → `loopscale`: `vaultAddress` = the LP mint, the vault account in the meta. */
 declare function loopscaleOriginRow(r: LoopscaleEarnVault): OriginLoopscaleRow;
+/**
+ * A Kamino kvault → `kamino-kvault`. `vaultAddress` = the VAULT STATE (the
+ * uid pos-indexer's decoder builds, `vault.kamino-kvault:solana:<vault>`);
+ * the share mint is `meta.shareMint` and `shareAsset`. Fee = the
+ * performance fee in percent.
+ */
+declare function kaminoKvaultOriginRow(r: KaminoKvaultEarnVault): OriginKaminoKvaultRow;
 /** An Exponent PT → `exponent_vaults_latest` (the `buildPendleRow` leg + three columns). */
 declare function exponentOriginRow(r: ExponentPtMarket): ExponentOriginRow;
 /** Any Solana 4626-shaped earn row → its origin row, by family. */
-declare function toOriginVaultRow(r: SolsticeVault | HumaVault | LstEarnVault | JupiterLendEarnVault | LoopscaleEarnVault): OriginVaultRow;
+declare function toOriginVaultRow(r: SolsticeVault | HumaVault | LstEarnVault | JupiterLendEarnVault | LoopscaleEarnVault | KaminoKvaultEarnVault): OriginVaultRow;
 
 interface KaminoOracleEntryOptions extends KaminoApiOptions {
     /** unix seconds; defaults to now — the reference for each price's own `maxAgeInSeconds`. */
@@ -7855,23 +8524,35 @@ declare function fetchJupiterLendOracleEntries(opts?: JupiterLendApiOptions): Pr
     [lender: string]: OraclePriceEntry[];
 }>;
 
-/**
- * Save's reserve prices — the stored `liquidity.marketPrice` of every served
- * reserve, USD × 1e18 as of the reserve's last refresh (minutes old on
- * touched reserves; can be DAYS old on a dormant one, hence `feedUpdatedAt`
- * is absent and `description` carries the slot). Pyth pull for the majors,
- * Switchboard On-Demand for the tail; every SOL-LST is the SOL feed × the
- * reserve's `scaledPriceOffsetBPS` dial, and says so.
- *
- * This is the Solana side's second price source after Kamino's, and the
- * first to cover the SOL-LST basket (mSOL, bSOL, JitoSOL, JupSOL, saveSOL …).
- */
-declare function fetchSaveOracleEntries(opts?: FetchSavePublicOptions & {
+interface FetchSaveOracleOptions extends FetchSavePublicOptions {
     /** Reuse an already-fetched public response instead of fetching. */
     publicData?: {
         [lender: string]: SavePublicResponse;
     };
-}): Promise<{
+    /** For the feed reads; the package's default public pool otherwise. */
+    rpc?: SvmRpc;
+    /** `false` = the stored reserve price only (no RPC). Default true. */
+    live?: boolean;
+}
+/**
+ * Save's reserve prices, read off the FEEDS the reserves name: the Pyth
+ * `PriceUpdateV2` (`pythOracle`) or the Switchboard account
+ * (`switchboardOracle` — On-Demand pull feed, or a V2 aggregator on old
+ * reserves), plus the legacy Pyth price account on a few. Of the reserve's
+ * readable feeds the most recently updated one is used — the program reads
+ * Pyth first and falls back to Switchboard when Pyth is stale, so the
+ * freshest feed is the one a refresh would land on. Every SOL-LST is the SOL
+ * feed × the reserve's `scaledPriceOffsetBPS` dial, applied here as the
+ * program does (`price × (1 + bps / 1e4)`).
+ *
+ * `feedUpdatedAt` is the FEED's own timestamp: a live feed reads fresh even
+ * when the reserve has not been refreshed for days, and a dead feed (a
+ * Switchboard V2 aggregator, an uncranked pull feed) reads as old as it is.
+ * When no feed decodes (no RPC, an unknown owner), the reserve's STORED
+ * `liquidity.marketPrice` is served as before — with no `feedUpdatedAt`,
+ * because its age is the reserve's, not a feed's.
+ */
+declare function fetchSaveOracleEntries(opts?: FetchSaveOracleOptions): Promise<{
     [lender: string]: OraclePriceEntry[];
 }>;
 
@@ -7883,6 +8564,8 @@ interface FetchOraclePricesOptions extends KaminoApiOptions {
     };
     /** Restrict to these fetchers (`['kamino']`). */
     onlyFetchers?: string[];
+    /** The pool for the on-chain reads (Save's feeds, Project 0's banks + feeds); the package's default public pool otherwise. */
+    rpc?: SvmRpc;
 }
 /**
  * margin-fetcher's `fetchOraclePrices`, reduced: per chain, run every
@@ -7891,7 +8574,8 @@ interface FetchOraclePricesOptions extends KaminoApiOptions {
  * `failedChains`, never silently empty — the yield-tracer cron logs it.
  *
  * Five fetchers: Kamino (its API's oracle prices), Jupiter Lend (the
- * vault oracle per vault), Save (each reserve's stored `marketPrice`),
+ * vault oracle per vault), Save (each reserve's Pyth / Switchboard feed,
+ * read live; the stored `marketPrice` when no feed decodes),
  * Loopscale (USD derived from its API — the only reader of the RWA
  * collaterals its book is made of) and Project 0 (the bank's Pyth feed ×
  * its stake-pool rate, live — the only reader of the native-stake tokens).
@@ -8885,4 +9569,4 @@ declare function loopscaleTermAdapter(m: LoopscaleMarketMeta, term?: LoopscaleTe
  */
 declare function project0TermAdapter(row: P0PoolData, group?: P0GroupMeta): DeepPartial<TermSheet>;
 
-export { type Base58, type BasketParams, type ConvertContext, type ConvertJupiterLendOptions, type ConvertLoopscaleOptions, type ConvertLoopscaleUserOptions, DEFAULT_ELEVATION_GROUP, type DecimalString, type DecodedStakePool, type Denomination, EXPONENT_API_BASE, EXPONENT_PROGRAMS, type EusxRate, type ExponentApi, type ExponentApiOptions, type ExponentAssetRef, type ExponentOriginRow, type ExponentPtMarket, type ExponentPtMarkets, type ExponentSyToken, type ExponentToken, type ExponentVault, FLUID_ORACLE_DECIMALS, FLUID_VAULT_TYPE_T1, type FetchExponentPtOptions, type FetchHumaVaultsOptions, type FetchJupiterLendPublicOptions, type FetchKaminoPublicOptions, type FetchKaminoUserOnchainOptions, type FetchKaminoUserOptions, type FetchLenderAllOptions, type FetchLoopscaleEarnVaultsOptions, type FetchLoopscalePublicOptions, type FetchLoopscaleUserOptions, type FetchLstVaultsOptions, type FetchOraclePricesOptions, type FetchP0PublicOptions, type FetchP0UserOptions, type FetchSavePublicOptions, type FetchSaveUserOptions, type FetchSolsticeUserOptions, type FetchSolsticeVaultsOptions, type FetchUserAllOptions, type GetLenderPublicDataAllOptions, HUMA_CLASSIC_MODE_ID, HUMA_DECIMALS, HUMA_IDL, HUMA_MPST_MINT, HUMA_POOL, HUMA_PROGRAM, HUMA_PST_MINT, HUMA_REDEMPTION_REQUEST_SIZE, HUMA_REDEMPTION_SLA_SECONDS, HUMA_SEEDS, HttpError, type HttpOptions, type HumaChainState, type HumaConvertContext, type HumaInstantWithdrawalFeeConfig, type HumaLenderState, type HumaModeConfig, type HumaModeState, type HumaPoolConfig, type HumaPoolState, type HumaRedemptionGating, type HumaRedemptionRequest, type HumaVault, type HumaVaults, JL_BPS, JL_FACTOR_SCALE, JL_ORACLE_DECIMALS, JL_ORACLE_SCALE, JUPITER_LEND_API_BASE, JUPITER_LEND_KEYED_API_BASE, JUPITER_LEND_MARKETS, JUPITER_LEND_PROFILE_ID, JUPITER_LEND_PROGRAMS, JUPITER_PRICE_API_BASE, JUPITER_PRICE_KEYED_API_BASE, JUP_FLASHLOAN_IDL, JUP_FLASHLOAN_PROGRAMS, JUP_LIQUIDITY_PROGRAMS, type JupFlashloanAdmin, type JupiterLendApi, type JupiterLendApiOptions, type JupiterLendBorrowPosition, type JupiterLendBundleParams, type JupiterLendConfigEntry, type JupiterLendConversion, type JupiterLendEarnPosition, type JupiterLendEarnToken, type JupiterLendEarnVault, type JupiterLendFluidSide, type JupiterLendFluidVault, type JupiterLendLiquidityBorrowData, type JupiterLendLiquiditySupplyData, type JupiterLendMarket, type JupiterLendMarketId, type JupiterLendOracleSource, type JupiterLendPoolData, type JupiterLendPublicResponse, type JupiterLendSkipReason, type JupiterLendToken, type JupiterLendUserExt, type JupiterLendUserResult, type JupiterLendVault, type JupiterLendVaultMeta, type JupiterPriceApiOptions, type JupiterPriceMap, KAMINO_API_BASE, KAMINO_MAIN_MARKET, KAMINO_MARKET_DENYLIST, KAMINO_MIN_MARKET_DEPOSITS_USD, KAMINO_OBLIGATION_TAGS, KAMINO_PRICE_AGREEMENT, KAMINO_PROFILE_ID, KLEND_COLLATERAL_MINT_DECIMALS, KLEND_IDL, KLEND_MARKET_SIZE, KLEND_OBLIGATION_DISCRIMINATOR, KLEND_OBLIGATION_OWNER_OFFSET, KLEND_OBLIGATION_SIZE, KLEND_PROGRAM_ID, KLEND_RESERVE_FLASH_SLICE, KLEND_RESERVE_SIZE, KLEND_RESERVE_SLICE, KLEND_U64_MAX, type KaminoApi, type KaminoApiOptions, type KaminoApiUserExt, type KaminoApyWindows, type KaminoBorrowReserveTerms, type KaminoCapBucket, type KaminoCollateralReserve, type KaminoCompoundMetadata, type KaminoConfigEntry, type KaminoLeveragePair, type KaminoLoanBorrow, type KaminoLoanDeposit, type KaminoLoanInfo, type KaminoMarketConfig, type KaminoMarketInputs, type KaminoMarketMeta, type KaminoMarketPrices, type KaminoModeContext, type KaminoObligation, type KaminoObligationLegs, type KaminoObligationView, type KaminoOnchainUserExt, type KaminoOracleEntryOptions, type KaminoOraclePrice, type KaminoOraclePriceMap, type KaminoPairIncentive, type KaminoPoolData, type KaminoPublicConversion, type KaminoPublicResponse, type KaminoRateBasis, type KaminoRateType, type KaminoReserveAccountData, type KaminoReserveExt, type KaminoReserveInputs, type KaminoReserveMetrics, type KaminoReserveMetricsDetail, type KaminoReserveRisk, type KaminoReserveState, type KaminoReserveStats, type KaminoReserveStatus, type KaminoRewardApy, type KaminoUserContext, type KaminoUserError, type KaminoUserObligationRef, type KaminoWithdrawalCapStats, type KaminoWithdrawalCapView, type KlendElevationGroupTerms, type KlendMarketChain, type KlendObligationReserves, type KlendReserveChain, type KlendReserveFlash, type KlendWithdrawalCap, LENDER_BRAND_NAMES, LOANS_PAGE, LOOPSCALE_ACCOUNT_DISCRIMINATORS, LOOPSCALE_API_BASE, LOOPSCALE_BEAM_ORACLE_PROGRAM_ID, LOOPSCALE_CONFIG_LABEL, LOOPSCALE_DOCS_URL, LOOPSCALE_GRACE_PERIOD_SECS, LOOPSCALE_IDL, LOOPSCALE_OPEN_LOANS, LOOPSCALE_PROFILE_ID, LOOPSCALE_PROGRAM_ID, LS_CBPS, LS_NO_ACCOUNT, LS_TENORS, LS_U64_MAX, type LayerTotals, type LenderBundle, type LenderPublicDataMap, type LenderPublicResponse, type LendingBasketMeta, type ListServedMarketsOptions, type LoopscaleApi, type LoopscaleApiOptions, type LoopscaleAssetData, type LoopscaleAssetTerms, type LoopscaleBestOffer, type LoopscaleCapMonitor, type LoopscaleCapsDecoded, type LoopscaleCollateralAccount, type LoopscaleConfigEntry, type LoopscaleConversion, type LoopscaleDuration, type LoopscaleDurationAndApy, type LoopscaleEarnVault, type LoopscaleExternalYieldInfo, type LoopscaleFixedTerm, type LoopscaleLadderLevel, type LoopscaleLedger, type LoopscaleLedgerAccount, type LoopscaleLedgerTerm, type LoopscaleLendingVaultInfo, type LoopscaleLoanAccount, type LoopscaleLoanBook, type LoopscaleLoanCollateral, type LoopscaleLoanDecoded, type LoopscaleLoanPiece, type LoopscaleLoanSummaryItem, type LoopscaleLoansRequest, type LoopscaleLoansResponse, type LoopscaleLoopInfo, type LoopscaleLoopsResponse, type LoopscaleMarketAsset, type LoopscaleMarketInfoDecoded, type LoopscaleMarketMeta, type LoopscaleMarketTerm, type LoopscaleMaxQuote, type LoopscaleMaxQuoteRequest, type LoopscaleMorphoMarket, type LoopscaleOfferingVault, type LoopscaleOpenParameter, type LoopscaleOracleRef, type LoopscalePair, type LoopscalePairBook, type LoopscalePieceLedger, type LoopscalePoolData, type LoopscalePrincipalCaps, type LoopscalePublicResponse, type LoopscaleQuoteOffer, type LoopscaleQuoteRequest, type LoopscaleRewardsSchedule, type LoopscaleRosterOptions, type LoopscaleStrategyAccount, type LoopscaleStrategyDecoded, type LoopscaleStrategyInfo, type LoopscaleStrategySummary, type LoopscaleStrategyTerms, type LoopscaleTerm, type LoopscaleTermId, type LoopscaleTotals, type LoopscaleUserExt, type LoopscaleUserLedger, type LoopscaleUserLoan, type LoopscaleUserPosition, type LoopscaleUserResult, type LoopscaleVaultAccount, type LoopscaleVaultMetadata, type LoopscaleVaultsRequest, type LoopscaleVaultsResponse, type LstConvertContext, type LstEarnVault, type LstEntry, type LstStakingApySource, type MarketOverrides, ORACLE_CANONICAL_SIZE, type OraclePriceEntry, type OraclePriceMap, type OriginJupiterLendMeta, type OriginJupiterLendRow, type OriginLoopscaleMeta, type OriginLoopscaleRow, type OriginLstMeta, type OriginLstMetaAdditions, type OriginLstRow, type OriginSavingsMeta, type OriginSavingsRow, type OriginVaultCommon, type OriginVaultProvider, type OriginVaultRow, type OriginWithdrawalMode, type P0AccountView, type P0Api, type P0ApiOptions, type P0AssetTag, type P0Balance, type P0BalanceView, type P0Bank, type P0BankCache, type P0BankConfig, type P0BankDto, type P0BankExt, type P0BankInputs, type P0BankMeta, type P0BankMetaMap, type P0BankPrice, type P0BankRef, type P0CircuitBreakerState, type P0ConfigEntry, type P0ConvertContext, type P0EmodeEntry, type P0EmodeLift, type P0EmodeRoster, type P0EmodeSettings, type P0EmodeTag, type P0Group, type P0GroupInputs, type P0GroupMeta, type P0HealthCache, type P0Integration, type P0InterestRateConfig, type P0MarginfiAccount, type P0OnChainBankMeta, type P0OperationalState, type P0OracleSetup, type P0PoolData, type P0PriceMap, type P0PriceResolution, type P0PublicConversion, type P0PublicResponse, type P0RateLimitWindow, type P0RateLimiter, type P0RatePoint, type P0Rates, type P0RiskTier, type P0StateSemantics, type P0UnservedBalance, type P0UserExt, type P0UserResponse, type P0VenueMultiplier, type P0VenueMultiplierMap, P0_ACCOUNT_AUTHORITY_OFFSET, P0_ACCOUNT_FLAGS, P0_ACCOUNT_GROUP_OFFSET, P0_ADJUSTED_CACHE_SETUPS, P0_API_BASE, P0_ASSET_TAG, P0_BANK_CONFIG_PYTH_PUSH_MIGRATED, P0_BANK_DISCRIMINATOR, P0_BANK_FLAGS, P0_BANK_GROUP_OFFSET, P0_BANK_SIZE, P0_CACHED_PRICE_MULTIPLIER_SETUPS, P0_DEFAULT_LIQUIDATION_FEE, P0_EMODE_BASE_LABEL, P0_EMODE_ON, P0_GROUP_PROGRAM_FEES_ENABLED, P0_GROUP_SIZE, P0_I80F48_FRACTION_BITS, P0_IDL, P0_LIQUIDATION_CLOSEOUT_USD, P0_LOOKUP_TABLES, P0_MAIN_GROUP, P0_MARGINFI_ACCOUNT_DISCRIMINATOR, P0_MARGINFI_ACCOUNT_SIZE, P0_MAX_BALANCES, P0_MAX_EMODE_ENTRIES, P0_NATIVE_STAKE_LOOKUP_TABLES, P0_PAUSE_DURATION_SECONDS, P0_PROGRAM_ID, P0_PYTH_PUSH_SETUPS, P0_SECONDS_PER_YEAR, P0_SEEDS, P0_STAGING_GROUP, P0_STAGING_PROGRAM_ID, P0_STAKE_POOL_PROGRAMS, P0_SVSP_PHANTOM_TOKEN_AMOUNT, P0_U32_MAX, P0_U64_MAX, PROJECT_0_PROFILE_ID, PYTH_PRICE_UPDATE_V2_DISCRIMINATOR, PYTH_RECEIVER_PROGRAM, type PythPriceUpdate, type ResolveP0PricesOptions, type RewardsList, SAVE_API_BASE, SAVE_CREATOR, SAVE_DEFAULT_AVG_SLOT_SECONDS, SAVE_DEFAULT_OBLIGATION_PROBE, SAVE_FULL_LIQUIDATION_VALUE_USD, SAVE_INITIAL_EXCHANGE_RATE_WAD, SAVE_LIQUIDATION_CLOSE_FACTOR, SAVE_MAIN_MARKET, SAVE_MARKET_DENYLIST, SAVE_MAX_BONUS_PCT, SAVE_MAX_LIQUIDATABLE_VALUE_USD, SAVE_MAX_OBLIGATION_PROBE, SAVE_MAX_OBLIGATION_RESERVES, SAVE_NULL_ORACLE, SAVE_OBLIGATION_SIZE, SAVE_POSITION_LIMIT, SAVE_PROFILE_ID, SAVE_PROFILE_ID_PROSE, SAVE_PROGRAM_ID, SAVE_RESERVE_SIZE, SAVE_SLOTS_PER_YEAR, SAVE_U64_MAX, SAVE_UNBORROWABLE_BORROW_FACTOR, SAVE_WAD, SAVE_WALLET_POS_ID, SECONDS_PER_YEAR, SETTLEMENT_BATCH_SIZE, SOLANA_CHAIN_ID, SOLSTICE_APP_API_BASE, SOLSTICE_DECIMALS, SOLSTICE_MINTS, SOLSTICE_PRICE_DECIMALS, SOLSTICE_PROGRAMS, SOLSTICE_STRATEGIES, SOLSTICE_YIELD_STRATEGY_IDL, SOLSTICE_YIELD_VAULT_IDL, SPL_STAKE_POOL_LSTS, SPL_STAKE_POOL_PROGRAM, STABLECOIN_SYMBOLS, STAKE_ACCOUNT_RENT_EXEMPT_LAMPORTS, type SaveApi, type SaveApiOptions, type SaveCompoundV2Metadata, type SaveLastUpdate, type SaveLiquidityToken, type SaveMarketConfig, type SaveMarketInputs, type SaveMarketMeta, type SaveObligation, type SaveObligationBorrow, type SaveObligationDeposit, type SaveObligationView, type SavePoolData, type SavePublicConversion, type SavePublicResponse, type SaveRateLimiter, type SaveRates, type SaveReserveAccount, type SaveReserveCollateral, type SaveReserveConfig, type SaveReserveConfigState, type SaveReserveExt, type SaveReserveFees, type SaveReserveInputs, type SaveReserveLiquidity, type SaveReserveRef, type SaveReserveState, type SaveReservesResponse, type SaveRosterOptions, type SaveUnservedLeg, type SaveUserExt, type SaveUserResponse, type SaveWalletCTokenView, type ServedMarket, type SolanaPoolData, type SolanaSubAccountInfo, type SolanaUserPosition, type SolanaUserPositions, type SolanaUserResult, type SolsticeAccountingState, type SolsticeApiOptions, type SolsticeAppApi, type SolsticeChainState, type SolsticeController, type SolsticeConvertContext, type SolsticeCooldownEscrow, type SolsticeHolding, type SolsticeJuniorUnlockShare, type SolsticeOraclePrice, type SolsticePending, type SolsticeProtocolStats, type SolsticeSeniorUnlockCooldown, type SolsticeSettlementBatch, type SolsticeSettlementBatchView, type SolsticeStrategy, type SolsticeStrategyController, type SolsticeStrategyMode, type SolsticeStrategyName, type SolsticeStrategyPdas, type SolsticeUserPositions, type SolsticeVault, type SolsticeVaults, type SolsticeVestingSchedule, type SolsticeYieldPool, type SolsticeYieldVaultPdas, type StakePoolFee, type StructuredOraclePrices, TERM_PROFILES, type TokenListInput, type TrancheRates, type USDPriceMap, WSOL_MINT, type WireU64, type YieldProfile, accountDiscriminator, aggregateLoopscaleLoanBook, apyFractionToAprPercent, attributeBestOffer, attributeLoopscaleLoan, bigMax0, bpsToPercent, buildKaminoConfig, buildKaminoEModes, buildKaminoMarketMeta, buildLoopscaleRoster, buildLoopscaleTerms, buildP0EModes, buildSolsticeVaults, capOrUndefined, cbpsToFraction, cbpsToPercent, cbpsToWad, convertEusx, convertExponentVault, convertHumaPst, convertJupiterLendEarnToken, convertJupiterLendOracleEntries, convertJupiterLendUserPositions, convertJupiterLendVault, convertKaminoLoans, convertKaminoMarket, convertKaminoOraclePrices, convertKaminoReserve, convertLoopscalePair, convertLoopscaleUser, convertLoopscaleVault, convertLst, convertP0Bank, convertP0Group, convertSaveMarket, convertSaveReserve, convertTranche, createExponentApi, createJupiterLendApi, createKaminoApi, createLimiter, createLoopscaleApi, createMarketUid, createP0Api, createPacer, createSaveApi, createSolsticeAppApi, createWithSeed, decimalStringToI80F48, decodeAccountingState, decodeController, decodeCooldownEscrow, decodeHumaLenderState, decodeHumaModeConfig, decodeHumaPoolConfig, decodeHumaPoolState, decodeHumaRedemptionRequest, decodeJuniorUnlockShare, decodeJupFlashloanAdmin, decodeKaminoObligation, decodeKaminoReserveState, decodeLoopscaleLoan, decodeLoopscaleMarketInformation, decodeLoopscaleStrategy, decodeOracleCanonical, decodeP0Bank, decodeP0BankMetadata, decodeP0Group, decodeP0MarginfiAccount, decodePythPriceUpdate, decodeSaveObligation, decodeSeniorUnlockCooldown, decodeSettlementBatch, decodeStakePool, decodeStrategy, decodeStrategyController, decodeVestingSchedule, decodeYieldPool, denominationOf, deriveLayerTotals, deriveLoopscalePrices, deriveP0Mode, describeBasket, describeKaminoObligation, durationDays, epochRatePercent, epochRealizedApr, eusxAssetsToShares, eusxEpochRatePercent, eusxRate, eusxSharesToAssets, exchangeRateWad, exponentOriginRow, feeBps, fetchExponentPtMarkets, fetchHumaPstVaults, fetchJupiterLendEarnVaults, fetchJupiterLendOracleEntries, fetchJupiterLendPublic, fetchJupiterLendUser, fetchJupiterPrices, fetchKaminoOracleEntries, fetchKaminoOraclePrices, fetchKaminoPublic, fetchKaminoUser, fetchKaminoUserOnchain, fetchLenderAll, fetchLoopscaleEarnVaults, fetchLoopscaleLoanBook, fetchLoopscalePublic, fetchLoopscaleUser, fetchLstVaults, fetchOraclePrices, fetchProject0Public, fetchProject0User, fetchSaveOracleEntries, fetchSavePublic, fetchSaveUser, fetchSolsticeSettlementBatches, fetchSolsticeUser, fetchSolsticeVaults, fetchUserAll, formatRawUnits, getJson, getLenderPublicData, getLenderPublicDataAll, getLendersForChain, getTermProfile, humaDeploymentStatePda, humaLenderStatePda, humaModeConfigPda, humaModeMintPda, humaOriginRow, humaPoolAuthorityPda, humaPoolConfigPda, humaPoolStatePda, humaRedemptionRequestPda, i80f48ToDecimalString, i80f48ToNumber, isBorrowable, isLenderBrand, isLiveVault, isNullKey, isP0FixedSetup, isP0U64Max, isSaveBorrowable, isSaveUnrealizable, isStablecoinSymbol, isStaleKaminoPrice, isSyntheticQuoteMint, isU64Max, isUncapped, jlOraclePriceInBorrow, jlOracleToFluidRaw, joinableBatch, juniorUnlockSharePda, jupFlashBorrowPosition, jupFlashloanAdmin, jupLiquidity, jupLiquidityReserve, jupLiquidityVault, jupRateModel, jupiterLendCurrency, jupiterLendOriginRow, jupiterLendTermAdapter, kaminoAsset, kaminoBorrowFactorToRow, kaminoCloseFactor, kaminoDefaultEntry, kaminoGroupLabel, kaminoOracleEntriesFromMarkets, kaminoRewards, kaminoRiskByReserve, kaminoTagLabel, kaminoTermAdapter, klendMarketAuthority, klendObligationPda, ledgerFaceAt, ledgerInterestAt, ledgerPrincipal, lenderBrandName, lenderDisplayName, liquidityRatio, listServedMarkets, loopscaleOriginRow, loopscaleTermAdapter, lstOriginRow, maxLeverageOf, mintSupply, normalizeP0BankDto, num, obligationPubkey, oracleCanonicalPda, p0BankMetadataPda, p0BankRef, p0CurveKnots, p0DecimalString, p0EmodeRoster, p0FeeState, p0GroupPausedAt, p0Integration, p0LegacyBaseRate, p0LiquidationFee, p0LiquidityVault, p0LiquidityVaultAuthority, p0MarginfiAccountPda, p0MultipointBaseRate, p0NeedsVenueMultiplier, p0Rates, p0StateSemantics, p0SupplyCapTokens, p0Utilization, parseExpirySeconds, pieceLqt, podBool, podDecimalToNumber, podToBigInt, podToNumber, postJson, project0TermAdapter, readEpochClock, readHumaChainState, readHumaLenderState, readHumaRedemptionRequests, readJupFlashAssets, readJupFlashAvailable, readJupFlashloanAdmin, readKlendElevationGroups, readKlendFlashFacts, readKlendLendingMarket, readKlendMarketState, readKlendObligationReserves, readKlendReserveChain, readKlendReserveFlash, readLoopscaleLoans, readLoopscaleMarketInformation, readP0BankMetadata, readP0Banks, readReserveLamports, readSolsticeChainState, readStakePools, registriesToRead, resolveP0Prices, sameDuration, saveAssetGroup, saveBorrowCurvePercent, saveBorrowedRaw, saveExchangeRateWad, saveLiquidationPenalty, saveObligationAddress, saveObligationSeed, saveRates, saveReserveRef, saveSlotYearScale, saveTermAdapter, saveTotalSupplyWads, saveUtilization, scaledToDecimal, scanP0Banks, selectAssetGroupPrices, selectSaveMarkets, seniorCooldownPdas, settlementBatchPdas, solsticeOriginRow, strategyMode, strategyNameOf, strategyPdas, strategyTvlRaw, tenorOf, termIdOf, toOriginVaultRow, tokenAmount, trancheAssetsToShares, trancheRates, trancheSharesToAssets, u32ToBasis, u32ToCenti, u32ToMilli, unvestedAt, valueKaminoObligations, wadToNumber, wadsToFloat, yieldVaultCooldownPdas, yieldVaultPdas };
+export { type Base58, type BasketParams, type ConvertContext, type ConvertJupiterLendOptions, type ConvertLoopscaleOptions, type ConvertLoopscaleUserOptions, DEFAULT_ELEVATION_GROUP, type DecimalString, type DecodedStakePool, type Denomination, EXPONENT_API_BASE, EXPONENT_PROGRAMS, type EusxRate, type ExponentApi, type ExponentApiOptions, type ExponentAssetRef, type ExponentOriginRow, type ExponentPtMarket, type ExponentPtMarkets, type ExponentSyToken, type ExponentToken, type ExponentVault, FLUID_ORACLE_DECIMALS, FLUID_VAULT_TYPE_T1, type FetchExponentPtOptions, type FetchHumaVaultsOptions, type FetchJupiterLendPublicOptions, type FetchKaminoKvaultsOptions, type FetchKaminoPublicOptions, type FetchKaminoUserOnchainOptions, type FetchKaminoUserOptions, type FetchLenderAllOptions, type FetchLoopscaleEarnVaultsOptions, type FetchLoopscalePublicOptions, type FetchLoopscaleUserOptions, type FetchLstVaultsOptions, type FetchOraclePricesOptions, type FetchP0PublicOptions, type FetchP0UserOptions, type FetchSaveOracleOptions, type FetchSavePublicOptions, type FetchSaveUserOptions, type FetchSolsticeUserOptions, type FetchSolsticeVaultsOptions, type FetchUserAllOptions, type GetLenderPublicDataAllOptions, HUMA_CLASSIC_MODE_ID, HUMA_DECIMALS, HUMA_IDL, HUMA_MPST_MINT, HUMA_POOL, HUMA_PROGRAM, HUMA_PST_MINT, HUMA_REDEMPTION_REQUEST_SIZE, HUMA_REDEMPTION_SLA_SECONDS, HUMA_SEEDS, HttpError, type HttpOptions, type HumaChainState, type HumaConvertContext, type HumaInstantWithdrawalFeeConfig, type HumaLenderState, type HumaModeConfig, type HumaModeState, type HumaPoolConfig, type HumaPoolState, type HumaRedemptionGating, type HumaRedemptionRequest, type HumaVault, type HumaVaults, JL_BPS, JL_EXCHANGE_PRICES_PRECISION, JL_FACTOR_SCALE, JL_ORACLE_DECIMALS, JL_ORACLE_SCALE, JL_VAULTS_ACCOUNTS_IDL, JL_VAULT_AMOUNT_DECIMALS, JUPITER_LEND_API_BASE, JUPITER_LEND_KEYED_API_BASE, JUPITER_LEND_MARKETS, JUPITER_LEND_PROFILE_ID, JUPITER_LEND_PROGRAMS, JUPITER_PRICE_API_BASE, JUPITER_PRICE_KEYED_API_BASE, JUP_DEX_PROGRAM, JUP_FLASHLOAN_IDL, JUP_FLASHLOAN_PROGRAMS, JUP_LIQUIDITY_PROGRAMS, JUP_VAULTS_PROGRAMS, type JlLayerIrm, type JlOnchainVault, type JupFlashloanAdmin, type JupiterLendApi, type JupiterLendApiOptions, type JupiterLendBorrowPosition, type JupiterLendBundleParams, type JupiterLendConfigEntry, type JupiterLendConversion, type JupiterLendEarnPosition, type JupiterLendEarnToken, type JupiterLendEarnVault, type JupiterLendFluidSide, type JupiterLendFluidVault, type JupiterLendLiquidityBorrowData, type JupiterLendLiquiditySupplyData, type JupiterLendMarket, type JupiterLendMarketId, type JupiterLendOracleSource, type JupiterLendPoolData, type JupiterLendPublicResponse, type JupiterLendSkipReason, type JupiterLendToken, type JupiterLendUserExt, type JupiterLendUserResult, type JupiterLendVault, type JupiterLendVaultMeta, type JupiterPriceApiOptions, type JupiterPriceMap, KAMINO_API_BASE, KAMINO_MAIN_MARKET, KAMINO_MARKET_DENYLIST, KAMINO_MIN_MARKET_DEPOSITS_USD, KAMINO_OBLIGATION_TAGS, KAMINO_PRICE_AGREEMENT, KAMINO_PROFILE_ID, KLEND_COLLATERAL_MINT_DECIMALS, KLEND_IDL, KLEND_MARKET_SIZE, KLEND_OBLIGATION_DISCRIMINATOR, KLEND_OBLIGATION_OWNER_OFFSET, KLEND_OBLIGATION_SIZE, KLEND_PROGRAM_ID, KLEND_RESERVE_FLASH_SLICE, KLEND_RESERVE_SIZE, KLEND_RESERVE_SLICE, KLEND_U64_MAX, KVAULT_PROGRAM_ID, type KaminoApi, type KaminoApiOptions, type KaminoApiUserExt, type KaminoApyWindows, type KaminoBorrowReserveTerms, type KaminoCapBucket, type KaminoCollateralReserve, type KaminoCompoundMetadata, type KaminoConfigEntry, type KaminoKvault, type KaminoKvaultAllocation, type KaminoKvaultApi, type KaminoKvaultApiOptions, type KaminoKvaultEarnVault, type KaminoKvaultMetrics, type KaminoKvaultState, type KaminoLeveragePair, type KaminoLoanBorrow, type KaminoLoanDeposit, type KaminoLoanInfo, type KaminoMarketConfig, type KaminoMarketInputs, type KaminoMarketMeta, type KaminoMarketPrices, type KaminoModeContext, type KaminoObligation, type KaminoObligationLegs, type KaminoObligationView, type KaminoOnchainUserExt, type KaminoOracleEntryOptions, type KaminoOraclePrice, type KaminoOraclePriceMap, type KaminoPairIncentive, type KaminoPoolData, type KaminoPublicConversion, type KaminoPublicResponse, type KaminoRateBasis, type KaminoRateType, type KaminoReserveAccountData, type KaminoReserveExt, type KaminoReserveInputs, type KaminoReserveMetrics, type KaminoReserveMetricsDetail, type KaminoReserveRisk, type KaminoReserveState, type KaminoReserveStats, type KaminoReserveStatus, type KaminoRewardApy, type KaminoUserContext, type KaminoUserError, type KaminoUserObligationRef, type KaminoWithdrawalCapStats, type KaminoWithdrawalCapView, type KlendElevationGroupTerms, type KlendMarketChain, type KlendObligationReserves, type KlendReserveChain, type KlendReserveFlash, type KlendWithdrawalCap, LENDER_BRAND_NAMES, LOANS_PAGE, LOOPSCALE_ACCOUNT_DISCRIMINATORS, LOOPSCALE_API_BASE, LOOPSCALE_BEAM_ORACLE_PROGRAM_ID, LOOPSCALE_CONFIG_LABEL, LOOPSCALE_DOCS_URL, LOOPSCALE_GRACE_PERIOD_SECS, LOOPSCALE_IDL, LOOPSCALE_OPEN_LOANS, LOOPSCALE_PROFILE_ID, LOOPSCALE_PROGRAM_ID, LS_CBPS, LS_NO_ACCOUNT, LS_TENORS, LS_U64_MAX, type LayerTotals, type LenderBundle, type LenderPublicDataMap, type LenderPublicResponse, type LendingBasketMeta, type ListServedMarketsOptions, type LoopscaleApi, type LoopscaleApiOptions, type LoopscaleAssetData, type LoopscaleAssetTerms, type LoopscaleBestOffer, type LoopscaleCapMonitor, type LoopscaleCapsDecoded, type LoopscaleCollateralAccount, type LoopscaleConfigEntry, type LoopscaleConversion, type LoopscaleDuration, type LoopscaleDurationAndApy, type LoopscaleEarnVault, type LoopscaleExternalYieldInfo, type LoopscaleFixedTerm, type LoopscaleLadderLevel, type LoopscaleLedger, type LoopscaleLedgerAccount, type LoopscaleLedgerTerm, type LoopscaleLendingVaultInfo, type LoopscaleLoanAccount, type LoopscaleLoanBook, type LoopscaleLoanCollateral, type LoopscaleLoanDecoded, type LoopscaleLoanPiece, type LoopscaleLoanSummaryItem, type LoopscaleLoansRequest, type LoopscaleLoansResponse, type LoopscaleLoopInfo, type LoopscaleLoopsResponse, type LoopscaleMarketAsset, type LoopscaleMarketInfoDecoded, type LoopscaleMarketMeta, type LoopscaleMarketTerm, type LoopscaleMaxQuote, type LoopscaleMaxQuoteRequest, type LoopscaleMorphoMarket, type LoopscaleOfferingVault, type LoopscaleOpenParameter, type LoopscaleOracleRef, type LoopscalePair, type LoopscalePairBook, type LoopscalePieceLedger, type LoopscalePoolData, type LoopscalePrincipalCaps, type LoopscalePublicResponse, type LoopscaleQuoteOffer, type LoopscaleQuoteRequest, type LoopscaleRewardsSchedule, type LoopscaleRosterOptions, type LoopscaleStrategyAccount, type LoopscaleStrategyDecoded, type LoopscaleStrategyInfo, type LoopscaleStrategySummary, type LoopscaleStrategyTerms, type LoopscaleTerm, type LoopscaleTermId, type LoopscaleTotals, type LoopscaleUserExt, type LoopscaleUserLedger, type LoopscaleUserLoan, type LoopscaleUserPosition, type LoopscaleUserResult, type LoopscaleVaultAccount, type LoopscaleVaultMetadata, type LoopscaleVaultsRequest, type LoopscaleVaultsResponse, type LstConvertContext, type LstEarnVault, type LstEntry, type LstStakingApySource, type MarketOverrides, ORACLE_CANONICAL_SIZE, type OraclePriceEntry, type OraclePriceMap, type OriginJupiterLendMeta, type OriginJupiterLendRow, type OriginKaminoKvaultMeta, type OriginKaminoKvaultRow, type OriginLoopscaleMeta, type OriginLoopscaleRow, type OriginLstMeta, type OriginLstMetaAdditions, type OriginLstRow, type OriginSavingsMeta, type OriginSavingsRow, type OriginVaultCommon, type OriginVaultProvider, type OriginVaultRow, type OriginWithdrawalMode, type P0AccountView, type P0Api, type P0ApiOptions, type P0AssetTag, type P0Balance, type P0BalanceView, type P0Bank, type P0BankCache, type P0BankConfig, type P0BankDto, type P0BankExt, type P0BankInputs, type P0BankMeta, type P0BankMetaMap, type P0BankPrice, type P0BankRef, type P0CircuitBreakerState, type P0ConfigEntry, type P0ConvertContext, type P0EmodeEntry, type P0EmodeLift, type P0EmodeRoster, type P0EmodeSettings, type P0EmodeTag, type P0Group, type P0GroupInputs, type P0GroupMeta, type P0HealthCache, type P0Integration, type P0InterestRateConfig, type P0MarginfiAccount, type P0OnChainBankMeta, type P0OperationalState, type P0OracleSetup, type P0PoolData, type P0PriceMap, type P0PriceResolution, type P0PublicConversion, type P0PublicResponse, type P0RateLimitWindow, type P0RateLimiter, type P0RatePoint, type P0Rates, type P0RiskTier, type P0StateSemantics, type P0UnservedBalance, type P0UserExt, type P0UserResponse, type P0VenueMultiplier, type P0VenueMultiplierMap, P0_ACCOUNT_AUTHORITY_OFFSET, P0_ACCOUNT_FLAGS, P0_ACCOUNT_GROUP_OFFSET, P0_ADJUSTED_CACHE_SETUPS, P0_API_BASE, P0_ASSET_TAG, P0_BANK_CONFIG_PYTH_PUSH_MIGRATED, P0_BANK_DISCRIMINATOR, P0_BANK_FLAGS, P0_BANK_GROUP_OFFSET, P0_BANK_SIZE, P0_CACHED_PRICE_MULTIPLIER_SETUPS, P0_DEFAULT_LIQUIDATION_FEE, P0_EMODE_BASE_LABEL, P0_EMODE_ON, P0_GROUP_PROGRAM_FEES_ENABLED, P0_GROUP_SIZE, P0_I80F48_FRACTION_BITS, P0_IDL, P0_LIQUIDATION_CLOSEOUT_USD, P0_LOOKUP_TABLES, P0_MAIN_GROUP, P0_MARGINFI_ACCOUNT_DISCRIMINATOR, P0_MARGINFI_ACCOUNT_SIZE, P0_MAX_BALANCES, P0_MAX_EMODE_ENTRIES, P0_NATIVE_STAKE_LOOKUP_TABLES, P0_PAUSE_DURATION_SECONDS, P0_PROGRAM_ID, P0_PYTH_PUSH_SETUPS, P0_SECONDS_PER_YEAR, P0_SEEDS, P0_STAGING_GROUP, P0_STAGING_PROGRAM_ID, P0_STAKE_POOL_PROGRAMS, P0_SVSP_PHANTOM_TOKEN_AMOUNT, P0_U32_MAX, P0_U64_MAX, PROJECT_0_PROFILE_ID, PYTH_PRICE_UPDATE_V2_DISCRIMINATOR, PYTH_RECEIVER_PROGRAM, type PythPriceUpdate, type ReadJlVaultsOptions, type ResolveP0PricesOptions, type RewardsList, SAVE_API_BASE, SAVE_CREATOR, SAVE_DEFAULT_AVG_SLOT_SECONDS, SAVE_DEFAULT_OBLIGATION_PROBE, SAVE_FULL_LIQUIDATION_VALUE_USD, SAVE_INITIAL_EXCHANGE_RATE_WAD, SAVE_LIQUIDATION_CLOSE_FACTOR, SAVE_MAIN_MARKET, SAVE_MARKET_DENYLIST, SAVE_MAX_BONUS_PCT, SAVE_MAX_LIQUIDATABLE_VALUE_USD, SAVE_MAX_OBLIGATION_PROBE, SAVE_MAX_OBLIGATION_RESERVES, SAVE_NULL_ORACLE, SAVE_OBLIGATION_SIZE, SAVE_POSITION_LIMIT, SAVE_PROFILE_ID, SAVE_PROFILE_ID_PROSE, SAVE_PROGRAM_ID, SAVE_RESERVE_SIZE, SAVE_SLOTS_PER_YEAR, SAVE_U64_MAX, SAVE_UNBORROWABLE_BORROW_FACTOR, SAVE_WAD, SAVE_WALLET_POS_ID, SECONDS_PER_YEAR, SETTLEMENT_BATCH_SIZE, SOLANA_CHAIN_ID, SOLSTICE_APP_API_BASE, SOLSTICE_DECIMALS, SOLSTICE_MINTS, SOLSTICE_PRICE_DECIMALS, SOLSTICE_PROGRAMS, SOLSTICE_STRATEGIES, SOLSTICE_YIELD_STRATEGY_IDL, SOLSTICE_YIELD_VAULT_IDL, SPL_STAKE_POOL_LSTS, SPL_STAKE_POOL_PROGRAM, STABLECOIN_SYMBOLS, STAKE_ACCOUNT_RENT_EXEMPT_LAMPORTS, type SaveApi, type SaveApiOptions, type SaveCompoundV2Metadata, type SaveLastUpdate, type SaveLiquidityToken, type SaveMarketConfig, type SaveMarketInputs, type SaveMarketMeta, type SaveObligation, type SaveObligationBorrow, type SaveObligationDeposit, type SaveObligationView, type SavePoolData, type SavePublicConversion, type SavePublicResponse, type SaveRateLimiter, type SaveRates, type SaveReserveAccount, type SaveReserveCollateral, type SaveReserveConfig, type SaveReserveConfigState, type SaveReserveExt, type SaveReserveFees, type SaveReserveInputs, type SaveReserveLiquidity, type SaveReserveRef, type SaveReserveState, type SaveReservesResponse, type SaveRosterOptions, type SaveUnservedLeg, type SaveUserExt, type SaveUserResponse, type SaveWalletCTokenView, type ServedMarket, type SolanaPoolData, type SolanaSubAccountInfo, type SolanaUserPosition, type SolanaUserPositions, type SolanaUserResult, type SolsticeAccountingState, type SolsticeApiOptions, type SolsticeAppApi, type SolsticeChainState, type SolsticeController, type SolsticeConvertContext, type SolsticeCooldownEscrow, type SolsticeHolding, type SolsticeJuniorUnlockShare, type SolsticeOraclePrice, type SolsticePending, type SolsticeProtocolStats, type SolsticeSeniorUnlockCooldown, type SolsticeSettlementBatch, type SolsticeSettlementBatchView, type SolsticeStrategy, type SolsticeStrategyController, type SolsticeStrategyMode, type SolsticeStrategyName, type SolsticeStrategyPdas, type SolsticeUserPositions, type SolsticeVault, type SolsticeVaults, type SolsticeVestingSchedule, type SolsticeYieldPool, type SolsticeYieldVaultPdas, type StakePoolFee, type StructuredOraclePrices, TERM_PROFILES, type TokenListInput, type TrancheRates, type USDPriceMap, WSOL_MINT, type WireU64, type YieldProfile, accountDiscriminator, aggregateLoopscaleLoanBook, apyFractionToAprPercent, attributeBestOffer, attributeLoopscaleLoan, bigMax0, bpsToPercent, buildKaminoConfig, buildKaminoEModes, buildKaminoMarketMeta, buildLoopscaleRoster, buildLoopscaleTerms, buildP0EModes, buildSolsticeVaults, capOrUndefined, cbpsToFraction, cbpsToPercent, cbpsToWad, convertEusx, convertExponentVault, convertHumaPst, convertJupiterLendEarnToken, convertJupiterLendOracleEntries, convertJupiterLendUserPositions, convertJupiterLendVault, convertKaminoKvault, convertKaminoLoans, convertKaminoMarket, convertKaminoOraclePrices, convertKaminoReserve, convertLoopscalePair, convertLoopscaleUser, convertLoopscaleVault, convertLst, convertP0Bank, convertP0Group, convertSaveMarket, convertSaveReserve, convertTranche, createExponentApi, createJupiterLendApi, createKaminoApi, createKaminoKvaultApi, createLimiter, createLoopscaleApi, createMarketUid, createP0Api, createPacer, createSaveApi, createSolsticeAppApi, createWithSeed, decimalStringToI80F48, decimalStringToRaw, decodeAccountingState, decodeController, decodeCooldownEscrow, decodeHumaLenderState, decodeHumaModeConfig, decodeHumaPoolConfig, decodeHumaPoolState, decodeHumaRedemptionRequest, decodeJlRateModel, decodeJuniorUnlockShare, decodeJupFlashloanAdmin, decodeKaminoObligation, decodeKaminoReserveState, decodeLoopscaleLoan, decodeLoopscaleMarketInformation, decodeLoopscaleStrategy, decodeOracleCanonical, decodeP0Bank, decodeP0BankMetadata, decodeP0Group, decodeP0MarginfiAccount, decodePythPriceUpdate, decodeSaveObligation, decodeSeniorUnlockCooldown, decodeSettlementBatch, decodeStakePool, decodeStrategy, decodeStrategyController, decodeVestingSchedule, decodeYieldPool, denominationOf, deriveLayerTotals, deriveLoopscalePrices, deriveP0Mode, describeBasket, describeKaminoObligation, durationDays, epochRatePercent, epochRealizedApr, eusxAssetsToShares, eusxEpochRatePercent, eusxRate, eusxSharesToAssets, exchangeRateWad, exponentOriginRow, feeBps, fetchExponentPtMarkets, fetchHumaPstVaults, fetchJupiterLendEarnVaults, fetchJupiterLendOracleEntries, fetchJupiterLendPublic, fetchJupiterLendUser, fetchJupiterPrices, fetchKaminoKvaults, fetchKaminoOracleEntries, fetchKaminoOraclePrices, fetchKaminoPublic, fetchKaminoUser, fetchKaminoUserOnchain, fetchLenderAll, fetchLoopscaleEarnVaults, fetchLoopscaleLoanBook, fetchLoopscalePublic, fetchLoopscaleUser, fetchLstVaults, fetchOraclePrices, fetchProject0Public, fetchProject0User, fetchSaveOracleEntries, fetchSavePublic, fetchSaveUser, fetchSolsticeSettlementBatches, fetchSolsticeUser, fetchSolsticeVaults, fetchUserAll, formatRawUnits, getJson, getLenderPublicData, getLenderPublicDataAll, getLendersForChain, getTermProfile, humaDeploymentStatePda, humaLenderStatePda, humaModeConfigPda, humaModeMintPda, humaOriginRow, humaPoolAuthorityPda, humaPoolConfigPda, humaPoolStatePda, humaRedemptionRequestPda, i80f48ToDecimalString, i80f48ToNumber, isBorrowable, isJlSmartCol, isJlSmartDebt, isLenderBrand, isLiveVault, isNullKey, isP0FixedSetup, isP0U64Max, isSaveBorrowable, isSaveUnrealizable, isStablecoinSymbol, isStaleKaminoPrice, isSyntheticQuoteMint, isU64Max, isUncapped, jlLiquidityExchangePrices, jlOraclePriceInBorrow, jlOracleToFluidRaw, jlOverallTokenData, jlUserBorrowData, jlUserSupplyData, jlVaultAdminPda, jlVaultConfigPda, jlVaultExchangePrices, jlVaultStatePda, jlVaultToRaw, joinableBatch, juniorUnlockSharePda, jupFlashBorrowPosition, jupFlashloanAdmin, jupLiquidity, jupLiquidityReserve, jupLiquidityVault, jupRateModel, jupiterLendCurrency, jupiterLendOriginRow, jupiterLendTermAdapter, kaminoAsset, kaminoBorrowFactorToRow, kaminoCloseFactor, kaminoDefaultEntry, kaminoGroupLabel, kaminoKvaultOriginRow, kaminoOracleEntriesFromMarkets, kaminoRewards, kaminoRiskByReserve, kaminoTagLabel, kaminoTermAdapter, klendMarketAuthority, klendObligationPda, ledgerFaceAt, ledgerInterestAt, ledgerPrincipal, lenderBrandName, lenderDisplayName, liquidityRatio, listServedMarkets, loopscaleOriginRow, loopscaleTermAdapter, lstOriginRow, maxLeverageOf, mintSupply, normalizeP0BankDto, num, obligationPubkey, oracleCanonicalPda, p0BankMetadataPda, p0BankRef, p0CurveKnots, p0DecimalString, p0EmodeRoster, p0FeeState, p0GroupPausedAt, p0Integration, p0LegacyBaseRate, p0LiquidationFee, p0LiquidityVault, p0LiquidityVaultAuthority, p0MarginfiAccountPda, p0MultipointBaseRate, p0NeedsVenueMultiplier, p0Rates, p0StateSemantics, p0SupplyCapTokens, p0Utilization, parseExpirySeconds, pieceLqt, podBool, podDecimalToNumber, podToBigInt, podToNumber, postJson, project0TermAdapter, readEpochClock, readHumaChainState, readHumaLenderState, readHumaRedemptionRequests, readJlLayerIrms, readJlNextVaultId, readJupFlashAssets, readJupFlashAvailable, readJupFlashloanAdmin, readJupiterLendVaultsOnchain, readKlendElevationGroups, readKlendFlashFacts, readKlendLendingMarket, readKlendMarketState, readKlendObligationReserves, readKlendReserveChain, readKlendReserveFlash, readLoopscaleLoans, readLoopscaleMarketInformation, readP0BankMetadata, readP0Banks, readReserveLamports, readSolsticeChainState, readStakePools, registriesToRead, resolveP0Prices, sameDuration, saveAssetGroup, saveBorrowCurvePercent, saveBorrowedRaw, saveExchangeRateWad, saveLiquidationPenalty, saveObligationAddress, saveObligationSeed, saveRates, saveReserveRef, saveSlotYearScale, saveTermAdapter, saveTotalSupplyWads, saveUtilization, scaledToDecimal, scanP0Banks, selectAssetGroupPrices, selectSaveMarkets, seniorCooldownPdas, settlementBatchPdas, solsticeOriginRow, strategyMode, strategyNameOf, strategyPdas, strategyTvlRaw, tenorOf, termIdOf, toOriginVaultRow, tokenAmount, trancheAssetsToShares, trancheRates, trancheSharesToAssets, u32ToBasis, u32ToCenti, u32ToMilli, unvestedAt, valueKaminoObligations, wadToNumber, wadsToFloat, yieldVaultCooldownPdas, yieldVaultPdas };