@gearbox-protocol/sdk 16.0.0-next.2 → 16.0.0-next.21

package/dist/types/onchain/plugins/types.d.ts

@@ -0,0 +1,123 @@
+import { BaseState, IBaseContract } from "../base/types.js";
+import { OnchainSDK } from "../OnchainSDK.js";
+import "../base/index.js";
+//#region src/onchain/plugins/types.d.ts
+/**
+ * Serialisable snapshot of a plugin's state, used for hydration.
+ *
+ * When `loaded` is `false` only the `version` field is present;
+ * when `loaded` is `true` the full `State` payload is included.
+ *
+ * @typeParam State - Plugin-specific state shape.
+ **/
+type IPluginState<State extends Record<keyof State, unknown> = {}> = {
+  version: number;
+} & ({
+  loaded: false;
+} | ({
+  loaded: true;
+} & State));
+/**
+ * @internal
+ * Constructor signature that the SDK uses to instantiate a plugin.
+ *
+ * @typeParam TState  - Plugin-specific state shape.
+ * @typeParam TPlugin - Concrete plugin type produced by the constructor.
+ **/
+type IOnchainSDKPluginConstructor<TState extends Record<keyof TState, unknown>, TPlugin extends IOnchainSDKPlugin<TState>> = new (sdk: OnchainSDK<any>) => TPlugin;
+/**
+ * Public contract every SDK plugin must satisfy.
+ *
+ * Plugins extend the SDK with domain-specific data and behaviour
+ * (e.g. farming rewards, zapper helpers). They participate in the
+ * SDK lifecycle: attach, hydrate, sync, and on-demand load.
+ *
+ * @typeParam TState - Plugin-specific state shape.
+ **/
+interface IOnchainSDKPlugin<TState extends Record<keyof TState, unknown> = {}> {
+  /**
+   * Reference to the parent SDK instance.
+   * Set automatically by the SDK constructor.
+   **/
+  sdk: OnchainSDK<any>;
+  /**
+   * Plugin version, used to verify state compatibility during hydration.
+   **/
+  version: number;
+  /**
+   * Whether the plugin's state is ready to use.
+   * `true` regardless of how the state was obtained (attach, hydrate, or on-demand load).
+   **/
+  loaded: boolean;
+  /**
+   * Plugin state, can be hydrated later.
+   **/
+  state: TState;
+  /**
+   * Loads state on demand.
+   * If already loaded, returns the existing state unless `force` is `true`.
+   *
+   * @param force - Re-fetch even if state is already loaded.
+   * @returns The loaded plugin state.
+   **/
+  load?: (force?: boolean) => Promise<TState>;
+  /**
+   * Called after SDK is attached to the chain.
+   * Plugins are not required to implement this — a plugin can be stateless
+   * or load state on demand only.
+   **/
+  attach?: () => Promise<void>;
+  /**
+   * Restores plugin state from a previously saved snapshot.
+   *
+   * @param state - state to restore from.
+   **/
+  hydrate?: (state: TState) => void;
+  /**
+   * Hook to sync plugin state after sdk state is synced.
+   * Called after SDK state is already synced, meaning that block number
+   * and timestamp are accessible from the SDK.
+   **/
+  syncState?: () => Promise<void>;
+  /**
+   * Factory hook called by the SDK to create auxiliary contracts.
+   * If not implemented, the SDK falls back to generic {@link BaseContract}
+   * instances.
+   *
+   * @param params - On-chain identification parameters for the contract.
+   * @returns A contract instance, or `undefined` to let the SDK use the default.
+   **/
+  createContract?: (params: BaseState) => IBaseContract | undefined;
+  /**
+   * Human-readable state snapshot for diagnostics.
+   *
+   * @param raw - When `true`, include raw numeric values alongside formatted ones
+   *   (e.g. `1 ETH (1000000000000000000)`).
+   * @returns An untyped object suitable for logging or inspection.
+   **/
+  stateHuman?: (raw?: boolean) => unknown;
+}
+/**
+ * Helper type that extracts the state type from a plugin instance.
+ **/
+type PluginState<T> = T extends IOnchainSDKPlugin<infer TState> ? IPluginState<TState> : never;
+/**
+ * @internal
+ * Mapping between plugin name and plugin instance.
+ **/
+type PluginsMap = Record<string, IOnchainSDKPlugin<any>>;
+/**
+ * @internal
+ * Mapping that infers plugin states from plugin instances.
+ **/
+type PluginStatesMap<T extends PluginsMap> = { [K in keyof T]: PluginState<T[K]>; };
+/**
+ * Factory function that produces a plugin instance.
+ **/
+type PluginFactory<P extends IOnchainSDKPlugin> = () => P;
+/**
+ * Map of plugin factories keyed by plugin name.
+ **/
+type PluginFactoriesMap<Plugins extends PluginsMap> = { [K in keyof Plugins]: PluginFactory<Plugins[K]>; };
+//#endregion
+export { IOnchainSDKPlugin, IOnchainSDKPluginConstructor, IPluginState, PluginFactoriesMap, PluginFactory, PluginState, PluginStatesMap, PluginsMap };

