@gearbox-protocol/sdk 16.0.0-next.2 → 16.0.0-next.21

package/dist/types/onchain/accounts/withdrawal-compressor/errors.d.ts

@@ -0,0 +1,16 @@
+import { Hex } from "viem";
+//#region src/onchain/accounts/withdrawal-compressor/errors.d.ts
+/**
+ * Thrown when a delayed-withdrawal request or redemption log carries
+ * non-empty `extraData` that cannot be decoded as a `DelayedIntent`.
+ * Requests produced by our stack always encode a valid intent, so garbage
+ * here means a malformed/foreign transaction that must not be previewed as
+ * if it were fine.
+ */
+declare class InvalidDelayedIntentError extends Error {
+  /** Raw `extraData` that failed to decode. */
+  readonly extraData: Hex;
+  constructor(extraData: Hex, cause?: unknown);
+}
+//#endregion
+export { InvalidDelayedIntentError };

package/dist/types/onchain/accounts/withdrawal-compressor/intent-codec.d.ts

@@ -0,0 +1,30 @@
+import { DelayedIntent } from "../../../model/delayed-intents.js";
+import "../../../model/index.js";
+import { Hex } from "viem";
+//#region src/onchain/accounts/withdrawal-compressor/intent-codec.d.ts
+/**
+ * Current version of the delayed intent encoding schema.
+ * Bump when the layout of any intent type changes.
+ **/
+declare const DELAYED_INTENT_VERSION = 1;
+/**
+ * Stable uint8 discriminants for intent types.
+ * Starts at 1 so that all-zero data cannot decode as a valid intent.
+ * Never reuse or renumber existing values.
+ **/
+declare const DELAYED_INTENT_TYPES: Record<DelayedIntent["type"], number>;
+/**
+ * ABI-encodes a delayed intent as
+ * `(uint8 version, uint8 intentType, ...intent-specific fields)`.
+ * @throws if the intent has an unknown type or fields that cannot be
+ * abi-encoded (e.g. an invalid address)
+ **/
+declare function encodeDelayedIntent(intent: DelayedIntent): Hex;
+/**
+ * Decodes a delayed intent from abi-encoded `extraData`.
+ * @throws if data is empty, malformed, has an unsupported version,
+ * or an unknown intent type
+ **/
+declare function decodeDelayedIntent(data: Hex): DelayedIntent;
+//#endregion
+export { DELAYED_INTENT_TYPES, DELAYED_INTENT_VERSION, decodeDelayedIntent, encodeDelayedIntent };

package/dist/types/onchain/accounts/withdrawal-compressor/types.d.ts

