@gearbox-protocol/sdk 13.3.3 → 13.4.0-beta.2

package/dist/types/sdk/accounts/types.d.ts

@@ -3,55 +3,154 @@ import type { creditAccountCompressorAbi } from "../../abi/compressors/creditAcc
 import type { iWithdrawalCompressorV310Abi } from "../../abi/IWithdrawalCompressorV310.js";
 import type { ConnectedBotData, Construct, CreditAccountData } from "../base/index.js";
 import type { GearboxSDK } from "../GearboxSDK.js";
-import type { CreditSuite, OnDemandPriceUpdates, UpdatePriceFeedsResult } from "../market/index.js";
-import type { Asset, CreditAccountTokensSlice, RouterCASlice, RouterCloseResult } from "../router/index.js";
+import type { CreditSuite, PriceUpdate } from "../market/index.js";
+import type { Asset, RouterCASlice, RouterCloseResult } from "../router/index.js";
 import type { MultiCall, RawTx } from "../types/index.js";
+/**
+ * @internal
+ * Arguments tuple for the credit account compressor's `getCreditAccounts` view method.
+ **/
 export type GetCreditAccountsArgs = ContractFunctionArgs<typeof creditAccountCompressorAbi, "pure" | "view", "getCreditAccounts">;
+/**
+ * @internal
+ * Filtering criteria applied to individual credit accounts when querying the compressor.
+ **/
 export interface CreditAccountFilter {
+    /**
+     * Filter by account owner address.
+     **/
     owner: Address;
+    /**
+     * Whether to include accounts with zero outstanding debt.
+     **/
     includeZeroDebt: boolean;
+    /**
+     * Minimum health factor threshold (inclusive).
+     * 18 digits precision (10^18 = 1)
+     **/
     minHealthFactor: bigint;
+    /**
+     * Maximum health factor threshold (inclusive).
+     * 18 digits precision (10^18 = 1)
+     **/
     maxHealthFactor: bigint;
+    /**
+     * Whether to return only accounts whose health computation reverts.
+     **/
     reverting: boolean;
 }
+/**
+ * @internal
+ * Filtering criteria to select which credit managers to query.
+ **/
 export interface CreditManagerFilter {
+    /**
+     * Only include credit managers owned by these market configurators.
+     **/
     configurators: readonly Address[];
+    /**
+     * Only include these specific credit manager addresses.
+     **/
     creditManagers: readonly Address[];
+    /**
+     * Only include credit managers linked to these pool addresses.
+     **/
     pools: readonly Address[];
+    /**
+     * Only include credit managers with this underlying token.
+     **/
     underlying: Address;
 }
+/**
+ * Options for fetching credit accounts, allowing filtering by credit manager, owner, and health factor range.
+ **/
 export interface GetCreditAccountsOptions {
+    /**
+     * If set, only return accounts from this credit manager; otherwise query all attached markets.
+     **/
     creditManager?: Address;
+    /**
+     * If set, only return accounts owned by this address.
+     **/
     owner?: Address;
+    /**
+     * Whether to include accounts with zero outstanding debt.
+     * @default false
+     **/
     includeZeroDebt?: boolean;
+    /**
+     * Minimum health factor threshold (inclusive).
+     * 18 digits precision (10^18 = 1)
+     * @default 0n
+     **/
     minHealthFactor?: bigint;
+    /**
+     * Maximum health factor threshold (inclusive).
+     * 18 digits precision (10^18 = 1)
+     * @default MAX_UINT256
+     **/
     maxHealthFactor?: bigint;
     /**
-     * If true, will filter out reserve price updates
-     */
-    ignoreReservePrices?: boolean;
-}
-export interface PriceUpdatesOptions {
-    creditManager: Address;
-    creditAccount?: CreditAccountTokensSlice;
-    desiredQuotas?: Asset[];
+     * If true, exclude reserve price feed updates from the query.
+     **/
     ignoreReservePrices?: boolean;
 }
