@instadapp/fluid-sui-read-sdk 0.0.0-stage → 0.2.0

package/dist/index.d.mts

@@ -0,0 +1,2152 @@
+import { ClientWithCoreApi } from "@mysten/sui/client";
+import { BcsType } from "@mysten/sui/bcs";
+import { Transaction, TransactionResult } from "@mysten/sui/transactions";
+import * as _mysten_bcs0 from "@mysten/bcs";
+
+//#region src/types.d.ts
+/**
+ * Public types. Field names match `@jup-ag/lend-read` one-for-one wherever the protocol
+ * concept is the same; differences:
+ *   - `PublicKey` → `string` (a Sui object id, or a coin type for tokens)
+ *   - `BN` → `bigint`
+ *   - Solana `nftId: number` → Sui `positionId: string` (+ `capId`, the PositionOwnerCap)
+ */
+type RateDataV1 = {
+  token: string;
+  rateAtUtilizationZero: bigint;
+  kink: bigint;
+  rateAtUtilizationKink: bigint;
+  rateAtUtilizationMax: bigint;
+};
+type RateDataV2 = {
+  token: string;
+  rateAtUtilizationZero: bigint;
+  kink1: bigint;
+  rateAtUtilizationKink1: bigint;
+  kink2: bigint;
+  rateAtUtilizationKink2: bigint;
+  rateAtUtilizationMax: bigint;
+};
+type RateData = {
+  token: string;
+  /** 0 = unset, 1 = V1, 2 = V2 (`TokenReserve.rate_data_version`). */
+  version: number;
+  rateDataV1: RateDataV1;
+  rateDataV2: RateDataV2;
+};
+type RateModelAccount = {
+  mint: string;
+  version: number;
+  rateAtUtilizationZero: bigint;
+  kink?: bigint;
+  rateAtUtilizationKink?: bigint;
+  kink1?: bigint;
+  rateAtUtilizationKink1?: bigint;
+  kink2?: bigint;
+  rateAtUtilizationKink2?: bigint;
+  rateAtUtilizationMax: bigint;
+};
+type ExchangePricesAndConfig = {
+  supplyExchangePrice: bigint;
+  borrowExchangePrice: bigint;
+  borrowRate: bigint;
+  fee: bigint;
+  lastStoredUtilization: bigint;
+  lastUpdateTimestamp: bigint;
+  maxUtilization: bigint;
+};
+type TotalAmounts = {
+  supplyRawInterest: bigint;
+  supplyInterestFree: bigint;
+  borrowRawInterest: bigint;
+  borrowInterestFree: bigint;
+  /** Solana-only concept (claim accounts); always 0 on Sui. */
+  totalClaimAmount: bigint;
+};
+type ExchangePriceResult = {
+  supplyExchangePrice: bigint;
+  borrowExchangePrice: bigint;
+};
+type OverallTokenData = {
+  rateData: RateData;
+  supplyExchangePrice: bigint;
+  borrowExchangePrice: bigint;
+  borrowRate: bigint;
+  fee: bigint;
+  lastStoredUtilization: bigint;
+  lastUpdateTimestamp: bigint;
+  maxUtilization: bigint;
+  supplyRawInterest: bigint;
+  supplyInterestFree: bigint;
+  borrowRawInterest: bigint;
+  borrowInterestFree: bigint;
+  totalSupply: bigint;
+  totalBorrow: bigint;
+  revenue: bigint;
+  supplyRate: bigint;
+};
+type UserSupplyPositionAccount = {
+  user: string;
+  mint: string;
+  amount: bigint;
+  withdrawalLimit: bigint;
+  baseWithdrawalLimit: bigint;
+  lastUpdateTimestamp: bigint;
+  expandPercent: bigint;
+  expandDuration: bigint;
+  modeWithInterest: boolean;
+  decayAmount: bigint;
+  decayDuration: bigint;
+  /** Sui extras. */
+  configured: boolean;
+  pausedSupply: boolean;
+  pausedWithdraw: boolean;
+};
+type UserBorrowPositionAccount = {
+  user: string;
+  mint: string;
+  amount: bigint;
+  borrowLimit: bigint;
+  baseBorrowLimit: bigint;
+  maxBorrowLimit: bigint;
+  lastUpdateTimestamp: bigint;
+  expandPercent: bigint;
+  expandDuration: bigint;
+  modeWithInterest: boolean;
+  /** Sui extras. */
+  configured: boolean;
+  pausedBorrow: boolean;
+  pausedPayback: boolean;
+};
+type UserSupplyData = {
+  modeWithInterest: boolean;
+  supply: bigint;
+  withdrawalLimit: bigint;
+  lastUpdateTimestamp: bigint;
+  expandPercent: bigint;
+  expandDuration: bigint;
+  baseWithdrawalLimit: bigint;
+  withdrawableUntilLimit: bigint;
+  withdrawable: bigint;
+  decayAmount: bigint;
+  decayEndTimestamp: bigint;
+};
+type UserBorrowData = {
+  modeWithInterest: boolean;
+  borrow: bigint;
+  borrowLimit: bigint;
+  lastUpdateTimestamp: bigint;
+  expandPercent: bigint;
+  expandDuration: bigint;
+  baseBorrowLimit: bigint;
+  maxBorrowLimit: bigint;
+  borrowLimitUtilization: bigint;
+  borrowableUntilLimit: bigint;
+  borrowable: bigint;
+};
+type LiquidityAccount = {
+  id: string;
+  version: bigint;
+  revenueCollector: string;
+  /** Global pause flags (true = paused). */
+  status: {
+    supply: boolean;
+    borrow: boolean;
+    payback: boolean;
+    withdraw: boolean;
+  };
+  activeCapsTableId: string;
+  activeCapsCount: bigint;
+};
+/** fToken = the lending (share) token on Sui, `Coin<FToken<T>>` (Solana calls it jlToken). */
+type FTokenDetails = {
+  /** Sui: `FToken<T>` coin type. */
+  tokenAddress: string;
+  /** Sui: the `LendingState<T>` object id. */
+  lendingStateId: string;
+  name: string;
+  symbol: string;
+  decimals: number;
+  underlyingAddress: string;
+  totalAssets: bigint;
+  totalSupply: bigint;
+  conversionRateToShares: bigint;
+  conversionRateToAssets: bigint;
+  /**
+   * RATES: every rate field is bps (1e4 = 100% per year), floored. Raw 1e12 values:
+   * `liquidityMath.supplyRateAt` / `lendingMath.currentRewardsRate`.
+   */
+  /** Rewards rate from the active schedule, priced on the pre-accrual TVL. bps. */
+  rewardsRate: bigint;
+  /** Organic (liquidity-layer) supply rate, exact on-chain formula. bps. */
+  supplyRate: bigint;
+  /** `supplyRate + rewardsRate`. bps. */
+  totalRate: bigint;
+  rebalanceDifference: bigint;
+  userSupplyData: UserSupplyData;
+};
+/** @deprecated Solana name; use `FTokenDetails`. */
+type JlTokenDetails = FTokenDetails;
+/**
+ * Generic per-fToken lending state (`lending.getLendingStateData`). Exchange prices are 1e12;
+ * amounts are in underlying token units (no USD: every lending token is USD-pegged); every rate
+ * is bps (1e4 = 100% per year).
+ */
+type LendingStateData = {
+  /** `FToken<T>` coin type (the share coin is `Coin<FToken<T>>`). */
+  fTokenType: string;
+  /** Underlying coin type `T`. */
+  asset: string;
+  decimals: number;
+  lendingStateId: string;
+  /** Chain time (unix s, on-chain Clock) every "accrued" value below is computed at. */
+  timestamp: bigint;
+  /** fToken -> underlying, rewards INCLUDED, accrued to `timestamp`. */
+  tokenExchangePrice: bigint;
+  /** The underlying's liquidity-layer supply exchange price, rewards EXCLUDED, accrued to `timestamp`. */
+  liquidityExchangePrice: bigint;
+  /** As stored on LendingState at its last update (no accrual). */
+  storedTokenExchangePrice: bigint;
+  storedLiquidityExchangePrice: bigint;
+  /** LendingState last update; `timestamp - lastUpdateS` = how stale the stored prices are. */
+  lastUpdateS: bigint;
+  /** TokenReserve (liquidity layer) last update. */
+  liquidityLastUpdateS: bigint;
+  /** fToken shares outstanding. */
+  totalShares: bigint;
+  /** `totalShares` at the accrued `tokenExchangePrice`, token units (floor, = accounting::total_assets). */
+  totalAssets: bigint;
+  /** Organic liquidity supply rate (exact on-chain formula). */
+  supplyRate: bigint;
+  /** Rewards rate from the active window, priced on the pre-accrual TVL as the contract does. */
+  rewardsRate: bigint;
+  /** `supplyRate + rewardsRate`. */
+  totalRate: bigint;
+  /** Rewards schedule as stored; `null` when the pool has none. Times are unix seconds. */
+  rewards: {
+    startTvl: bigint;
+    startS: bigint;
+    endS: bigint;
+    yearlyReward: bigint;
+    nextStartS: bigint;
+    nextEndS: bigint;
+    nextYearlyReward: bigint;
+  } | null;
+};
+/** One wallet holding `Coin<FToken<T>>` objects. */
+type FTokenHolder = {
+  /** Wallet address (AddressOwner or ConsensusAddressOwner). */
+  owner: string;
+  /** Sum of the wallet's Coin<FToken<T>> objects at `checkpoint` (shares). */
+  balance: bigint;
+  /** Number of coin objects summed. */
+  coins: number;
+  /** Cross-check via fullnode `getBalance` (live, after the checkpoint). Present when `verify`. */
+  rpc?: {
+    balance: bigint;
+    coinBalance: bigint;
+    addressBalance: bigint;
+  };
+  /** `rpc.coinBalance === balance && rpc.addressBalance === 0n`. A mismatch means the wallet moved
+   *  shares after `checkpoint` or holds an address balance (credited without a coin object). */
+  agrees?: boolean;
+};
+type FTokenHolders = {
+  fTokenType: string;
+  asset: string;
+  /** Checkpoint the coin listing and `totalSupply` were read at. */
+  checkpoint: bigint;
+  /** Wallets, largest first. */
+  holders: FTokenHolder[];
+  /** Sum of `holders[].balance`. */
+  countedTotal: bigint;
+  /** LendingState total shares at `checkpoint`. */
+  totalSupply: bigint;
+};
+type LendingUserPosition = {
+  /** fToken shares held (`Coin<FToken<T>>` balance). */
+  fTokenShares: bigint;
+  underlyingAssets: bigint;
+  underlyingBalance: bigint;
+};
+type FTokenDetailsUserPosition = {
+  fTokenDetails: FTokenDetails;
+  userPosition: LendingUserPosition;
+};
+/** @deprecated Solana name; use `FTokenDetailsUserPosition`. */
+type JlTokenDetailsUserPosition = FTokenDetailsUserPosition;
+type RewardsRateModelConfig = {
+  duration: bigint;
+  startTime: bigint;
+  endTime: bigint;
+  startTvl: bigint;
+  maxRate: bigint;
+  rewardAmount: bigint;
+  /** Sui extras: the queued next schedule. `maxRate` is bps (5000 = the 50% cap). */
+  nextStartTime: bigint;
+  nextEndTime: bigint;
+  nextRewardAmount: bigint;
+};
+type PreviewData = {
+  previewDeposit: bigint;
+  previewMint: bigint;
+  previewWithdraw: bigint;
+  previewRedeem: bigint;
+};
+type FTokenInternalData = {
+  /** Sui: TokenReserve<T> id backing the pool. */
+  liquidity: string;
+  /** Sui: LendingRegistry id. */
+  lendingFactory: string;
+  /** Sui: rewards writer cap id, if one is installed. */
+  lendingRewardsRateModel: string | null;
+  liquidityBalance: bigint;
+  liquidityExchangePrice: bigint;
+  tokenExchangePrice: bigint;
+};
+/** @deprecated Solana name; use `FTokenInternalData`. */
+type JlTokenInternalData = FTokenInternalData;
+type LendingAccount = {
+  id: string;
+  mint: string;
+  fTokenMint: string;
+  decimals: number;
+  totalShares: bigint;
+  liquidityExchangePrice: bigint;
+  tokenExchangePrice: bigint;
+  lastUpdateTimestamp: bigint;
+  tokenReservesLiquidity: string;
+  rewardsWriter: string | null;
+};
+type ConstantViews = {
+  liquidity: string;
+  /** Collateral TokenReserve id. */
+  supply: string;
+  /** Debt TokenReserve id. */
+  borrow: string;
+  supplyToken: string;
+  borrowToken: string;
+  vaultId: number;
+  vaultType: number;
+};
+type Configs = {
+  supplyRateMagnifier: bigint;
+  borrowRateMagnifier: bigint;
+  collateralFactor: bigint;
+  liquidationThreshold: bigint;
+  liquidationMaxLimit: bigint;
+  withdrawalGap: bigint;
+  liquidationPenalty: bigint;
+  borrowFee: bigint;
+  oracle: string;
+  oraclePriceOperate?: bigint;
+  oraclePriceLiquidate?: bigint;
+  lastUpdateTimestamp?: bigint;
+};
+type ExchangePricesAndRates = {
+  lastStoredLiquiditySupplyExchangePrice: bigint;
+  lastStoredLiquidityBorrowExchangePrice: bigint;
+  lastStoredVaultSupplyExchangePrice: bigint;
+  lastStoredVaultBorrowExchangePrice: bigint;
+  liquiditySupplyExchangePrice: bigint;
+  liquidityBorrowExchangePrice: bigint;
+  vaultSupplyExchangePrice: bigint;
+  vaultBorrowExchangePrice: bigint;
+  supplyRateLiquidity: bigint;
+  borrowRateLiquidity: bigint;
+  supplyRateVault: bigint;
+  borrowRateVault: bigint;
+  rewardsOrFeeRateSupply: bigint;
+  rewardsOrFeeRateBorrow: bigint;
+};
+type TotalSupplyAndBorrow = {
+  totalSupplyVault: bigint;
+  totalBorrowVault: bigint;
+  totalSupplyLiquidityOrDex: bigint;
+  totalBorrowLiquidityOrDex: bigint;
+  absorbedSupply: bigint;
+  absorbedBorrow: bigint;
+};
+type LimitsAndAvailability = {
+  withdrawLimit: bigint;
+  withdrawableUntilLimit: bigint;
+  withdrawable: bigint;
+  borrowLimit: bigint;
+  borrowLimitUtilization: bigint;
+  borrowableUntilLimit: bigint;
+  borrowable: bigint;
+  minimumBorrowing: bigint;
+};
+type CurrentBranchState = {
+  /** 0 NotLiquidated · 1 Liquidated · 2 Merged · 3 Closed. */
+  status: number;
+  minimaTick: number;
+  debtFactor: bigint;
+  partials: bigint;
+  debtLiquidity: bigint;
+  baseBranchId: number;
+  baseBranchMinima: number;
+};
+type VaultState = {
+  topTick: number;
+  currentBranch: number;
+  totalBranch: number;
+  totalSupply: bigint;
+  totalBorrow: bigint;
+  /** Positions ever opened (EVM parity). DERIVED on Sui (no on-chain counter): events + object
+   *  reads via `vault.getVaultPositionCounts`; -1 if `positionCounts: false` or endpoint down. */
+  totalPositions: number;
+  currentBranchState?: CurrentBranchState;
+  branchLiquidated: boolean;
+  absorbedDebtAmount: bigint;
+  absorbedColAmount: bigint;
+  absorbedDustDebt: bigint;
+  liquiditySupplyExchangePrice: bigint;
+  liquidityBorrowExchangePrice: bigint;
+  vaultSupplyExchangePrice: bigint;
+  vaultBorrowExchangePrice: bigint;
+  /** `totalPositions + 1`, DERIVED. Ordinal only: Sui position ids are object ids. -1 as above. */
+  nextPositionId: number;
+  /** Sui extra: seconds. */
+  lastUpdateTimestamp: bigint;
+};
+type VaultConfig = {
+  vaultId: number;
+  /** Sui: the VaultMarket object id. */
+  vault: string;
+  supplyRateMagnifier: number;
+  borrowRateMagnifier: number;
+  collateralFactor: number;
+  liquidationThreshold: number;
+  liquidationMaxLimit: number;
+  withdrawGap: number;
+  liquidationPenalty: number;
+  borrowFee: number;
+  oracle: string;
+  liquidityProgram: string;
+  oracleProgram: string;
+  supplyToken: string;
+  borrowToken: string;
+  vaultType: number;
+  collateralDecimals: number;
+  debtDecimals: number;
+};
+type VaultEntireData = {
+  vault: string;
+  isSmartCol: boolean;
+  isSmartDebt: boolean;
+  constantViews: ConstantViews;
+  configs: Configs;
+  exchangePricesAndRates: ExchangePricesAndRates;
+  limitsAndAvailability: LimitsAndAvailability;
+  liquidityUserSupplyData: UserSupplyData;
+  liquidityUserBorrowData: UserBorrowData;
+  vaultState: VaultState;
+  totalSupplyAndBorrow: TotalSupplyAndBorrow;
+};
+type VaultEntireDataV2 = VaultEntireData & {
+  vaultId: number;
+  vaultType: number;
+  /** No DEX on Sui yet. */
+  supplyDex: null;
+  borrowDex: null;
+  supplyDexPosition: null;
+  borrowDexPosition: null;
+};
+/** Raw on-chain Position (Solana `UserPosition`). */
+type UserPosition = {
+  vaultId: number;
+  /** Sui: Position object id (Solana nftId). */
+  positionId: string;
+  /** Sui: VaultMarket object id. */
+  vault: string;
+  /** Sui: PositionOwnerCap id (Solana positionMint). */
+  positionMint: string;
+  isSupplyOnlyPosition: boolean;
+  tick: number;
+  tickId: number;
+  supplyAmount: bigint;
+  dustDebtAmount: bigint;
+};
+type UserPositionWithDebt = {
+  tick: number;
+  tickId: number;
+  colRaw: bigint;
+  debtRaw: bigint;
+  dustDebtRaw: bigint;
+  finalAmount: bigint;
+  isSupplyOnlyPosition: boolean;
+  userLiquidationStatus?: boolean;
+  postLiquidationBranchId?: number;
+};
+type NftPosition = {
+  /** Sui: Position object id. */
+  nftId: string;
+  /** Owner of the PositionOwnerCap (address, or object id when wrapped/object-owned). */
+  owner: string | null;
+  capId: string;
+  isSupplyPosition: boolean;
+  supply: bigint;
+  beforeSupply: bigint;
+  dustBorrow: bigint;
+  beforeDustBorrow: bigint;
+  tick: number;
+  tickId: number;
+  borrow: bigint;
+  beforeBorrow: bigint;
+  isLiquidated: boolean;
+};
+type DecodedTick = {
+  isLiquidated: boolean;
+  totalIds: number;
+  rawDebt: bigint;
+  isFullyLiquidated: boolean;
+  liquidationBranchId: number;
+  debtFactor: bigint;
+};
+type DecodedBranch = {
+  branchId: number;
+  status: number;
+  minimaTick: number;
+  minimaTickPartials: number;
+  debtLiquidity: bigint;
+  debtFactor: bigint;
+  connectedBranchId: number;
+  connectedMinimaTick: number;
+};
+type DecodedTickIdLiquidation = {
+  isFullyLiquidated: boolean;
+  liquidationBranchId: number;
+  debtFactor: bigint;
+};
+type PositionWithRiskRatio = NftPosition & {
+  vaultId: number;
+  /** debt / (collateral * oracle price), 1e4 scale (e.g. 7500 = 75%). */
+  riskRatio: bigint;
+};
+type OraclePrice = {
+  oracle: string;
+  /** Collateral-per-debt price used on operate (1e15). `null` = the operate view aborts right now (v2: a route stale/invalid). */
+  operate: bigint | null;
+  /** Price used on liquidate (1e15). `null` = the liquidate view aborts (v2: every route dead). */
+  liquidate: bigint | null;
+  /** v2: abort reason of the operate view, when `operate` is null. */
+  operateError?: string;
+  liquidateError?: string;
+};
+type OracleSource = {
+  /** 0x-hex 32-byte feed id. */
+  feedId: string;
+  invert: boolean;
+  provider: "redstone" | "pyth";
+  /** RedStone only: the PriceAdapter the oracle is pinned to. */
+  adapterId?: string;
+};
+type OracleData = {
+  id: string;
+  nonce: number;
+  main: OracleSource;
+  guard: OracleSource | null;
+};
+/** One route read on its own (see `Oracle.getOracleRoutes`). */
+type OracleRoute = OracleSource & {
+  rawPrice: bigint;
+  decimals: number;
+  /** 1e15 rate this route contributes (0 when invalid). */
+  rate: bigint;
+  publishedMs: bigint;
+  /** Seconds since publish at the chain clock (-1 = timestamp in the future). */
+  ageS: bigint;
+  /** Pyth only. */
+  confidence?: bigint;
+  usableOperate: boolean;
+  usableLiquidate: boolean;
+};
+declare namespace liquidity_d_exports {
+  export { MathVariant, ReserveSnapshot, calcBorrowLimitBeforeOperate, calcRevenue, calcWithdrawalLimitBeforeOperate, calculateExchangePrice, emptyUserBorrowData, emptyUserSupplyData, processOverallTokenData, processUserBorrowData, processUserSupplyData, supplyRateAt, supplyRateRaw, totalAmountsOf, totalBorrowNormal, totalSupplyNormal };
+}
+/** The TokenReserve fields the exchange-price maths needs. */
+type ReserveSnapshot = {
+  supplyExchangePrice: bigint;
+  borrowExchangePrice: bigint;
+  borrowRate: bigint;
+  fee: bigint;
+  lastUtilization: bigint;
+  lastUpdateTimestamp: bigint;
+  maxUtilization: bigint;
+  totalSupplyWithInterest: bigint;
+  totalSupplyInterestFree: bigint;
+  totalBorrowWithInterest: bigint;
+  totalBorrowInterestFree: bigint;
+  /** Coin balance held by the reserve. */
+  vaultBalance: bigint;
+};
+/**
+ * Which on-chain liquidity/lending maths a deployment runs.
+ * - "audited": fluid-packages-sui after the audit fixes (7e470fb, in 742ea21 and later): the
+ *   borrow with-interest/free ratio uses the PRE-accrual borrow exchange price, the inverted
+ *   supply ratio is computed at full precision, and the rewards TVL is rounded up.
+ * - "pre-audit": the 2026-09-18 staging packages (verified from deployed bytecode 2026-10-26):
+ *   ratio on the accrued borrow price, inverse of the floored 1e4 ratio, rewards TVL floored.
+ */
+type MathVariant = "pre-audit" | "audited";
+/**
+ * Supply rate the reserve credits for a period starting from these exchange prices, at
+ * `SUPPLY_RATE_PRECISION` (1e12 = 100% per year): exactly `borrow_rate * ratio_supply_yield * (1e4 - fee)`
+ * from `reserve::calculate_exchange_prices` (interest-free ratios on both sides, fee applied).
+ * `borrowEpForRatio` is the borrow exchange price the contract normalises the borrow ratio with.
+ */
+declare function supplyRateRaw(r: ReserveSnapshot, supplyExchangePrice: bigint, borrowEpForRatio: bigint, variant: MathVariant): bigint;
+/** `reserve::calculate_exchange_prices(now)`. */
+declare function calculateExchangePrice(r: ReserveSnapshot, now: bigint, variant?: MathVariant): ExchangePriceResult;
+/**
+ * Instantaneous liquidity supply rate at `now` (1e12 = 100%): the rate the contract would credit
+ * for the period starting at `now`, i.e. `supplyRateRaw` on both exchange prices accrued to `now`.
+ */
+declare function supplyRateAt(r: ReserveSnapshot, now: bigint, variant?: MathVariant): bigint;
+/** `liquidity_calcs::get_total_supply` (floor). */
+declare const totalSupplyNormal: (r: ReserveSnapshot, supplyEp: bigint) => bigint;
+/** `liquidity_calcs::get_total_borrow` (floor). */
+declare const totalBorrowNormal: (r: ReserveSnapshot, borrowEp: bigint) => bigint;
+/** `reserve::calc_revenue` (supply side ceiled, saturating at 0). */
+declare function calcRevenue(r: ReserveSnapshot, supplyEp: bigint, borrowEp: bigint): bigint;
+declare function totalAmountsOf(r: ReserveSnapshot): TotalAmounts;
+/**
+ * Same shape as the Solana reader's `processOverallTokenData`. `supplyRate` (bps) is the exact
+ * on-chain supply rate at `now` (`supplyRateAt`, floored to bps), not the Solana approximation.
+ */
+declare function processOverallTokenData(r: ReserveSnapshot, rateData: RateData, now: bigint, variant?: MathVariant): OverallTokenData;
+/** `liquidity_calcs::calc_withdrawal_limit_before_operate`. */
+declare function calcWithdrawalLimitBeforeOperate(userAmount: bigint, lastLimit: bigint, expandPercent: bigint, expandDuration: bigint, lastUpdate: bigint, now: bigint): bigint;
+/** `liquidity_calcs::calc_borrow_limit_before_operate`. */
+declare function calcBorrowLimitBeforeOperate(userAmount: bigint, lastLimit: bigint, expandPercent: bigint, expandDuration: bigint, baseLimit: bigint, maxLimit: bigint, lastUpdate: bigint, now: bigint): bigint;
+declare function emptyUserSupplyData(): UserSupplyData;
+declare function emptyUserBorrowData(): UserBorrowData;
+/** Solana `processUserSupplyData`, with Sui's decay fields. */
+declare function processUserSupplyData(acc: UserSupplyPositionAccount | null, overall: OverallTokenData, liquidityBalance: bigint, now: bigint): UserSupplyData;
+/** Solana `processUserBorrowData`. */
+declare function processUserBorrowData(acc: UserBorrowPositionAccount | null, overall: OverallTokenData, liquidityBalance: bigint, now: bigint): UserBorrowData;
+//#endregion
+//#region src/config.d.ts
+type PackageIds = {
+  /** Latest version: target of move calls (views). */
+  packageId: string;
+  /** First version: address used in type tags and derived-object keys. */
+  originalId: string;
+};
+type FluidReadConfig = {
+  network: string;
+  packages: {
+    library: PackageIds;
+    liquidity: PackageIds;
+    lending: PackageIds;
+    /** Optional: lending rewards package (write-SDK parity; no read views depend on it yet). */
+    lendingRewards?: PackageIds;
+    oracle: PackageIds;
+    vaults: PackageIds;
+  };
+  objects: {
+    liquidityRegistry: string;
+    lendingRegistry: string;
+    oracleRegistry: string;
+    vaultRegistry: string;
+    liquidityAuth?: string;
+    lendingAuth?: string;
+    rewardsAuth?: string;
+    oracleAuth?: string;
+    vaultAdmin?: string;
+  };
+  /** RedStone main + optional Pyth guard; provider objects the quote needs. Pyth PriceInfoObjects keyed by 0x-hex feed id. */
+  oracle?: {
+    /** RedStone adapter used when an oracle has no RedStone route (the call still takes one). */
+    redstoneAdapter: string;
+    /** Package to call RedStone views on (route transparency only). */
+    redstonePackage: string;
+    pythPriceInfoObjects: Record<string, string>;
+    /** Pyth State + Wormhole State (write-SDK parity, needed only to build a Pyth price update). */
+    pythStateId?: string;
+    wormholeStateId?: string;
+  };
+  /**
+   * Coin types seeded into token discovery. Token discovery is pure state: these, plus the
+   * collateral/debt types of every VaultMarket (vault ids 1..total_vaults from the registry).
+   * Coverage is checked against `Registry.active_caps.size`; see `Liquidity.discoverTokens`.
+   */
+  tokens?: string[];
+  /** Fullnode endpoints, tried in order with failover. "jsonrpc+https://..." selects JSON-RPC. */
+  rpcUrls?: string[];
+  /**
+   * Type of the proposed on-chain position-index key (docs/onchain-position-index.md). A struct
+   * added in a package upgrade is defined at the upgraded package id, so set this to
+   * `<upgraded vaults package>::position_index::PositionIndexKey` once it ships. Default assumes
+   * `<vaults originalId>::position_index::PositionIndexKey`.
+   */
+  positionIndexKeyType?: string;
+  /** GraphQL indexer endpoint. Used with `discovery: "indexer"`, holder lists and checkpoint reads. */
+  graphqlUrl?: string;
+  /**
+   * On-chain maths the deployment runs (see `MathVariant`). Default "audited" (fluid-packages-sui
+   * 742ea21 and later). The 2026-09-18 staging liquidity/lending packages run "pre-audit".
+   */
+  mathVariant?: MathVariant;
+};
+/**
+ * STAGING deployment on Sui mainnet (staging deployment gist, 2026-09-30). NOT a final production
+ * deployment: ids change at the production launch. Build
+ * your own config from a deployment record with `configFromDeployment`.
+ *
+ * Fluid Sui staging-on-mainnet: library / liquidity / lending
+ * from 2026-09-18; oracle (RedStone main + Pyth guard) and vaults redeployed 2026-09-30.
+ * Vault 1 = VaultMarket<SUI, USDC> 0x3ba55ebc…72b8 on oracle nonce 1 (0x1a690d20…b279).
+ * Vault 2 = VaultMarket<SUI, USDSUI> 0x5120…0efa. fTokens: fUSDC, fUSDSUI.
+ * Ids match the write SDK (fluid-packages-sui deployments/mainnet.json @ 06828ff, 2026-10-01) and
+ * the live staging deployment (re-read on chain 2026-10-10). Alias: network "staging".
+ */
+declare const STAGING: FluidReadConfig;
+/**
+ * @deprecated Misleading name kept for compatibility: this is the STAGING deployment
+ * (`STAGING`), not production. Use `STAGING` / network "staging".
+ */
+declare const MAINNET: FluidReadConfig;
+declare const CONFIGS: Record<string, FluidReadConfig>;
+/**
+ * Deployment record: per-package ids plus the shared object ids the SDK reads. The ids alone are
+ * not enough: `liquidity`, `lending`, `oracle` and `vaults` must each carry `objects.registry`
+ * (see "Deployment record shape" in the README).
+ */
+type DeploymentRecord = {
+  packages: Record<"library" | "liquidity" | "lending" | "oracle" | "vaults" | "lending_rewards", {
+    packageId: string;
+    originalId?: string;
+    objects?: Record<string, string>;
+  } | undefined>;
+};
+/**
+ * Build a read config from a deployment record instead of the built-in ids, e.g.
+ * `configFromDeployment(JSON.parse(readFileSync(path, "utf8")), { network: "mainnet", oracle })`.
+ * The record has no RedStone package or Pyth feed map, so `oracle` comes from the caller.
+ * Throws once, listing every required field the record is missing.
+ */
+declare function configFromDeployment(rec: DeploymentRecord, opts: Pick<FluidReadConfig, "network" | "oracle"> & Partial<Pick<FluidReadConfig, "tokens" | "rpcUrls" | "graphqlUrl" | "mathVariant">>): FluidReadConfig;
+declare function resolveConfig(networkOrConfig: string | FluidReadConfig | undefined): FluidReadConfig;
+//#endregion
+//#region src/derive.d.ts
+declare function createDerive(cfg: FluidReadConfig): {
+  /** `TokenReserve<T>`: derived from the liquidity Registry, key `ReserveKey<T>`. */
+  tokenReserveId: (coinType: string) => string;
+  /** `LendingState<T>`: derived from the LendingRegistry, key `LendingStateKey<T>`. */
+  lendingStateId: (coinType: string) => string;
+  /** `VaultMarket<Col, Debt>`: derived from the VaultRegistry, key `VaultKey(u64)`. */
+  vaultMarketId: (vaultId: number | bigint) => string;
+  /** `Position`: derived from its VaultMarket, key `PositionKey(cap id)`. */
+  positionId: (vaultMarketId: string, capId: string) => string;
+  holderKeyType: string;
+  /** Entry of `TokenReserve.supply_positions` / `borrow_positions` for `Holder::Object(id)`. */
+  holderEntryId: (tableId: string, holderObjectId: string) => string;
+  /** `RateDataKey` dynamic field on a TokenReserve. */
+  rateDataId: (reserveId: string) => string;
+  /** `RewardsKey` dynamic field on a LendingState. */
+  rewardsId: (lendingStateId: string) => string;
+  /** `VaultMarket.ticks` entry. */
+  tickEntryId: (ticksTableId: string, tick: number) => string;
+  /** `VaultMarket.branches` entry. */
+  branchEntryId: (branchesTableId: string, branchId: number | bigint | string) => string;
+  /** `VaultMarket.liq_snaps` entry. */
+  liqSnapEntryId: (snapsTableId: string, tick: number, tickId: number) => string;
+  /** `VaultMarket.tick_bitmap` word. */
+  bitmapWordId: (bitmapTableId: string, word: number) => string;
+  /**
+   * Proposed on-chain position index (docs/onchain-position-index.md): dynamic field
+   * `PositionIndexKey()` on the VaultMarket. Returns null-safe ids; absent until shipped.
+   */
+  positionIndexKeyType: string;
+  positionIndexId: (vaultMarketId: string) => string;
+  /** Entry `n` (1-based ordinal) of the index's `caps: Table<u64, ID>`. */
+  positionIndexEntryId: (capsTableId: string, n: number | bigint) => string;
+  /** v2 `Oracle`: derived from the OracleRegistry, key `OracleKey(nonce: u16)`; nonces 1..total_oracles. */
+  oracleId: (nonce: number) => string;
+  fTokenType: (coinType: string) => string;
+  positionCapType: string;
+};
+type FluidDerive = ReturnType<typeof createDerive>;
+//#endregion
+//#region src/context.d.ts
+/**
+ * Where time-dependent maths gets "now" from.
+ * - "chain" (default): the on-chain Clock, read alongside the state (one extra object in the read).
+ * - "local": this machine's wall clock. Only for offline/back-testing use; elapsed time and the
+ *   rewards windows then depend on the server's clock.
+ * - a function: fixed or custom clock (unix seconds), e.g. a checkpoint timestamp.
+ */
+type ClockSource = "chain" | "local" | (() => bigint | Promise<bigint>);
+/**
+ * How far the SDK may go beyond pure object state when it has to ENUMERATE something.
+ *
+ * - "state" (default): only reads of objects by derived id (`getObjects`) and Move view
+ *   simulation. No list/scan queries of any kind. Anything that cannot be resolved this way
+ *   throws `NeedsDiscoveryError` naming the on-chain change that would make it pure.
+ * - "fullnode": also the fullnode's own secondary indexes (`listDynamicFields`,
+ *   `listOwnedObjects`). Same endpoint(s) as state reads, so failover covers them, but the
+ *   node must run with indexing enabled.
+ * - "indexer": also the external GraphQL indexer (event scans). Last resort.
+ */
+type DiscoveryLevel = "state" | "fullnode" | "indexer";
+declare class NeedsDiscoveryError extends Error {
+  readonly what: string;
+  readonly needed: DiscoveryLevel;
+  readonly onchainFix: string;
+  constructor(what: string, needed: DiscoveryLevel, onchainFix: string);
+}
+/** Shared state every module reads through. */
+type ReadContext = {
+  client: ClientWithCoreApi;
+  config: FluidReadConfig;
+  derive: FluidDerive;
+  /** Clock for time-dependent maths (unix seconds). Defaults to the on-chain Clock. */
+  now: () => Promise<bigint>;
+  discovery: DiscoveryLevel;
+  allows: (level: DiscoveryLevel) => boolean;
+  /** `config.mathVariant ?? "audited"`. */
+  math: MathVariant;
+  /** Coin metadata (immutable), fetched once per coin type and cached for the client's lifetime. */
+  coinMetadata: (coinType: string) => Promise<CoinMeta | null>;
+};
+type CoinMeta = {
+  name: string;
+  symbol: string;
+  decimals: number;
+};
+//#endregion
+//#region src/transport.d.ts
+type FailoverOptions = {
+  network: string;
+  /** Per-call timeout before moving to the next endpoint. Default 15000 ms. */
+  timeoutMs?: number;
+  /** Full passes over the endpoint list before giving up. Default 3. */
+  rounds?: number;
+  /** Wait before the second pass; doubles every pass. Default 250 ms. */
+  backoffMs?: number;
+  /** Cap on the wait between passes. Default 4000 ms. */
+  maxBackoffMs?: number;
+};
+/** Wait before pass `pass` (1-based, pass >= 2): exponential, capped, +/-25% jitter. */
+declare function backoffDelay(pass: number, base: number, cap: number): number;
+declare class AllEndpointsFailedError extends Error {
+  readonly method: string;
+  readonly errors: {
+    endpoint: string;
+    error: unknown;
+  }[];
+  constructor(method: string, errors: {
+    endpoint: string;
+    error: unknown;
+  }[]);
+}
+declare function clientForEndpoint(endpoint: string, network: string): ClientWithCoreApi;
+/**
+ * One `ClientWithCoreApi` over many endpoints. Accepts endpoint strings or ready clients
+ * (label = index). Synchronous core members (e.g. `resolveTransactionPlugin`) come from the
+ * currently preferred endpoint.
+ */
+declare function createFailoverClient(endpoints: readonly (string | ClientWithCoreApi)[], opts: FailoverOptions): ClientWithCoreApi & {
+  endpoints: string[];
+  preferred: () => string;
+};
+declare namespace bcs_d_exports {
+  export { Branch, BranchStatus, CapRecord, Field, Holder, LendingRegistry, LendingState, LiquidityRegistry, MoveTick, OracleObject, OracleRegistry, OracleSource$1 as OracleSource, OracleSourceType, PauseFlags, Position, PositionIndex$1 as PositionIndex, PositionIndexEntry, PositionIndexField, PriceQuote, PythPriceInfoObject, RateDataV1Params, RateDataV2Params, RateMagnifier, RewardsSchedule$1 as RewardsSchedule, RiskConfig, Table, TickIdLiquidation, TickIdLiquidationKey, TokenReserve, TypeName, UnitKey, UserBorrowConfig, UserBorrowPosition, UserSupplyConfig, UserSupplyPosition, VaultMarket, VaultRegistry, VaultTick, bcsId, bcsU16, bcsU256, bcsU64 };
+}
+declare const TypeName: _mysten_bcs0.BcsStruct<{
+  name: BcsType<string, string, "string">;
+}, string>;
+declare const MoveTick: _mysten_bcs0.BcsStruct<{
+  mag: BcsType<number, number, "u32">;
+  neg: BcsType<boolean, boolean, "bool">;
+}, string>;
+declare const Table: _mysten_bcs0.BcsStruct<{
+  id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  size: BcsType<string, string | number | bigint, "u64">;
+}, string>;
+declare const PauseFlags: _mysten_bcs0.BcsStruct<{
+  supply: BcsType<boolean, boolean, "bool">;
+  borrow: BcsType<boolean, boolean, "bool">;
+  payback: BcsType<boolean, boolean, "bool">;
+  withdraw: BcsType<boolean, boolean, "bool">;
+}, string>;
+declare const Holder: _mysten_bcs0.BcsEnum<{
+  Object: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  Type: _mysten_bcs0.BcsStruct<{
+    name: BcsType<string, string, "string">;
+  }, string>;
+}, "Holder">;
+declare const LiquidityRegistry: _mysten_bcs0.BcsStruct<{
+  id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  version: BcsType<string, string | number | bigint, "u64">;
+  pause: _mysten_bcs0.BcsStruct<{
+    supply: BcsType<boolean, boolean, "bool">;
+    borrow: BcsType<boolean, boolean, "bool">;
+    payback: BcsType<boolean, boolean, "bool">;
+    withdraw: BcsType<boolean, boolean, "bool">;
+  }, string>;
+  revenue_collector: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  active_caps: _mysten_bcs0.BcsStruct<{
+    id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    size: BcsType<string, string | number | bigint, "u64">;
+  }, string>;
+}, string>;
+declare const TokenReserve: _mysten_bcs0.BcsStruct<{
+  id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  pause: _mysten_bcs0.BcsStruct<{
+    supply: BcsType<boolean, boolean, "bool">;
+    borrow: BcsType<boolean, boolean, "bool">;
+    payback: BcsType<boolean, boolean, "bool">;
+    withdraw: BcsType<boolean, boolean, "bool">;
+  }, string>;
+  vault: BcsType<string, string | number | bigint, "u64">;
+  borrow_rate: BcsType<string, string | number | bigint, "u64">;
+  fee: BcsType<string, string | number | bigint, "u64">;
+  last_utilization: BcsType<string, string | number | bigint, "u64">;
+  last_update_timestamp: BcsType<string, string | number | bigint, "u64">;
+  supply_exchange_price: BcsType<string, string | number | bigint, "u64">;
+  borrow_exchange_price: BcsType<string, string | number | bigint, "u64">;
+  max_utilization: BcsType<string, string | number | bigint, "u64">;
+  total_supply_with_interest: BcsType<string, string | number | bigint, "u64">;
+  total_supply_interest_free: BcsType<string, string | number | bigint, "u64">;
+  total_borrow_with_interest: BcsType<string, string | number | bigint, "u64">;
+  total_borrow_interest_free: BcsType<string, string | number | bigint, "u64">;
+  rate_data_version: BcsType<number, number, "u8">;
+  supply_positions: _mysten_bcs0.BcsStruct<{
+    id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    size: BcsType<string, string | number | bigint, "u64">;
+  }, string>;
+  borrow_positions: _mysten_bcs0.BcsStruct<{
+    id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    size: BcsType<string, string | number | bigint, "u64">;
+  }, string>;
+}, string>;
+declare const UserSupplyConfig: _mysten_bcs0.BcsStruct<{
+  mode: BcsType<number, number, "u8">;
+  expand_percent: BcsType<string, string | number | bigint, "u64">;
+  expand_duration: BcsType<string, string | number | bigint, "u64">;
+  base_withdrawal_limit: BcsType<string, string | number | bigint, "u64">;
+}, string>;
+declare const UserBorrowConfig: _mysten_bcs0.BcsStruct<{
+  mode: BcsType<number, number, "u8">;
+  expand_percent: BcsType<string, string | number | bigint, "u64">;
+  expand_duration: BcsType<string, string | number | bigint, "u64">;
+  base_debt_ceiling: BcsType<string, string | number | bigint, "u64">;
+  max_debt_ceiling: BcsType<string, string | number | bigint, "u64">;
+}, string>;
+declare const UserSupplyPosition: _mysten_bcs0.BcsStruct<{
+  config: BcsType<{
+    mode: number;
+    expand_percent: string;
+    expand_duration: string;
+    base_withdrawal_limit: string;
+  } | null, {
+    mode: number;
+    expand_percent: string | number | bigint;
+    expand_duration: string | number | bigint;
+    base_withdrawal_limit: string | number | bigint;
+  } | null | undefined, `Option<${string}>`>;
+  paused_supply: BcsType<boolean, boolean, "bool">;
+  paused_withdraw: BcsType<boolean, boolean, "bool">;
+  amount: BcsType<string, string | number | bigint, "u64">;
+  withdrawal_limit: BcsType<string, string | number | bigint, "u64">;
+  last_update: BcsType<string, string | number | bigint, "u64">;
+  decay_amount: BcsType<string, string | number | bigint, "u64">;
+  decay_duration: BcsType<string, string | number | bigint, "u64">;
+}, string>;
+declare const UserBorrowPosition: _mysten_bcs0.BcsStruct<{
+  config: BcsType<{
+    mode: number;
+    expand_percent: string;
+    expand_duration: string;
+    base_debt_ceiling: string;
+    max_debt_ceiling: string;
+  } | null, {
+    mode: number;
+    expand_percent: string | number | bigint;
+    expand_duration: string | number | bigint;
+    base_debt_ceiling: string | number | bigint;
+    max_debt_ceiling: string | number | bigint;
+  } | null | undefined, `Option<${string}>`>;
+  paused_borrow: BcsType<boolean, boolean, "bool">;
+  paused_payback: BcsType<boolean, boolean, "bool">;
+  amount: BcsType<string, string | number | bigint, "u64">;
+  debt_ceiling: BcsType<string, string | number | bigint, "u64">;
+  last_update: BcsType<string, string | number | bigint, "u64">;
+}, string>;
+declare const RateDataV1Params: _mysten_bcs0.BcsStruct<{
+  kink: BcsType<string, string | number | bigint, "u64">;
+  rate_at_utilization_zero: BcsType<string, string | number | bigint, "u64">;
+  rate_at_utilization_kink: BcsType<string, string | number | bigint, "u64">;
+  rate_at_utilization_max: BcsType<string, string | number | bigint, "u64">;
+}, string>;
+declare const RateDataV2Params: _mysten_bcs0.BcsStruct<{
+  kink1: BcsType<string, string | number | bigint, "u64">;
+  kink2: BcsType<string, string | number | bigint, "u64">;
+  rate_at_utilization_zero: BcsType<string, string | number | bigint, "u64">;
+  rate_at_utilization_kink1: BcsType<string, string | number | bigint, "u64">;
+  rate_at_utilization_kink2: BcsType<string, string | number | bigint, "u64">;
+  rate_at_utilization_max: BcsType<string, string | number | bigint, "u64">;
+}, string>;
+declare const CapRecord: _mysten_bcs0.BcsStruct<{
+  token: _mysten_bcs0.BcsStruct<{
+    name: BcsType<string, string, "string">;
+  }, string>;
+  holder: _mysten_bcs0.BcsEnum<{
+    Object: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    Type: _mysten_bcs0.BcsStruct<{
+      name: BcsType<string, string, "string">;
+    }, string>;
+  }, "Holder">;
+}, string>;
+declare const LendingState: _mysten_bcs0.BcsStruct<{
+  id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  supply: BcsType<string, string | number | bigint, "u64">;
+  reserve_id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  rewards_writer: BcsType<string | null, string | Uint8Array<ArrayBufferLike> | null | undefined, "Option<bytes[32]>">;
+  token_exchange_price: BcsType<string, string | number | bigint, "u64">;
+  liquidity_exchange_price: BcsType<string, string | number | bigint, "u64">;
+  last_update_s: BcsType<string, string | number | bigint, "u64">;
+}, string>;
+declare const RewardsSchedule$1: _mysten_bcs0.BcsStruct<{
+  start_tvl: BcsType<string, string | number | bigint, "u64">;
+  start_s: BcsType<string, string | number | bigint, "u64">;
+  end_s: BcsType<string, string | number | bigint, "u64">;
+  yearly_reward: BcsType<string, string | number | bigint, "u64">;
+  next_start_s: BcsType<string, string | number | bigint, "u64">;
+  next_end_s: BcsType<string, string | number | bigint, "u64">;
+  next_yearly_reward: BcsType<string, string | number | bigint, "u64">;
+}, string>;
+declare const LendingRegistry: _mysten_bcs0.BcsStruct<{
+  id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  version: BcsType<string, string | number | bigint, "u64">;
+}, string>;
+declare const RiskConfig: _mysten_bcs0.BcsStruct<{
+  collateral_factor: BcsType<number, number, "u16">;
+  liquidation_threshold: BcsType<number, number, "u16">;
+  liquidation_max_limit: BcsType<number, number, "u16">;
+  withdraw_gap: BcsType<number, number, "u16">;
+  liquidation_penalty: BcsType<number, number, "u16">;
+  borrow_fee: BcsType<number, number, "u8">;
+}, string>;
+declare const RateMagnifier: _mysten_bcs0.BcsStruct<{
+  magnitude: BcsType<number, number, "u16">;
+  negative: BcsType<boolean, boolean, "bool">;
+}, string>;
+declare const VaultMarket: _mysten_bcs0.BcsStruct<{
+  id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  vault_id: BcsType<string, string | number | bigint, "u64">;
+  risk: _mysten_bcs0.BcsStruct<{
+    collateral_factor: BcsType<number, number, "u16">;
+    liquidation_threshold: BcsType<number, number, "u16">;
+    liquidation_max_limit: BcsType<number, number, "u16">;
+    withdraw_gap: BcsType<number, number, "u16">;
+    liquidation_penalty: BcsType<number, number, "u16">;
+    borrow_fee: BcsType<number, number, "u8">;
+  }, string>;
+  supply_rate_magnifier: _mysten_bcs0.BcsStruct<{
+    magnitude: BcsType<number, number, "u16">;
+    negative: BcsType<boolean, boolean, "bool">;
+  }, string>;
+  borrow_rate_magnifier: _mysten_bcs0.BcsStruct<{
+    magnitude: BcsType<number, number, "u16">;
+    negative: BcsType<boolean, boolean, "bool">;
+  }, string>;
+  vault_type: BcsType<number, number, "u8">;
+  oracle: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  liquidity_program: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  col_decimals: BcsType<number, number, "u8">;
+  debt_decimals: BcsType<number, number, "u8">;
+  branch_liquidated: BcsType<boolean, boolean, "bool">;
+  topmost_tick: _mysten_bcs0.BcsStruct<{
+    mag: BcsType<number, number, "u32">;
+    neg: BcsType<boolean, boolean, "bool">;
+  }, string>;
+  current_branch_id: BcsType<string, string | number | bigint, "u64">;
+  total_branch_id: BcsType<string, string | number | bigint, "u64">;
+  total_supply: BcsType<string, string | number | bigint, "u64">;
+  total_borrow: BcsType<string, string | number | bigint, "u64">;
+  absorbed_debt_amount: BcsType<string, string | number | bigint, "u128">;
+  absorbed_col_amount: BcsType<string, string | number | bigint, "u128">;
+  absorbed_dust_debt: BcsType<string, string | number | bigint, "u64">;
+  liquidity_supply_exchange_price: BcsType<string, string | number | bigint, "u64">;
+  liquidity_borrow_exchange_price: BcsType<string, string | number | bigint, "u64">;
+  vault_supply_exchange_price: BcsType<string, string | number | bigint, "u64">;
+  vault_borrow_exchange_price: BcsType<string, string | number | bigint, "u64">;
+  last_update_timestamp: BcsType<string, string | number | bigint, "u64">;
+  ticks: _mysten_bcs0.BcsStruct<{
+    id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    size: BcsType<string, string | number | bigint, "u64">;
+  }, string>;
+  branches: _mysten_bcs0.BcsStruct<{
+    id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    size: BcsType<string, string | number | bigint, "u64">;
+  }, string>;
+  liq_snaps: _mysten_bcs0.BcsStruct<{
+    id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    size: BcsType<string, string | number | bigint, "u64">;
+  }, string>;
+  tick_bitmap: _mysten_bcs0.BcsStruct<{
+    id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    size: BcsType<string, string | number | bigint, "u64">;
+  }, string>;
+}, string>;
+declare const VaultTick: _mysten_bcs0.BcsStruct<{
+  is_liquidated: BcsType<boolean, boolean, "bool">;
+  total_ids: BcsType<number, number, "u32">;
+  raw_debt: BcsType<string, string | number | bigint, "u64">;
+  is_fully_liquidated: BcsType<boolean, boolean, "bool">;
+  liquidation_branch_id: BcsType<string, string | number | bigint, "u64">;
+  debt_factor: BcsType<string, string | number | bigint, "u64">;
+}, string>;
+declare const TickIdLiquidation: _mysten_bcs0.BcsStruct<{
+  is_fully_liquidated: BcsType<boolean, boolean, "bool">;
+  liquidation_branch_id: BcsType<string, string | number | bigint, "u64">;
+  debt_factor: BcsType<string, string | number | bigint, "u64">;
+}, string>;
+declare const TickIdLiquidationKey: _mysten_bcs0.BcsStruct<{
+  tick: _mysten_bcs0.BcsStruct<{
+    mag: BcsType<number, number, "u32">;
+    neg: BcsType<boolean, boolean, "bool">;
+  }, string>;
+  tick_map: BcsType<number, number, "u32">;
+}, string>;
+declare const BranchStatus: _mysten_bcs0.BcsEnum<{
+  NotLiquidated: null;
+  Liquidated: null;
+  Merged: null;
+  Closed: null;
+}, "BranchStatus">;
+declare const Branch: _mysten_bcs0.BcsStruct<{
+  status: _mysten_bcs0.BcsEnum<{
+    NotLiquidated: null;
+    Liquidated: null;
+    Merged: null;
+    Closed: null;
+  }, "BranchStatus">;
+  minima_tick: _mysten_bcs0.BcsStruct<{
+    mag: BcsType<number, number, "u32">;
+    neg: BcsType<boolean, boolean, "bool">;
+  }, string>;
+  minima_tick_partials: BcsType<number, number, "u32">;
+  debt_liquidity: BcsType<string, string | number | bigint, "u64">;
+  debt_factor: BcsType<string, string | number | bigint, "u64">;
+  connected_branch_id: BcsType<string, string | number | bigint, "u64">;
+  connected_minima_tick: _mysten_bcs0.BcsStruct<{
+    mag: BcsType<number, number, "u32">;
+    neg: BcsType<boolean, boolean, "bool">;
+  }, string>;
+}, string>;
+declare const Position: _mysten_bcs0.BcsStruct<{
+  id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  vault_id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  position_mint: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  is_supply_only_position: BcsType<boolean, boolean, "bool">;
+  tick: _mysten_bcs0.BcsStruct<{
+    mag: BcsType<number, number, "u32">;
+    neg: BcsType<boolean, boolean, "bool">;
+  }, string>;
+  tick_id: BcsType<number, number, "u32">;
+  supply_amount: BcsType<string, string | number | bigint, "u64">;
+  dust_debt_amount: BcsType<string, string | number | bigint, "u64">;
+}, string>;
+declare const VaultRegistry: _mysten_bcs0.BcsStruct<{
+  id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  next_vault_id: BcsType<string, string | number | bigint, "u64">;
+  version: BcsType<string, string | number | bigint, "u64">;
+}, string>;
+declare const OracleRegistry: _mysten_bcs0.BcsStruct<{
+  id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  version: BcsType<string, string | number | bigint, "u64">;
+  total_oracles: BcsType<string, string | number | bigint, "u64">;
+}, string>;
+declare const OracleSourceType: _mysten_bcs0.BcsEnum<{
+  Redstone: _mysten_bcs0.BcsStruct<{
+    adapter_id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  }, string>;
+  Pyth: null;
+}, "SourceType">;
+declare const OracleSource$1: _mysten_bcs0.BcsStruct<{
+  feed_id: BcsType<number[], Iterable<number> & {
+    length: number;
+  }, string>;
+  invert: BcsType<boolean, boolean, "bool">;
+  source_type: _mysten_bcs0.BcsEnum<{
+    Redstone: _mysten_bcs0.BcsStruct<{
+      adapter_id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, string>;
+    Pyth: null;
+  }, "SourceType">;
+}, string>;
+/** `fluid_oracle::oracle::Oracle` derived from the registry by nonce. */
+declare const OracleObject: _mysten_bcs0.BcsStruct<{
+  id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  nonce: BcsType<number, number, "u16">;
+  main: _mysten_bcs0.BcsStruct<{
+    feed_id: BcsType<number[], Iterable<number> & {
+      length: number;
+    }, string>;
+    invert: BcsType<boolean, boolean, "bool">;
+    source_type: _mysten_bcs0.BcsEnum<{
+      Redstone: _mysten_bcs0.BcsStruct<{
+        adapter_id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      }, string>;
+      Pyth: null;
+    }, "SourceType">;
+  }, string>;
+  guard: BcsType<{
+    feed_id: number[];
+    invert: boolean;
+    source_type: _mysten_bcs0.EnumOutputShapeWithKeys<{
+      Redstone: {
+        adapter_id: string;
+      };
+      Pyth: true;
+    }, "Redstone" | "Pyth">;
+  } | null, {
+    feed_id: Iterable<number> & {
+      length: number;
+    };
+    invert: boolean;
+    source_type: _mysten_bcs0.EnumInputShape<{
+      Redstone: {
+        adapter_id: string | Uint8Array<ArrayBufferLike>;
+      };
+      Pyth: boolean | object | null;
+    }>;
+  } | null | undefined, `Option<${string}>`>;
+}, string>;
+/** `view::PriceQuote`: each rate is optional (operate-only / liquidate-only quotes). */
+declare const PriceQuote: _mysten_bcs0.BcsStruct<{
+  oracle_id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  rate_liquidate: BcsType<string | null, string | number | bigint | null | undefined, "Option<u128>">;
+  rate_operate: BcsType<string | null, string | number | bigint | null | undefined, "Option<u128>">;
+}, string>;
+/** `pyth::price_info::PriceInfoObject`. */
+declare const PythPriceInfoObject: _mysten_bcs0.BcsStruct<{
+  id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  price_info: _mysten_bcs0.BcsStruct<{
+    attestation_time: BcsType<string, string | number | bigint, "u64">;
+    arrival_time: BcsType<string, string | number | bigint, "u64">;
+    price_feed: _mysten_bcs0.BcsStruct<{
+      price_identifier: _mysten_bcs0.BcsStruct<{
+        bytes: BcsType<number[], Iterable<number> & {
+          length: number;
+        }, string>;
+      }, string>;
+      price: _mysten_bcs0.BcsStruct<{
+        price: _mysten_bcs0.BcsStruct<{
+          negative: BcsType<boolean, boolean, "bool">;
+          magnitude: BcsType<string, string | number | bigint, "u64">;
+        }, string>;
+        conf: BcsType<string, string | number | bigint, "u64">;
+        expo: _mysten_bcs0.BcsStruct<{
+          negative: BcsType<boolean, boolean, "bool">;
+          magnitude: BcsType<string, string | number | bigint, "u64">;
+        }, string>;
+        timestamp: BcsType<string, string | number | bigint, "u64">;
+      }, string>;
+      ema_price: _mysten_bcs0.BcsStruct<{
+        price: _mysten_bcs0.BcsStruct<{
+          negative: BcsType<boolean, boolean, "bool">;
+          magnitude: BcsType<string, string | number | bigint, "u64">;
+        }, string>;
+        conf: BcsType<string, string | number | bigint, "u64">;
+        expo: _mysten_bcs0.BcsStruct<{
+          negative: BcsType<boolean, boolean, "bool">;
+          magnitude: BcsType<string, string | number | bigint, "u64">;
+        }, string>;
+        timestamp: BcsType<string, string | number | bigint, "u64">;
+      }, string>;
+    }, string>;
+  }, string>;
+}, string>;
+/** `0x2::dynamic_field::Field<K, V>` wrapper. */
+declare function Field<K, KI, V, VI>(name: BcsType<K, KI>, value: BcsType<V, VI>): _mysten_bcs0.BcsStruct<{
+  id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  name: BcsType<K, KI, string>;
+  value: BcsType<V, VI, string>;
+}, string>;
+declare const bcsU64: BcsType<string, string | number | bigint, "u64">;
+declare const bcsU16: BcsType<number, number, "u16">;
+declare const bcsU256: BcsType<string, string | number | bigint, "u256">;
+declare const bcsId: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+/** Unit key struct (`RateDataKey`, `RewardsKey`, ...): BCS `dummy_field: bool`. */
+declare const UnitKey: BcsType<boolean, boolean, "bool">;
+/** Proposed `fluid_vaults::position_index::PositionIndex` (docs/onchain-position-index.md). */
+declare const PositionIndex$1: _mysten_bcs0.BcsStruct<{
+  next_position_id: BcsType<string, string | number | bigint, "u64">;
+  caps: _mysten_bcs0.BcsStruct<{
+    id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    size: BcsType<string, string | number | bigint, "u64">;
+  }, string>;
+  ordinals: _mysten_bcs0.BcsStruct<{
+    id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    size: BcsType<string, string | number | bigint, "u64">;
+  }, string>;
+}, string>;
+declare const PositionIndexField: _mysten_bcs0.BcsStruct<{
+  id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  name: BcsType<boolean, boolean, string>;
+  value: BcsType<{
+    next_position_id: string;
+    caps: {
+      id: string;
+      size: string;
+    };
+    ordinals: {
+      id: string;
+      size: string;
+    };
+  }, {
+    next_position_id: string | number | bigint;
+    caps: {
+      id: string | Uint8Array<ArrayBufferLike>;
+      size: string | number | bigint;
+    };
+    ordinals: {
+      id: string | Uint8Array<ArrayBufferLike>;
+      size: string | number | bigint;
+    };
+  }, string>;
+}, string>;
+/** `caps: Table<u64, ID>` entry: ordinal -> PositionOwnerCap id. */
+declare const PositionIndexEntry: _mysten_bcs0.BcsStruct<{
+  id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+  name: BcsType<string, string | number | bigint, string>;
+  value: BcsType<string, string | Uint8Array<ArrayBufferLike>, string>;
+}, string>;
+//#endregion
+//#region src/objects.d.ts
+type FetchedObject = {
+  objectId: string;
+  type: string;
+  content: Uint8Array;
+  owner: unknown;
+};
+declare class ObjectNotFoundError extends Error {
+  readonly objectId: string;
+  readonly what: string;
+  constructor(objectId: string, what: string);
+}
+//#endregion
+//#region src/liquidity.d.ts
+type ReserveRecord = {
+  token: string;
+  id: string;
+  raw: ReturnType<typeof TokenReserve.parse>;
+  snapshot: ReserveSnapshot;
+  rateData: RateData;
+};
+declare class Liquidity {
+  private readonly ctx;
+  constructor(ctx: ReadContext);
+  /** Object ids `loadReserves` reads: every reserve, then every reserve's rate-data field. */
+  reserveObjectIds(tokens: readonly string[]): string[];
+  /** Parse objects fetched for `reserveObjectIds(tokens)` (same order). */
+  reservesFromObjects(tokens: readonly string[], objs: readonly (FetchedObject | null)[]): ReserveRecord[];
+  /** Reserves + their rate-data fields in one batched `getObjects`. */
+  loadReserves(tokens: readonly string[]): Promise<ReserveRecord[]>;
+  loadReserve(token: string): Promise<ReserveRecord>;
+  /** Supply/borrow Table entries of `holders` on `reserves` (one batched round trip). */
+  loadUserEntries(pairs: readonly {
+    holder: string;
+    reserve: ReserveRecord;
+  }[]): Promise<{
+    supply: UserSupplyPositionAccount | null;
+    borrow: UserBorrowPositionAccount | null;
+  }[]>;
+  getLiquidityAccount(): Promise<LiquidityAccount>;
+  getRevenueCollector(): Promise<string>;
+  /**
+   * Protocol holders discoverable from object state alone: every VaultMarket (ids 1..total from
+   * `VaultRegistry.next_vault_id`, derived) and every LendingState of a candidate token
+   * (derived). Pure state, no list query.
+   */
+  discoverProtocolHolders(seedTokens?: readonly string[]): Promise<{
+    vaults: {
+      vaultId: number;
+      id: string;
+      collateralType: string;
+      debtType: string;
+      capCount: number;
+    }[];
+    lendings: {
+      token: string;
+      id: string;
+    }[];
+  }>;
+  /**
+   * Token discovery from object state alone (default, no indexer, no list query):
+   * seed tokens (`config.tokens`) ∪ collateral/debt types of every VaultMarket, kept if their
+   * `TokenReserve` exists (derived id). Coverage check: every liquidity user cap is counted in
+   * `Registry.active_caps.size`; caps held by known holders (2 per vault, 1 per LendingState)
+   * are subtracted, and `untrackedCaps > 0` means some other holder exists that state alone
+   * cannot name (a token listed only by a non-Fluid integrator, or a test holder).
+   */
+  discoverTokens(): Promise<{
+    tokens: string[];
+    activeCaps: number;
+    untrackedCaps: number;
+    source: "state" | "state+fullnode-index";
+  }>;
+  /** Listed tokens (see `discoverTokens`; pure state by default). */
+  listedTokens(): Promise<string[]>;
+  getExchangePricesAndConfig(token: string): Promise<ExchangePricesAndConfig>;
+  /** Pure: accrue a reserve snapshot to `now` (unix seconds; use `await ctx.now()` for chain time). */
+  calculateExchangePrice(snapshot: ReserveSnapshot, now: bigint): ExchangePriceResult;
+  getRateConfig(token: string): Promise<RateModelAccount | null>;
+  getTotalAmounts(token: string): Promise<TotalAmounts>;
+  getConfigs2(token: string): Promise<{
+    maxUtilization: bigint;
+  }>;
+  getRevenue(token: string): Promise<bigint>;
+  getTokenRateData(token: string): Promise<RateData>;
+  getTokensRateData(tokens: readonly string[]): Promise<RateData[]>;
+  overallFromRecord(r: ReserveRecord, now: bigint): OverallTokenData;
+  getOverallTokenData(token: string): Promise<OverallTokenData>;
+  getOverallTokensData(tokens: readonly string[]): Promise<OverallTokenData[]>;
+  getAllOverallTokensData(): Promise<OverallTokenData[]>;
+  /** Raw supply position of a holder, or `0n` when none exists (Solana returns BN 0). */
+  getUserSupply(user: string, token: string): Promise<UserSupplyPositionAccount | bigint>;
+  getUserBorrow(user: string, token: string): Promise<UserBorrowPositionAccount | bigint>;
+  supplyDataFromRecords(reserve: ReserveRecord, acc: UserSupplyPositionAccount | null, now: bigint): {
+    userSupplyData: UserSupplyData;
+    overallTokenData: OverallTokenData;
+  };
+  borrowDataFromRecords(reserve: ReserveRecord, acc: UserBorrowPositionAccount | null, now: bigint): {
+    userBorrowData: UserBorrowData;
+    overallTokenData: OverallTokenData;
+  };
+  getUserSupplyData(user: string, token: string): Promise<{
+    userSupplyData: UserSupplyData;
+    overallTokenData: OverallTokenData;
+  }>;
+  getUserBorrowData(user: string, token: string): Promise<{
+    userBorrowData: UserBorrowData;
+    overallTokenData: OverallTokenData;
+  }>;
+  getUserMultipleSupplyData(user: string, tokens: readonly string[]): Promise<{
+    userSuppliesData: UserSupplyData[];
+    overallTokensData: OverallTokenData[];
+  }>;
+  getUserMultipleBorrowData(user: string, tokens: readonly string[]): Promise<{
+    userBorrowingsData: UserBorrowData[];
+    overallTokensData: OverallTokenData[];
+  }>;
+  getUserMultipleBorrowSupplyData(user: string, supplyTokens: readonly string[], borrowTokens: readonly string[]): Promise<{
+    userSuppliesData: UserSupplyData[];
+    overallSupplyTokensData: OverallTokenData[];
+    userBorrowingsData: UserBorrowData[];
+    overallBorrowTokensData: OverallTokenData[];
+  }>;
+  /**
+   * Every supply/borrow position on every listed reserve, grouped by holder.
+   *
+   * Default ("state"): holders = every VaultMarket + LendingState (derived), entries read by
+   * derived Table-entry id. `untracked` = `Table.size` minus entries found, per reserve: rows of
+   * holders that object state cannot name (non-Fluid integrators). With `discovery: "fullnode"`
+   * the tables are listed and `untracked` is always empty.
+   */
+  getAllUserPositionsDetailed(): Promise<{
+    positions: {
+      user: string;
+      supply: Record<string, UserSupplyPositionAccount>;
+      borrow: Record<string, UserBorrowPositionAccount>;
+    }[];
+    untracked: {
+      token: string;
+      supply: number;
+      borrow: number;
+    }[];
+    source: "state" | "fullnode-index";
+  }>;
+  /** Positions only (see `getAllUserPositionsDetailed`). */
+  getAllUserPositions(): Promise<{
+    user: string;
+    supply: Record<string, UserSupplyPositionAccount>;
+    borrow: Record<string, UserBorrowPositionAccount>;
+  }[]>;
+  /** Fullnode-index tier: lists every Table entry. */
+  private listAllUserPositions;
+}
+declare namespace lending_d_exports {
+  export { LendingSnapshot, RewardsSchedule, accruedTokenExchangePrice, currentRewardsRate, previews, rateSegments, rewardsRateFor, rewardsTvl, toAssets, toShares };
+}
+type RewardsSchedule = {
+  startTvl: bigint;
+  startS: bigint;
+  endS: bigint;
+  yearlyReward: bigint;
+  nextStartS: bigint;
+  nextEndS: bigint;
+  nextYearlyReward: bigint;
+};
+type LendingSnapshot = {
+  totalShares: bigint;
+  liquidityExchangePrice: bigint;
+  tokenExchangePrice: bigint;
+  lastUpdateS: bigint;
+  rewards: RewardsSchedule | null;
+};
+declare const toShares: (assets: bigint, ep: bigint, roundUp: boolean) => bigint;
+declare const toAssets: (shares: bigint, ep: bigint, roundUp: boolean) => bigint;
+/** `lending_calcs::calc_rewards_rate` via `rewards::rate_for`. */
+declare function rewardsRateFor(yearlyReward: bigint, totalAssets: bigint, startTvl: bigint): bigint;
+/** `rewards::get_rate_segments`. */
+declare function rateSegments(s: RewardsSchedule, totalAssets: bigint, fromS: bigint, nowS: bigint): {
+  rate: bigint;
+  fromS: bigint;
+  toS: bigint;
+}[];
+/**
+ * TVL the contract prices rewards on: total shares at the STORED (pre-accrual) token exchange
+ * price, as `accounting::accrued_token_exchange_price` does. Rounded up on "audited" packages
+ * (742ea21+), floored on the 09-18 "pre-audit" packages.
+ */
+declare const rewardsTvl: (state: LendingSnapshot, variant?: MathVariant) => bigint;
+/**
+ * Current rewards rate (raw, RETURN_PERCENT_PRECISION: 1e14 = 100%) at `now`, from the active schedule segment, priced on
+ * the pre-accrual TVL (`rewardsTvl`) exactly as the contract prices the segment it will credit.
+ * Windows are [start, end): the rate is live from `startS` and gone at `endS`.
+ */
+declare function currentRewardsRate(state: LendingSnapshot, now: bigint, variant?: MathVariant): bigint;
+/** `accounting::accrued_token_exchange_price`. */
+declare function accruedTokenExchangePrice(state: LendingSnapshot, newLiquidityExchangePrice: bigint, nowS: bigint, variant?: MathVariant): bigint;
+/** `accounting::preview_*` given the reserve's current liquidity (supply) exchange price. */
+declare function previews(state: LendingSnapshot, liquidityExchangePrice: bigint, nowS: bigint, assets: bigint, shares: bigint, variant?: MathVariant): {
+  tokenExchangePrice: bigint;
+  previewDeposit: bigint;
+  previewMint: bigint;
+  previewWithdraw: bigint;
+  previewRedeem: bigint;
+};
+//#endregion
+//#region src/lending.d.ts
+type LendingRecord = {
+  token: string;
+  id: string;
+  raw: ReturnType<typeof LendingState.parse>;
+  snapshot: LendingSnapshot;
+};
+type Pool = {
+  lending: LendingRecord;
+  reserve: ReserveRecord;
+  supplyEntry: UserSupplyPositionAccount | null;
+};
+declare class Lending {
+  private readonly ctx;
+  private readonly liquidity;
+  constructor(ctx: ReadContext, liquidity: Liquidity);
+  /** Object ids `loadLendings` reads: every LendingState, then every rewards field. */
+  lendingObjectIds(tokens: readonly string[]): string[];
+  /** LendingStates (+ rewards fields) for `tokens`; `null` where no pool exists. */
+  loadLendings(tokens: readonly string[]): Promise<(LendingRecord | null)[]>;
+  lendingsFromObjects(tokens: readonly string[], objs: readonly (FetchedObject | null)[]): (LendingRecord | null)[];
+  /**
+   * Everything a pool read needs in ONE `getObjects` batch (LendingState, rewards field,
+   * TokenReserve, rate data per token; 50 ids per request, chunks in parallel), plus the chain
+   * clock in parallel. With `withEntries`, a second batch reads each pool's liquidity supply entry.
+   */
+  loadPools(tokens: readonly string[], withEntries?: boolean): Promise<{
+    pools: Pool[];
+    now: bigint;
+  }>;
+  private loadOne;
+  getAllLendings(): Promise<LendingAccount[]>;
+  /** Underlying coin types that have a lending pool. */
+  getAllFTokens(): Promise<string[]>;
+  /** @deprecated Solana name; use `getAllFTokens`. */
+  getAllJlTokens: () => Promise<string[]>;
+  /** Token exchange price accrued to now (`accounting::calculate_new_token_exchange_price`). */
+  getExchangePrice(token: string): Promise<bigint>;
+  getPreviews(token: string, assets: bigint, shares: bigint): Promise<PreviewData>;
+  detailsFromRecords(lending: LendingRecord, reserve: ReserveRecord, supplyEntry: Parameters<Liquidity["supplyDataFromRecords"]>[1], meta: {
+    name: string;
+    symbol: string;
+    decimals: number;
+  }, now: bigint): FTokenDetails;
+  /** fToken name/symbol/decimals (cached; falls back to the underlying's metadata). */
+  fTokenMeta(token: string): Promise<CoinMeta>;
+  getFTokenDetails(token: string): Promise<FTokenDetails>;
+  /** Details for many fTokens: 2 batched object reads + the clock, metadata cached. */
+  getFTokensDetails(tokens: readonly string[]): Promise<FTokenDetails[]>;
+  private detailsWithPrices;
+  /** @deprecated Solana name; use `getFTokenDetails`. */
+  getJlTokenDetails: (token: string) => Promise<FTokenDetails>;
+  getAllFTokenDetails(): Promise<FTokenDetails[]>;
+  /** Underlying coin types that have a lending pool (pure state: one batched existence read). */
+  listedLendingTokens(): Promise<string[]>;
+  /** @deprecated Solana name; use `getAllFTokenDetails`. */
+  getAllJlTokenDetails: () => Promise<FTokenDetails[]>;
+  getFTokenInternalData(token: string): Promise<FTokenInternalData>;
+  /** @deprecated Solana name; use `getFTokenInternalData`. */
+  getJlTokenInternalData: (token: string) => Promise<FTokenInternalData>;
+  /**
+   * Generic lending state per fToken (identity, accrued + stored exchange prices, TVL, rates in
+   * bps, rewards schedule) for `tokens` (underlying coin types), or every listed pool when
+   * omitted. One batched `getObjects` for all pools + the on-chain Clock; metadata cached.
+   */
+  getLendingStateData(tokens?: readonly string[]): Promise<LendingStateData[]>;
+  /** Pure: `LendingStateData` from loaded records at `now`. */
+  stateDataFrom(lending: LendingRecord, reserve: ReserveRecord, decimals: number, now: bigint): LendingStateData;
+  /**
+   * Wallet holders of `Coin<FToken<T>>` for `token` (underlying coin type), via the GraphQL
+   * indexer (`config.graphqlUrl`; needs `discovery: "indexer"`). Lists every Coin<FToken<T>>
+   * object by type and keeps the ones with an ADDRESS owner (AddressOwner or
+   * ConsensusAddressOwner), aggregated by owner, all pages at one checkpoint (consistent cursors).
+   *
+   * LIMITS (documented, by design): coins owned by other objects, shared/immutable coins and
+   * wrapped `Balance<FToken<T>>` (inside other protocols' objects) are NOT attributed to a wallet;
+   * nor are address balances (funds credited to an address without a coin object), since they are
+   * not objects and cannot be enumerated by type. `totalSupply` is returned so a caller can
+   * compare it with the sum of the wallets. With `verify` (default true) each wallet is cross-checked against
+   * fullnode `getBalance` (coinBalance + addressBalance), `concurrency` at a time (default 8).
+   */
+  getFTokenHolders(token: string, opts?: {
+    verify?: boolean;
+    concurrency?: number;
+    pageSize?: number;
+  }): Promise<FTokenHolders>;
+  /** `[rewards writer cap id, current rewards rate in bps]`. */
+  getFTokenRewards(token: string): Promise<[string | null, bigint]>;
+  /** @deprecated Solana name; use `getFTokenRewards`. */
+  getJlTokenRewards: (token: string) => Promise<[string | null, bigint]>;
+  getFTokenRewardsRateModelConfig(token: string): Promise<RewardsRateModelConfig | null>;
+  /** @deprecated Solana name; use `getFTokenRewardsRateModelConfig`. */
+  getJlTokenRewardsRateModelConfig: (token: string) => Promise<RewardsRateModelConfig | null>;
+  getUserPosition(token: string, user: string): Promise<LendingUserPosition>;
+  getUserPositions(user: string): Promise<FTokenDetailsUserPosition[]>;
+  /** `lending::auth::is_admin(&Auth, addr)` via simulation. */
+  isLendingAdmin(addr: string): Promise<boolean>;
+  /** `lending::auth::has_role(&Auth, addr)` (any role) via simulation. */
+  isLendingAuth(addr: string): Promise<boolean>;
+  private authView;
+}
+//#endregion
+//#region src/oracle.d.ts
+/** Oracle rates are debt-per-collateral in the vault's internal 1e9 space, scaled by 1e15. */
+declare const ORACLE_RATE_PRECISION = 1000000000000000n;
+/** Mirrors `fluid_oracle::constants` of the deployed v2 package. */
+declare const ORACLE_LIMITS: {
+  readonly rateOutputDecimals: 15;
+  readonly maxAgeOperateS: 600n;
+  readonly maxAgeLiquidateS: 7200n;
+  readonly maxPythArrivalLagS: 60n;
+  readonly confidenceScaleOperate: 50n;
+  readonly confidenceScaleLiquidate: 25n;
+  readonly maxPythExponent: 12n;
+  readonly redstoneDecimals: 8;
+  readonly maxInvertibleRate: bigint;
+};
+/** `rate::scale_and_invert`: raw provider price with `decimals` → 1e15 rate, optionally inverted. */
+declare function scaleAndInvert(raw: bigint, decimals: number, invert: boolean): bigint;
+declare class Oracle {
+  private readonly ctx;
+  constructor(ctx: ReadContext);
+  private get providers();
+  /** v2 oracle object: nonce + main / guard routes. */
+  getOracle(oracleId: string): Promise<OracleData>;
+  /** Provider objects the v2 views take for this oracle. */
+  private providerArgs;
+  private quote;
+  /** Price exactly as vaults see it. v2: operate and liquidate simulated separately (one can abort alone). */
+  getOraclePrice(oracleId: string): Promise<OraclePrice>;
+  /**
+   * Each v2 route read on its own, at the chain's clock: raw price, 1e15 rate, age, and whether it
+   * passes the operate / liquidate checks (`*_core::reading_error`, mirrored off-chain).
+   * Operate price = min over routes; liquidate = min over routes usable for liquidate.
+   */
+  getOracleRoutes(oracleId: string): Promise<{
+    oracle: OracleData;
+    nowMs: bigint;
+    main: OracleRoute;
+    guard: OracleRoute | null;
+  }>;
+  /** Human price (collateral priced in debt units) from a raw 1e15 rate. */
+  static toNumber(rate: bigint): number;
+}
+//#endregion
+//#region src/math/core.d.ts
+/** Integer helpers that mirror `fluid_library::math` (all bigint, floor unless named ceil). */
+declare const FOUR_DECIMALS = 10000n;
+declare const SECONDS_PER_YEAR = 31536000n;
+/** Liquidity / vault / lending exchange-price precision (1e12). */
+declare const EXCHANGE_PRICES_PRECISION = 1000000000000n;
+/** `exchange_price_rate_output_decimals` in liquidity (1e17). */
+declare const RATE_OUTPUT_DECIMALS = 100000000000000000n;
+/** Vault exchange-price scale factor (1e18). */
+declare const EXCHANGE_PRICE_SCALE_FACTOR = 1000000000000000000n;
+/** Lending return precision (1e14 = 1e12 * 100). */
+declare const RETURN_PERCENT_PRECISION = 100000000000000n;
+/**
+ * The two raw on-chain rate scales differ, which is why every rate FIELD the SDK returns is bps
+ * (1e4 = 100% per year, floored):
+ * - liquidity supply rate (`reserve::calculate_exchange_prices`): 1e12 = 100%  -> SUPPLY_RATE_PRECISION
+ * - lending rewards rate (`rewards`, `lending_calcs`): 1e14 = 100%             -> RETURN_PERCENT_PRECISION
+ */
+declare const SUPPLY_RATE_PRECISION = 1000000000000n;
+/** Raw liquidity supply rate (1e12 = 100%) -> bps, floored. */
+declare const supplyRateToBps: (raw: bigint) => bigint;
+/** Raw lending rewards rate (1e14 = 100%) -> bps, floored. */
+declare const rewardsRateToBps: (raw: bigint) => bigint;
+/** Lending max rewards rate: 50% at RETURN_PERCENT_PRECISION (1e14 = 100%). */
+declare const MAX_REWARDS_RATE = 50000000000000n;
+declare function mulDiv(a: bigint, b: bigint, c: bigint): bigint;
+declare function divCeil(a: bigint, b: bigint): bigint;
+declare function mulDivCeil(a: bigint, b: bigint, c: bigint): bigint;
+declare const max: (a: bigint, b: bigint) => bigint;
+declare const min: (a: bigint, b: bigint) => bigint;
+/** Current unix time in seconds (the default `now` for time-dependent reads). */
+declare const nowSeconds: () => bigint;
+//#endregion
+//#region src/positionIndex.d.ts
+type PositionSource = "state" | "fullnode-index" | "events+objects";
+type PositionCounts = {
+  vaultId: number;
+  /** Positions ever opened in this vault (EVM `totalPositions` semantics). */
+  totalPositions: number;
+  /** Positions whose object exists right now (verified on-chain, never from events alone). */
+  openPositions: number;
+  /** On-chain `next_position_id` when the index exists, else `totalPositions + 1` (ordinal). */
+  nextPositionId: number;
+  /** Open position object ids (index order when the on-chain index exists). */
+  openPositionIds: string[];
+  /** Where the enumeration came from. Only "state" is a stored on-chain value. */
+  source: PositionSource;
+};
+type PositionIndexOptions = {
+  /** Override `config.graphqlUrl`. */
+  graphqlUrl?: string;
+  pageSize?: number;
+  retries?: number;
+  /** Base backoff in ms (doubles per attempt). */
+  backoffMs?: number;
+  fetchImpl?: typeof fetch;
+};
+declare const POSITION_INDEX_FIX: string;
+declare class PositionIndex {
+  private ctx;
+  private opts;
+  private streams;
+  private inflight;
+  constructor(ctx: ReadContext, opts?: PositionIndexOptions);
+  /**
+   * Reads the proposed on-chain index by derived ids. `null` when the vault has no index yet.
+   * Returns ordinal -> cap id for every position ever opened, and the stored counter.
+   */
+  readOnchainIndex(vaultMarketId: string): Promise<{
+    nextPositionId: number;
+    capIds: string[];
+  } | null>;
+  /** Every position id ever claimed on `vaultMarketId` (`derived_object::Claimed` fields). */
+  claimedIds(vaultMarketId: string): Promise<string[]>;
+  counts(vaultId: number, vaultMarketId: string): Promise<PositionCounts>;
+  private finish;
+  /** Lowest discovery level `counts` would need right now for this vault. */
+  requiredLevel(vaultMarketId: string): Promise<DiscoveryLevel>;
+  private get url();
+  private type;
+  private post;
+  /** All events of `type`, resuming from the last cursor. Concurrent callers share one scan. */
+  private sync;
+  /** Every position id ever opened in `vaultMarketId` (event order, deduped). Indexer tier. */
+  openedIds(vaultMarketId: string): Promise<string[]>;
+  /** Position ids with a `LogClosePosition` for numeric `vaultId`. Indexer tier. */
+  closedIds(vaultId: number): Promise<Set<string>>;
+  /** Drop cached cursors (forces a full rescan next call). */
+  reset(): void;
+}
+//#endregion
+//#region src/vault.d.ts
+/** `withOracle` (default true): oracle price via one simulation. `positionCounts` (default true):
+ *  fill `totalPositions` / `nextPositionId` from the derived position index (-1 if unreachable). */
+type VaultReadOpts = {
+  withOracle?: boolean;
+  positionCounts?: boolean;
+};
+type VaultRecord = {
+  vaultId: number;
+  id: string;
+  collateralType: string;
+  debtType: string;
+  raw: ReturnType<typeof VaultMarket.parse>;
+};
+declare class Vault {
+  private readonly ctx;
+  private readonly liquidity;
+  private readonly oracle;
+  /** Derived per-vault position counts (no counter exists on-chain on Sui). */
+  readonly positions: PositionIndex;
+  constructor(ctx: ReadContext, liquidity: Liquidity, oracle: Oracle);
+  /**
+   * totalPositions (ever opened, EVM parity), openPositions (object exists now), nextPositionId
+   * (stored counter once the on-chain index ships, else totalPositions + 1). Pure state when the
+   * vault has the on-chain index; otherwise needs `discovery: "fullnode"` (derived_object claims)
+   * or "indexer" (events), and throws `NeedsDiscoveryError` under the default "state".
+   */
+  getVaultPositionCounts(vaultId: number): Promise<PositionCounts>;
+  /** Counts for state fills: never lets an event-endpoint outage break a vault read (-1 then). */
+  private countsOrNull;
+  getTotalVaults(): Promise<number>;
+  loadVaults(vaultIds: readonly number[]): Promise<VaultRecord[]>;
+  loadVault(vaultId: number): Promise<VaultRecord>;
+  configFromRecord(v: VaultRecord): VaultConfig;
+  getVaultConfig(vaultId: number): Promise<VaultConfig>;
+  batchGetTicks(vaultId: number, ticks: readonly number[]): Promise<(DecodedTick | null)[]>;
+  private ticksOf;
+  getTick({
+    vaultId,
+    tick
+  }: {
+    vaultId: number;
+    tick: number;
+  }): Promise<DecodedTick | null>;
+  batchGetBranches(vaultId: number, branchIds: readonly number[]): Promise<(DecodedBranch | null)[]>;
+  private branchesOf;
+  getBranch({
+    vaultId,
+    branchId
+  }: {
+    vaultId: number;
+    branchId: number;
+  }): Promise<DecodedBranch | null>;
+  /** Branches 1..total_branch_id. */
+  getAllBranches(vaultId: number): Promise<DecodedBranch[]>;
+  getTickIdLiquidation({
+    vaultId,
+    tick,
+    tickId
+  }: {
+    vaultId: number;
+    tick: number;
+    tickId: number;
+  }): Promise<DecodedTickIdLiquidation | null>;
+  /** Raw `tick_bitmap` words (u256) for `words`; missing words = 0. */
+  getTickHasDebtArray(vaultId: number, words: readonly number[]): Promise<{
+    word: number;
+    bitmap: bigint;
+  }[]>;
+  private stateFromRecord;
+  getVaultState(vaultId: number, opts?: {
+    positionCounts?: boolean;
+  }): Promise<VaultState>;
+  /** `user::get_exchange_prices`: (liqSupply, liqBorrow, vaultSupply, vaultBorrow) accrued to `now`. */
+  exchangePricesFromRecords(v: VaultRecord, colReserve: ReserveRecord, debtReserve: ReserveRecord, now: bigint): {
+    liquiditySupplyExchangePrice: bigint;
+    liquidityBorrowExchangePrice: bigint;
+    vaultSupplyExchangePrice: bigint;
+    vaultBorrowExchangePrice: bigint;
+  };
+  /** Full vault view. `withOracle` (default true) adds the oracle price via one simulation. */
+  getVaultEntireData(vaultId: number, opts?: VaultReadOpts): Promise<VaultEntireData>;
+  getVaultEntireDataV2(vaultId: number, opts?: VaultReadOpts): Promise<VaultEntireDataV2>;
+  getAllVaults(opts?: VaultReadOpts): Promise<VaultEntireData[]>;
+  getAllVaultsV2(opts?: VaultReadOpts): Promise<VaultEntireDataV2[]>;
+  getVaultByVaultId: (vaultId: number) => Promise<VaultEntireData>;
+  private toV2;
+  private entireDataFor;
+  /** Raw Position object. `vaultId` is resolved from the position's VaultMarket if omitted. */
+  getUserPosition({
+    positionId,
+    vaultId
+  }: {
+    positionId: string;
+    vaultId?: number;
+  }): Promise<UserPosition | null>;
+  batchGetUserPositions(positionIds: readonly string[]): Promise<(UserPosition | null)[]>;
+  private vaultIdOf;
+  /** Everything `fetch_latest_position` needs for one position (tick, snapshot, branch chain). */
+  private liquidationLookups;
+  /** Solana `getCurrentPositionState`: raw col/debt after any liquidation, as operate would settle it. */
+  getCurrentPositionState({
+    vaultId,
+    position
+  }: {
+    vaultId: number;
+    position: UserPosition;
+  }): Promise<UserPositionWithDebt>;
+  getFinalPosition({
+    vaultId,
+    positionId
+  }: {
+    vaultId: number;
+    positionId: string;
+  }): Promise<UserPositionWithDebt>;
+  /** Owner of a PositionOwnerCap (Solana `getNftOwner`). */
+  getPositionOwner(capId: string): Promise<string | null>;
+  getNftOwner: (capId: string) => Promise<string | null>;
+  /** Solana `buildNftPositionFromPositionAccount` semantics, on a fetched vault context. */
+  private buildNftPosition;
+  /** Solana `getPositionByVaultId(vaultId, nftId)`; Sui takes the Position object id. */
+  getPositionByVaultId(vaultId: number, positionId: string): Promise<NftPosition & {
+    vault: VaultEntireData;
+  }>;
+  getPositionByVaultIdV2(vaultId: number, positionId: string): Promise<{
+    vault: VaultEntireDataV2;
+    nftId: string;
+    owner: string | null;
+    capId: string;
+    isSupplyPosition: boolean;
+    supply: bigint;
+    beforeSupply: bigint;
+    dustBorrow: bigint;
+    beforeDustBorrow: bigint;
+    tick: number;
+    tickId: number;
+    borrow: bigint;
+    beforeBorrow: bigint;
+    isLiquidated: boolean;
+  }>;
+  /**
+   * Every position whose PositionOwnerCap `user` owns, across all vaults.
+   *
+   * Pure state when every vault has the on-chain position index: all cap ids come from the
+   * index, their owners from the cap objects themselves. Otherwise needs `discovery: "fullnode"`
+   * (`listOwnedObjects`). If the caller already knows the cap ids (a wallet does), use
+   * `getUserPositionsByCapIds`, which is always pure state.
+   */
+  getAllUserPositions(user: string): Promise<(NftPosition & {
+    vault: VaultEntireData;
+  })[]>;
+  /** Positions for known PositionOwnerCap ids (pure state: derived position ids only). */
+  getUserPositionsByCapIds(capIds: readonly string[], user?: string): Promise<(NftPosition & {
+    vault: VaultEntireData;
+  })[]>;
+  getAllUserPositionsV2: (user: string) => Promise<{
+    vault: VaultEntireDataV2;
+    nftId: string;
+    owner: string | null;
+    capId: string;
+    isSupplyPosition: boolean;
+    supply: bigint;
+    beforeSupply: bigint;
+    dustBorrow: bigint;
+    beforeDustBorrow: bigint;
+    tick: number;
+    tickId: number;
+    borrow: bigint;
+    beforeBorrow: bigint;
+    isLiquidated: boolean;
+  }[]>;
+  /** Open Position ids in a vault: opened events, minus closes, verified by object existence. */
+  getAllPositionIdsForVault(vaultId: number): Promise<string[]>;
+  /** All open positions of a vault with `riskRatio` = debt / (col × liquidate price), 1e4 scale. */
+  getAllPositionsWithRiskRatio(vaultId: number): Promise<PositionWithRiskRatio[]>;
+  /** Oracle price of a vault's oracle (as vaults consume it). */
+  getOraclePrice(vaultId: number): Promise<OraclePrice>;
+  /** Raw vault-internal 1e9 amounts → token units (`constants::unscale_amounts`). */
+  static unscale(amount: bigint, decimals: number): bigint;
+}
+//#endregion
+//#region src/client.d.ts
+declare const DEFAULT_RPC_URL = "https://fullnode.mainnet.sui.io:443";
+type ClientOptions = {
+  /**
+   * REQUIRED. Built-in network name ("staging") or a
+   * full config (e.g. production from `configFromDeployment`). No default, so nobody reads
+   * staging believing it is production.
+   */
+  network: string | FluidReadConfig;
+  /**
+   * Clock for time-dependent maths. Default "chain": the on-chain Clock (0x6), so accrual and the
+   * rewards windows never depend on this server's clock. "local" = wall clock; or a function
+   * returning unix seconds.
+   */
+  now?: ClockSource;
+  /** Enumeration policy. Default "state" (no indexer, no list queries). See `DiscoveryLevel`. */
+  discovery?: DiscoveryLevel;
+  /** Per-call timeout before failing over to the next endpoint. Default 15000 ms. */
+  timeoutMs?: number;
+  /** Retry passes over the endpoints with exponential backoff (see `FailoverOptions`). Default 3 passes, 250 ms base, 4 s cap. */
+  retry?: Pick<FailoverOptions, "rounds" | "backoffMs" | "maxBackoffMs">;
+};
+/**
+ * Unified reader, same shape as `@jup-ag/lend-read`'s `Client`:
+ * `client.liquidity`, `client.lending`, `client.vault` (+ `client.oracle`, Sui-only).
+ *
+ * @example
+ * const client = new Client(undefined, { network: "staging" });  // staging deployment, Sui mainnet gRPC
+ * const client = new Client("https://my-fullnode:443", { network: prodConfig });
+ * const client = new Client(existingSuiGrpcClient, { network: "staging" });
+ * const vault = await client.vault.getVaultEntireData(1);
+ */
+declare class Client {
+  readonly liquidity: Liquidity;
+  readonly lending: Lending;
+  readonly vault: Vault;
+  readonly oracle: Oracle;
+  readonly context: ReadContext;
+  constructor(rpc: string | readonly (string | ClientWithCoreApi)[] | ClientWithCoreApi | undefined, opts: ClientOptions);
+  /**
+   * The same reader pinned to a past `checkpoint`: every object read comes from the GraphQL service
+   * (`config.graphqlUrl`) at that checkpoint and the clock is the checkpoint's timestamp, so
+   * `lending.getLendingStateData()`, rates, reserves and vault state are what the chain held then.
+   * Move views / oracle quotes / balances are not available historically (`CheckpointReadError`).
+   * Needs `discovery: "indexer"` (it is a GraphQL read).
+   *
+   * @example
+   * const past = await client.atCheckpoint(330_000_000);
+   * const state = await past.lending.getLendingStateData();
+   */
+  atCheckpoint(checkpoint: number | bigint): Promise<Client>;
+}
+/**
+ * `$extend` form, same pattern as the write SDK's `fluid()`:
+ * `const c = new SuiGrpcClient({...}).$extend(fluidRead());  c.fluidRead.vault...`
+ */
+declare function fluidRead(opts: ClientOptions): {
+  name: "fluidRead";
+  register: (client: ClientWithCoreApi) => Client;
+};
+//#endregion
+//#region src/view.d.ts
+declare class ViewCallError extends Error {
+  readonly details?: unknown | undefined;
+  constructor(message: string, details?: unknown | undefined);
+}
+/**
+ * Build a PTB with `build`, simulate it, and return every command's return values as raw BCS.
+ * `results[i][j]` = return value j of command i.
+ */
+declare function simulateView(client: ClientWithCoreApi, build: (tx: Transaction) => void | TransactionResult | unknown): Promise<Uint8Array[][]>;
+//#endregion
+//#region src/graphql.d.ts
+declare class GraphQLError extends Error {
+  readonly errors?: unknown | undefined;
+  constructor(message: string, errors?: unknown | undefined);
+}
+type GraphQLOptions = {
+  /** Attempts in total. Default 3. */
+  rounds?: number;
+  backoffMs?: number;
+  maxBackoffMs?: number;
+  timeoutMs?: number;
+};
+/**
+ * POST one query. Network errors, timeouts, HTTP 429/5xx are retried with backoff; a GraphQL
+ * `errors` payload (bad query, unknown object) is NOT retried.
+ */
+declare function graphqlQuery<T>(url: string, query: string, variables?: Record<string, unknown>, opts?: GraphQLOptions): Promise<T>;
+//#endregion
+//#region src/checkpoint.d.ts
+declare class CheckpointReadError extends Error {
+  constructor(method: string, checkpoint: bigint);
+}
+/** Timestamp of `checkpoint` in unix seconds (floored, as `units::from_clock` reads it). */
+declare function checkpointTimestampSeconds(url: string, checkpoint: bigint, opts?: GraphQLOptions): Promise<bigint>;
+/** Latest checkpoint the GraphQL service has indexed. */
+declare function latestCheckpoint(url: string, opts?: GraphQLOptions): Promise<bigint>;
+/**
+ * A core client pinned to `checkpoint`: `getObjects` via GraphQL at that checkpoint,
+ * `getCoinMetadata` from `live` (immutable data), every other core read throws.
+ */
+declare function checkpointClient(url: string, checkpoint: bigint, live: ClientWithCoreApi, opts?: GraphQLOptions): ClientWithCoreApi & {
+  checkpoint: bigint;
+};
+declare namespace vault_d_exports {
+  export { BRANCH_STATUS, LiquidationLookups, SignedMagnifier, currentPositionState, fetchLatestPosition, loadVaultExchangePrices, minimumDebt, needsLiquidationSettle, positionInfo, rawToNormal, unscale };
+}
+declare const BRANCH_STATUS: {
+  readonly NotLiquidated: 0;
+  readonly Liquidated: 1;
+  readonly Merged: 2;
+  readonly Closed: 3;
+};
+/** Signed rate magnifier (Move `RateMagnifier { magnitude, negative }` → signed bigint). */
+type SignedMagnifier = bigint;
+/** `exchange_price::load_exchange_prices` → `(vaultSupplyExPrice, vaultBorrowExPrice)`. */
+declare function loadVaultExchangePrices(p: {
+  vaultSupplyExPrice: bigint;
+  vaultBorrowExPrice: bigint;
+  oldLiqSupplyExPrice: bigint;
+  oldLiqBorrowExPrice: bigint;
+  liqSupplyExPrice: bigint;
+  liqBorrowExPrice: bigint;
+  timeDiff: bigint;
+  supplyRateMagnifier: SignedMagnifier;
+  borrowRateMagnifier: SignedMagnifier;
+}): {
+  vaultSupplyExchangePrice: bigint;
+  vaultBorrowExchangePrice: bigint;
+};
+/** `position::get_position_info`: (colRaw, dustDebtRaw, debtRaw, tick, tickId). Debt is rounded up. */
+declare function positionInfo(pos: {
+  isSupplyOnlyPosition: boolean;
+  tick: number;
+  tickId: number;
+  supplyAmount: bigint;
+  dustDebtAmount: bigint;
+}): {
+  colRaw: bigint;
+  dustDebtRaw: bigint;
+  debtRaw: bigint;
+  tick: number;
+  tickId: number;
+};
+type LiquidationLookups = {
+  tick: DecodedTick;
+  /** Required when `tick.totalIds !== tickId` (the position's id was snapshotted). */
+  snap?: DecodedTickIdLiquidation | null;
+  /** Branch lookup by id; must cover every branch on the merge chain. */
+  branch: (id: number) => DecodedBranch;
+};
+/**
+ * `operate_utils::fetch_latest_position`: the position's debt/col after liquidations, as
+ * `operate` would settle it. `debtRaw` is the position's pre-liquidation raw debt.
+ */
+declare function fetchLatestPosition(debtRaw: bigint, tickId: number, l: LiquidationLookups): {
+  tick: number;
+  colRaw: bigint;
+  debtRaw: bigint;
+  branchId: number;
+};
+/** Whether `operate` would run `fetch_latest_position` for this position. */
+declare const needsLiquidationSettle: (tick: DecodedTick, tickId: number) => boolean;
+/** Current raw state of a position (Solana `getCurrentPositionState`). */
+declare function currentPositionState(pos: {
+  isSupplyOnlyPosition: boolean;
+  tick: number;
+  tickId: number;
+  supplyAmount: bigint;
+  dustDebtAmount: bigint;
+}, lookups: LiquidationLookups | null, debtDecimals?: number): UserPositionWithDebt;
+/** raw (internal 1e9 space) → normal (still internal space) through a vault exchange price. */
+declare const rawToNormal: (raw: bigint, exPrice: bigint) => bigint;
+/** `constants::get_minimum_debt(decimals)` in the internal 1e9 space. */
+declare const minimumDebt: (decimals: number) => bigint;
+/** Internal 1e9 space → token units (`constants::unscale_amounts`, floor). */
+declare const unscale: (amount: bigint, decimals: number) => bigint;
+declare namespace tick_d_exports {
+  export { COLD_TICK, MAX_MASK_DEBT_FACTOR, MAX_TICK, MIN_TICK, SHIFT, TICK_SPACING, X30, ZERO_TICK_SCALED_RATIO, getRatioAtTick, mulBigNumber, mulDivNormal, tickFromMove, tickToMove };
+}
+/** Port of `fluid_library::tick_math` + `fluid_library::big_number` (the parts a reader needs). */
+declare const MAX_TICK = 16383;
+declare const MIN_TICK = -16383;
+/** `tick_math::cold_tick()` = { mag: 2^31, neg: true }: "no tick" (supply-only / fully liquidated). */
+declare const COLD_TICK = -2147483648;
+declare const TICK_SPACING = 10015n;
+declare const ZERO_TICK_SCALED_RATIO = 281474976710656n;
+declare const SHIFT = 48n;
+declare const X30 = 1073741823n;
+/** Move `Tick { mag, neg }` → signed number. */
+declare function tickFromMove(t: {
+  mag: number;
+  neg: boolean;
+}): number;
+/** Signed number → Move `Tick { mag, neg }` (zero is `neg: false`). */
+declare function tickToMove(tick: number): {
+  mag: number;
+  neg: boolean;
+};
+/** ratioX48 = 1.0015^tick * 2^48, bit-exact with `tick_math::get_ratio_at_tick`. */
+declare function getRatioAtTick(tick: number): bigint;
+declare const MAX_MASK_DEBT_FACTOR = 1125899906842623n;
+/** `big_number::mul_big_number`. */
+declare function mulBigNumber(a: bigint, b: bigint): bigint;
+/** `big_number::mul_div_normal`: normal * bn1 / bn2. */
+declare function mulDivNormal(normal: bigint, bn1: bigint, bn2: bigint): bigint;
+//#endregion
+export { AllEndpointsFailedError, CONFIGS, CheckpointReadError, Client, type ClientOptions, Configs, ConstantViews, CurrentBranchState, DEFAULT_RPC_URL, DecodedBranch, DecodedTick, DecodedTickIdLiquidation, type DeploymentRecord, type DiscoveryLevel, EXCHANGE_PRICES_PRECISION, EXCHANGE_PRICE_SCALE_FACTOR, ExchangePriceResult, ExchangePricesAndConfig, ExchangePricesAndRates, FOUR_DECIMALS, FTokenDetails, FTokenDetailsUserPosition, FTokenHolder, FTokenHolders, FTokenInternalData, type FailoverOptions, type FluidDerive, type FluidReadConfig, GraphQLError, type GraphQLOptions, JlTokenDetails, JlTokenDetailsUserPosition, JlTokenInternalData, Lending, LendingAccount, type LendingRecord, LendingStateData, LendingUserPosition, LimitsAndAvailability, Liquidity, LiquidityAccount, MAINNET, MAX_REWARDS_RATE, NeedsDiscoveryError, NftPosition, ORACLE_LIMITS, ORACLE_RATE_PRECISION, ObjectNotFoundError, Oracle, OracleData, OraclePrice, OracleRoute, OracleSource, OverallTokenData, POSITION_INDEX_FIX, type PackageIds, type PositionCounts, PositionIndex, type PositionIndexOptions, type PositionSource, PositionWithRiskRatio, PreviewData, RATE_OUTPUT_DECIMALS, RETURN_PERCENT_PRECISION, RateData, RateDataV1, RateDataV2, RateModelAccount, type ReadContext, type ReserveRecord, RewardsRateModelConfig, SECONDS_PER_YEAR, STAGING, SUPPLY_RATE_PRECISION, TotalAmounts, TotalSupplyAndBorrow, UserBorrowData, UserBorrowPositionAccount, UserPosition, UserPositionWithDebt, UserSupplyData, UserSupplyPositionAccount, Vault, VaultConfig, VaultEntireData, VaultEntireDataV2, type VaultReadOpts, type VaultRecord, VaultState, ViewCallError, backoffDelay, bcs_d_exports as bcsTypes, checkpointClient, checkpointTimestampSeconds, clientForEndpoint, configFromDeployment, createDerive, createFailoverClient, divCeil, fluidRead, graphqlQuery, latestCheckpoint, lending_d_exports as lendingMath, liquidity_d_exports as liquidityMath, max, min, mulDiv, mulDivCeil, nowSeconds, resolveConfig, rewardsRateToBps, scaleAndInvert, simulateView, supplyRateToBps, tick_d_exports as tickMath, vault_d_exports as vaultMath };