@@ -0,0 +1,410 @@
+import { DelayedIntent } from "../../../model/delayed-intents.js";
+import "../../../model/index.js";
+import { MulticallBatch } from "../../utils/viem/executeMulticallBatches.js";
+import "../../utils/viem/index.js";
+import { IBaseContract } from "../../base/types.js";
+import { MultiCall } from "../../types/transactions.js";
+import "../../types/index.js";
+import "../../base/index.js";
+import { Address, Hex } from "viem";
+//#region src/onchain/accounts/withdrawal-compressor/types.d.ts
+/**
+ * Delayed intent decoded from `extraData`, enriched with data known at read time.
+ **/
+type DelayedIntentExtended = DelayedIntent & {
+  /**
+   * Credit manager of the credit account the withdrawal belongs to
+   **/
+  creditManager: Address;
+};
+/**
+ * A single output of a (delayed) withdrawal: one token amount produced by
+ * requesting or claiming a withdrawal.
+ **/
+interface WithdrawalOutput {
+  /**
+   * Output token. For a delayed output, this is the withdrawal phantom token;
+   * otherwise the actual token received (usually the withdrawable asset's
+   * `underlying`)
+   **/
+  token: Address;
+  /**
+   * When `false`, the amount lands on the credit account immediately.
+   * When `true`, the amount is only represented by the withdrawal phantom
+   * token and becomes claimable after the withdrawal delay. A request can
+   * produce both kinds at once, e.g. Mellow serves the liquid part of a
+   * withdrawal instantly and queues the remainder
+   **/
+  isDelayed: boolean;
+  /**
+   * Amount of `token` produced (or expected to be produced) by the withdrawal
+   **/
+  amount: bigint;
+}
+/**
+ * An asset that can be withdrawn from a credit manager via delayed withdrawal.
+ **/
+interface WithdrawableAsset {
+  /**
+   * Credit manager the asset is withdrawable from
+   **/
+  creditManager: Address;
+  /**
+   * Source token: the collateral that is spent when the
+   * withdrawal is requested, e.g. a Mellow multivault share, a Securitize
+   * dsToken or a Midas mToken
+   **/
+  token: Address;
+  /**
+   * Withdrawal phantom token: a non-transferable collateral
+   * token that represents the in-flight withdrawal position on the credit
+   * account while the withdrawal is pending
+   **/
+  withdrawalPhantomToken: Address;
+  /**
+   * Target token: the token ultimately received when the
+   * withdrawal is claimed
+   **/
+  underlying: Address;
+  /**
+   * Expected delay between requesting and claiming a withdrawal, in seconds
+   **/
+  withdrawalLength: bigint;
+  /**
+   * Maximum number of simultaneously open withdrawal requests per credit
+   * account.
+   * Not available on v310 compressors
+   **/
+  maxWithdrawals?: bigint;
+}
+/**
+ * A single delayed withdrawal that is ready to be claimed.
+ **/
+interface ClaimableWithdrawal {
+  /**
+   * Source token the withdrawal was requested from
+   **/
+  token: Address;
+  /**
+   * Withdrawal phantom token that represents this withdrawal position
+   **/
+  withdrawalPhantomToken: Address;
+  /**
+   * Amount of the withdrawal phantom token that will be burned when the
+   * withdrawal is claimed
+   **/
+  withdrawalTokenSpent: bigint;
+  /**
+   * Tokens received by the credit account upon claiming
+   **/
+  outputs: WithdrawalOutput[];
+  /**
+   * Credit facade multicall (adapter calls) that executes the claim
+   **/
+  claimCalls: MultiCall[];
+  /**
+   * Redeemer contract the withdrawal is claimed from. `undefined` on
+   * compressor versions below 313, which do not report it
+   **/
+  redeemer?: Address;
+  /**
+   * Delayed intent decoded from the withdrawal's `extraData`, enriched with
+   * the credit manager of the credit account. `undefined` on compressor
+   * versions below 313, and on v313+ when the withdrawal was requested
+   * without an intent (empty `extraData`).
+   **/
+  intent?: DelayedIntentExtended;
+}
+/**
+ * A single pending delayed withdrawal that is not yet claimable.
+ **/
+interface PendingWithdrawal {
+  /**
+   * Source token the withdrawal was requested from
+   **/
+  token: Address;
+  /**
+   * Withdrawal phantom token that represents this withdrawal position
+   **/
+  withdrawalPhantomToken: Address;
+  /**
+   * Estimated tokens the credit account will receive once the withdrawal
+   * matures and is claimed
+   **/
+  expectedOutputs: WithdrawalOutput[];
+  /**
+   * Unix timestamp (in seconds) when the withdrawal becomes claimable
+   **/
+  claimableAt: bigint;
+  /**
+   * Redeemer contract the withdrawal will be claimed from. `undefined` on
+   * compressor versions below 313, which do not report it
+   **/
+  redeemer?: Address;
+  /**
+   * Delayed intent decoded from the withdrawal's `extraData`, enriched with
+   * the credit manager of the credit account. `undefined` on compressor
+   * versions below 313, and on v313+ when the withdrawal was requested
+   * without an intent (empty `extraData`).
+   **/
+  intent?: DelayedIntentExtended;
+}
+/**
+ * Result of previewing a delayed withdrawal request.
+ **/
+interface RequestableWithdrawal {
+  /**
+   * Source token that will be spent by the request
+   **/
+  token: Address;
+  /**
+   * Amount of `token` that will actually be spent; the contract caps the
+   * requested amount at the credit account's balance
+   **/
+  amountIn: bigint;
+  /**
+   * Expected outputs of the request: instant outputs land on the credit
+   * account in the same transaction, delayed outputs become claimable
+   * at `claimableAt`
+   **/
+  outputs: WithdrawalOutput[];
+  /**
+   * Credit facade multicall (adapter calls) that submits the withdrawal request
+   **/
+  requestCalls: MultiCall[];
+  /**
+   * Estimated unix timestamp (in seconds) when the delayed outputs become
+   * claimable
+   **/
+  claimableAt: bigint;
+}
+/**
+ * Delayed withdrawals of a credit account, split into immediately claimable
+ * and still-pending entries.
+ **/
+interface CurrentWithdrawals {
+  /**
+   * Withdrawals that have matured and can be claimed now
+   **/
+  claimable: ClaimableWithdrawal[];
+  /**
+   * Withdrawals that are still maturing
+   **/
+  pending: PendingWithdrawal[];
+}
+/**
+ * Status of a single delayed withdrawal (redeemer contract).
+ * Mirrors the on-chain `WithdrawalStatus` enum.
+ **/
+type WithdrawalStatus = "NULL" | "PENDING" | "CLAIMABLE" | "CLAIMED";
+/**
+ * Maps the on-chain `WithdrawalStatus` enum value to its string representation.
+ **/
+declare function toWithdrawalStatus(status: number): WithdrawalStatus;
+/**
+ * Serializable snapshot of the withdrawal compressor's assets cache,
+ * stored in the core SDK state (`GearboxState.withdrawals`).
+ **/
+interface WithdrawalsState {
+  /**
+   * Cached withdrawable assets, keyed by credit manager
+   **/
+  withdrawableAssets: Record<Address, WithdrawableAsset[]>;
+}
+/**
+ * Props for {@link IWithdrawalCompressorContract.getExternalAccountCurrentWithdrawals}.
+ **/
+interface GetExternalAccountCurrentWithdrawalsProps {
+  /**
+   * External address (non-credit-account, e.g. liquidator EOA) that owns
+   * the redemption receipts.
+   **/
+  account: Address;
+  /**
+   * Withdrawal phantom tokens to query. Empty or omitted returns empty lists.
+   **/
+  withdrawalTokens?: Address[];
+  /**
+   * Block to read at. Defaults to the latest block.
+   **/
+  blockNumber?: bigint;
+}
+/**
+ * Props for {@link IWithdrawalCompressorContract.getWithdrawalRequestResult}.
+ **/
+interface GetWithdrawalRequestResultProps {
+  /**
+   * Credit account to withdraw from
+   **/
+  creditAccount: Address;
+  /**
+   * Source token to withdraw (e.g. a Mellow multivault share, a Securitize
+   * dsToken or a Midas mToken)
+   **/
+  token: Address;
+  /**
+   * Amount of `token` to withdraw; capped at the credit account's balance
+   * by the contract
+   **/
+  amount: bigint;
+  /**
+   * Withdrawal phantom token that selects a specific withdrawal config when
+   * the source token has more than one. When omitted, the contract resolves
+   * it from the first matching withdrawable asset of the account's credit
+   * manager
+   **/
+  withdrawalPhantomToken?: Address;
+  /**
+   * Delayed intent to attach to the request as `extraData` (v313+ only)
+   **/
+  intent?: DelayedIntent;
+}
+/**
+ * Version-agnostic interface of the WithdrawalCompressor contract.
+ **/
+interface IWithdrawalCompressorContract extends IBaseContract {
+  /**
+   * Returns cached assets that can be withdrawn via delayed withdrawal.
+   * With no arguments, returns assets of all credit managers; with arguments,
+   * only assets of the given credit managers.
+   * @throws When the cache was never loaded (via {@link loadWithdrawableAssets}
+   * or state hydration).
+   **/
+  getWithdrawableAssets(...creditManagers: Address[]): WithdrawableAsset[];
+  /**
+   * @internal
+   *
+   * Returns the multicall batch that loads withdrawable assets of all credit
+   * managers known to the SDK's market register. Used by the SDK to warm this
+   * cache together with other loaders in a single multicall.
+   *
+   * Returns an empty batch when the cache is already loaded and `force` is not set.
+   *
+   * @param force - Invalidate the cache and refetch even if already loaded.
+   **/
+  getLoadWithdrawableAssetsMulticall(force?: boolean): MulticallBatch;
+  /**
+   * Loads withdrawable assets of all credit managers known to the SDK's
+   * market register into the cache (a single multicall, only once per SDK
+   * lifetime) and returns them. Failed per-manager calls are logged and
+   * skipped.
+   *
+   * Assets loaded during SDK attach or restored by state hydration are kept
+   * unless `force` is set, so calling this after either is a no-op.
+   *
+   * @param force - Invalidate the cache and refetch even if already loaded.
+   * @param blockNumber - Block to read at. Defaults to the latest block.
+   **/
+  loadWithdrawableAssets(force?: boolean, blockNumber?: bigint): Promise<WithdrawableAsset[]>;
+  /**
+   * Returns all withdrawal configs of a withdrawable source token
+   * (e.g. a Mellow multivault share) of the given credit manager.
+   * Loads the cache if necessary.
+   **/
+  findWithdrawableAssets(creditManager: Address, token: Address): Promise<WithdrawableAsset[]>;
+  /**
+   * Returns withdrawal configs with the given withdrawal phantom token
+   * across all credit managers. Loads the cache if necessary.
+   **/
+  findWithdrawableAssetsByPhantomToken(withdrawalPhantomToken: Address): Promise<WithdrawableAsset[]>;
+  /**
+   * Resolves the withdrawal phantom token for a withdrawable source token
+   * (e.g. a Mellow multivault share) of the given credit manager.
+   * @throws When the token is not withdrawable from the credit manager.
+   **/
+  getWithdrawalPhantomToken(creditManager: Address, token: Address): Promise<Address>;
+  /**
+   * Resolves the source token of a withdrawal phantom token (e.g. `ACRED` for
+   * `srpACRED_USDC`), or `undefined` when the token is not a known withdrawal
+   * phantom token. The phantom-to-source binding is fixed at phantom token
+   * deployment, so no credit manager is needed.
+   * @throws When the cache was never loaded (via {@link loadWithdrawableAssets}
+   * or state hydration).
+   **/
+  getWithdrawalSourceToken(withdrawalPhantomToken: Address): Address | undefined;
+  /**
+   * Returns claimable and pending delayed withdrawals of the given credit account.
+   *
+   * @param creditAccount - Credit account to query.
+   * @param blockNumber - Block to read at. Defaults to the latest block.
+   **/
+  getCurrentWithdrawals(creditAccount: Address, blockNumber?: bigint): Promise<CurrentWithdrawals>;
+  /**
+   * Returns claimable and pending delayed withdrawals of an external address
+   * (non-credit-account, e.g. liquidator EOA) in the given withdrawal phantom
+   * tokens. With no tokens given, returns empty lists.
+   * Only supported on v313+ compressors; on older versions throws if
+   * `sdk.strictContractTypes` is `true`, otherwise logs a warning and
+   * returns empty lists.
+   **/
+  getExternalAccountCurrentWithdrawals(props: GetExternalAccountCurrentWithdrawalsProps): Promise<CurrentWithdrawals>;
+  /**
+   * Returns statuses of the given redeemer contracts.
+   * Only supported on v313+ compressors; on older versions throws if
+   * `sdk.strictContractTypes` is `true`, otherwise logs a warning and
+   * returns `"NULL"` statuses.
+   **/
+  getWithdrawalStatus(...redeemers: Address[]): Promise<WithdrawalStatus[]>;
+  /**
+   * Previews a delayed withdrawal request.
+   *
+   * When `intent` is provided, it is abi-encoded and passed as `extraData` to
+   * the contract on v313+ compressors. On older versions, passing an intent
+   * throws if `sdk.strictContractTypes` is `true`, otherwise a warning is
+   * logged and the intent is ignored.
+   **/
+  getWithdrawalRequestResult(props: GetWithdrawalRequestResultProps): Promise<RequestableWithdrawal>;
+  /**
+   * Seeds the assets cache from a previously serialized snapshot.
+   **/
+  hydrate(state: WithdrawalsState): void;
+  /**
+   * Serializable snapshot of the assets cache, or `undefined` if the cache
+   * was never loaded.
+   **/
+  readonly state: WithdrawalsState | undefined;
+}
+/**
+ * Redemption data logged by a delayed-withdrawal gateway (Securitize, Midas)
+ * when a redemption is requested, keyed by the redeemer contract address.
+ **/
+interface RedemptionLog {
+  /**
+   * Credit account the redemption was requested for
+   */
+  creditAccount: Address;
+  /**
+   * Redeemer contract address
+   */
+  redeemer: Address;
+  /**
+   * Additional redemption data; carries the abi-encoded `DelayedIntent`
+   * when the request had one, `0x` otherwise
+   */
+  extraData: Hex;
+}
+/**
+ * Version-agnostic interface of the RedemptionLogger contract that stores
+ * redemption data logged by delayed-withdrawal gateways for off-chain
+ * indexing.
+ **/
+interface IRedemptionLoggerContract extends IBaseContract {
+  /**
+   * Returns the redemption data logged for a redeemer; all-zero fields when
+   * nothing was logged for it.
+   **/
+  getRedemptionLog(redeemer: Address, blockNumber?: bigint): Promise<RedemptionLog>;
+  /**
+   * Reads the redemption log of a redeemer and decodes the recorded intent.
+   *
+   * @param redeemer - Redeemer contract the withdrawal is claimed from.
+   * @param blockNumber - Optional block number to read the log at.
+   * @returns The decoded intent, or `undefined` when the log carries none
+   * (including when nothing was logged for the redeemer).
+   * @throws InvalidDelayedIntentError when the logged `extraData` is
+   * non-empty but cannot be decoded as a `DelayedIntent`.
+   **/
+  getDelayedIntent(redeemer: Address, blockNumber?: bigint): Promise<DelayedIntent | undefined>;
+}
+//#endregion
+export { ClaimableWithdrawal, CurrentWithdrawals, DelayedIntentExtended, GetExternalAccountCurrentWithdrawalsProps, GetWithdrawalRequestResultProps, IRedemptionLoggerContract, IWithdrawalCompressorContract, PendingWithdrawal, RedemptionLog, RequestableWithdrawal, WithdrawableAsset, WithdrawalOutput, WithdrawalStatus, WithdrawalsState, toWithdrawalStatus };