+/**
+ * Lightweight slice of credit-account data containing only token
+ * balances and the enabled-tokens bitmask.
+ **/
+export type CreditAccountTokensSlice = Pick<CreditAccountData, "creditManager" | "creditAccount" | "tokens" | "enabledTokensMask">;
+/**
+ * Result of closing or liquidating a credit account, including the router's optimal close path.
+ **/
 export interface CloseCreditAccountResult extends CreditAccountOperationResult {
+    /**
+     * Router result describing the swap path used to convert account tokens into the underlying.
+     **/
     routerCloseResult: RouterCloseResult;
 }
+/**
+ * Result of a full liquidation, extending the close result with optional loss policy data.
+ **/
 export interface FullyLiquidateResult extends CloseCreditAccountResult {
+    /**
+     * Encoded loss policy data submitted with the liquidation, if a loss policy was applied.
+     **/
     lossPolicyData?: Hex;
 }
+/**
+ * Result of a credit account operation, containing everything needed to execute the transaction.
+ **/
 export interface CreditAccountOperationResult {
+    /**
+     * Raw transaction data ready to be signed and submitted.
+     **/
     tx: RawTx;
+    /**
+     * Ordered multicall entries that make up the operation.
+     **/
     calls: Array<MultiCall>;
+    /**
+     * Credit facade contract used for the operation.
+     **/
     creditFacade: CreditSuite["creditFacade"];
 }
+/**
+ * Lightweight operation result without a raw transaction, containing only multicall data.
+ **/
 export interface CreditManagerOperationResult {
+    /**
+     * Ordered multicall entries that make up the operation.
+     **/
     calls: Array<MultiCall>;
+    /**
+     * Credit facade contract used for the operation.
+     **/
     creditFacade: CreditSuite["creditFacade"];
 }