package/dist/types/onchain/pools/PoolService.d.ts

@@ -0,0 +1,78 @@
+import { PoolPosition } from "../../model/positions.js";
+import "../../model/index.js";
+import { IPoolContract } from "../market/pool/types.js";
+import "../market/index.js";
+import { AddLiquidityProps, DepositMetadata, IPoolsService, ListPoolPositionsProps, PoolServiceCallResult, PoolSimulation, RemoveLiquidityProps, SimulatePoolOperationProps, WithdrawalMetadata } from "./types.js";
+import { SDKConstruct } from "../base/SDKConstruct.js";
+import "../base/index.js";
+import { Address } from "viem";
+//#region src/onchain/pools/PoolService.d.ts
+declare class PoolService extends SDKConstruct implements IPoolsService {
+  #private;
+  /**
+   * {@inheritDoc IPoolsService.getDepositTokensIn}
+   */
+  getDepositTokensIn(pool: Address): Address[];
+  /**
+   * {@inheritDoc IPoolsService.getDepositTokensOut}
+   */
+  getDepositTokensOut(pool: Address, tokenIn: Address): Address[];
+  /**
+   * {@inheritDoc IPoolsService.getDepositMetadata}
+   */
+  getDepositMetadata(pool: Address, tokenIn: Address, tokenOut?: Address): DepositMetadata;
+  /**
+   * {@inheritDoc IPoolsService.addLiquidity}
+   */
+  addLiquidity(props: AddLiquidityProps): PoolServiceCallResult | undefined;
+  /**
+   * {@inheritDoc IPoolsService.getWithdrawalTokensIn}
+   */
+  getWithdrawalTokensIn(pool: Address): Address[];
+  /**
+   * {@inheritDoc IPoolsService.getWithdrawalTokensOut}
+   */
+  getWithdrawalTokensOut(pool: Address, tokenIn: Address): Address[];
+  /**
+   * {@inheritDoc IPoolsService.simulateDeposit}
+   */
+  simulateDeposit(props: SimulatePoolOperationProps): PoolSimulation;
+  /**
+   * {@inheritDoc IPoolsService.simulateWithdraw}
+   */
+  simulateWithdraw(props: SimulatePoolOperationProps): PoolSimulation;
+  /**
+   * {@inheritDoc IPoolsService.simulateRedeem}
+   */
+  simulateRedeem(props: SimulatePoolOperationProps): PoolSimulation;
+  /**
+   * {@inheritDoc IPoolsService.removeLiquidity}
+   */
+  removeLiquidity(props: RemoveLiquidityProps): PoolServiceCallResult;
+  /**
+   * {@inheritDoc IPoolsService.getWithdrawalMetadata}
+   */
+  getWithdrawalMetadata(pool: Address, tokenIn: Address, tokenOut?: Address): WithdrawalMetadata;
+  /**
+   * {@inheritDoc IPoolsService.listPositions}
+   */
+  listPositions(props: ListPoolPositionsProps): Promise<PoolPosition[]>;
+}
+/**
+ * Shares minted for `assets`, as `previewDeposit` would report them.
+ *
+ * Both directions convert through the diesel rate — underlying per RAY of
+ * shares — because that is the rate the pool itself divides by, and the only
+ * exact one the SDK holds: `totalAssets` is this rate multiplied out, so
+ * converting back through it costs a wei on large amounts. Rounds down, as
+ * minting does.
+ */
+declare function toShares(pool: IPoolContract, assets: bigint): bigint;
+/**
+ * Shares a withdrawal of `assets` burns, as `previewWithdraw` would report
+ * them: {@link toShares} rounded the other way, since the burn has to cover
+ * the payout the caller asked for.
+ */
+declare function toSharesUp(pool: IPoolContract, assets: bigint): bigint;
+//#endregion
+export { PoolService, toShares, toSharesUp };