package/dist/types/onchain/base/BaseContract.d.ts

@@ -0,0 +1,193 @@
+import { SimulateCallOptions } from "../utils/viem/simulateCall.js";
+import { IBaseContract, ParsedCall, ParsedCallArgs, ParsedCallV2 } from "./types.js";
+import { BaseContractStateHuman } from "../types/state-human.js";
+import { RawTx } from "../types/transactions.js";
+import { Construct, ConstructOptions } from "./Construct.js";
+import "../types/index.js";
+import { Abi, Address, BaseError, Chain, ContractEventArgs, ContractEventName, ContractFunctionName, DecodeFunctionDataReturnType, EncodeFunctionDataParameters, GetContractEventsReturnType, GetContractReturnType, Hex, Log, PublicClient, Transport } from "viem";
+//#region src/onchain/base/BaseContract.d.ts
+/**
+ * Arguments for constructing a {@link BaseContract}.
+ **/
+interface BaseContractArgs<abi extends Abi | readonly unknown[]> {
+  /**
+   * Contract ABI used for encoding/decoding.
+   **/
+  abi: abi;
+  /**
+   *  On-chain address of the contract.
+   **/
+  addr: Address;
+  /**
+   * Optional display name for the contract.
+   **/
+  name?: string;
+  /**
+   * Contract version
+   * @default 0
+   **/
+  version?: number | bigint;
+  /**
+   * Gearbox contract type identifier (hex bytes32 or parsed string).
+   **/
+  contractType?: string;
+}
+/**
+ * Options supplied to the {@link ContractParseError} constructor.
+ **/
+interface ContractParseErrorOptions {
+  /**
+   * Address of the contract where parsing failed.
+   **/
+  address: Address;
+  /**
+   * Raw calldata that could not be decoded.
+   **/
+  callData: Hex;
+  /**
+   * Optional display name for the contract.
+   **/
+  contractName?: string;
+}
+/**
+ * Error thrown when calldata cannot be decoded against a contract's ABI.
+ * Captures the target address and raw calldata for diagnostics.
+ */
+declare class ContractParseError extends BaseError {
+  readonly address: Address;
+  readonly callData: Hex;
+  readonly selector: Hex;
+  constructor(cause: Error, options: ContractParseErrorOptions);
+}
+/**
+ * Wrapper around a single on-chain contract, providing calldata decoding,
+ * event fetching, and human-readable state output.
+ *
+ * @typeParam abi - Narrowed ABI type for this contract.
+ **/
+declare class BaseContract<abi extends Abi | readonly unknown[]> extends Construct implements IBaseContract {
+  /**
+   * Viem contract instance for direct read calls
+   **/
+  readonly contract: GetContractReturnType<abi, PublicClient<Transport, Chain>, Address>;
+  /**
+   * Contract ABI
+   **/
+  readonly abi: abi;
+  /**
+   * Gearbox contract type identifier (e.g. `"CREDIT_MANAGER"`), or empty string if unknown.
+   **/
+  readonly contractType: string;
+  /**
+   * Contract version number.
+   * @default 0
+   **/
+  readonly version: number;
+  /**
+   * On-chain address of the contract.
+   **/
+  readonly address: Address;
+  /**
+   * Display name for the contract.
+   **/
+  readonly name: string;
+  constructor(options: ConstructOptions, args: BaseContractArgs<abi>);
+  /** {@inheritDoc IBaseContract.stateHuman} */
+  stateHuman(_?: boolean): BaseContractStateHuman;
+  /**
+   * Applies an on-chain event to update this contract's local state.
+   *
+   * @param _log - Decoded event log emitted by this contract.
+   **/
+  processLog(_log: Log<bigint, number, false, undefined, undefined, abi, ContractEventName<abi>>): void;
+  /**
+   * Return parsed args and function name from calldata belonging to this contract
+   * 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: Hex): ParsedCall;
+  /**
+   * Same as {@link parseFunctionData}, but throws {@link ContractParseError} if error occurs
+   * @param callData
+   * @returns
+   */
+  mustParseFunctionData(callData: Hex): ParsedCall;
+  /**
+   * 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
+   */
+  protected parseFunctionParams(params: DecodeFunctionDataReturnType<abi>): ParsedCallArgs;
+  /**
+   * Converts contract calldata to some human-friendly string
+   * This is safe function which should not throw
+   * @param calldata
+   * @returns
+   */
+  stringifyFunctionData(calldata: Hex): string;
+  /**
+   * Same as {@link stringifyFunctionData}, but throws if error occurs.
+   * @param calldata - Raw ABI-encoded calldata.
+   */
+  mustStringifyFunctionData(calldata: Hex): string;
+  /**
+   * 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
+   */
+  protected stringifyFunctionParams(decoded: DecodeFunctionDataReturnType<abi>): string[];
+  protected wrapParseCall(functionName: string, args: Record<string, string>): ParsedCall;
+  /**
+   * 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: Hex, strict?: boolean): ParsedCallV2;
+  /**
+   * 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
+   */
+  protected parseFunctionParamsV2(params: DecodeFunctionDataReturnType<abi>, _strict?: boolean): Record<string, unknown>;
+  protected wrapParseCallV2(functionName: string, calldata: Hex, rawArgs: Record<string, unknown>): ParsedCallV2;
+  /**
+   * Creates a raw transaction for a function in this contract
+   * @param parameters
+   * @returns
+   */
+  createRawTx<functionName extends ContractFunctionName<abi> | undefined = undefined>(parameters: Omit<EncodeFunctionDataParameters<abi, functionName>, "abi"> & {
+    description?: string;
+  }): RawTx;
+  /**
+   * 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.
+   */
+  simulateCall(callData: Hex, options?: SimulateCallOptions<Chain>): Promise<Hex>;
+  /**
+   * 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
+   */
+  getEvents<EventName extends ContractEventName<abi>>(eventName: EventName, fromBlock: bigint, toBlock: bigint, args?: ContractEventArgs<abi, EventName extends ContractEventName<abi> ? EventName : ContractEventName<abi>> | undefined, chunkSize?: number): Promise<GetContractEventsReturnType<abi, EventName, undefined, bigint, bigint>>;
+}
+//#endregion
+export { BaseContract, BaseContractArgs, ContractParseError, ContractParseErrorOptions };