@gearbox-protocol/sdk 13.3.2 → 13.3.4

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

@@ -6,52 +6,167 @@ 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 { 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
-     */
+     * If true, exclude reserve price feed updates from the query.
+     **/
     ignoreReservePrices?: boolean;
 }
+/**
+ * Options for generating on-demand price feed updates scoped to a specific credit manager.
+ **/
 export interface PriceUpdatesOptions {
+    /**
+     * Credit manager whose collateral tokens determine which price feeds to update.
+     **/
     creditManager: Address;
+    /**
+     * Credit account token balances; when provided, only tokens with non-dust enabled balances are updated.
+     **/
     creditAccount?: CreditAccountTokensSlice;
+    /**
+     * Tokens for which quota is being bought; their price feeds are updated even if the account has no balance yet.
+     **/
     desiredQuotas?: Asset[];
+    /**
+     * If true, exclude reserve price feed updates.
+     **/
     ignoreReservePrices?: boolean;
 }
+/**
+ * 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 +205,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 +218,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 +226,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 +279,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 +323,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 +472,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 +561,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 +573,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 +588,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 +616,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 +640,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 +673,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)
      */

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

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

@@ -3,6 +3,15 @@ import type { NetworkType } from "../chain/index.js";
 import type { ILogger } from "../types/index.js";
 import { ChainContractsRegister } from "./ChainContractsRegister.js";
 import type { TokensMeta } from "./TokensMeta.js";
+/**
+ * Options accepted by the {@link Construct} base class constructor.
+ *
+ * @param register - A {@link ChainContractsRegister} instance to use for cross-contract lookups.
+ * You may choose not to pass it if you plan to instantiate contracts manually and do not need any cross-contract lookups.
+ * @param client - A viem {@link PublicClient} instance to use for chain access.
+ * @param logger - An optional logger instance to use for logging
+ *
+ */
 export type ConstructOptions = ChainContractsRegister | {
     client: PublicClient<Transport, Chain>;
     logger?: ILogger;
@@ -10,6 +19,13 @@ export type ConstructOptions = ChainContractsRegister | {
     register: ChainContractsRegister;
     logger?: ILogger;
 };
+/**
+ * Base class for all SDK objects that need chain access.
+ *
+ * Provides a viem {@link PublicClient}, optional structured logging, and an
+ * optional {@link ChainContractsRegister} for cross-contract lookups.
+ * Most SDK classes inherit from this (or from {@link SDKConstruct}).
+ */
 export declare class Construct {
     #private;
     readonly logger?: ILogger;
@@ -21,17 +37,32 @@ export declare class Construct {
      */
     get register(): ChainContractsRegister;
     protected safeGetRegister(): ChainContractsRegister | undefined;
+    /**
+     * The viem {@link Chain} object associated with the connected client.
+     **/
     get chain(): Chain;
+    /**
+     * Numeric chain ID (e.g. `1` for Ethereum mainnet).
+     **/
     get chainId(): number;
+    /**
+     * Gearbox network type for this chain (e.g. `"Mainnet"`, `"Arbitrum"`).
+     * @throws If the chain was not created by the Gearbox SDK.
+     */
     get networkType(): NetworkType;
     /**
+     * @internal
      * Indicates that contract state diverged from onchain state and needs to be updated
      */
     get dirty(): boolean;
     protected set dirty(value: boolean);
+    /**
+     * Information about tokens known on this chain
+     */
     protected get tokensMeta(): TokensMeta;
     protected labelAddress(address: Address, omitAddress?: boolean): string;
     /**
+     * @internal
      * Returns list of addresses that should be watched for events to sync state
      */
     get watchAddresses(): Set<Address>;

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

@@ -3,6 +3,9 @@ import { BaseContract } from "./BaseContract.js";
 import type { ConstructOptions } from "./index.js";
 declare const abi: unknown[];
 type abi = typeof abi;
+/**
+ * @internal
+ */
 export declare class PlaceholderContract extends BaseContract<abi> {
     constructor(options: ConstructOptions, args: Omit<BaseContractArgs<abi>, "abi">);
 }

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

@@ -1,6 +1,16 @@
 import type { GearboxSDK } from "../GearboxSDK.js";
 import type { PluginsMap } from "../plugins/index.js";
 import { Construct } from "./Construct.js";
+/**
+ * @internal
+ * Extended base class for SDK components that need a reference to the
+ * top-level {@link GearboxSDK} instance (and its plugins).
+ *
+ * Prefer this over {@link Construct} when the component accesses SDK-level
+ * services such as market registers, plugins, or hooks.
+ *
+ * @typeParam Plugins - Map of attached plugin types.
+ */
 export declare class SDKConstruct<const Plugins extends PluginsMap = {}> extends Construct {
     readonly sdk: GearboxSDK<Plugins>;
     constructor(sdk: GearboxSDK<Plugins>);