+/**
+ * Close operation type: `"close"` fully closes the account, `"zeroDebt"` repays all debt but keeps the account open.
+ **/
 export type CloseOptions = "close" | "zeroDebt";
 export interface CloseCreditAccountProps {
     /**
@@ -90,10 +189,10 @@ export interface RepayCreditAccountProps extends RepayAndLiquidateCreditAccountP
 }
 export interface RepayAndLiquidateCreditAccountProps {
     /**
-     * tokens to repay dept.
-        In the current implementation, this is the (debt+interest+fess) * buffer,
-        where buffer refers to amount of tokens which will exceed current debt
-        in order to cover possible debt increase over tx execution
+     * Tokens to repay debt.
+     * In the current implementation, this is the (debt+interest+fees) * buffer,
+     * where buffer refers to amount of tokens which will exceed current debt
+     * in order to cover possible debt increase over tx execution.
      */
     collateralAssets: Array<Asset>;
     /**
@@ -103,7 +202,7 @@ export interface RepayAndLiquidateCreditAccountProps {
      */
     assetsToWithdraw: Array<Asset>;
     /**
-     * minimal credit account data on which operation is performed on which operation is performed
+     * Minimal credit account data on which operation is performed.
      */
     creditAccount: RouterCASlice;
     /**
@@ -111,7 +210,7 @@ export interface RepayAndLiquidateCreditAccountProps {
      */
     to: Address;
     /**
-     * permits of tokens to withdraw (in any permittable token is present)
+     * Permits of tokens to withdraw (if any permittable token is present).
      */
     permits: Record<string, PermitResult>;
     tokensToClaim: Asset[];
@@ -164,8 +263,17 @@ export interface WithdrawCollateralProps extends PrepareUpdateQuotasProps {
      */
     creditAccount: RouterCASlice;
 }
+/**
+ * Credit account and credit manager address pair, used for batch queries such as connected bot lookups.
+ **/
 export type AccountToCheck = {
+    /**
+     * Address of the credit account.
+     **/
     creditAccount: Address;
+    /**
+     * Address of the credit manager that manages this account.
+     **/
     creditManager: Address;
 };
 export interface ExecuteSwapProps extends PrepareUpdateQuotasProps {
@@ -199,12 +307,30 @@ export interface GetPendingWithdrawalsProps {
     creditAccount: Address;
 }
 type WithdrawalCompressorV310InstanceType = GetContractReturnType<typeof iWithdrawalCompressorV310Abi, PublicClient>;
+/**
+ * Result of previewing a delayed withdrawal request, as returned by the withdrawal compressor.
+ **/
 export type PreviewDelayedWithdrawalResult = Awaited<ReturnType<WithdrawalCompressorV310InstanceType["read"]["getWithdrawalRequestResult"]>>;
 type PendingWithdrawalResult = Awaited<ReturnType<WithdrawalCompressorV310InstanceType["read"]["getCurrentWithdrawals"]>>;
+/**
+ * A single pending delayed withdrawal that is not yet claimable.
+ **/
 export type PendingWithdrawal = PendingWithdrawalResult[1][number];
+/**
+ * A single delayed withdrawal that is ready to be claimed.
+ **/
 export type ClaimableWithdrawal = PendingWithdrawalResult[0][number];
+/**
+ * Aggregated delayed withdrawal status, split into immediately claimable and still-pending entries.
+ **/
 export interface GetPendingWithdrawalsResult {
+    /**
+     * Withdrawals that have matured and can be claimed now.
+     **/
     claimableNow: Array<ClaimableWithdrawal>;
+    /**
+     * Withdrawals that are still in their delay period.
+     **/
     pending: Array<PendingWithdrawal>;
 }
 export interface StartDelayedWithdrawalProps extends PrepareUpdateQuotasProps {
@@ -330,25 +456,70 @@ export interface FullyLiquidateProps {
      */
     applyLossPolicy?: boolean;
     /**
-     * Debt only mode - will try to sell just enought of most valuable token to cover debt
+     * Debt only mode — will try to sell just enough of the most valuable token to cover debt.
      */
     debtOnly?: boolean;
 }
+/**
+ * EIP-2612 permit signature data for a token, enabling gasless approval for credit account operations.
+ **/
 export interface PermitResult {
+    /**
+     * ECDSA signature `r` component.
+     **/
     r: Address;
+    /**
+     * ECDSA signature `s` component.
+     **/
     s: Address;
+    /**
+     * ECDSA signature `v` component.
+     **/
     v: number;
+    /**
+     * Token address the permit is for.
+     **/
     token: Address;
+    /**
+     * Address of the token holder granting the permit.
+     **/
     owner: Address;
+    /**
+     * Address authorized to spend the tokens.
+     **/
     spender: Address;
+    /**
+     * Amount of tokens approved.
+     **/
     value: bigint;
+    /**
+     * Timestamp after which the permit expires.
+     **/
     deadline: bigint;
+    /**
+     * Owner's current permit nonce.
+     **/
     nonce: bigint;
 }
+/**
+ * Claimable reward tokens associated with a single staking adapter and phantom token pair.
+ **/
 export interface Rewards {
+    /**
+     * Address of the reward pool adapter on the credit account.
+     **/
     adapter: Address;
+    /**
+     * Address of the staked phantom token representing the staking position.
+     **/
     stakedPhantomToken: Address;
+    /**
+     * Multicall entries to claim these rewards.
+     **/
     calls: Array<MultiCall>;
+    /**
+     * List of reward token amounts claimable from this adapter.
+     **/
     rewards: Array<Asset>;
 }
 interface CMSlice {
@@ -374,6 +545,9 @@ export interface SetBotProps {
         type: "creditAccount";
     }) | CMSlice;
 }
+/**
+ * Multicall result of querying connected bots across multiple credit accounts.
+ **/
 export type GetConnectedBotsResult = Array<{
     error?: undefined;
     result: readonly ConnectedBotData[];
@@ -383,6 +557,9 @@ export type GetConnectedBotsResult = Array<{
     result?: undefined;
     status: "failure";
 }>;
+/**
+ * Result of querying a migration bot's status across credit accounts, or `undefined` if no migration bot was provided.
+ **/
 export type GetConnectedMigrationBotsResult = {
     result: ({
         error: Error;
@@ -395,17 +572,26 @@ export type GetConnectedMigrationBotsResult = {
     })[];
     botAddress: Address;
 } | undefined;
+/**
+ * Input for previewing a proportional Llamathena withdrawal.
+ **/
 export interface PreviewWithdrawLlamathenaProportionallyProps {
+    /**
+     * Llamathena token and amount to withdraw.
+     **/
     llamathena: Asset;
 }
+/**
+ * Result of a proportional Llamathena withdrawal preview.
+ **/
 export interface PreviewWithdrawLlamathenaProportionallyResult {
     /**
-     * Assets to get
-     */
+     * Underlying assets received from the withdrawal.
+     **/
     assets: [Asset];
     /**
-     * Llamathena asset
-     */
+     * Staked Llamathena token consumed.
+     **/
     stkLlamathena: [Asset];
 }
 export interface LlamathenaProportionalWithdrawProps extends PrepareUpdateQuotasProps {
@@ -414,7 +600,7 @@ export interface LlamathenaProportionalWithdrawProps extends PrepareUpdateQuotas
      */
     preview: PreviewWithdrawLlamathenaProportionallyResult;
     /**
-     * minimal credit account data on which operation is performed on which operation is performed
+     * Minimal credit account data on which operation is performed.
      */
     creditAccount: RouterCASlice;
 }
@@ -438,8 +624,8 @@ export interface ICreditAccountsService extends Construct {
      */
     getCreditAccounts(options?: GetCreditAccountsOptions, blockNumber?: bigint): Promise<Array<CreditAccountData>>;
     /**
-     * Method to get all claimable rewards for credit account (ex. stkUSDS SKY rewards)
-     * Assosiates rewards by adapter + stakedPhantomToken
+     * Method to get all claimable rewards for credit account (ex. stkUSDS SKY rewards).
+     * Associates rewards by adapter + stakedPhantomToken.
      * @param {Address} creditAccount - address of credit account to get rewards for
      * @returns {Array<Rewards>} list of {@link Rewards} that can be claimed
      */
@@ -471,7 +657,7 @@ export interface ICreditAccountsService extends Construct {
     /**
      * Closes credit account or closes credit account and keeps it open with zero debt.
      * - Ca is closed in the following order: price update -> close path to swap all tokens into underlying ->
-     * -> disable quotas of exiting tokens -> decrease debt -> disable exiting tokens tokens -> withdraw underlying tokenz
+     * -> disable quotas of exiting tokens -> decrease debt -> disable exiting tokens -> withdraw underlying tokens
      * @param props - {@link CloseCreditAccountProps}
      * @returns All necessary data to execute the transaction (call, credit facade)
      */
@@ -554,26 +740,37 @@ export interface ICreditAccountsService extends Construct {
      * @param ca
      */
     getOptimalHFForPartialLiquidation(ca: CreditAccountData): bigint;
-    /**
-     * Returns raw txs that are needed to update all price feeds so that all credit accounts (possibly from different markets) compute
-     *
-     * This can be used by batch liquidator
-     * @param accounts
-     * @returns
-     */
-    getUpdateForAccounts(accounts: Array<RouterCASlice>): Promise<UpdatePriceFeedsResult>;
     /**
      * Returns account price updates that can be used in credit facade multicall or liquidator calls
-     * @param options
-     * @returns
+     * @param account - Credit account to get price updates for
+     * @param ignoreReservePrices - If true, exclude reserve price feed updates
+     * @returns Array of price updates
      */
-    getOnDemandPriceUpdates(options: PriceUpdatesOptions): Promise<OnDemandPriceUpdates>;
+    getOnDemandPriceUpdates(account: CreditAccountTokensSlice, ignoreReservePrices?: boolean): Promise<PriceUpdate[]>;
     /**
-     * Returns price updates in format that is accepted by various credit facade methods (multicall, close/liquidate, etc...).
-     * @param options
-     * @returns
+     * Executes a multicall on a credit account, automatically prepending
+     * necessary on-demand price feed updates inferred from the calls array.
+     *
+     * @param creditAccount - Credit account to execute multicall on
+     * @param calls - Array of multicall operations (price updates will be inferred)
+     * @param options - Optional settings for price update generation
+     * @returns Raw transaction ready to be signed and sent
      */
-    getPriceUpdatesForFacade(options: PriceUpdatesOptions): Promise<Array<MultiCall>>;
+    multicall(creditAccount: RouterCASlice, calls: Array<MultiCall>, options?: {
+        ignoreReservePrices?: boolean;
+    }): Promise<RawTx>;
+    /**
+     * Executes a bot multicall on a credit account, automatically prepending
+     * necessary on-demand price feed updates inferred from the calls array.
+     *
+     * @param creditAccount - Credit account to execute bot multicall on
+     * @param calls - Array of multicall operations (price updates will be inferred)
+     * @param options - Optional settings for price update generation
+     * @returns Raw transaction ready to be signed and sent
+     */
+    botMulticall(creditAccount: RouterCASlice, calls: Array<MultiCall>, options?: {
+        ignoreReservePrices?: boolean;
+    }): Promise<RawTx>;
     /**
      * Withdraws a single collateral from credit account to wallet to and updates quotas;
      * technically can withdraw several tokens at once

package/dist/types/sdk/base/BaseContract.d.ts

@@ -3,37 +3,99 @@ import { BaseError } from "viem";
 import type { BaseContractStateHuman, RawTx } from "../types/index.js";
 import { Construct, type ConstructOptions } from "./Construct.js";
 import type { IBaseContract, ParsedCall, ParsedCallArgs, ParsedCallV2 } from "./types.js";
+/**
+ * Arguments for constructing a {@link BaseContract}.
+ **/
 export interface BaseContractArgs<abi extends Abi | readonly unknown[]> {
+    /**
+     * Contract ABI used for encoding/decoding.
+     **/
     abi: abi;
+    /**
+     *  On-chain address of the contract.
+     **/
     addr: Address;
+    /**
+     * Optional display name for the contract.
+     **/
     name?: string;
+    /**
+     * Contract version
+     * @default 0
+     **/
     version?: number | bigint;
+    /**
+     * Gearbox contract type identifier (hex bytes32 or parsed string).
+     **/
     contractType?: string;
 }
+/**
+ * Options supplied to the {@link ContractParseError} constructor.
+ **/
 export interface ContractParseErrorOptions {
+    /**
+     * Address of the contract where parsing failed.
+     **/
     address: Address;
+    /**
+     * Raw calldata that could not be decoded.
+     **/
     callData: Hex;
+    /**
+     * Optional display name for the contract.
+     **/
     contractName?: string;
 }
+/**
+ * Error thrown when calldata cannot be decoded against a contract's ABI.
+ * Captures the target address and raw calldata for diagnostics.
+ */
 export declare class ContractParseError extends BaseError {
     readonly address: Address;
     readonly callData: Hex;
     readonly selector: Hex;
     constructor(cause: Error, options: ContractParseErrorOptions);
 }
+/**
+ * Wrapper around a single on-chain contract, providing calldata decoding,
+ * event fetching, and human-readable state output.
+ *
+ * @typeParam abi - Narrowed ABI type for this contract.
+ **/
 export declare class BaseContract<abi extends Abi | readonly unknown[]> extends Construct implements IBaseContract {
+    /**
+     * Viem contract instance for direct read calls
+     **/
     readonly contract: GetContractReturnType<abi, PublicClient<Transport, Chain>, Address>;
+    /**
+     * Contract ABI
+     **/
     readonly abi: abi;
+    /**
+     * Gearbox contract type identifier (e.g. `"CREDIT_MANAGER"`), or empty string if unknown.
+     **/
     readonly contractType: string;
+    /**
+     * Contract version number.
+     * @default 0
+     **/
     readonly version: number;
+    /**
+     * On-chain address of the contract.
+     **/
     readonly address: Address;
+    /**
+     * Display name for the contract.
+     **/
     readonly name: string;
     constructor(options: ConstructOptions, args: BaseContractArgs<abi>);
+    /** {@inheritDoc IBaseContract.stateHuman} */
     stateHuman(_?: boolean): BaseContractStateHuman;
     /**
-     * Updates (or not) contract's internal state from event
-     * @param _log
-     */
+     * Applies an on-chain event to update this contract's local state.
+     *
+     * @param _log - Decoded event log emitted by this contract.
+     **/
     processLog(_log: Log<bigint, number, false, undefined, undefined, abi, ContractEventName<abi>>): void;
     /**
      * Return parsed args and function name from calldata belonging to this contract
@@ -64,9 +126,8 @@ export declare class BaseContract<abi extends Abi | readonly unknown[]> extends
      */
     stringifyFunctionData(calldata: Hex): string;
     /**
-     * Same as {@link stingifyFunctionData}, but throws if error occurs
-     * @param calldata
-     * @returns
+     * Same as {@link stringifyFunctionData}, but throws if error occurs.
+     * @param calldata - Raw ABI-encoded calldata.
      */
     mustStringifyFunctionData(calldata: Hex): string;
     /**

package/dist/types/sdk/base/ChainContractsRegister.d.ts

@@ -4,24 +4,73 @@ import type { ILogger } from "../types/logger.js";
 import type { BaseContract } from "./BaseContract.js";
 import { TokensMeta } from "./TokensMeta.js";
 import type { ParsedCall, ParsedCallV2 } from "./types.js";
+/**
+ * @internal
+ * Conditional type that resolves to `BaseContract<T>` when `T` is an ABI type,
+ * or returns `T` unchanged otherwise. Used by register lookup methods to
+ * provide strongly-typed contract references.
+ */
 export type ContractOrInterface<T> = T extends Abi | readonly unknown[] ? BaseContract<T> : T;
+/**
+ * Central registry of all known contracts on a single chain.
+ *
+ * Used to share information between contracts, enables instances of {@link BaseContract} to discover each other
+ * This is critical for parsing of calls that involve multiple contracts
+ */
 export declare class ChainContractsRegister {
     private readonly contracts;
     private readonly labels;
     readonly client: PublicClient<Transport, Chain>;
     /**
-     * Token metadata such as symbol and decimals
-     */
+     * Shared token metadata (symbol, decimals) for all tokens known on this chain.
+     **/
     readonly tokensMeta: TokensMeta;
     readonly logger?: ILogger;
     constructor(client: PublicClient<Transport, Chain>, logger?: ILogger);
+    /**
+     * Clears all registered contracts, address labels, and token metadata.
+     **/
     resetContracts(): void;
+    /**
+     * Looks up a contract by address.
+     * @param address - On-chain address.
+     * @returns The contract wrapper, or `undefined` if not registered.
+     */
     getContract<T = unknown[]>(address: Address): ContractOrInterface<T> | undefined;
+    /**
+     * Looks up a contract by address, throwing if not found.
+     * @param address - On-chain address.
+     * @throws If no contract is registered at this address.
+     */
     mustGetContract<T = unknown[]>(address: Address): ContractOrInterface<T>;
+    /**
+     * Registers (or replaces) a contract at the given address.
+     * @param address - On-chain address.
+     * @param contract - Contract wrapper instance.
+     */
     setContract(address: Address, contract: BaseContract<any>): void;
+    /**
+     * Assigns a human-readable label to an address for use in logging and
+     * parsed call output.
+     * @param address - On-chain address.
+     * @param label - Static label string, or a function that receives the
+     *   current label and returns a new one.
+     */
     setAddressLabel(address: Address, label: string | ((oldLabel?: string) => string)): void;
+    /**
+     * Returns a display string for an address, incorporating its label if one exists.
+     * @param address - On-chain address.
+     * @param omitAddress - When `true`, returns only the label (no address prefix).
+     *   Falls back to the raw address when no label is set.
+     */
     labelAddress(address: Address, omitAddress?: boolean): string;
+    /**
+     * The viem {@link Chain} object for this register's connected client.
+     **/
     get chain(): Chain;
+    /**
+     * Numeric chain ID (e.g. `1` for Ethereum mainnet).
+     **/
     get chainId(): number;
     /**
      * Converts contract call into some human-friendly string