package/dist/types/onchain/pools/types.d.ts

@@ -0,0 +1,282 @@
+import { PoolPosition } from "../../model/positions.js";
+import "../../model/index.js";
+import { Asset, PermitResult } from "../base/types.js";
+import { IZapperContract } from "../market/zapper/types.js";
+import "../market/index.js";
+import { MultiCall, RawTx } from "../types/transactions.js";
+import "../base/index.js";
+import { Abi, Address, ContractFunctionArgs, ContractFunctionName } from "viem";
+//#region src/onchain/pools/types.d.ts
+type PoolServiceCall<abi extends Abi | readonly unknown[] = Abi, functionName extends ContractFunctionName<abi, "nonpayable" | "payable"> = ContractFunctionName<abi, "nonpayable" | "payable">, args extends ContractFunctionArgs<abi, "nonpayable" | "payable", functionName> = ContractFunctionArgs<abi, "nonpayable" | "payable", functionName>> = {
+  abi: abi;
+  functionName: functionName;
+  args: args;
+  target: Address;
+  value?: bigint;
+};
+interface PoolServiceCallResult {
+  tx: RawTx;
+  calls: Array<MultiCall>;
+}
+interface AddLiquidityProps {
+  /**
+   * Token and amount to deposit.
+   **/
+  collateral: Asset;
+  /**
+   * Address of the Gearbox lending pool.
+   **/
+  pool: Address;
+  wallet: Address;
+  meta: DepositMetadata;
+  permit?: PermitResult;
+  referralCode?: bigint;
+}
+/**
+ * Parameters for withdrawing liquidity from a Gearbox lending pool.
+ *
+ * A direct withdrawal goes to the pool itself; anything else is routed through
+ * a zapper that redeems the share-like token it minted.
+ **/
+interface RemoveLiquidityProps {
+  /**
+   * Address of the Gearbox lending pool.
+   **/
+  pool: Address;
+  /**
+   * Amount of underlying the wallet wants back, matching
+   * {@link PoolSimulation.tokenOut} when {@link RemoveLiquidityProps.mode} is
+   * `"withdraw"`. Amount of pool shares to burn when `mode` is `"redeem"`.
+   **/
+  amount: bigint;
+  wallet: Address;
+  permit: PermitResult | undefined;
+  meta: WithdrawalMetadata;
+  /**
+   * `withdraw` calls the pool's ERC-4626 `withdraw(assets, …)`; `redeem` calls
+   * `redeem(shares, …)` or the zapper's redeem with shares directly.
+   *
+   * @default "withdraw"
+   **/
+  mode?: "withdraw" | "redeem";
+}
+type MarketType = "rwa-on-demand" | "rwa-default" | "classic";
+interface DepositMetadata {
+  /**
+   * Zapper that will perform the deposit, undefined in case of direct pool underlying deposit
+   */
+  zapper?: IZapperContract;
+  /**
+   * Before deposit user will nedd to call approve method on token that he wants to deposit,
+   * this is the spender address that will be used to call approve method.
+   */
+  approveTarget: Address;
+  /**
+   * If true, user can avoid approval step and deposit with permit
+   */
+  permissible: boolean;
+  /**
+   * Type of deposit
+   * @default "classic"
+   */
+  type?: MarketType;
+}
+interface WithdrawalMetadata {
+  /**
+   * Zapper that will perform the withdrawal, undefined in case of direct pool underlying withdrawal
+   */
+  zapper?: IZapperContract;
+  /**
+   * Before withdrawal user will need to call approve method on token that he wants to withdraw (diesel token),
+   * this is the spender address that will be used to call approve method.
+   */
+  approveTarget?: Address;
+  /**
+   * If true, user can avoid approval step and withdrawal with permit
+   */
+  permissible: boolean;
+  /**
+   * Type of withdrawal
+   * @default "classic"
+   */
+  type?: MarketType;
+}
+/**
+ * Props shared by {@link IPoolsService.simulateDeposit},
+ * {@link IPoolsService.simulateWithdraw}, and
+ * {@link IPoolsService.simulateRedeem}.
+ **/
+interface SimulatePoolOperationProps {
+  /**
+   * Address of the Gearbox lending pool.
+   **/
+  pool: Address;
+  /**
+   * Operation amount. Means `tokenIn` on deposit and redeem, `tokenOut` on
+   * withdraw — see each method's docs.
+   **/
+  amount: bigint;
+  /**
+   * Token the user parts with. Defaults to the pool underlying for deposits and
+   * to the pool shares (diesel token) for withdrawals.
+   **/
+  tokenIn?: Address;
+  /**
+   * Token the user receives. Defaults to the only route available for `tokenIn`;
+   * required when several routes exist.
+   **/
+  tokenOut?: Address;
+}
+/**
+ * Both sides of a simulated pool operation, converted at the pool's current
+ * share rate.
+ **/
+interface PoolSimulation {
+  /**
+   * Token and amount leaving the wallet — exactly what was asked for.
+   **/
+  tokenIn: Asset;
+  /**
+   * Token and amount arriving in the wallet at the rate the pool state implies.
+   **/
+  tokenOut: Asset;
+  /**
+   * Zapper the operation would be routed through; unset for direct pool
+   * operations.
+   **/
+  zapper?: Address;
+  /**
+   * Withdrawals only: underlying the pool can actually pay out right now,
+   * shaved by a hair so a withdrawal sized against it does not fail on rounding.
+   *
+   * The conversion is a rate, not a promise that the pool is liquid enough, so
+   * compare `tokenOut.balance` against this to see if the withdrawal fits.
+   **/
+  availableLiquidity?: bigint;
+}
+/**
+ * Props for {@link IPoolsService.listPositions}.
+ **/
+interface ListPoolPositionsProps {
+  /**
+   * Wallet whose pool shares to describe.
+   **/
+  wallet: Address;
+  /**
+   * Block to read at. Defaults to the latest block.
+   **/
+  blockNumber?: bigint;
+}
+/**
+ * Service interface for pool liquidity operations.
+ **/
+interface IPoolsService {
+  /**
+   * Lists all pool positions a wallet holds.
+   *
+   * @param props - {@link ListPoolPositionsProps}
+   **/
+  listPositions(props: ListPoolPositionsProps): Promise<PoolPosition[]>;
+  /**
+   * Returns list of tokens that can be deposited to a pool
+   * @param pool
+   */
+  getDepositTokensIn(pool: Address): Address[];
+  /**
+   * Returns list of tokens that user can receive after depositing to a pool,
+   * depends on the pool type and the token being deposited (one of returned by {@link getDepositTokensIn}).
+   *
+   * Can return empty array if no tokens can be received (e.g. for RWA underlying on demand)
+   *
+   * @param pool
+   * @param tokenIn
+   */
+  getDepositTokensOut(pool: Address, tokenIn: Address): Address[];
+  /**
+   * After user chooses tokenIn from {@link getDepositTokensIn} and tokenOut from {@link getDepositTokensOut},
+   * this method returns metadata that will be used to perform the deposit.
+   *
+   * @param pool
+   * @param tokenIn
+   * @param tokenOut can be undefined if deposit is not resulting in a token out (e.g. for RWA underlying on demand)
+   */
+  getDepositMetadata(pool: Address, tokenIn: Address, tokenOut?: Address): DepositMetadata;
+  /**
+   * Returns a list of tokens that can be redeemed from a pool
+   * @param pool
+   */
+  getWithdrawalTokensIn(pool: Address): Address[];
+  /**
+   * Returns a list of tokens that can be received after redeeming from a pool
+   * @param pool
+   * @param tokenIn token that will be redeemed from the pool
+   */
+  getWithdrawalTokensOut(pool: Address, tokenIn: Address): Address[];
+  /**
+   * After user chooses tokenIn from {@link getWithdrawalTokensIn} and tokenOut from {@link getWithdrawalTokensOut},
+   * this method returns metadata that will be used to perform the withdrawal.
+   * @param pool
+   * @param tokenIn
+   * @param tokenOut
+   */
+  getWithdrawalMetadata(pool: Address, tokenIn: Address, tokenOut?: Address): WithdrawalMetadata;
+  /**
+   * Simulates a deposit and reports what the wallet would receive.
+   *
+   * The ERC-4626 conversion of the pool, computed from the state the SDK already
+   * holds rather than read back from the chain, so the answer is synchronous and
+   * as fresh as the loaded market. Nothing is executed, so balances and
+   * allowances are irrelevant.
+   *
+   * A zapper leg converts one-for-one — every zapper wraps rather than trades —
+   * so a routed deposit reports the same amount as a direct one.
+   *
+   * @param props - {@link SimulatePoolOperationProps}
+   * @returns {@link PoolSimulation}
+   * @throws If the token pair has no route, or if `tokenOut` is omitted while
+   * several routes exist (RWA on-demand markets have no rate at all).
+   **/
+  simulateDeposit(props: SimulatePoolOperationProps): PoolSimulation;
+  /**
+   * Simulates a withdrawal and reports what the wallet would receive.
+   *
+   * The mirror of {@link simulateDeposit}: `amount` is the underlying the
+   * wallet wants back, and the result is the shares it costs at the pool's
+   * current rate.
+   *
+   * @param props - {@link SimulatePoolOperationProps}
+   * @returns {@link PoolSimulation}
+   * @throws If the token pair has no route, or if `tokenOut` is omitted while
+   * several routes exist.
+   **/
+  simulateWithdraw(props: SimulatePoolOperationProps): PoolSimulation;
+  /**
+   * Simulates a redemption and reports what the wallet would receive.
+   *
+   * The ERC-4626 `previewRedeem` mirror: `amount` is the shares to burn, and
+   * the result is the underlying they convert to, less the pool's withdrawal
+   * fee.
+   *
+   * @param props - {@link SimulatePoolOperationProps}
+   * @returns {@link PoolSimulation}
+   * @throws If the token pair has no route, or if `tokenOut` is omitted while
+   * several routes exist.
+   **/
+  simulateRedeem(props: SimulatePoolOperationProps): PoolSimulation;
+  /**
+   * Returns contract call parameters for adding liquidity to a pool
+   * Or undefined if no deposit action is required (e.g. for RWA underlying on demand)
+   * @param props - {@link AddLiquidityProps}
+   * @returns - {@link AddLiquidityCall}
+   */
+  addLiquidity(props: AddLiquidityProps): PoolServiceCallResult | undefined;
+  /**
+   * Construct a call to remove liquidity from a Gearbox lending pool.
+   *
+   * @param props - {@link RemoveLiquidityProps}
+   * @returns - {@link RemoveLiquidityCall}
+   */
+  removeLiquidity(props: RemoveLiquidityProps): PoolServiceCallResult;
+}
+//#endregion
+export { AddLiquidityProps, DepositMetadata, IPoolsService, ListPoolPositionsProps, MarketType, PoolServiceCall, PoolServiceCallResult, PoolSimulation, RemoveLiquidityProps, SimulatePoolOperationProps, WithdrawalMetadata };

