@gearbox-protocol/sdk 15.0.0 → 15.1.0-next.2

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

@@ -1,367 +1,343 @@
-"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 });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_abi_errors = require("../../abi/errors.js");
+const require_sdk_utils_json = require("../utils/json.js");
+const require_sdk_utils_abi_decode = require("../utils/abi-decode.js");
+const require_sdk_utils_bytes32ToString = require("../utils/bytes32ToString.js");
+const require_sdk_utils_createRawTx = require("../utils/createRawTx.js");
+require("../utils/index.js");
+const require_sdk_utils_viem_simulateCall = require("../utils/viem/simulateCall.js");
+const require_sdk_base_Construct = require("./Construct.js");
+let viem = require("viem");
+//#region src/sdk/base/BaseContract.ts
+/**
+* Error thrown when calldata cannot be decoded against a contract's ABI.
+* Captures the target address and raw calldata for diagnostics.
+*/
+var ContractParseError = class extends 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;
+	}
 };
-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;
+/**
+* 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.
+**/
+var BaseContract = class extends require_sdk_base_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);
+		this.abi = args.abi;
+		this.address = (0, viem.getAddress)(args.addr);
+		this.contract = (0, viem.getContract)({
+			address: this.address,
+			abi: [...this.abi, ...require_abi_errors.errorAbis],
+			client: this.client
+		});
+		this.version = Number(args.version || 0);
+		this.contractType = args.contractType ?? "";
+		if ((0, viem.isHex)(this.contractType)) this.contractType = require_sdk_utils_bytes32ToString.bytes32ToString(this.contractType);
+		this.name = args.name || this.contractType || this.address || this.constructor.name;
+		const register = this.safeGetRegister();
+		if (register) {
+			register.setContract(this.address, this);
+			register.setAddressLabel(this.address, this.name);
+		}
+	}
+	/** {@inheritDoc IBaseContract.stateHuman} */
+	stateHuman(_ = true) {
+		return {
+			address: this.labelAddress(this.address),
+			version: this.version,
+			contractType: this.contractType
+		};
+	}
+	/**
+	* Applies an on-chain event to update this contract's local state.
+	*
+	* @param _log - Decoded event log emitted by this contract.
+	**/
+	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, 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 require_sdk_utils_abi_decode.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) {
+		try {
+			return this.mustStringifyFunctionData(calldata);
+		} catch (e) {
+			const selector = calldata.slice(0, 10);
+			this.logger?.warn(`error parsing function with selector ${selector} in ${this.name} v${this.version} at ${this.address}: ${e}`);
+			return `unknown: ${this.labelAddress(this.address)}.${selector}`;
+		}
+	}
+	/**
+	* Same as {@link stringifyFunctionData}, but throws if error occurs.
+	* @param calldata - Raw ABI-encoded calldata.
+	*/
+	mustStringifyFunctionData(calldata) {
+		const decoded = (0, viem.decodeFunctionData)({
+			abi: this.abi,
+			data: calldata
+		});
+		const abiItem = (0, viem.getAbiItem)({
+			abi: this.abi,
+			name: decoded.functionName,
+			args: decoded.args
+		});
+		if (!abiItem || abiItem.type !== "function") 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(", ")}})`;
+	}
+	/**
+	* 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
+	* @returns
+	*/
+	stringifyFunctionParams(decoded) {
+		const abiItem = (0, viem.getAbiItem)({
+			abi: this.abi,
+			name: decoded.functionName,
+			args: decoded.args
+		});
+		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") ? require_sdk_utils_json.json_stringify(v) : `${v}`;
+		});
+		return Object.entries(decoded.args || {}).map((v) => `${v}`);
+	}
+	wrapParseCall(functionName, args) {
+		return {
+			chainId: this.chainId,
+			target: this.address,
+			contractType: this.contractType,
+			label: this.labelAddress(this.address, true),
+			functionName,
+			args
+		};
+	}
+	/**
+	* Parses calldata into structured result with preserved original types.
+	* When strict is true, throws {@link ContractParseError} on unknown selectors;
+	* otherwise returns a fallback with the raw calldata.
+	*/
+	parseFunctionDataV2(calldata, strict) {
+		try {
+			const decoded = (0, viem.decodeFunctionData)({
+				abi: this.abi,
+				data: calldata
+			});
+			const functionName = require_sdk_utils_abi_decode.getFunctionSignature(this.abi, calldata);
+			return this.wrapParseCallV2(functionName, calldata, this.parseFunctionParamsV2(decoded, strict));
+		} catch (e) {
+			if (strict) throw new ContractParseError(e, {
+				address: this.address,
+				callData: calldata,
+				contractName: this.name
+			});
+			this.logger?.warn(e);
+			const selector = calldata.slice(0, 10);
+			const data = `0x${calldata.slice(10)}`;
+			return this.wrapParseCallV2(`unknown function ${selector}`, calldata, { _data: data });
+		}
+	}
+	/**
+	* Converts viem-decoded function arguments to a record preserving original types.
+	* Override in subclasses to handle nesting (e.g., multicall inner calls).
+	* @param strict - propagated from parseFunctionDataV2 for recursive parsing
+	*/
+	parseFunctionParamsV2(params, _strict) {
+		return require_sdk_utils_abi_decode.functionArgsToRecord(this.abi, params.functionName, params.args);
+	}
+	wrapParseCallV2(functionName, calldata, rawArgs) {
+		return {
+			chainId: this.chainId,
+			target: this.address,
+			contractType: this.contractType,
+			label: this.labelAddress(this.address, true),
+			version: this.version,
+			functionName,
+			calldata,
+			rawArgs
+		};
+	}
+	/**
+	* Creates a raw transaction for a function in this contract
+	* @param parameters
+	* @returns
+	*/
+	createRawTx(parameters) {
+		const { description: argsDescription } = parameters;
+		const tx = require_sdk_utils_createRawTx.createRawTx(this.address, {
+			...parameters,
+			abi: this.abi
+		}, argsDescription);
+		tx.description = argsDescription || this.stringifyFunctionData(tx.callData);
+		return tx;
+	}
+	/**
+	* Simulates calldata against this contract with `eth_call`, returning the raw response.
+	*
+	* Nothing is encoded or decoded on success: pass calldata that already exists (e.g. from
+	* {@link createRawTx}) instead of decoding it into a function name and arguments first.
+	* On revert, this contract's abi and the shared exception abis are used to decode the error.
+	*
+	* @param callData - Encoded calldata, passed to the node as-is.
+	* @param options - Call options, plus any extra `abis` needed to decode custom errors.
+	* @throws {@link SimulationError} when the call reverts or the request fails.
+	*/
+	async simulateCall(callData, options = {}) {
+		const { abis = [], ...rest } = options;
+		const { data } = await require_sdk_utils_viem_simulateCall.simulateCall(this.client, {
+			...rest,
+			to: this.address,
+			data: callData,
+			abis: [
+				this.abi,
+				require_abi_errors.errorAbis,
+				...abis
+			]
+		});
+		return data;
+	}
+	/**
+	* 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
+			}));
+			return (await Promise.all(getEventPromises)).flat();
+		}
+		try {
+			return await this.client.getContractEvents({
+				address: this.address,
+				fromBlock,
+				toBlock,
+				abi: this.abi,
+				eventName,
+				args
+			});
+		} catch (e) {
+			if (e instanceof Error && [
+				"query exceeds max block",
+				"range is too large",
+				"eth_getLogs is limited to",
+				"Unable to perform request",
+				"Block range limit exceeded"
+			].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;
+		}
+	}
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var BaseContract_exports = {};
-__export(BaseContract_exports, {
-  BaseContract: () => BaseContract,
-  ContractParseError: () => ContractParseError
-});
-module.exports = __toCommonJS(BaseContract_exports);
-var import_viem = require("viem");
-var import_errors = require("../../abi/errors.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 {
-  /**
-   * 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);
-    this.abi = args.abi;
-    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: this.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;
-    const register = this.safeGetRegister();
-    if (register) {
-      register.setContract(this.address, this);
-      register.setAddressLabel(this.address, this.name);
-    }
-  }
-  /** {@inheritDoc IBaseContract.stateHuman} */
-  stateHuman(_ = true) {
-    return {
-      address: this.labelAddress(this.address),
-      version: this.version,
-      contractType: this.contractType
-    };
-  }
-  /**
-   * Applies an on-chain event to update this contract's local state.
-   *
-   * @param _log - Decoded event log emitted by this contract.
-   **/
-  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) {
-    try {
-      return this.mustStringifyFunctionData(calldata);
-    } catch (e) {
-      const selector = calldata.slice(0, 10);
-      this.logger?.warn(
-        `error parsing function with selector ${selector} in ${this.name} v${this.version} at ${this.address}: ${e}`
-      );
-      return `unknown: ${this.labelAddress(this.address)}.${selector}`;
-    }
-  }
-  /**
-   * Same as {@link stringifyFunctionData}, but throws if error occurs.
-   * @param calldata - Raw ABI-encoded calldata.
-   */
-  mustStringifyFunctionData(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") {
-      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(", ")}})`;
-  }
-  /**
-   * 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
-   * @returns
-   */
-  stringifyFunctionParams(decoded) {
-    const abiItem = (0, import_viem.getAbiItem)({
-      abi: this.abi,
-      name: decoded.functionName,
-      args: decoded.args
-    });
-    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}`);
-  }
-  wrapParseCall(functionName, args) {
-    return {
-      chainId: this.chainId,
-      target: this.address,
-      contractType: this.contractType,
-      label: this.labelAddress(this.address, true),
-      functionName,
-      args
-    };
-  }
-  /**
-   * Parses calldata into structured result with preserved original types.
-   * When strict is true, throws {@link ContractParseError} on unknown selectors;
-   * otherwise returns a fallback with the raw calldata.
-   */
-  parseFunctionDataV2(calldata, strict) {
-    try {
-      const decoded = (0, import_viem.decodeFunctionData)({
-        abi: this.abi,
-        data: calldata
-      });
-      const functionName = (0, import_utils.getFunctionSignature)(this.abi, calldata);
-      return this.wrapParseCallV2(
-        functionName,
-        this.parseFunctionParamsV2(decoded, strict)
-      );
-    } catch (e) {
-      if (strict) {
-        throw new ContractParseError(e, {
-          address: this.address,
-          callData: calldata,
-          contractName: this.name
-        });
-      }
-      this.logger?.warn(e);
-      const selector = calldata.slice(0, 10);
-      const data = `0x${calldata.slice(10)}`;
-      return this.wrapParseCallV2(`unknown function ${selector}`, {
-        _data: data
-      });
-    }
-  }
-  /**
-   * Converts viem-decoded function arguments to a record preserving original types.
-   * Override in subclasses to handle nesting (e.g., multicall inner calls).
-   * @param strict - propagated from parseFunctionDataV2 for recursive parsing
-   */
-  parseFunctionParamsV2(params, _strict) {
-    return (0, import_utils.functionArgsToRecord)(this.abi, params.functionName, params.args);
-  }
-  wrapParseCallV2(functionName, rawArgs) {
-    return {
-      chainId: this.chainId,
-      target: this.address,
-      contractType: this.contractType,
-      label: this.labelAddress(this.address, true),
-      version: this.version,
-      functionName,
-      rawArgs
-    };
-  }
-  /**
-   * 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)(
-      this.address,
-      {
-        ...parameters,
-        abi: this.abi
-      },
-      argsDescription
-    );
-    tx.description = argsDescription || this.stringifyFunctionData(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
-});
+//#endregion
+exports.BaseContract = BaseContract;
+exports.ContractParseError = ContractParseError;