@gearbox-protocol/sdk 13.3.2 → 13.3.4

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

@@ -13,100 +13,302 @@ import { type PluginsMap } from "./plugins/index.js";
 import { type IRouterContract } from "./router/index.js";
 import type { GearboxState, GearboxStateHuman } from "./types/index.js";
 /**
- * State version, checked duryng hydration
- */
+ * Serialised state format version, checked during hydration to detect
+ * incompatible snapshots.
+ **/
 export declare const STATE_VERSION = 1;
+/**
+ * Explicit network identity, required when working with forked testnets
+ * whose chain IDs differ from the canonical mainnet/testnet values.
+ **/
 export interface NetworkOptions {
     /**
-     * Chain Id needs to be set, because we sometimemes use forked testnets with different chain ids
-     */
+     * EVM chain ID.
+     * Must be set explicitly for forked testnets whose chain ID differs
+     * from the canonical network.
+     **/
     chainId: number;
     /**
-     * NetworkType needs to be set, because we sometimemes use forked testnets with different chain ids
-     */
+     * Gearbox network type (e.g. `"Mainnet"`, `"Arbitrum"`).
+     * Must be set explicitly for forked testnets whose chain ID differs
+     * from the canonical network.
+     **/
     networkType: NetworkType;
 }
+/**
+ * Connection options for the underlying JSON-RPC provider.
+ *
+ * Supply **one** of the three variants:
+ * - `rpcURLs` — the SDK creates a viem transport internally (with optional
+ *    fallback when multiple URLs are given).
+ * - `transport` — bring your own viem `Transport`.
+ * - `client` — bring your own fully-configured viem `PublicClient`.
+ *    When using this variant, the client is responsible for carrying the
+ *    correct `networkType` and `chainId`.
+ *
+ * ### Network detection
+ *
+ * For the `rpcURLs` and `transport` variants, `networkType` and `chainId` are
+ * resolved as follows (see {@link NetworkOptions}):
+ * - If `networkType` is provided, it is used directly; `chainId` defaults to
+ *   the canonical chain ID for that network when omitted.
+ * - If `networkType` is **not** provided, it is detected automatically using {@link detectNetwork}.
+ *   When `chainId` is also omitted it is fetched via `eth_chainId`.
+ *
+ **/
 export type ClientOptions = {
     /**
-     * RPC URL (and fallbacks) to use.
-     */
+     * One or more JSON-RPC endpoint URLs.
+     * When more than one URL is provided, a viem `fallback` transport is created.
+     **/
     rpcURLs: string[];
     /**
-     * RPC client timeout in milliseconds
-     */
+     * Per-request timeout in milliseconds.
+     **/
     timeout?: number;
     /**
-     * Retry count for RPC
-     */
+     * Number of automatic retries per RPC call.
+     **/
     retryCount?: number;
+    /**
+     * Low-level options forwarded to the viem HTTP transport.
+     **/
     httpTransportOptions?: HttpRpcClientOptions | undefined;
 } | {
     /**
-     * Alternatively, can pass viem transport
-     */
+     * Pre-built viem transport.
+     **/
     transport: Transport;
 } | {
     /**
-     * Alternatively, can pass entire viem client
-     * If you bring your own client, it is responsible for defining networkType and chainId
-     */
+     * Pre-built viem public client.
+     * Must already carry a {@link GearboxChain} definition with `networkType`
+     * and `chainId`.
+     **/
     client: PublicClient<Transport, GearboxChain>;
 };
+/**
+ * Options accepted by {@link GearboxSDK.hydrate}.
+ *
+ * Same as {@link SDKOptions} but without fields that are already captured
+ * inside the serialised {@link GearboxState} (`blockNumber`,
+ * `addressProvider`, `marketConfigurators`).
+ *
+ * @typeParam Plugins - Map of plugin names to plugin instances.
+ **/
 export type HydrateOptions<Plugins extends PluginsMap> = Omit<SDKOptions<Plugins>, "blockNumber" | "addressProvider" | "marketConfigurators">;
+/**
+ * Options for {@link GearboxSDK.syncState}, controlling which block to
+ * sync to and whether updatable price feeds should be refreshed.
+ **/
 export interface SyncStateOptions {
+    /**
+     * Target block number to sync to.
+     **/
     blockNumber: bigint;
+    /**
+     * Block timestamp corresponding to `blockNumber`.
+     **/
     timestamp: bigint;
+    /**
+     * When `true`, skip refreshing updatable price feeds during this sync.
+     **/
     ignoreUpdateablePrices?: boolean;
 }
