@gearbox-protocol/sdk 11.9.0-next.2 → 11.10.0

package/dist/cjs/sdk/accountMigration/AbstractMigrateCreditAccountsService.js

@@ -27,7 +27,9 @@ var import_createCreditAccountService = require("../accounts/createCreditAccount
 var import_base = require("../base/index.js");
 var import_chains = require("../chain/chains.js");
 var import_versions = require("../constants/versions.js");
+var import_utils = require("../utils/index.js");
 class AbstractMigrateCreditAccountsService extends import_base.SDKConstruct {
+  #logger;
   #version;
   #service;
   // TODO: HARDCODED
@@ -49,7 +51,8 @@ class AbstractMigrateCreditAccountsService extends import_base.SDKConstruct {
     super(sdk);
     this.#version = version;
     this.#service = (0, import_createCreditAccountService.createCreditAccountService)(this.sdk, version);
-    this.logger?.debug(
+    this.#logger = (0, import_utils.childLogger)("MigrateCreditAccountsService", sdk.logger);
+    this.#logger?.debug(
       `Created MigrateCreditAccountsService with version: ${this.#version}`
     );
   }

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

@@ -44,6 +44,7 @@ function getWithdrawalCompressorAddress(chainId) {
 class AbstractCreditAccountService extends import_base.SDKConstruct {
   #compressor;
   #batchSize;
+  #logger;
   constructor(sdk, options) {
     super(sdk);
     [this.#compressor] = sdk.addressProvider.mustGetLatest(
@@ -51,7 +52,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
       import_constants.VERSION_RANGE_310
     );
     this.#batchSize = options?.batchSize;
-    this.logger?.debug(
+    this.#logger = (0, import_utils.childLogger)("CreditAccountsService", sdk.logger);
+    this.#logger?.debug(
       `credit account compressor address: ${this.#compressor}`
     );
   }
@@ -153,7 +155,7 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
         offset = newOffset;
       } while (offset !== 0n);
     }
-    this.logger?.debug(
+    this.#logger?.debug(
       `loaded ${allCAs.length} credit accounts (${allCAs.length - revertingOffset} reverting)`
     );
     return allCAs.sort((a, b) => Number(a.healthFactor - b.healthFactor));
@@ -264,7 +266,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
       force = false,
       keepAssets,
       ignoreReservePrices,
-      applyLossPolicy
+      applyLossPolicy,
+      debtOnly
     } = props;
     const cm = this.sdk.marketRegister.findCreditManager(account.creditManager);
     const routerCloseResult = await this.sdk.routerFor(account).findBestClosePath({
@@ -272,7 +275,8 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
       creditManager: cm.creditManager,
       slippage,
       force,
-      keepAssets
+      keepAssets,
+      debtOnly
     });
     const priceUpdates = await this.getPriceUpdatesForFacade({
       creditManager: account.creditManager,
@@ -288,7 +292,7 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
       lossPolicyData = await market.lossPolicy.getLiquidationData(
         account.creditAccount
       );
-      this.logger?.debug({ lossPolicyData }, "loss policy data");
+      this.#logger?.debug({ lossPolicyData }, "loss policy data");
     }
     const tx = cm.creditFacade.liquidateCreditAccount(
       account.creditAccount,
@@ -846,7 +850,7 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
         gas: this.sdk.gasLimit
       });
     }
-    this.logger?.debug(
+    this.#logger?.debug(
       {
         accounts: resp[0]?.length ?? 0,
         nextOffset: Number(resp[1])
@@ -926,7 +930,7 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     });
     const tStr = Array.from(tokens).map((t) => this.labelAddress(t)).join(", ");
     const remark = ignoreReservePrices ? " main" : "";
-    this.logger?.debug(
+    this.#logger?.debug(
       { account: creditAccount?.creditAccount, manager: cm.name },
       `generating price feed updates for ${tStr} from ${priceFeeds.length}${remark} price feeds`
     );