package/dist/types/onchain/positions/MultichainPositionsService.d.ts

@@ -0,0 +1,23 @@
+import { Position } from "../../model/positions.js";
+import { DataResponse } from "../../model/response.js";
+import "../../model/index.js";
+import { PluginsMap } from "../plugins/types.js";
+import "../plugins/index.js";
+import { IMultichainPositionsService, ListPositionsProps } from "./types.js";
+import { MultichainConstruct } from "../base/MultichainConstruct.js";
+import "../base/index.js";
+//#region src/onchain/positions/MultichainPositionsService.d.ts
+/**
+ * Cross-chain counterpart of {@link PositionsService}.
+ *
+ * @typeParam Plugins - Map of attached plugin types.
+ **/
+declare class MultichainPositionsService<const Plugins extends PluginsMap = {}> extends MultichainConstruct<Plugins> implements IMultichainPositionsService {
+  /**
+   * Positions of a wallet on all queried chains, see
+   * {@link PositionsService.list}.
+   **/
+  list(props: ListPositionsProps<true>): Promise<DataResponse<Position[]>>;
+}
+//#endregion
+export { MultichainPositionsService };

package/dist/types/onchain/positions/PositionsService.d.ts

@@ -0,0 +1,72 @@
+import { Bps } from "../../model/primitives.js";
+import { BorrowRateBreakdown, Position, StrategyPosition } from "../../model/positions.js";
+import "../../model/index.js";
+import { AccountSnapshot, ListPositionsProps, ListStrategyPositionsProps } from "./types.js";
+import { SDKConstruct } from "../base/SDKConstruct.js";
+import "../base/index.js";
+//#region src/onchain/positions/PositionsService.d.ts
+/**
+ * Options of the projection-aware position metrics: {@link PositionsService.borrowRate}
+ * and {@link PositionsService.timeToLiquidation}.
+ **/
+interface ProjectedPoolOptions {
+  /**
+   * Change the operation makes to the pool's available liquidity, in
+   * underlying units: `oldDebt − newDebt`. Negative when the operation borrows
+   * more (liquidity leaves the pool, utilization and the base rate rise),
+   * positive when it repays. When set, the base borrow rate is re-quoted from
+   * the interest rate model at the projected utilization instead of the pool's
+   * current rate.
+   **/
+  availableLiquidityChange?: bigint;
+}
+/**
+ * The `positions` read model of one chain: everything a wallet holds in the
+ * protocol — pool shares, open credit accounts, and delayed withdrawals it
+ * took over by liquidating.
+ **/
+declare class PositionsService extends SDKConstruct {
+  #private;
+  /**
+   * Every position of a wallet on this chain, optionally narrowed by
+   * {@link PositionFilter} (see {@link matchesPositionFilter} for what each
+   * condition selects). Reads live chain state, so rows reflect the moment of
+   * the call rather than the SDK's loaded snapshot.
+   **/
+  list(props: ListPositionsProps): Promise<Position[]>;
+  /**
+   * Describes all credit accounts of a wallet as strategy positions.
+   *
+   * @param props - {@link ListStrategyPositionsProps}
+   **/
+  listStrategyPositions(props: ListStrategyPositionsProps): Promise<StrategyPosition[]>;
+  /**
+   * Health factor of an account state, in basis points (`10000` = 1.0).
+   **/
+  healthFactor(snapshot: AccountSnapshot, options?: {
+    safePrices?: boolean;
+  }): Bps;
+  /**
+   * Cost of an account state's debt, broken down into the pool's base rate
+   * and per-token quota rates. A projection passes the operation's liquidity
+   * delta via {@link ProjectedPoolOptions} to have the base rate re-quoted at
+   * the post-operation pool utilization.
+   **/
+  borrowRate(snapshot: AccountSnapshot, options?: ProjectedPoolOptions): BorrowRateBreakdown;
+  /**
+   * Estimated milliseconds until the account's health factor decays to
+   * `10000` under its current borrow rate, or `null` when the debt carries
+   * no rate (or the account is already liquidatable). Takes the same
+   * projection options as {@link PositionsService.borrowRate}, so a projected
+   * state decays at the projected rate.
+   **/
+  timeToLiquidation(snapshot: AccountSnapshot, options?: ProjectedPoolOptions): bigint | null;
+  /**
+   * Price of the single non-underlying collateral at which the account
+   * becomes liquidatable, or `null` when the account holds zero or several
+   * non-underlying assets.
+   **/
+  liquidationPrice(snapshot: AccountSnapshot): bigint | null;
+}
+//#endregion
+export { PositionsService, ProjectedPoolOptions };