+/**
+ * Hook event map for the SDK lifecycle.
+ *
+ * Register listeners via {@link GearboxSDK.addHook} and remove them
+ * with {@link GearboxSDK.removeHook}.
+ *
+ * - `syncState` — fired after {@link GearboxSDK.syncState} completes.
+ * - `rehydrate` — fired after {@link GearboxSDK.rehydrate} completes.
+ **/
 export type SDKHooks = {
     syncState: [SyncStateOptions];
     rehydrate: [SyncStateOptions];
 };
+/**
+ * Main entry point for the Gearbox SDK.
+ *
+ * `GearboxSDK` aggregates on-chain state for the Gearbox protocol — markets,
+ * credit managers, pools, price oracles, and price feeds — into a single
+ * queryable object that can be kept up-to-date via {@link syncState} or
+ * serialised/restored via {@link state}/{@link hydrate}.
+ *
+ * It represents on-chain state using instances of js classes that provide convenient methods
+ * to read state and prepare transactions to interact with the protocol.
+ *
+ * Create an instance with the static {@link GearboxSDK.attach | attach}
+ * (reads live chain data) or {@link GearboxSDK.hydrate | hydrate}
+ * (restores from a saved snapshot) factory methods.
+ *
+ * @typeParam Plugins - Map of plugin names to plugin instances that extend
+ *   the SDK with additional domain-specific functionality.
+ **/
 export declare class GearboxSDK<const Plugins extends PluginsMap = {}> extends ChainContractsRegister {
     #private;
+    /**
+     * Registered plugin instances, keyed by plugin name.
+     **/
     readonly plugins: Plugins;
+    /**
+     * Gas limit applied to read-only `eth_call` requests.
+     * `undefined` means that gas limit will not be set on read-only calls,
+     * leaving it to rpc provider to decide.
+     **/
     readonly gasLimit: bigint | undefined;
     /**
-     * Will throw an error if contract type is not supported, otherwise will try to use generic contract first, if possible
-     */
+     * When `true`, the SDK throws on unrecognised contract types instead of
+     * falling back to a generic contract wrapper.
+     **/
     readonly strictContractTypes: boolean;
+    /**
+     * Registers a callback for an SDK lifecycle event.
+     *
+     * @see {@link SDKHooks} for available event names.
+     **/
     addHook: <K extends keyof SDKHooks>(hookName: K, fn: (...args: SDKHooks[K]) => void | Promise<void>) => void;
+    /**
+     * Removes a previously registered lifecycle callback.
+     *
+     * @see {@link SDKHooks} for available event names.
+     **/
     removeHook: <K extends keyof SDKHooks>(hookName: K, fn: (...args: SDKHooks[K]) => void | Promise<void>) => void;
+    /**
+     * Creates and initialises a new SDK instance by reading live on-chain state.
+     *
+     * This is the primary way to bootstrap the SDK.  The method connects to the
+     * chain, discovers the address provider and all configured markets, and
+     * attaches any supplied plugins.
+     *
+     * @param options - Combined SDK, client, and (optional) network options.
+     * @returns A fully initialised SDK instance.
+     **/
     static attach<const Plugins extends PluginsMap>(options: SDKOptions<Plugins> & ClientOptions & Partial<NetworkOptions>): Promise<GearboxSDK<Plugins>>;
+    /**
+     * Creates a new SDK instance from a previously serialised {@link GearboxState}
+     * snapshot, without making any on-chain calls.
+     *
+     * Use this for fast startup when a recent state snapshot is available
+     * (e.g. loaded from a file or received from a backend service).
+     *
+     * @param options - SDK and client options (block number and address provider
+     *   are taken from the snapshot).
+     * @param state - Serialised state obtained from {@link GearboxSDK.state}.
+     * @returns A fully initialised SDK instance.
+     * @throws If the snapshot's {@link STATE_VERSION} does not match.
+     **/
     static hydrate<const Plugins extends PluginsMap>(options: HydrateOptions<Plugins> & ClientOptions, state: GearboxState<Plugins>): GearboxSDK<Plugins>;
     private constructor();
     /**
-     * Reattach SDK with the same config as before, without re-creating instance. Will load all state from scratch
-     * Be mindful of block number, for example
-     */
+     * Re-attaches the SDK using the same configuration, discarding all cached
+     * state and re-reading everything from the chain.
+     *
+     * Useful when the SDK needs a full refresh (e.g. after a protocol upgrade).
+     * Note that if the original `blockNumber` was pinned, the same block is
+     * re-used — call {@link syncState} instead if you want to advance.
+     *
+     * @throws If the SDK has not been attached yet.
+     **/
     reattach(): Promise<void>;
     /**
-     * Rehydrate existing SDK from new state without re-creating instance
-     */
+     * Replaces the SDK's in-memory state with a new serialised snapshot
+     * without re-creating the instance.
+     *
+     * After hydration the `rehydrate` hook is triggered so that listeners
+     * can react to the state change.
+     *
+     * @param state - Serialised state obtained from {@link GearboxSDK.state}.
+     * @throws If the SDK has not been attached or hydrated yet.
+     **/
     rehydrate(state: GearboxState<Plugins>): Promise<void>;
+    /**
+     * Gearbox network type the SDK is connected to (e.g. `"Mainnet"`, `"Arbitrum"`).
+     **/
     get networkType(): NetworkType;
+    /**
+     * Returns a human-readable snapshot of the entire SDK state, suitable
+     * for logging or diagnostic inspection.
+     *
+     * @param raw - When `true`, include raw numeric values alongside
+     *   formatted ones.
+     * @default true
+     **/
     stateHuman(raw?: boolean): GearboxStateHuman;
+    /**
+     * Serialisable snapshot of the current SDK state.
+     *
+     * The returned object can be persisted (e.g. written to a file) and later
+     * passed to {@link GearboxSDK.hydrate} for instant restoration without
+     * on-chain reads.
+     **/
     get state(): GearboxState<Plugins>;
     /**
-     * Reloads markets states based on events from last processed block to new block (defaults to latest block)
-     * @param opts
-     * @returns true if successful, false if was skipped or failed
-     */
+     * Incrementally updates the SDK state by replaying on-chain events from the
+     * last processed block up to the target block (defaults to `latest`).
+     *
+     * Use the to periodically update sdk state on cron, or subscribe to new blocks
+     * using viem's `watchBlocks`
+     *
+     * On failure the SDK reverts to the previous block/timestamp so that
+     * subsequent calls can retry.
+     *
+     * @param opts - Target block and sync behaviour. When omitted the latest
+     *   block is fetched automatically.
+     * @returns `true` if the sync completed successfully, `false` if it was
+     *   skipped or failed.
+     **/
     syncState(opts?: SyncStateOptions): Promise<boolean>;
+    /**
+     * Block number that the SDK state corresponds to.
+     *
+     * @throws If the SDK has not been attached or hydrated yet.
+     **/
     get currentBlock(): bigint;
+    /**
+     * Block timestamp (Unix epoch seconds) corresponding to {@link currentBlock}.
+     *
+     * @throws If the SDK has not been attached or hydrated yet.
+     **/
     get timestamp(): bigint;
     /**
-     * All price feeds known to sdk, without oracle-related data (stalenessPeriod, main/reserve, etc.)
-     */
+     * Global registry of all price feeds known to the SDK (on all markets).
+     *
+     * Unlike per-oracle price feed references, this register does not carry
+     * oracle-specific metadata (staleness period, main/reserve designation, etc.).
+     *
+     * @throws If the SDK has not been attached or hydrated yet.
+     **/
     get priceFeeds(): PriceFeedRegister;
+    /**
+     * Address of the GEAR governance token on this chain, or `undefined`
+     * if the address provider does not list it.
+     **/
     get gear(): Address | undefined;
+    /**
+     * The chain's address provider contract, the central directory for all
+     * protocol-wide Gearbox protocol addresses.
+     *
+     * @throws If the SDK has not been attached or hydrated yet.
+     **/
     get addressProvider(): IAddressProviderContract;
+    /**
+     * Registry of all loaded markets (pools, credit managers, oracles, etc.).
+     *
+     * @throws If the SDK has not been attached or hydrated yet.
+     **/
     get marketRegister(): MarketRegister;
     /**
-     * Returns router contract that will work for given credit manager or credit facade, or simply version range
-     * @param params
-     * @returns
-     */
+     * Resolves the appropriate router contract for a given credit manager,
+     * credit facade, or explicit version range.
+     *
+     * @param params - Identifies the context: a credit manager address/state,
+     *   a credit facade address/state, or a {@link VersionRange}.
+     * @returns The matching router contract instance.
+     * @throws If the credit facade version is unsupported or no router is
+     *   registered for the resolved version range.
+     **/
     routerFor(params: {
         creditManager: Address | BaseState | IBaseContract;
     } | {

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

@@ -6,43 +6,43 @@ import type { OnDemandPriceUpdates, UpdatePriceFeedsResult } from "../market/ind
 import { type Asset, type RouterCASlice } from "../router/index.js";
 import type { MultiCall } from "../types/index.js";
 import type { AccountToCheck, AddCollateralProps, ChangeDeptProps, ClaimDelayedProps, CloseCreditAccountProps, CloseCreditAccountResult, CreditAccountOperationResult, ExecuteSwapProps, FullyLiquidateProps, FullyLiquidateResult, GetConnectedBotsResult, GetConnectedMigrationBotsResult, GetCreditAccountsOptions, GetPendingWithdrawalsProps, GetPendingWithdrawalsResult, OpenCAProps, PermitResult, PrepareUpdateQuotasProps, PreviewDelayedWithdrawalProps, PreviewDelayedWithdrawalResult, PriceUpdatesOptions, Rewards, StartDelayedWithdrawalProps, UpdateQuotasProps } from "./types.js";
+/**
+ * Options for configuring the credit account service.
+ **/
 export interface CreditAccountServiceOptions {
+    /**
+     * Maximum number of credit accounts to fetch per compressor call.
+     * When set, accounts are loaded in batches of this size until all are fetched.
+     **/
     batchSize?: number;
 }
+/**
+ * Returns the withdrawal compressor contract address for the given chain, or `undefined` if none is configured.
+ * @param chainId - Numeric chain ID.
+ * @returns Withdrawal compressor address, or `undefined`.
+ **/
 export declare function getWithdrawalCompressorAddress(chainId: number): `0x${string}`;
+/**
+ * @internal
+ */
 export declare abstract class AbstractCreditAccountService extends SDKConstruct {
     #private;
     constructor(sdk: GearboxSDK, options?: CreditAccountServiceOptions);
     /**
-     * Returns single credit account data, or undefined if it's not found
-     * Performs all necessary price feed updates under the hood
-     * @param account
-     * @param blockNumber
-     * @returns
-     */
+     * {@inheritDoc ICreditAccountsService.getCreditAccountData}
+     **/
     getCreditAccountData(account: Address, blockNumber?: bigint): Promise<CreditAccountData | undefined>;
     /**
-     * Methods to get all credit accounts with some optional filtering
-     * Performs all necessary price feed updates under the hood
-     *
-     * @param options
-     * @param blockNumber
-     * @returns returned credit accounts are sorted by health factor in ascending order
-     */
+     * {@inheritDoc ICreditAccountsService.getCreditAccounts}
+     **/
     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
-     * @param {Address} creditAccount - address of credit account to get rewards for
-     * @returns {Array<Rewards>} list of {@link Rewards} that can be claimed
-     */
+     * {@inheritDoc ICreditAccountsService.getRewards}
+     **/
     getRewards(creditAccount: Address): Promise<Array<Rewards>>;
     /**
-     * Method to get all connected bots for credit account
-     * @param {Array<AccountToCheck>} accountsToCheck - list of credit accounts
-        and their credit managers to check connected bots on
-     * @returns call result of getConnectedBots for each credit account
-     */
+     * {@inheritDoc ICreditAccountsService.getConnectedBots}
+     **/
     getConnectedBots(accountsToCheck: Array<AccountToCheck>, legacyMigrationBot: Address | undefined, additionalBots: Array<Address>): Promise<{
         legacy: GetConnectedBotsResult;
         legacyMigration: GetConnectedMigrationBotsResult;
@@ -51,155 +51,69 @@ export declare abstract class AbstractCreditAccountService extends SDKConstruct
     private getActiveBots;
     private getActiveMigrationBots;
     /**
-     * Generates transaction to liquidate credit account
-     * @param props - {@link FullyLiquidateProps}
-     * @returns
-     */
+     * {@inheritDoc ICreditAccountsService.fullyLiquidate}
+     **/
     fullyLiquidate(props: FullyLiquidateProps): Promise<FullyLiquidateResult>;
     /**
-     * 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
-     * @param {CloseOptions} operation - {@link CloseOptions}: close or zeroDebt
-     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
-     * @param {Array<Address>} assetsToWithdraw - tokens to withdraw from credit account.
-        For credit account closing this is the underlying token, because during the closure,
-        all tokens on account are swapped into the underlying,
-        and only the underlying token will remain on the credit account
-     * @param {Address} to - Wallet address to withdraw underlying to
-     * @param {number} slippage  - Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
-     * @default 50n
-     * @param {RouterCloseResult | undefined} closePath - result of findBestClosePath method from router; if omited, calls marketRegister.findCreditManager {@link RouterCloseResult}
-     * @returns All necessary data to execute the transaction (call, credit facade)
-     */
+     * {@inheritDoc ICreditAccountsService.closeCreditAccount}
+     **/
     closeCreditAccount({ operation, assetsToWithdraw, creditAccount: ca, to, slippage, closePath, }: CloseCreditAccountProps): Promise<CloseCreditAccountResult>;
     /**
-     * Updates quota of credit account.
-       - CA quota updated in the following order: price update -> update quotas
-     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
-     * @param {Array<Asset>} averageQuota - average quota for desired tokens {@link Asset}
-     * @param {Array<Asset>} minQuota - minimum quota for desired tokens {@link Asset}
-     * @returns All necessary data to execute the transaction (call, credit facade)
-     */
+     * {@inheritDoc ICreditAccountsService.updateQuotas}
+     **/
     updateQuotas({ minQuota, averageQuota, creditAccount, }: UpdateQuotasProps): Promise<CreditAccountOperationResult>;
     /**
-     * Adds a single collateral to credit account and updates quotas
-       - Collateral is added in the following order: price update -> add collateral (with permit) -> update quotas
-     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
-     * @param {Array<Asset>} averageQuota - average quota for desired token {@link Asset}
-     * @param {Array<Asset>} minQuota - minimum quota for desired token {@link Asset}
-     * @param {Asset} asset - asset to add as collateral {@link Asset}
-     * @param {PermitResult | undefined} permits - permits of collateral asset if it is permittable {@link PermitResult}
-     * @param {bigint} ethAmount - native token amount to attach to tx
-     * @returns All necessary data to execute the transaction (call, credit facade)
-     */
+     * {@inheritDoc ICreditAccountsService.addCollateral}
+     **/
     addCollateral({ creditAccount, asset, permit, ethAmount, minQuota, averageQuota, }: AddCollateralProps): Promise<CreditAccountOperationResult>;
     /**
-     * Increases or decreases debt of credit account; debt decrease uses token ON CREDIT ACCOUNT
-       - Debt is changed in the following order: price update -> (enables underlying if it was disabled) -> change debt
-     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
-     * @param {bigint} amount - amount to change debt by;
-        0 - prohibited value;
-        negative value for debt decrease;
-        positive value for debt increase.
-     * @returns All necessary data to execute the transaction (call, credit facade)
-     */
+     * {@inheritDoc ICreditAccountsService.changeDebt}
+     **/
     changeDebt({ creditAccount, amount, addCollateral, }: ChangeDeptProps): Promise<CreditAccountOperationResult>;
     /**
-     * Executes swap specified by given calls, update quotas of affected tokens
-       - Swap is executed in the following order: price update -> execute swap path -> update quotas
-     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
-     * @param {Array<Asset>} averageQuota - average quota for desired token {@link Asset}
-     * @param {Array<Asset>} minQuota - minimum quota for desired token {@link Asset}
-     * @param {Array<MultiCall>} calls - array of MultiCall from router methods getSingleSwap or getAllSwaps {@link MultiCall}
-     * @returns All necessary data to execute the transaction (call, credit facade)
-     */
+     * {@inheritDoc ICreditAccountsService.executeSwap}
+     **/
     executeSwap({ creditAccount, calls: swapCalls, minQuota, averageQuota, }: ExecuteSwapProps): Promise<CreditAccountOperationResult>;
     /**
-     * Preview delayed withdrawal for given token
-     * @param props - {@link PreviewDelayedWithdrawalProps}
-     * @returns
-     */
+     * {@inheritDoc ICreditAccountsService.previewDelayedWithdrawal}
+     **/
     previewDelayedWithdrawal({ creditAccount, amount, token, }: PreviewDelayedWithdrawalProps): Promise<PreviewDelayedWithdrawalResult>;
     /**
-     * Get claimable and pending withdrawals of an account
-     * @param props - {@link GetPendingWithdrawalsProps}
-     * @returns
-     */
+     * {@inheritDoc ICreditAccountsService.getPendingWithdrawals}
+     **/
     getPendingWithdrawals({ creditAccount, }: GetPendingWithdrawalsProps): Promise<GetPendingWithdrawalsResult>;
     /**
-     * Start delayed withdrawal for given token
-       - Withdrawal is executed in the following order: price update -> execute withdraw calls -> update quotas
-     * @param props - {@link StartDelayedWithdrawalProps}
-     * @returns
-    */
+     * {@inheritDoc ICreditAccountsService.startDelayedWithdrawal}
+     **/
     startDelayedWithdrawal({ creditAccount, minQuota, averageQuota, preview, }: StartDelayedWithdrawalProps): Promise<CreditAccountOperationResult>;
     /**
-     * Claim tokens with delayed withdrawal
-       - Claim is executed in the following order: price update -> execute claim calls -> update quotas
-     * @param props - {@link ClaimDelayedProps}
-     * @returns
-    */
+     * {@inheritDoc ICreditAccountsService.claimDelayed}
+     **/
     claimDelayed({ creditAccount, minQuota, averageQuota, claimableNow, }: ClaimDelayedProps): Promise<CreditAccountOperationResult>;
     /**
-     * Executes swap specified by given calls, update quotas of affected tokens
-       - Open credit account is executed in the following order: price update -> increase debt -> add collateral ->
-        -> update quotas -> (optionally: execute swap path for trading/strategy) ->
-        -> (optionally: withdraw debt for lending)
-      - Basic open credit account: price update -> increase debt -> add collateral -> update quotas
-      - Lending: price update -> increase debt -> add collateral -> update quotas -> withdraw debt
-      - Strategy/trading: price update -> increase debt -> add collateral -> update quotas -> execute swap path
-      - In strategy is possible situation when collateral is added, but not swapped; the only swapped value in this case will be debt
-     * @param {bigint} ethAmount - native token amount to attach to tx
-     * @param {Address} creditManager - address of credit manager to open credit account on
-     * @param {Array<Asset>} collateral - array of collateral which can be just directly added or swapped using the path {@link Asset}
-     * @param {Record<Address, PermitResult>} permits - permits of collateral tokens (in any permittable token is present) {@link PermitResult}
-     * @param {bigint} debt - debt to open credit account with
-     * @param {boolean} withdrawDebt - flag to withdraw debt to wallet after opening credit account;
-        used for borrowing functionality
-     * @param {bigint} referralCode - referral code to open credit account with
-     * @param {Address} to - wallet address to transfer credit account to\
-     * @param {Array<MultiCall>} calls - array of MultiCall from router methods findOpenStrategyPath {@link MultiCall}.
-        Used for trading and strategy functionality
-     * @param {Array<Asset>} averageQuota - average quota for tokens after open {@link Asset}
-     * @param {Array<Asset>} minQuota - minimum quota for tokens after open  {@link Asset}
-     * @returns All necessary data to execute the transaction (call, credit facade)
-     */
+     * {@inheritDoc ICreditAccountsService.openCA}
+     **/
     openCA({ ethAmount, creditManager, collateral, permits, debt, withdrawDebt, referralCode, to, calls: openPathCalls, minQuota, averageQuota, }: OpenCAProps): Promise<CreditAccountOperationResult>;
     /**
-     * Returns borrow rate with 4 digits precision (10000 = 100%)
-     * @param ca
-     * @returns
-     */
+     * {@inheritDoc ICreditAccountsService.getBorrowRate}
+     **/
     getBorrowRate(ca: CreditAccountData): bigint;
     /**
-     * Returns optimal HF for partial liquidation with 4 digits precision (10000 = 100%)
-     * @param ca
-     */
+     * {@inheritDoc ICreditAccountsService.getOptimalHFForPartialLiquidation}
+     **/
     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
-     */
+     * {@inheritDoc ICreditAccountsService.getUpdateForAccounts}
+     **/
     getUpdateForAccounts(accounts: Array<RouterCASlice>): Promise<UpdatePriceFeedsResult>;
     protected getUpdateForAccount(options: PriceUpdatesOptions): Promise<UpdatePriceFeedsResult>;
     /**
-     * Returns account price updates that can be used in credit facade multicall or liquidator calls
-     * @param options
-     * @returns
-     */
+     * {@inheritDoc ICreditAccountsService.getOnDemandPriceUpdates}
+     **/
     getOnDemandPriceUpdates(options: PriceUpdatesOptions): Promise<OnDemandPriceUpdates>;
     /**
-     * Returns price updates in format that is accepted by various credit facade methods (multicall, close/liquidate, etc...).
-     * - If there are desiredQuotas and creditAccount update quotaBalance > 0 || (balance > 10n && isEnabled). Is used when account has both: balances and quota buys.
-     * - If there is creditAccount update balance > 10n && isEnabled. Is used in credit account actions when quota is not being bought.
-     * - If there is desiredQuotas update quotaBalance > 0. Is used on credit account opening, when quota is bought for the first time.
-     * @param acc
-     * @returns
-     */
+     * {@inheritDoc ICreditAccountsService.getPriceUpdatesForFacade}
+     **/
     getPriceUpdatesForFacade(options: PriceUpdatesOptions): Promise<Array<MultiCall>>;
     protected prepareDisableQuotas(ca: RouterCASlice): Array<MultiCall>;
     protected prepareUpdateQuotas(creditFacade: Address, { averageQuota, minQuota }: PrepareUpdateQuotasProps): Array<MultiCall>;

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

@@ -1,24 +1,33 @@
 import { AbstractCreditAccountService } from "./AbstractCreditAccountsService.js";
 import type { ClaimFarmRewardsProps, CreditAccountOperationResult, CreditManagerOperationResult, ICreditAccountsService, LlamathenaProportionalWithdrawProps, PreviewWithdrawLlamathenaProportionallyProps, PreviewWithdrawLlamathenaProportionallyResult, RepayAndLiquidateCreditAccountProps, RepayCreditAccountProps, SetBotProps, WithdrawCollateralProps } from "./types.js";
+/**
+ * Service for querying and operating on Gearbox credit accounts.
+ *
+ * Provides methods to fetch account data, build transactions for common operations
+ * (open, close, liquidate, swap, manage collateral/debt/quotas), and generate
+ * the price feed updates required by the credit facade.
+ *
+ * @see {@link ICreditAccountsService}
+ **/
 export declare class CreditAccountServiceV310 extends AbstractCreditAccountService implements ICreditAccountsService {
     /**
-     * Implements {@link ICreditAccountsService.setBot}
+     * {@inheritDoc ICreditAccountsService.setBot}
      */
     setBot({ botAddress, permissions: defaultPermissions, targetContract, }: SetBotProps): Promise<CreditAccountOperationResult | CreditManagerOperationResult>;
     /**
-     * Implements {@link ICreditAccountsService.withdrawCollateral}
+     * {@inheritDoc ICreditAccountsService.withdrawCollateral}
      */
     withdrawCollateral({ creditAccount, assetsToWithdraw, to, minQuota, averageQuota, }: WithdrawCollateralProps): Promise<CreditAccountOperationResult>;
     /**
-     * Implements {@link ICreditAccountsService.repayCreditAccount}
+     * {@inheritDoc ICreditAccountsService.repayCreditAccount}
      */
     repayCreditAccount({ operation, collateralAssets, assetsToWithdraw, creditAccount: ca, permits, to, tokensToClaim, }: RepayCreditAccountProps): Promise<CreditAccountOperationResult>;
     /**
-     * Implements {@link ICreditAccountsService.repayAndLiquidateCreditAccount}
+     * {@inheritDoc ICreditAccountsService.repayAndLiquidateCreditAccount}
      */
     repayAndLiquidateCreditAccount({ collateralAssets, assetsToWithdraw, creditAccount: ca, permits, to, tokensToClaim, }: RepayAndLiquidateCreditAccountProps): Promise<CreditAccountOperationResult>;
     /**
-     * Implements {@link ICreditAccountsService.claimFarmRewards}
+     * {@inheritDoc ICreditAccountsService.claimFarmRewards}
      */
     claimFarmRewards({ calls: externalCalls, creditAccount: ca, minQuota, averageQuota, tokensToClaim, }: ClaimFarmRewardsProps): Promise<CreditAccountOperationResult>;
     previewWithdrawLlamathenaProportionally(_: PreviewWithdrawLlamathenaProportionallyProps): Promise<PreviewWithdrawLlamathenaProportionallyResult>;