@@ -942,7 +946,7 @@ class AbstractCreditAccountService extends import_base.SDKConstruct {
     const market = this.sdk.marketRegister.findByCreditManager(creditManager);
     const cm = this.sdk.marketRegister.findCreditManager(creditManager);
     const update = await this.getUpdateForAccount(options);
-    this.logger?.debug(
+    this.#logger?.debug(
       { account: creditAccount?.creditAccount, manager: cm.name },
       `getting on demand price updates from ${update.txs.length} txs`
     );

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

@@ -34,15 +34,17 @@ class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.Abst
     botAddress,
     botBaseType,
     stopBot,
-    creditAccount: ca
+    targetContract
   }) {
-    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
-    const priceUpdatesCalls = await this.getPriceUpdatesForFacade({
-      creditManager: ca.creditManager,
-      creditAccount: ca
-    });
+    const cm = this.sdk.marketRegister.findCreditManager(
+      targetContract.creditManager
+    );
+    const priceUpdatesCalls = targetContract.type === "creditAccount" ? await this.getPriceUpdatesForFacade({
+      creditManager: targetContract.creditManager,
+      creditAccount: targetContract
+    }) : [];
     const addBotCall = {
-      target: ca.creditFacade,
+      target: cm.creditFacade.address,
       callData: (0, import_viem.encodeFunctionData)({
         abi: import_generated.iCreditFacadeMulticallV310Abi,
         functionName: "setBotPermissions",
@@ -50,7 +52,7 @@ class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.Abst
       })
     };
     const calls = [...priceUpdatesCalls, addBotCall];
-    const tx = cm.creditFacade.multicall(ca.creditAccount, calls);
+    const tx = targetContract.type === "creditAccount" ? cm.creditFacade.multicall(targetContract.creditAccount, calls) : void 0;
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**

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

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AddressLabeller_exports = {};
+__export(AddressLabeller_exports, {
+  AddressLabeller: () => AddressLabeller
+});
+module.exports = __toCommonJS(AddressLabeller_exports);
+var import_constants = require("../constants/index.js");
+var import_utils = require("../utils/index.js");
+class AddressLabeller {
+  #labels = new import_utils.AddressMap(void 0, "addressLabeller");
+  set(address, label) {
+    if (address === import_constants.NOT_DEPLOYED) {
+      return;
+    }
+    if (typeof label === "string") {
+      this.#labels.upsert(address, label);
+    } else {
+      this.#labels.upsert(address, label(this.#labels.get(address)));
+    }
+  }
+  get(address) {
+    const label = this.#labels.get(address);
+    return label ? `${address} [${label}]` : address;
+  }
+  get all() {
+    return this.#labels.asRecord();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AddressLabeller
+});

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

@@ -18,61 +18,66 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var BaseContract_exports = {};
 __export(BaseContract_exports, {
-  BaseContract: () => BaseContract,
-  ContractParseError: () => ContractParseError
+  BaseContract: () => BaseContract
 });
 module.exports = __toCommonJS(BaseContract_exports);
 var import_viem = require("viem");
 var import_errors = require("../../abi/errors.js");
+var import_iVersion = require("../../abi/iVersion.js");
+var import_constants = require("../constants/index.js");
 var import_utils = require("../utils/index.js");
-var import_Construct = require("./Construct.js");
-class ContractParseError extends import_viem.BaseError {
-  address;
-  callData;
-  selector;
-  constructor(cause, options) {
-    const { address, callData, contractName } = options;
-    const selector = callData.slice(0, 10);
-    super(
-      `failed to parse function data for ${contractName ?? "unknown contract"} at ${address} with selector ${selector}`,
-      {
-        cause
-      }
-    );
-    this.callData = callData;
-    this.selector = selector;
-    this.address = address;
-  }
-}
-class BaseContract extends import_Construct.Construct {
+var import_SDKConstruct = require("./SDKConstruct.js");
+class BaseContract extends import_SDKConstruct.SDKConstruct {
   contract;
   abi;
+  logger;
   contractType;
   version;
-  address;
-  name;
-  constructor({ client, logger }, args) {
-    super({ client, logger });
+  #name;
+  #address;
+  constructor(sdk, args) {
+    super(sdk);
     this.abi = args.abi;
-    this.address = (0, import_viem.getAddress)(args.addr);
+    this.#address = (0, import_viem.getAddress)(args.addr);
     this.contract = (0, import_viem.getContract)({
       address: this.address,
       // add exceptions for better error decoding
       abi: [...this.abi, ...import_errors.errorAbis],
-      client
+      client: {
+        public: sdk.client
+      }
     });
     this.version = Number(args.version || 0);
     this.contractType = args.contractType ?? "";
     if ((0, import_viem.isHex)(this.contractType)) {
       this.contractType = (0, import_utils.bytes32ToString)(this.contractType);
     }
-    this.name = args.name || this.contractType || this.address || this.constructor.name;
-    this.register.setContract(this.address, this);
-    this.register.setAddressLabel(this.address, this.name);
+    this.name = this.#name = args.name || this.contractType || this.#address;
+    this.logger = (0, import_utils.childLogger)(this.name, sdk.logger);
+    sdk.contracts.upsert(this.address, this);
+  }
+  get address() {
+    return this.#address;
+  }
+  set address(address) {
+    if (this.#address !== import_constants.ADDRESS_0X0) {
+      throw new Error(`Address can't be changed, currently: ${this.#address}`);
+    }
+    this.#address = (0, import_viem.getAddress)(address);
+    this.sdk.addressLabels.set(address, this.#name);
+  }
+  get name() {
+    return this.#name;
+  }
+  set name(name) {
+    this.#name = name;
+    if (this.#address !== import_constants.ADDRESS_0X0) {
+      this.sdk.addressLabels.set(this.#address, name);
+    }
   }
   stateHuman(_ = true) {
     return {
-      address: this.labelAddress(this.address),
+      address: this.sdk.labelAddress(this.address),
       version: this.version,
       contractType: this.contractType
     };
@@ -83,69 +88,15 @@ class BaseContract extends import_Construct.Construct {
    */
   processLog(_log) {
   }
-  /**
-   * Return parsed args and function name from calldata belonging to this contract
-   * Target of the call is always this contract, but args can be parsed into calls to other contracts (de-facto recursive ParsedCall)
-   * @param calldata
-   * @returns
-   */
-  parseFunctionData(calldata) {
-    try {
-      return this.mustParseFunctionData(calldata);
-    } catch (e) {
-      this.logger?.warn(e);
-      return {
-        chainId: this.chainId,
-        target: this.address,
-        contractType: this.contractType,
-        label: this.name,
-        functionName: `Unknown function: ${calldata}`,
-        args: {}
-      };
-    }
-  }
-  /**
-   * Same as {@link parseFunctionData}, but throws {@link ContractParseError} if error occurs
-   * @param callData
-   * @returns
-   */
-  mustParseFunctionData(callData) {
-    try {
-      const decoded = (0, import_viem.decodeFunctionData)({
-        abi: this.abi,
-        data: callData
-      });
-      return this.wrapParseCall(
-        decoded.functionName,
-        this.parseFunctionParams(decoded)
-      );
-    } catch (e) {
-      throw new ContractParseError(e, {
-        address: this.address,
-        callData,
-        contractName: this.name
-      });
-    }
-  }
-  /**
-   * Parses viem-decoded contract function arguments to a map of named arguments
-   * This default implementation uses abi-based parsing, you can override it,
-   * but use this super implementation as fallback
-   * @param params
-   * @returns
-   */
-  parseFunctionParams(params) {
-    return (0, import_utils.functionArgsToMap)(this.abi, params.functionName, params.args);
-  }
   /**
    * Converts contract calldata to some human-friendly string
    * This is safe function which should not throw
    * @param calldata
    * @returns
    */
-  stringifyFunctionData(calldata) {
+  parseFunctionData(calldata) {
     try {
-      return this.mustStringifyFunctionData(calldata);
+      return this.mustParseFunctionData(calldata);
     } catch (e) {
       const selector = calldata.slice(0, 10);
       this.logger?.warn(
@@ -154,64 +105,59 @@ class BaseContract extends import_Construct.Construct {
       return `unknown: ${this.labelAddress(this.address)}.${selector}`;
     }
   }
-  /**
-   * Same as {@link stingifyFunctionData}, but throws if error occurs
-   * @param calldata
-   * @returns
-   */
-  mustStringifyFunctionData(calldata) {
+  mustParseFunctionData(calldata) {
     const decoded = (0, import_viem.decodeFunctionData)({
       abi: this.abi,
       data: calldata
     });
-    const abiItem = (0, import_viem.getAbiItem)({
-      abi: this.abi,
-      name: decoded.functionName,
-      args: decoded.args
-    });
-    if (!abiItem || abiItem.type !== "function") {
+    const abiItem = this.abi.find(
+      (abiItem2) => abiItem2?.name === decoded.functionName && abiItem2?.type === "function"
+    );
+    if (!abiItem) {
       return `Unknown function: ${decoded.functionName}`;
     }
-    const params = this.stringifyFunctionParams(decoded).map(
-      (v, i) => `${abiItem.inputs[i].name}: ${v}`
-    );
-    return `${this.name}.${decoded.functionName}({${params.join(", ")}})`;
+    let paramsHuman;
+    const humanParams = this.parseFunctionParams(decoded);
+    if (humanParams) {
+      paramsHuman = humanParams.map((value, i) => {
+        return `${abiItem.inputs[i].name}: ${value}`;
+      });
+    } else if (Array.isArray(decoded.args)) {
+      paramsHuman = decoded.args.map((value, i) => {
+        return `${abiItem.inputs[i].name}: ${abiItem.inputs[i].type === "address" ? this.labelAddress(value) : abiItem.inputs[i].type.startsWith("tuple") ? (0, import_utils.json_stringify)(value) : value}`;
+      });
+    } else {
+      paramsHuman = Object.entries(decoded.args || {}).map(
+        ([key, value]) => `${key}: ${value}`
+      );
+    }
+    return `${this.name}.${decoded.functionName}({${paramsHuman.join(", ")}})`;
   }
   /**
-   * Pretty-prints values of function arguments (do not include parameter names)
-   * Can be overriden in classes, but use this super implementation as fallback
-   *
-   * @param decoded - Function arguments decoded by viem
+   * Return args and function name from calldata
+   * @param calldata
    * @returns
    */
-  stringifyFunctionParams(decoded) {
-    const abiItem = (0, import_viem.getAbiItem)({
+  parseFunctionDataToObject(calldata) {
+    const decoded = (0, import_viem.decodeFunctionData)({
       abi: this.abi,
-      name: decoded.functionName,
-      args: decoded.args
+      data: calldata
     });
-    if (Array.isArray(decoded.args)) {
-      return decoded.args.map((v, i) => {
-        return abiItem.inputs[i].type === "address" ? this.labelAddress(v) : abiItem.inputs[i].type.startsWith("tuple") ? (0, import_utils.json_stringify)(v) : `${v}`;
-      });
-    }
-    return Object.entries(decoded.args || {}).map((v) => `${v}`);
+    return decoded;
   }
-  wrapParseCall(functionName, args) {
-    return {
-      chainId: this.chainId,
-      target: this.address,
-      contractType: this.contractType,
-      label: this.register.labelAddress(this.address),
-      functionName,
-      args
-    };
+  parseFunctionParams(_params) {
+    return void 0;
+  }
+  async getVersion() {
+    this.version = Number(
+      await this.sdk.client.readContract({
+        abi: import_iVersion.iVersionAbi,
+        functionName: "version",
+        address: this.address
+      })
+    );
+    return this.version;
   }
-  /**
-   * Creates a raw transaction for a function in this contract
-   * @param parameters
-   * @returns
-   */
   createRawTx(parameters) {
     const { description: argsDescription } = parameters;
     const tx = (0, import_utils.createRawTx)(
@@ -222,72 +168,11 @@ class BaseContract extends import_Construct.Construct {
       },
       argsDescription
     );
-    tx.description = argsDescription || this.stringifyFunctionData(tx.callData);
+    tx.description = argsDescription || this.parseFunctionData(tx.callData);
     return tx;
   }
-  /**
-   * Get events in safe manner, by bisecting block range if needed
-   *
-   * @deprecated TODO: this should be moved to viem transport
-   *
-   * @param eventName
-   * @param fromBlock
-   * @param toBlock
-   * @param args
-   * @param chunkSize
-   * @returns
-   */
-  async getEvents(eventName, fromBlock, toBlock, args, chunkSize) {
-    if (chunkSize) {
-      const chunkSizeBigint = BigInt(chunkSize);
-      const getEventPromises = [];
-      for (let i = fromBlock; i < toBlock; i += chunkSizeBigint) {
-        getEventPromises.push(
-          this.client.getContractEvents({
-            address: this.address,
-            fromBlock: i,
-            toBlock: i + chunkSizeBigint,
-            abi: this.abi,
-            eventName,
-            args
-          })
-        );
-      }
-      const events = (await Promise.all(getEventPromises)).flat();
-      return events;
-    }
-    try {
-      const events = await this.client.getContractEvents({
-        address: this.address,
-        fromBlock,
-        toBlock,
-        abi: this.abi,
-        eventName,
-        args
-      });
-      return events;
-    } catch (e) {
-      const blockRangeErrors = [
-        "query exceeds max block",
-        "range is too large",
-        "eth_getLogs is limited to",
-        "Unable to perform request",
-        "Block range limit exceeded"
-      ];
-      if (e instanceof Error && blockRangeErrors.some((errorText) => e.message.includes(errorText))) {
-        const middle = (fromBlock + toBlock) / 2n;
-        const [firstHalfEvents, secondHalfEvents] = await Promise.all([
-          this.getEvents(eventName, fromBlock, middle, args),
-          this.getEvents(eventName, middle + 1n, toBlock, args)
-        ]);
-        return [...firstHalfEvents, ...secondHalfEvents];
-      }
-      throw e;
-    }
-  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  BaseContract,
-  ContractParseError
+  BaseContract
 });

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

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var IAddressLabeller_exports = {};
+module.exports = __toCommonJS(IAddressLabeller_exports);

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

@@ -21,13 +21,39 @@ __export(SDKConstruct_exports, {
   SDKConstruct: () => SDKConstruct
 });
 module.exports = __toCommonJS(SDKConstruct_exports);
-var import_Construct = require("./Construct.js");
-class SDKConstruct extends import_Construct.Construct {
+class SDKConstruct {
   sdk;
+  /**
+   * Indicates that contract state needs to be updated
+   */
+  #dirty = false;
   constructor(sdk) {
-    super(sdk);
     this.sdk = sdk;
   }
+  get networkType() {
+    return this.sdk.networkType;
+  }
+  get client() {
+    return this.sdk.client;
+  }
+  /**
+   * Indicates that contract state needs to be updated
+   */
+  get dirty() {
+    return this.#dirty;
+  }
+  set dirty(value) {
+    this.#dirty = value;
+  }
+  labelAddress(address) {
+    return this.sdk.labelAddress(address);
+  }
+  /**
+   * Returns list of addresses that should be watched for events to sync state
+   */
+  get watchAddresses() {
+    return /* @__PURE__ */ new Set();
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -25,11 +25,11 @@ var import_iVersion = require("../../abi/iVersion.js");
 var import__ = require("../index.js");
 var import_utils = require("../utils/index.js");
 class TokensMeta extends import_utils.AddressMap {
-  #client;
+  #sdk;
   #phantomTokensLoaded;
-  constructor(client) {
+  constructor(sdk) {
     super(void 0, "tokensMeta");
-    this.#client = client;
+    this.#sdk = sdk;
   }
   symbol(token) {
     return this.mustGet(token).symbol;
@@ -84,7 +84,7 @@ class TokensMeta extends import_utils.AddressMap {
   async loadPhantomTokens() {
     this.#phantomTokensLoaded = new import_utils.AddressSet();
     const tokens = this.keys();
-    const resp = await this.#client.multicall({
+    const resp = await this.#sdk.client.multicall({
       contracts: tokens.map(
         (t) => ({
           address: t,

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

@@ -15,18 +15,16 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var base_exports = {};
 module.exports = __toCommonJS(base_exports);
+__reExport(base_exports, require("./AddressLabeller.js"), module.exports);
 __reExport(base_exports, require("./BaseContract.js"), module.exports);
-__reExport(base_exports, require("./ChainContractsRegister.js"), module.exports);
-__reExport(base_exports, require("./Construct.js"), module.exports);
 __reExport(base_exports, require("./PlaceholderContract.js"), module.exports);
 __reExport(base_exports, require("./SDKConstruct.js"), module.exports);
 __reExport(base_exports, require("./TokensMeta.js"), module.exports);
 __reExport(base_exports, require("./types.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ...require("./AddressLabeller.js"),
   ...require("./BaseContract.js"),
-  ...require("./ChainContractsRegister.js"),
-  ...require("./Construct.js"),
   ...require("./PlaceholderContract.js"),
   ...require("./SDKConstruct.js"),
   ...require("./TokensMeta.js"),

package/dist/cjs/sdk/core/BotListV3Contract.js

@@ -32,7 +32,7 @@ class BotListContract extends import_base.BaseContract {
     super(sdk, { addr: address, name: "BotListV3", abi });
     this.#currentBlock = sdk.chain.firstBlock ?? 0n;
   }
-  stringifyFunctionParams(params) {
+  parseFunctionParams(params) {
     switch (params.functionName) {
       case "setCreditManagerApprovedStatus": {
         const [creditManager, status] = params.args;
@@ -47,7 +47,7 @@ class BotListContract extends import_base.BaseContract {
         ];
       }
       default:
-        return super.stringifyFunctionParams(params);
+        return void 0;
     }
   }
   async syncState(toBlock) {

package/dist/cjs/sdk/core/GearStakingV3Contract.js

@@ -29,14 +29,14 @@ class GearStakingContract extends import_base.BaseContract {
   constructor(sdk, address) {
     super(sdk, { addr: address, name: "GearStakingV3", abi });
   }
-  stringifyFunctionParams(params) {
+  parseFunctionParams(params) {
     switch (params.functionName) {
       case "setVotingContractStatus": {
         const [address, status] = params.args;
         return [this.labelAddress(address), import_base.VotingContractStatus[status]];
       }
       default:
-        return super.stringifyFunctionParams(params);
+        return void 0;
     }
   }
   stateHuman(raw = true) {