package/dist/types/onchain/positions/calcBorrowRate.d.ts

@@ -0,0 +1,46 @@
+import { Bps, Token } from "../../model/primitives.js";
+import { BorrowRateBreakdown } from "../../model/positions.js";
+import "../../model/index.js";
+import { AccountSnapshot } from "./types.js";
+import { Address } from "viem";
+//#region src/onchain/positions/calcBorrowRate.d.ts
+/**
+ * Inputs of {@link calcBorrowRate}.
+ **/
+interface CalcBorrowRateProps {
+  snapshot: AccountSnapshot;
+  /**
+   * Pool base interest rate in ray — the pool's current one, or the rate the
+   * interest model quotes at a projected utilization.
+   **/
+  baseInterestRate: bigint;
+  /**
+   * Credit manager interest fee in basis points.
+   **/
+  feeInterest: number;
+  /**
+   * Active quota rates in basis points. Missing keys are treated as inactive
+   * (zero contribution), but a per-token entry is still reported.
+   **/
+  quotaRates: Record<Address, Bps>;
+  /**
+   * Resolves full token metadata for a quota token address.
+   **/
+  resolveToken: (address: Address) => Token;
+}
+/**
+ * Cost of an account state's debt, broken down into the pool's base rate and
+ * per-token quota rates.
+ *
+ * The base rate is the market's borrow APY: whatever `baseInterestRate` the
+ * caller hands over, plus the credit manager's interest fee — the same value
+ * `borrowApy` reports on a position, and the same arithmetic when a projection
+ * hands over the rate its post-operation utilization implies. Quota
+ * contributions are `quotaBalance * quotaRate` with the interest fee on top,
+ * normalized against the total value (`total`, `quotas`) and against the
+ * debt (`totalOnDebt`, the rate the debt itself grows at). Formulas are in
+ * parity with the frontend's `BorrowRateUtils`.
+ **/
+declare function calcBorrowRate(props: CalcBorrowRateProps): BorrowRateBreakdown;
+//#endregion
+export { CalcBorrowRateProps, calcBorrowRate };

