@gearbox-protocol/sdk 13.3.3 → 13.3.4

package/dist/cjs/sdk/GearboxSDK.js

@@ -76,24 +76,50 @@ async function attachClient(options, network) {
 }
 class GearboxSDK extends import_base.ChainContractsRegister {
   #hooks = new import_internal.Hooks();
+  /**
+   * Registered plugin instances, keyed by plugin name.
+   **/
   plugins;
-  // Block which was use for data query
   #currentBlock;
   #timestamp;
   #syncing = false;
-  // Collection of core singleton contracts
   #addressProvider;
   #attachConfig;
-  // Collection of markets
   #marketRegister;
   #priceFeeds;
+  /**
+   * 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.
+   **/
   gasLimit;
   /**
-   * 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.
+   **/
   strictContractTypes;
+  /**
+   * Registers a callback for an SDK lifecycle event.
+   *
+   * @see {@link SDKHooks} for available event names.
+   **/
   addHook = this.#hooks.addHook.bind(this.#hooks);
+  /**
+   * Removes a previously registered lifecycle callback.
+   *
+   * @see {@link SDKHooks} for available event names.
+   **/
   removeHook = this.#hooks.removeHook.bind(this.#hooks);
+  /**
+   * 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 async attach(options) {
     const {
       logger,
@@ -129,6 +155,19 @@ class GearboxSDK extends import_base.ChainContractsRegister {
       pyth
     });
   }
+  /**
+   * 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(options, state) {
     const { logger, plugins, strictContractTypes, gasLimit, ...rest } = options;
     const client = createClient(options, {
@@ -281,9 +320,15 @@ class GearboxSDK extends import_base.ChainContractsRegister {
     return this;
   }
   /**
-   * 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.
+   **/
   async reattach() {
     if (!this.#attachConfig) {
       throw new Error("cannot reattach, attach config is not set");
@@ -291,8 +336,15 @@ class GearboxSDK extends import_base.ChainContractsRegister {
     await this.#attach(this.#attachConfig);
   }
   /**
-   * 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.
+   **/
   async rehydrate(state) {
     if (!this.#attachConfig) {
       throw new Error("cannot rehydrate, attach config is not set");
@@ -308,9 +360,20 @@ class GearboxSDK extends import_base.ChainContractsRegister {
       timestamp: state.timestamp
     });
   }
+  /**
+   * Gearbox network type the SDK is connected to (e.g. `"Mainnet"`, `"Arbitrum"`).
+   **/
   get networkType() {
     return this.client.chain.network;
   }
+  /**
+   * 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 = true) {
     return {
       block: Number(this.currentBlock),
@@ -328,6 +391,13 @@ class GearboxSDK extends import_base.ChainContractsRegister {
       ...this.marketRegister.stateHuman(raw)
     };
   }
+  /**
+   * 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() {
     return {
       version: STATE_VERSION,
@@ -346,10 +416,20 @@ class GearboxSDK extends import_base.ChainContractsRegister {
     };
   }
   /**
-   * 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.
+   **/
   async syncState(opts) {
     let {
       blockNumber,
@@ -451,12 +531,22 @@ class GearboxSDK extends import_base.ChainContractsRegister {
     }
     return success;
   }
+  /**
+   * Block number that the SDK state corresponds to.
+   *
+   * @throws If the SDK has not been attached or hydrated yet.
+   **/
   get currentBlock() {
     if (this.#currentBlock === void 0) {
       throw ERR_NOT_ATTACHED;
     }
     return this.#currentBlock;
   }
+  /**
+   * Block timestamp (Unix epoch seconds) corresponding to {@link currentBlock}.
+   *
+   * @throws If the SDK has not been attached or hydrated yet.
+   **/
   get timestamp() {
     if (this.#timestamp === void 0) {
       throw ERR_NOT_ATTACHED;
@@ -464,14 +554,23 @@ class GearboxSDK extends import_base.ChainContractsRegister {
     return this.#timestamp;
   }
   /**
-   * 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() {
     if (this.#priceFeeds === void 0) {
       throw ERR_NOT_ATTACHED;
     }
     return this.#priceFeeds;
   }
+  /**
+   * Address of the GEAR governance token on this chain, or `undefined`
+   * if the address provider does not list it.
+   **/
   get gear() {
     try {
       const g = this.addressProvider.getAddress(import_constants.AP_GEAR_TOKEN, import_constants.NO_VERSION);
@@ -481,12 +580,23 @@ class GearboxSDK extends import_base.ChainContractsRegister {
       return void 0;
     }
   }
+  /**
+   * 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() {
     if (this.#addressProvider === void 0) {
       throw ERR_NOT_ATTACHED;
     }
     return this.#addressProvider;
   }
+  /**
+   * Registry of all loaded markets (pools, credit managers, oracles, etc.).
+   *
+   * @throws If the SDK has not been attached or hydrated yet.
+   **/
   get marketRegister() {
     if (this.#marketRegister === void 0) {
       throw ERR_NOT_ATTACHED;
@@ -494,10 +604,15 @@ class GearboxSDK extends import_base.ChainContractsRegister {
     return this.#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) {
     let routerRange;
     if (Array.isArray(params)) {

package/dist/cjs/sdk/accounts/AbstractCreditAccountsService.js

@@ -57,12 +57,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     );
   }
   /**
-   * 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}
+   **/
   async getCreditAccountData(account, blockNumber) {
     let raw;
     try {
@@ -101,13 +97,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     return cad;
   }
   /**
-   * 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}
+   **/
   async getCreditAccounts(options, blockNumber) {
     const {
       creditManager,
@@ -160,11 +151,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     return allCAs.sort((a, b) => Number(a.healthFactor - b.healthFactor));
   }
   /**
-   * 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}
+   **/
   async getRewards(creditAccount) {
     const rewards = await this.client.readContract({
       abi: import_rewardsCompressor.rewardsCompressorAbi,
@@ -204,11 +192,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     return Object.values(r);
   }
   /**
-   * 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}
+   **/
   async getConnectedBots(accountsToCheck, legacyMigrationBot, additionalBots) {
     const allResp = await this.client.multicall({
       contracts: [
@@ -312,10 +297,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     return void 0;
   }
   /**
-   * Generates transaction to liquidate credit account
-   * @param props - {@link FullyLiquidateProps}
-   * @returns
-   */
+   * {@inheritDoc ICreditAccountsService.fullyLiquidate}
+   **/
   async fullyLiquidate(props) {
     const {
       account,
@@ -365,21 +348,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     };
   }
   /**
-   * 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}
+   **/
   async closeCreditAccount({
     operation,
     assetsToWithdraw,
@@ -411,13 +381,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     return { tx, calls, routerCloseResult, creditFacade: cm.creditFacade };
   }
   /**
-   * 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}
+   **/
   async updateQuotas({
     minQuota,
     averageQuota,
@@ -441,16 +406,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
-   * 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}
+   **/
   async addCollateral({
     creditAccount,
     asset,
@@ -484,15 +441,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
-   * 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}
+   **/
   async changeDebt({
     creditAccount,
     amount,
@@ -529,14 +479,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
-   * 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}
+   **/
   async executeSwap({
     creditAccount,
     calls: swapCalls,
@@ -564,10 +508,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
-   * Preview delayed withdrawal for given token
-   * @param props - {@link PreviewDelayedWithdrawalProps}
-   * @returns
-   */
+   * {@inheritDoc ICreditAccountsService.previewDelayedWithdrawal}
+   **/
   async previewDelayedWithdrawal({
     creditAccount,
     amount,
@@ -591,10 +533,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     return resp;
   }
   /**
-   * Get claimable and pending withdrawals of an account
-   * @param props - {@link GetPendingWithdrawalsProps}
-   * @returns
-   */
+   * {@inheritDoc ICreditAccountsService.getPendingWithdrawals}
+   **/
   async getPendingWithdrawals({
     creditAccount
   }) {
@@ -620,11 +560,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     return respResult;
   }
   /**
-   * 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}
+   **/
   async startDelayedWithdrawal({
     creditAccount,
     minQuota,
@@ -680,11 +617,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
-   * 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}
+   **/
   async claimDelayed({
     creditAccount,
     minQuota,
@@ -745,29 +679,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
-   * 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}
+   **/
   async openCA({
     ethAmount,
     creditManager,
@@ -803,10 +716,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     return { calls, tx, creditFacade: cmSuite.creditFacade };
   }
   /**
-   * Returns borrow rate with 4 digits precision (10000 = 100%)
-   * @param ca
-   * @returns
-   */
+   * {@inheritDoc ICreditAccountsService.getBorrowRate}
+   **/
   getBorrowRate(ca) {
     const { creditManager } = this.sdk.marketRegister.findCreditManager(
       ca.creditManager
@@ -832,9 +743,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     return r + qr;
   }
   /**
-   * Returns optimal HF for partial liquidation with 4 digits precision (10000 = 100%)
-   * @param ca
-   */
+   * {@inheritDoc ICreditAccountsService.getOptimalHFForPartialLiquidation}
+   **/
   getOptimalHFForPartialLiquidation(ca) {
     const borrowRate = this.getBorrowRate(ca);
     return import_constants.PERCENTAGE_FACTOR + (borrowRate < 100n ? borrowRate : 100n);
@@ -883,12 +793,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     return resp;
   }
   /**
-   * 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}
+   **/
   async getUpdateForAccounts(accounts) {
     const tokensByPool = /* @__PURE__ */ new Map();
     const oracleByPool = /* @__PURE__ */ new Map();
@@ -960,10 +866,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     return this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(priceFeeds);
   }
   /**
-   * Returns account price updates that can be used in credit facade multicall or liquidator calls
-   * @param options
-   * @returns
-   */
+   * {@inheritDoc ICreditAccountsService.getOnDemandPriceUpdates}
+   **/
   async getOnDemandPriceUpdates(options) {
     const { creditManager, creditAccount } = options;
     const market = this.sdk.marketRegister.findByCreditManager(creditManager);
@@ -979,13 +883,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     );
   }
   /**
-   * 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}
+   **/
   async getPriceUpdatesForFacade(options) {
     const updates = await this.getOnDemandPriceUpdates(options);
     return updates.multicall;

package/dist/cjs/sdk/accounts/CreditAccountsServiceV310.js

@@ -27,7 +27,7 @@ var import_math = require("../constants/math.js");
 var import_AbstractCreditAccountsService = require("./AbstractCreditAccountsService.js");
 class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.AbstractCreditAccountService {
   /**
-   * Implements {@link ICreditAccountsService.setBot}
+   * {@inheritDoc ICreditAccountsService.setBot}
    */
   async setBot({
     botAddress,
@@ -69,7 +69,7 @@ class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.Abst
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
-   * Implements {@link ICreditAccountsService.withdrawCollateral}
+   * {@inheritDoc ICreditAccountsService.withdrawCollateral}
    */
   async withdrawCollateral({
     creditAccount,
@@ -104,7 +104,7 @@ class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.Abst
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
-   * Implements {@link ICreditAccountsService.repayCreditAccount}
+   * {@inheritDoc ICreditAccountsService.repayCreditAccount}
    */
   async repayCreditAccount({
     operation,
@@ -140,7 +140,7 @@ class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.Abst
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
-   * Implements {@link ICreditAccountsService.repayAndLiquidateCreditAccount}
+   * {@inheritDoc ICreditAccountsService.repayAndLiquidateCreditAccount}
    */
   async repayAndLiquidateCreditAccount({
     collateralAssets,
@@ -177,7 +177,7 @@ class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.Abst
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
-   * Implements {@link ICreditAccountsService.claimFarmRewards}
+   * {@inheritDoc ICreditAccountsService.claimFarmRewards}
    */
   async claimFarmRewards({
     calls: externalCalls,

package/dist/cjs/sdk/base/BaseContract.js

@@ -45,11 +45,30 @@ class ContractParseError extends import_viem.BaseError {
   }
 }
 class BaseContract extends import_Construct.Construct {
+  /**
+   * Viem contract instance for direct read calls
+   **/
   contract;
+  /**
+   * Contract ABI
+   **/
   abi;
+  /**
+   * Gearbox contract type identifier (e.g. `"CREDIT_MANAGER"`), or empty string if unknown.
+   **/
   contractType;
+  /**
+   * Contract version number.
+   * @default 0
+   **/
   version;
+  /**
+   * On-chain address of the contract.
+   **/
   address;
+  /**
+   * Display name for the contract.
+   **/
   name;
   constructor(options, args) {
     super(options);
@@ -73,6 +92,7 @@ class BaseContract extends import_Construct.Construct {
       register.setAddressLabel(this.address, this.name);
     }
   }
+  /** {@inheritDoc IBaseContract.stateHuman} */
   stateHuman(_ = true) {
     return {
       address: this.labelAddress(this.address),
@@ -81,9 +101,10 @@ class BaseContract extends import_Construct.Construct {
     };
   }
   /**
-   * 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) {
   }
   /**
@@ -158,9 +179,8 @@ class BaseContract extends import_Construct.Construct {
     }
   }
   /**
-   * 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) {
     const decoded = (0, import_viem.decodeFunctionData)({