package/dist/types/onchain/positions/calcHealthFactor.d.ts

@@ -0,0 +1,55 @@
+import { Bps } from "../../model/primitives.js";
+import "../../model/index.js";
+import { AccountSnapshot } from "./types.js";
+import { Address } from "viem";
+//#region src/onchain/positions/calcHealthFactor.d.ts
+/**
+ * Inputs of {@link calcHealthFactor}.
+ **/
+interface CalcHealthFactorProps {
+  snapshot: AccountSnapshot;
+  /**
+   * Market underlying. Debt and quota balances are valued in this token.
+   **/
+  underlying: Address;
+  /**
+   * Token decimals. Missing keys default to 18.
+   **/
+  decimals: Record<Address, number>;
+  /**
+   * Oracle main-feed prices in 8-decimal (`PRICE_DECIMALS`) fixed point. A
+   * missing key is an unpriceable token and contributes nothing.
+   **/
+  prices: Record<Address, bigint>;
+  /**
+   * Oracle reserve-feed prices, when available. Used with {@link safePrices}
+   * to value collateral at the lower of the two feeds.
+   **/
+  reservePrices?: Record<Address, bigint>;
+  /**
+   * Value collateral at safe prices — the lower of each token's main and
+   * reserve feeds. Debt and quota balances always use the main feed.
+   **/
+  safePrices?: boolean;
+  /**
+   * Liquidation thresholds in basis points. Missing keys are treated as 0.
+   **/
+  liquidationThresholds: Record<Address, Bps>;
+  /**
+   * Whether each token's quota is currently active. Missing keys are inactive.
+   **/
+  activeQuotas: Record<Address, boolean>;
+}
+/**
+ * Health factor of an account state, in basis points (`10000` = 1.0).
+ *
+ * Collateral is valued under liquidation thresholds, with quoted tokens
+ * capped by their quota, and compared against the debt's value. An account
+ * with no debt reports `65535` (`MAX_UINT16`), the contract's own sentinel
+ * scaled down. Formulas are in parity with the legacy `calcHealthFactor`.
+ * Tokens with no price in {@link CalcHealthFactorProps.prices} contribute
+ * nothing.
+ **/
+declare function calcHealthFactor(props: CalcHealthFactorProps): Bps;
+//#endregion
+export { CalcHealthFactorProps, calcHealthFactor };