/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
} from "ethers";
import {
  Contract,
  ContractTransaction,
  Overrides,
  PayableOverrides,
  CallOverrides,
} from "@ethersproject/contracts";
import { BytesLike } from "@ethersproject/bytes";
import { Listener, Provider } from "@ethersproject/providers";
import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";

interface StarkInterface extends ethers.utils.Interface {
  functions: {
    "VERSION()": FunctionFragment;
    "initialize(bytes)": FunctionFragment;
    "DEPOSIT_CANCEL_DELAY()": FunctionFragment;
    "FREEZE_GRACE_PERIOD()": FunctionFragment;
    "MAIN_GOVERNANCE_INFO_TAG()": FunctionFragment;
    "MAX_VERIFIER_COUNT()": FunctionFragment;
    "UNFREEZE_DELAY()": FunctionFragment;
    "VERIFIER_REMOVAL_DELAY()": FunctionFragment;
    "announceAvailabilityVerifierRemovalIntent(address)": FunctionFragment;
    "announceVerifierRemovalIntent(address)": FunctionFragment;
    "getRegisteredAvailabilityVerifiers()": FunctionFragment;
    "getRegisteredVerifiers()": FunctionFragment;
    "isAvailabilityVerifier(address)": FunctionFragment;
    "isFrozen()": FunctionFragment;
    "isVerifier(address)": FunctionFragment;
    "mainAcceptGovernance()": FunctionFragment;
    "mainCancelNomination()": FunctionFragment;
    "mainIsGovernor(address)": FunctionFragment;
    "mainNominateNewGovernor(address)": FunctionFragment;
    "mainRemoveGovernor(address)": FunctionFragment;
    "registerAvailabilityVerifier(address,string)": FunctionFragment;
    "registerVerifier(address,string)": FunctionFragment;
    "removeAvailabilityVerifier(address)": FunctionFragment;
    "removeVerifier(address)": FunctionFragment;
    "unFreeze()": FunctionFragment;
    "deposit(uint256,uint256,uint256)": FunctionFragment;
    "depositCancel(uint256,uint256,uint256)": FunctionFragment;
    "depositNft(uint256,uint256,uint256,uint256)": FunctionFragment;
    "depositNftReclaim(uint256,uint256,uint256,uint256)": FunctionFragment;
    "depositReclaim(uint256,uint256,uint256)": FunctionFragment;
    "freezeRequest(uint256,uint256)": FunctionFragment;
    "fullWithdrawalRequest(uint256,uint256)": FunctionFragment;
    "getAssetInfo(uint256)": FunctionFragment;
    "getCancellationRequest(uint256,uint256,uint256)": FunctionFragment;
    "getDepositBalance(uint256,uint256,uint256)": FunctionFragment;
    "getEthKey(uint256)": FunctionFragment;
    "getFullWithdrawalRequest(uint256,uint256)": FunctionFragment;
    "getQuantizedDepositBalance(uint256,uint256,uint256)": FunctionFragment;
    "getQuantum(uint256)": FunctionFragment;
    "getWithdrawalBalance(uint256,uint256)": FunctionFragment;
    "isOperator(address)": FunctionFragment;
    "isTokenAdmin(address)": FunctionFragment;
    "isUserAdmin(address)": FunctionFragment;
    "onERC721Received(address,address,uint256,bytes)": FunctionFragment;
    "registerOperator(address)": FunctionFragment;
    "registerToken(uint256,bytes)": FunctionFragment;
    "registerTokenAdmin(address)": FunctionFragment;
    "registerUser(address,uint256,bytes)": FunctionFragment;
    "registerUserAdmin(address)": FunctionFragment;
    "unregisterOperator(address)": FunctionFragment;
    "unregisterTokenAdmin(address)": FunctionFragment;
    "unregisterUserAdmin(address)": FunctionFragment;
    "withdraw(uint256,uint256)": FunctionFragment;
    "withdrawAndMint(uint256,uint256,bytes)": FunctionFragment;
    "withdrawNft(uint256,uint256,uint256)": FunctionFragment;
    "withdrawNftTo(uint256,uint256,uint256,address)": FunctionFragment;
    "withdrawTo(uint256,uint256,address)": FunctionFragment;
    "escape(uint256,uint256,uint256,uint256)": FunctionFragment;
    "getLastBatchId()": FunctionFragment;
    "getOrderRoot()": FunctionFragment;
    "getOrderTreeHeight()": FunctionFragment;
    "getSequenceNumber()": FunctionFragment;
    "getVaultRoot()": FunctionFragment;
    "getVaultTreeHeight()": FunctionFragment;
    "updateState(uint256[],uint256[])": FunctionFragment;
  };

  encodeFunctionData(functionFragment: "VERSION", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "DEPOSIT_CANCEL_DELAY",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "FREEZE_GRACE_PERIOD",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MAIN_GOVERNANCE_INFO_TAG",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MAX_VERIFIER_COUNT",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "UNFREEZE_DELAY",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "VERIFIER_REMOVAL_DELAY",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "announceAvailabilityVerifierRemovalIntent",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "announceVerifierRemovalIntent",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getRegisteredAvailabilityVerifiers",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getRegisteredVerifiers",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "isAvailabilityVerifier",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "isFrozen", values?: undefined): string;
  encodeFunctionData(functionFragment: "isVerifier", values: [string]): string;
  encodeFunctionData(
    functionFragment: "mainAcceptGovernance",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "mainCancelNomination",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "mainIsGovernor",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "mainNominateNewGovernor",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "mainRemoveGovernor",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "registerAvailabilityVerifier",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "registerVerifier",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "removeAvailabilityVerifier",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "removeVerifier",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "unFreeze", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "deposit",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "depositCancel",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "depositNft",
    values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "depositNftReclaim",
    values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "depositReclaim",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "freezeRequest",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "fullWithdrawalRequest",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getAssetInfo",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getCancellationRequest",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getDepositBalance",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getEthKey",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getFullWithdrawalRequest",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getQuantizedDepositBalance",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getQuantum",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getWithdrawalBalance",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "isOperator", values: [string]): string;
  encodeFunctionData(
    functionFragment: "isTokenAdmin",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "isUserAdmin", values: [string]): string;
  encodeFunctionData(
    functionFragment: "onERC721Received",
    values: [string, string, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "registerOperator",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "registerToken",
    values: [BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "registerTokenAdmin",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "registerUser",
    values: [string, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "registerUserAdmin",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "unregisterOperator",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "unregisterTokenAdmin",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "unregisterUserAdmin",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "withdraw",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawAndMint",
    values: [BigNumberish, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawNft",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawNftTo",
    values: [BigNumberish, BigNumberish, BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawTo",
    values: [BigNumberish, BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "escape",
    values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getLastBatchId",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getOrderRoot",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getOrderTreeHeight",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getSequenceNumber",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getVaultRoot",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getVaultTreeHeight",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "updateState",
    values: [BigNumberish[], BigNumberish[]]
  ): string;

  decodeFunctionResult(functionFragment: "VERSION", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "DEPOSIT_CANCEL_DELAY",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "FREEZE_GRACE_PERIOD",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MAIN_GOVERNANCE_INFO_TAG",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MAX_VERIFIER_COUNT",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "UNFREEZE_DELAY",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "VERIFIER_REMOVAL_DELAY",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "announceAvailabilityVerifierRemovalIntent",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "announceVerifierRemovalIntent",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRegisteredAvailabilityVerifiers",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRegisteredVerifiers",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isAvailabilityVerifier",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "isFrozen", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "isVerifier", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "mainAcceptGovernance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "mainCancelNomination",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "mainIsGovernor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "mainNominateNewGovernor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "mainRemoveGovernor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "registerAvailabilityVerifier",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "registerVerifier",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "removeAvailabilityVerifier",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "removeVerifier",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "unFreeze", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "depositCancel",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "depositNft", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "depositNftReclaim",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "depositReclaim",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "freezeRequest",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "fullWithdrawalRequest",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getAssetInfo",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getCancellationRequest",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDepositBalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getEthKey", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getFullWithdrawalRequest",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getQuantizedDepositBalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getQuantum", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getWithdrawalBalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "isOperator", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isTokenAdmin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isUserAdmin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "onERC721Received",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "registerOperator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "registerToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "registerTokenAdmin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "registerUser",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "registerUserAdmin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "unregisterOperator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "unregisterTokenAdmin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "unregisterUserAdmin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "withdrawAndMint",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawNft",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawNftTo",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "withdrawTo", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "escape", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getLastBatchId",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getOrderRoot",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getOrderTreeHeight",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getSequenceNumber",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getVaultRoot",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getVaultTreeHeight",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateState",
    data: BytesLike
  ): Result;

  events: {
    "LogFrozen()": EventFragment;
    "LogNewGovernorAccepted(address)": EventFragment;
    "LogNominatedGovernor(address)": EventFragment;
    "LogNominationCancelled()": EventFragment;
    "LogRemovedGovernor(address)": EventFragment;
    "LogUnFrozen()": EventFragment;
    "LogDeposit(address,uint256,uint256,uint256,uint256,uint256)": EventFragment;
    "LogDepositCancel(uint256,uint256,uint256)": EventFragment;
    "LogDepositCancelReclaimed(uint256,uint256,uint256,uint256,uint256)": EventFragment;
    "LogDepositNftCancelReclaimed(uint256,uint256,uint256,uint256,uint256)": EventFragment;
    "LogFullWithdrawalRequest(uint256,uint256)": EventFragment;
    "LogMintWithdrawalPerformed(uint256,uint256,uint256,uint256,uint256)": EventFragment;
    "LogMintableWithdrawalAllowed(uint256,uint256,uint256)": EventFragment;
    "LogNftDeposit(address,uint256,uint256,uint256,uint256,uint256)": EventFragment;
    "LogNftWithdrawalAllowed(uint256,uint256)": EventFragment;
    "LogNftWithdrawalPerformed(uint256,uint256,uint256,uint256,address)": EventFragment;
    "LogOperatorAdded(address)": EventFragment;
    "LogOperatorRemoved(address)": EventFragment;
    "LogTokenAdminAdded(address)": EventFragment;
    "LogTokenAdminRemoved(address)": EventFragment;
    "LogTokenRegistered(uint256,bytes)": EventFragment;
    "LogUserAdminAdded(address)": EventFragment;
    "LogUserAdminRemoved(address)": EventFragment;
    "LogUserRegistered(address,uint256,address)": EventFragment;
    "LogWithdrawalAllowed(uint256,uint256,uint256,uint256)": EventFragment;
    "LogWithdrawalPerformed(uint256,uint256,uint256,uint256,address)": EventFragment;
    "LogRootUpdate(uint256,uint256,uint256,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "LogFrozen"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogNewGovernorAccepted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogNominatedGovernor"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogNominationCancelled"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogRemovedGovernor"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogUnFrozen"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogDeposit"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogDepositCancel"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogDepositCancelReclaimed"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "LogDepositNftCancelReclaimed"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogFullWithdrawalRequest"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogMintWithdrawalPerformed"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "LogMintableWithdrawalAllowed"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogNftDeposit"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogNftWithdrawalAllowed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogNftWithdrawalPerformed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogOperatorAdded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogOperatorRemoved"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogTokenAdminAdded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogTokenAdminRemoved"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogTokenRegistered"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogUserAdminAdded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogUserAdminRemoved"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogUserRegistered"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogWithdrawalAllowed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogWithdrawalPerformed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LogRootUpdate"): EventFragment;
}

export class Stark extends Contract {
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  on(event: EventFilter | string, listener: Listener): this;
  once(event: EventFilter | string, listener: Listener): this;
  addListener(eventName: EventFilter | string, listener: Listener): this;
  removeAllListeners(eventName: EventFilter | string): this;
  removeListener(eventName: any, listener: Listener): this;

  interface: StarkInterface;

  functions: {
    VERSION(overrides?: CallOverrides): Promise<[string]>;

    "VERSION()"(overrides?: CallOverrides): Promise<[string]>;

    initialize(
      data: BytesLike,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "initialize(bytes)"(
      data: BytesLike,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    DEPOSIT_CANCEL_DELAY(overrides?: CallOverrides): Promise<[BigNumber]>;

    "DEPOSIT_CANCEL_DELAY()"(overrides?: CallOverrides): Promise<[BigNumber]>;

    FREEZE_GRACE_PERIOD(overrides?: CallOverrides): Promise<[BigNumber]>;

    "FREEZE_GRACE_PERIOD()"(overrides?: CallOverrides): Promise<[BigNumber]>;

    MAIN_GOVERNANCE_INFO_TAG(overrides?: CallOverrides): Promise<[string]>;

    "MAIN_GOVERNANCE_INFO_TAG()"(overrides?: CallOverrides): Promise<[string]>;

    MAX_VERIFIER_COUNT(overrides?: CallOverrides): Promise<[BigNumber]>;

    "MAX_VERIFIER_COUNT()"(overrides?: CallOverrides): Promise<[BigNumber]>;

    UNFREEZE_DELAY(overrides?: CallOverrides): Promise<[BigNumber]>;

    "UNFREEZE_DELAY()"(overrides?: CallOverrides): Promise<[BigNumber]>;

    VERIFIER_REMOVAL_DELAY(overrides?: CallOverrides): Promise<[BigNumber]>;

    "VERIFIER_REMOVAL_DELAY()"(overrides?: CallOverrides): Promise<[BigNumber]>;

    announceAvailabilityVerifierRemovalIntent(
      verifier: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "announceAvailabilityVerifierRemovalIntent(address)"(
      verifier: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    announceVerifierRemovalIntent(
      verifier: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "announceVerifierRemovalIntent(address)"(
      verifier: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    getRegisteredAvailabilityVerifiers(
      overrides?: CallOverrides
    ): Promise<[string[]] & { _verifers: string[] }>;

    "getRegisteredAvailabilityVerifiers()"(
      overrides?: CallOverrides
    ): Promise<[string[]] & { _verifers: string[] }>;

    getRegisteredVerifiers(
      overrides?: CallOverrides
    ): Promise<[string[]] & { _verifers: string[] }>;

    "getRegisteredVerifiers()"(
      overrides?: CallOverrides
    ): Promise<[string[]] & { _verifers: string[] }>;

    isAvailabilityVerifier(
      verifierAddress: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    "isAvailabilityVerifier(address)"(
      verifierAddress: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    isFrozen(
      overrides?: CallOverrides
    ): Promise<[boolean] & { frozen: boolean }>;

    "isFrozen()"(
      overrides?: CallOverrides
    ): Promise<[boolean] & { frozen: boolean }>;

    isVerifier(
      verifierAddress: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    "isVerifier(address)"(
      verifierAddress: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    mainAcceptGovernance(overrides?: Overrides): Promise<ContractTransaction>;

    "mainAcceptGovernance()"(
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    mainCancelNomination(overrides?: Overrides): Promise<ContractTransaction>;

    "mainCancelNomination()"(
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    mainIsGovernor(
      testGovernor: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    "mainIsGovernor(address)"(
      testGovernor: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    mainNominateNewGovernor(
      newGovernor: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "mainNominateNewGovernor(address)"(
      newGovernor: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    mainRemoveGovernor(
      governorForRemoval: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "mainRemoveGovernor(address)"(
      governorForRemoval: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    registerAvailabilityVerifier(
      verifier: string,
      identifier: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "registerAvailabilityVerifier(address,string)"(
      verifier: string,
      identifier: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    registerVerifier(
      verifier: string,
      identifier: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "registerVerifier(address,string)"(
      verifier: string,
      identifier: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    removeAvailabilityVerifier(
      verifier: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "removeAvailabilityVerifier(address)"(
      verifier: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    removeVerifier(
      verifier: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "removeVerifier(address)"(
      verifier: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    unFreeze(overrides?: Overrides): Promise<ContractTransaction>;

    "unFreeze()"(overrides?: Overrides): Promise<ContractTransaction>;

    "deposit(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      overrides?: PayableOverrides
    ): Promise<ContractTransaction>;

    "deposit(uint256,uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      quantizedAmount: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    depositCancel(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "depositCancel(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    depositNft(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "depositNft(uint256,uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    depositNftReclaim(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "depositNftReclaim(uint256,uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    depositReclaim(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "depositReclaim(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    freezeRequest(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "freezeRequest(uint256,uint256)"(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    fullWithdrawalRequest(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "fullWithdrawalRequest(uint256,uint256)"(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    getAssetInfo(
      assetType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string] & { assetInfo: string }>;

    "getAssetInfo(uint256)"(
      assetType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string] & { assetInfo: string }>;

    getCancellationRequest(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { request: BigNumber }>;

    "getCancellationRequest(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { request: BigNumber }>;

    getDepositBalance(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { balance: BigNumber }>;

    "getDepositBalance(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { balance: BigNumber }>;

    getEthKey(
      starkKey: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string] & { ethKey: string }>;

    "getEthKey(uint256)"(
      starkKey: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string] & { ethKey: string }>;

    getFullWithdrawalRequest(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { res: BigNumber }>;

    "getFullWithdrawalRequest(uint256,uint256)"(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { res: BigNumber }>;

    getQuantizedDepositBalance(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { balance: BigNumber }>;

    "getQuantizedDepositBalance(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { balance: BigNumber }>;

    getQuantum(
      presumedAssetType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { quantum: BigNumber }>;

    "getQuantum(uint256)"(
      presumedAssetType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { quantum: BigNumber }>;

    getWithdrawalBalance(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { balance: BigNumber }>;

    "getWithdrawalBalance(uint256,uint256)"(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { balance: BigNumber }>;

    isOperator(
      testedOperator: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    "isOperator(address)"(
      testedOperator: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    isTokenAdmin(
      testedAdmin: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    "isTokenAdmin(address)"(
      testedAdmin: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    isUserAdmin(
      testedAdmin: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    "isUserAdmin(address)"(
      testedAdmin: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    onERC721Received(
      arg0: string,
      arg1: string,
      arg2: BigNumberish,
      arg3: BytesLike,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "onERC721Received(address,address,uint256,bytes)"(
      arg0: string,
      arg1: string,
      arg2: BigNumberish,
      arg3: BytesLike,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    registerOperator(
      newOperator: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "registerOperator(address)"(
      newOperator: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "registerToken(uint256,bytes)"(
      assetType: BigNumberish,
      assetInfo: BytesLike,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "registerToken(uint256,bytes,uint256)"(
      assetType: BigNumberish,
      assetInfo: BytesLike,
      quantum: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    registerTokenAdmin(
      newAdmin: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "registerTokenAdmin(address)"(
      newAdmin: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    registerUser(
      ethKey: string,
      starkKey: BigNumberish,
      signature: BytesLike,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "registerUser(address,uint256,bytes)"(
      ethKey: string,
      starkKey: BigNumberish,
      signature: BytesLike,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    registerUserAdmin(
      newAdmin: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "registerUserAdmin(address)"(
      newAdmin: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    unregisterOperator(
      removedOperator: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "unregisterOperator(address)"(
      removedOperator: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    unregisterTokenAdmin(
      oldAdmin: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "unregisterTokenAdmin(address)"(
      oldAdmin: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    unregisterUserAdmin(
      oldAdmin: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "unregisterUserAdmin(address)"(
      oldAdmin: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    withdraw(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "withdraw(uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    withdrawAndMint(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      mintingBlob: BytesLike,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "withdrawAndMint(uint256,uint256,bytes)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      mintingBlob: BytesLike,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    withdrawNft(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "withdrawNft(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    withdrawNftTo(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      tokenId: BigNumberish,
      recipient: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "withdrawNftTo(uint256,uint256,uint256,address)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      tokenId: BigNumberish,
      recipient: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    withdrawTo(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      recipient: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "withdrawTo(uint256,uint256,address)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      recipient: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    escape(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      assetId: BigNumberish,
      quantizedAmount: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "escape(uint256,uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      assetId: BigNumberish,
      quantizedAmount: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    getLastBatchId(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { batchId: BigNumber }>;

    "getLastBatchId()"(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { batchId: BigNumber }>;

    getOrderRoot(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { root: BigNumber }>;

    "getOrderRoot()"(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { root: BigNumber }>;

    getOrderTreeHeight(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { height: BigNumber }>;

    "getOrderTreeHeight()"(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { height: BigNumber }>;

    getSequenceNumber(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { seq: BigNumber }>;

    "getSequenceNumber()"(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { seq: BigNumber }>;

    getVaultRoot(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { root: BigNumber }>;

    "getVaultRoot()"(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { root: BigNumber }>;

    getVaultTreeHeight(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { height: BigNumber }>;

    "getVaultTreeHeight()"(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { height: BigNumber }>;

    updateState(
      publicInput: BigNumberish[],
      applicationData: BigNumberish[],
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "updateState(uint256[],uint256[])"(
      publicInput: BigNumberish[],
      applicationData: BigNumberish[],
      overrides?: Overrides
    ): Promise<ContractTransaction>;
  };

  VERSION(overrides?: CallOverrides): Promise<string>;

  "VERSION()"(overrides?: CallOverrides): Promise<string>;

  initialize(
    data: BytesLike,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "initialize(bytes)"(
    data: BytesLike,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  DEPOSIT_CANCEL_DELAY(overrides?: CallOverrides): Promise<BigNumber>;

  "DEPOSIT_CANCEL_DELAY()"(overrides?: CallOverrides): Promise<BigNumber>;

  FREEZE_GRACE_PERIOD(overrides?: CallOverrides): Promise<BigNumber>;

  "FREEZE_GRACE_PERIOD()"(overrides?: CallOverrides): Promise<BigNumber>;

  MAIN_GOVERNANCE_INFO_TAG(overrides?: CallOverrides): Promise<string>;

  "MAIN_GOVERNANCE_INFO_TAG()"(overrides?: CallOverrides): Promise<string>;

  MAX_VERIFIER_COUNT(overrides?: CallOverrides): Promise<BigNumber>;

  "MAX_VERIFIER_COUNT()"(overrides?: CallOverrides): Promise<BigNumber>;

  UNFREEZE_DELAY(overrides?: CallOverrides): Promise<BigNumber>;

  "UNFREEZE_DELAY()"(overrides?: CallOverrides): Promise<BigNumber>;

  VERIFIER_REMOVAL_DELAY(overrides?: CallOverrides): Promise<BigNumber>;

  "VERIFIER_REMOVAL_DELAY()"(overrides?: CallOverrides): Promise<BigNumber>;

  announceAvailabilityVerifierRemovalIntent(
    verifier: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "announceAvailabilityVerifierRemovalIntent(address)"(
    verifier: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  announceVerifierRemovalIntent(
    verifier: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "announceVerifierRemovalIntent(address)"(
    verifier: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  getRegisteredAvailabilityVerifiers(
    overrides?: CallOverrides
  ): Promise<string[]>;

  "getRegisteredAvailabilityVerifiers()"(
    overrides?: CallOverrides
  ): Promise<string[]>;

  getRegisteredVerifiers(overrides?: CallOverrides): Promise<string[]>;

  "getRegisteredVerifiers()"(overrides?: CallOverrides): Promise<string[]>;

  isAvailabilityVerifier(
    verifierAddress: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  "isAvailabilityVerifier(address)"(
    verifierAddress: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isFrozen(overrides?: CallOverrides): Promise<boolean>;

  "isFrozen()"(overrides?: CallOverrides): Promise<boolean>;

  isVerifier(
    verifierAddress: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  "isVerifier(address)"(
    verifierAddress: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  mainAcceptGovernance(overrides?: Overrides): Promise<ContractTransaction>;

  "mainAcceptGovernance()"(overrides?: Overrides): Promise<ContractTransaction>;

  mainCancelNomination(overrides?: Overrides): Promise<ContractTransaction>;

  "mainCancelNomination()"(overrides?: Overrides): Promise<ContractTransaction>;

  mainIsGovernor(
    testGovernor: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  "mainIsGovernor(address)"(
    testGovernor: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  mainNominateNewGovernor(
    newGovernor: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "mainNominateNewGovernor(address)"(
    newGovernor: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  mainRemoveGovernor(
    governorForRemoval: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "mainRemoveGovernor(address)"(
    governorForRemoval: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  registerAvailabilityVerifier(
    verifier: string,
    identifier: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "registerAvailabilityVerifier(address,string)"(
    verifier: string,
    identifier: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  registerVerifier(
    verifier: string,
    identifier: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "registerVerifier(address,string)"(
    verifier: string,
    identifier: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  removeAvailabilityVerifier(
    verifier: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "removeAvailabilityVerifier(address)"(
    verifier: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  removeVerifier(
    verifier: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "removeVerifier(address)"(
    verifier: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  unFreeze(overrides?: Overrides): Promise<ContractTransaction>;

  "unFreeze()"(overrides?: Overrides): Promise<ContractTransaction>;

  "deposit(uint256,uint256,uint256)"(
    starkKey: BigNumberish,
    assetType: BigNumberish,
    vaultId: BigNumberish,
    overrides?: PayableOverrides
  ): Promise<ContractTransaction>;

  "deposit(uint256,uint256,uint256,uint256)"(
    starkKey: BigNumberish,
    assetType: BigNumberish,
    vaultId: BigNumberish,
    quantizedAmount: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  depositCancel(
    starkKey: BigNumberish,
    assetId: BigNumberish,
    vaultId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "depositCancel(uint256,uint256,uint256)"(
    starkKey: BigNumberish,
    assetId: BigNumberish,
    vaultId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  depositNft(
    starkKey: BigNumberish,
    assetType: BigNumberish,
    vaultId: BigNumberish,
    tokenId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "depositNft(uint256,uint256,uint256,uint256)"(
    starkKey: BigNumberish,
    assetType: BigNumberish,
    vaultId: BigNumberish,
    tokenId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  depositNftReclaim(
    starkKey: BigNumberish,
    assetType: BigNumberish,
    vaultId: BigNumberish,
    tokenId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "depositNftReclaim(uint256,uint256,uint256,uint256)"(
    starkKey: BigNumberish,
    assetType: BigNumberish,
    vaultId: BigNumberish,
    tokenId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  depositReclaim(
    starkKey: BigNumberish,
    assetType: BigNumberish,
    vaultId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "depositReclaim(uint256,uint256,uint256)"(
    starkKey: BigNumberish,
    assetType: BigNumberish,
    vaultId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  freezeRequest(
    starkKey: BigNumberish,
    vaultId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "freezeRequest(uint256,uint256)"(
    starkKey: BigNumberish,
    vaultId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  fullWithdrawalRequest(
    starkKey: BigNumberish,
    vaultId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "fullWithdrawalRequest(uint256,uint256)"(
    starkKey: BigNumberish,
    vaultId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  getAssetInfo(
    assetType: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  "getAssetInfo(uint256)"(
    assetType: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  getCancellationRequest(
    starkKey: BigNumberish,
    assetId: BigNumberish,
    vaultId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "getCancellationRequest(uint256,uint256,uint256)"(
    starkKey: BigNumberish,
    assetId: BigNumberish,
    vaultId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getDepositBalance(
    starkKey: BigNumberish,
    assetId: BigNumberish,
    vaultId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "getDepositBalance(uint256,uint256,uint256)"(
    starkKey: BigNumberish,
    assetId: BigNumberish,
    vaultId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getEthKey(starkKey: BigNumberish, overrides?: CallOverrides): Promise<string>;

  "getEthKey(uint256)"(
    starkKey: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  getFullWithdrawalRequest(
    starkKey: BigNumberish,
    vaultId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "getFullWithdrawalRequest(uint256,uint256)"(
    starkKey: BigNumberish,
    vaultId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getQuantizedDepositBalance(
    starkKey: BigNumberish,
    assetId: BigNumberish,
    vaultId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "getQuantizedDepositBalance(uint256,uint256,uint256)"(
    starkKey: BigNumberish,
    assetId: BigNumberish,
    vaultId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getQuantum(
    presumedAssetType: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "getQuantum(uint256)"(
    presumedAssetType: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getWithdrawalBalance(
    starkKey: BigNumberish,
    assetId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "getWithdrawalBalance(uint256,uint256)"(
    starkKey: BigNumberish,
    assetId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  isOperator(
    testedOperator: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  "isOperator(address)"(
    testedOperator: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isTokenAdmin(
    testedAdmin: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  "isTokenAdmin(address)"(
    testedAdmin: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isUserAdmin(testedAdmin: string, overrides?: CallOverrides): Promise<boolean>;

  "isUserAdmin(address)"(
    testedAdmin: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  onERC721Received(
    arg0: string,
    arg1: string,
    arg2: BigNumberish,
    arg3: BytesLike,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "onERC721Received(address,address,uint256,bytes)"(
    arg0: string,
    arg1: string,
    arg2: BigNumberish,
    arg3: BytesLike,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  registerOperator(
    newOperator: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "registerOperator(address)"(
    newOperator: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "registerToken(uint256,bytes)"(
    assetType: BigNumberish,
    assetInfo: BytesLike,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "registerToken(uint256,bytes,uint256)"(
    assetType: BigNumberish,
    assetInfo: BytesLike,
    quantum: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  registerTokenAdmin(
    newAdmin: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "registerTokenAdmin(address)"(
    newAdmin: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  registerUser(
    ethKey: string,
    starkKey: BigNumberish,
    signature: BytesLike,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "registerUser(address,uint256,bytes)"(
    ethKey: string,
    starkKey: BigNumberish,
    signature: BytesLike,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  registerUserAdmin(
    newAdmin: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "registerUserAdmin(address)"(
    newAdmin: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  unregisterOperator(
    removedOperator: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "unregisterOperator(address)"(
    removedOperator: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  unregisterTokenAdmin(
    oldAdmin: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "unregisterTokenAdmin(address)"(
    oldAdmin: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  unregisterUserAdmin(
    oldAdmin: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "unregisterUserAdmin(address)"(
    oldAdmin: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  withdraw(
    starkKey: BigNumberish,
    assetType: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "withdraw(uint256,uint256)"(
    starkKey: BigNumberish,
    assetType: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  withdrawAndMint(
    starkKey: BigNumberish,
    assetType: BigNumberish,
    mintingBlob: BytesLike,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "withdrawAndMint(uint256,uint256,bytes)"(
    starkKey: BigNumberish,
    assetType: BigNumberish,
    mintingBlob: BytesLike,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  withdrawNft(
    starkKey: BigNumberish,
    assetType: BigNumberish,
    tokenId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "withdrawNft(uint256,uint256,uint256)"(
    starkKey: BigNumberish,
    assetType: BigNumberish,
    tokenId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  withdrawNftTo(
    starkKey: BigNumberish,
    assetType: BigNumberish,
    tokenId: BigNumberish,
    recipient: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "withdrawNftTo(uint256,uint256,uint256,address)"(
    starkKey: BigNumberish,
    assetType: BigNumberish,
    tokenId: BigNumberish,
    recipient: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  withdrawTo(
    starkKey: BigNumberish,
    assetType: BigNumberish,
    recipient: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "withdrawTo(uint256,uint256,address)"(
    starkKey: BigNumberish,
    assetType: BigNumberish,
    recipient: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  escape(
    starkKey: BigNumberish,
    vaultId: BigNumberish,
    assetId: BigNumberish,
    quantizedAmount: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "escape(uint256,uint256,uint256,uint256)"(
    starkKey: BigNumberish,
    vaultId: BigNumberish,
    assetId: BigNumberish,
    quantizedAmount: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  getLastBatchId(overrides?: CallOverrides): Promise<BigNumber>;

  "getLastBatchId()"(overrides?: CallOverrides): Promise<BigNumber>;

  getOrderRoot(overrides?: CallOverrides): Promise<BigNumber>;

  "getOrderRoot()"(overrides?: CallOverrides): Promise<BigNumber>;

  getOrderTreeHeight(overrides?: CallOverrides): Promise<BigNumber>;

  "getOrderTreeHeight()"(overrides?: CallOverrides): Promise<BigNumber>;

  getSequenceNumber(overrides?: CallOverrides): Promise<BigNumber>;

  "getSequenceNumber()"(overrides?: CallOverrides): Promise<BigNumber>;

  getVaultRoot(overrides?: CallOverrides): Promise<BigNumber>;

  "getVaultRoot()"(overrides?: CallOverrides): Promise<BigNumber>;

  getVaultTreeHeight(overrides?: CallOverrides): Promise<BigNumber>;

  "getVaultTreeHeight()"(overrides?: CallOverrides): Promise<BigNumber>;

  updateState(
    publicInput: BigNumberish[],
    applicationData: BigNumberish[],
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "updateState(uint256[],uint256[])"(
    publicInput: BigNumberish[],
    applicationData: BigNumberish[],
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  callStatic: {
    VERSION(overrides?: CallOverrides): Promise<string>;

    "VERSION()"(overrides?: CallOverrides): Promise<string>;

    initialize(data: BytesLike, overrides?: CallOverrides): Promise<void>;

    "initialize(bytes)"(
      data: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    DEPOSIT_CANCEL_DELAY(overrides?: CallOverrides): Promise<BigNumber>;

    "DEPOSIT_CANCEL_DELAY()"(overrides?: CallOverrides): Promise<BigNumber>;

    FREEZE_GRACE_PERIOD(overrides?: CallOverrides): Promise<BigNumber>;

    "FREEZE_GRACE_PERIOD()"(overrides?: CallOverrides): Promise<BigNumber>;

    MAIN_GOVERNANCE_INFO_TAG(overrides?: CallOverrides): Promise<string>;

    "MAIN_GOVERNANCE_INFO_TAG()"(overrides?: CallOverrides): Promise<string>;

    MAX_VERIFIER_COUNT(overrides?: CallOverrides): Promise<BigNumber>;

    "MAX_VERIFIER_COUNT()"(overrides?: CallOverrides): Promise<BigNumber>;

    UNFREEZE_DELAY(overrides?: CallOverrides): Promise<BigNumber>;

    "UNFREEZE_DELAY()"(overrides?: CallOverrides): Promise<BigNumber>;

    VERIFIER_REMOVAL_DELAY(overrides?: CallOverrides): Promise<BigNumber>;

    "VERIFIER_REMOVAL_DELAY()"(overrides?: CallOverrides): Promise<BigNumber>;

    announceAvailabilityVerifierRemovalIntent(
      verifier: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "announceAvailabilityVerifierRemovalIntent(address)"(
      verifier: string,
      overrides?: CallOverrides
    ): Promise<void>;

    announceVerifierRemovalIntent(
      verifier: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "announceVerifierRemovalIntent(address)"(
      verifier: string,
      overrides?: CallOverrides
    ): Promise<void>;

    getRegisteredAvailabilityVerifiers(
      overrides?: CallOverrides
    ): Promise<string[]>;

    "getRegisteredAvailabilityVerifiers()"(
      overrides?: CallOverrides
    ): Promise<string[]>;

    getRegisteredVerifiers(overrides?: CallOverrides): Promise<string[]>;

    "getRegisteredVerifiers()"(overrides?: CallOverrides): Promise<string[]>;

    isAvailabilityVerifier(
      verifierAddress: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    "isAvailabilityVerifier(address)"(
      verifierAddress: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isFrozen(overrides?: CallOverrides): Promise<boolean>;

    "isFrozen()"(overrides?: CallOverrides): Promise<boolean>;

    isVerifier(
      verifierAddress: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    "isVerifier(address)"(
      verifierAddress: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    mainAcceptGovernance(overrides?: CallOverrides): Promise<void>;

    "mainAcceptGovernance()"(overrides?: CallOverrides): Promise<void>;

    mainCancelNomination(overrides?: CallOverrides): Promise<void>;

    "mainCancelNomination()"(overrides?: CallOverrides): Promise<void>;

    mainIsGovernor(
      testGovernor: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    "mainIsGovernor(address)"(
      testGovernor: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    mainNominateNewGovernor(
      newGovernor: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "mainNominateNewGovernor(address)"(
      newGovernor: string,
      overrides?: CallOverrides
    ): Promise<void>;

    mainRemoveGovernor(
      governorForRemoval: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "mainRemoveGovernor(address)"(
      governorForRemoval: string,
      overrides?: CallOverrides
    ): Promise<void>;

    registerAvailabilityVerifier(
      verifier: string,
      identifier: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "registerAvailabilityVerifier(address,string)"(
      verifier: string,
      identifier: string,
      overrides?: CallOverrides
    ): Promise<void>;

    registerVerifier(
      verifier: string,
      identifier: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "registerVerifier(address,string)"(
      verifier: string,
      identifier: string,
      overrides?: CallOverrides
    ): Promise<void>;

    removeAvailabilityVerifier(
      verifier: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "removeAvailabilityVerifier(address)"(
      verifier: string,
      overrides?: CallOverrides
    ): Promise<void>;

    removeVerifier(verifier: string, overrides?: CallOverrides): Promise<void>;

    "removeVerifier(address)"(
      verifier: string,
      overrides?: CallOverrides
    ): Promise<void>;

    unFreeze(overrides?: CallOverrides): Promise<void>;

    "unFreeze()"(overrides?: CallOverrides): Promise<void>;

    "deposit(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "deposit(uint256,uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      quantizedAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    depositCancel(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "depositCancel(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    depositNft(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "depositNft(uint256,uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    depositNftReclaim(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "depositNftReclaim(uint256,uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    depositReclaim(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "depositReclaim(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    freezeRequest(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "freezeRequest(uint256,uint256)"(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    fullWithdrawalRequest(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "fullWithdrawalRequest(uint256,uint256)"(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    getAssetInfo(
      assetType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    "getAssetInfo(uint256)"(
      assetType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    getCancellationRequest(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getCancellationRequest(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getDepositBalance(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getDepositBalance(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getEthKey(
      starkKey: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    "getEthKey(uint256)"(
      starkKey: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    getFullWithdrawalRequest(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getFullWithdrawalRequest(uint256,uint256)"(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getQuantizedDepositBalance(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getQuantizedDepositBalance(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getQuantum(
      presumedAssetType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getQuantum(uint256)"(
      presumedAssetType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getWithdrawalBalance(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getWithdrawalBalance(uint256,uint256)"(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isOperator(
      testedOperator: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    "isOperator(address)"(
      testedOperator: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isTokenAdmin(
      testedAdmin: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    "isTokenAdmin(address)"(
      testedAdmin: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isUserAdmin(
      testedAdmin: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    "isUserAdmin(address)"(
      testedAdmin: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    onERC721Received(
      arg0: string,
      arg1: string,
      arg2: BigNumberish,
      arg3: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

    "onERC721Received(address,address,uint256,bytes)"(
      arg0: string,
      arg1: string,
      arg2: BigNumberish,
      arg3: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

    registerOperator(
      newOperator: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "registerOperator(address)"(
      newOperator: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "registerToken(uint256,bytes)"(
      assetType: BigNumberish,
      assetInfo: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    "registerToken(uint256,bytes,uint256)"(
      assetType: BigNumberish,
      assetInfo: BytesLike,
      quantum: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    registerTokenAdmin(
      newAdmin: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "registerTokenAdmin(address)"(
      newAdmin: string,
      overrides?: CallOverrides
    ): Promise<void>;

    registerUser(
      ethKey: string,
      starkKey: BigNumberish,
      signature: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    "registerUser(address,uint256,bytes)"(
      ethKey: string,
      starkKey: BigNumberish,
      signature: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    registerUserAdmin(
      newAdmin: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "registerUserAdmin(address)"(
      newAdmin: string,
      overrides?: CallOverrides
    ): Promise<void>;

    unregisterOperator(
      removedOperator: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "unregisterOperator(address)"(
      removedOperator: string,
      overrides?: CallOverrides
    ): Promise<void>;

    unregisterTokenAdmin(
      oldAdmin: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "unregisterTokenAdmin(address)"(
      oldAdmin: string,
      overrides?: CallOverrides
    ): Promise<void>;

    unregisterUserAdmin(
      oldAdmin: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "unregisterUserAdmin(address)"(
      oldAdmin: string,
      overrides?: CallOverrides
    ): Promise<void>;

    withdraw(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "withdraw(uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    withdrawAndMint(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      mintingBlob: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    "withdrawAndMint(uint256,uint256,bytes)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      mintingBlob: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    withdrawNft(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "withdrawNft(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    withdrawNftTo(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      tokenId: BigNumberish,
      recipient: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "withdrawNftTo(uint256,uint256,uint256,address)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      tokenId: BigNumberish,
      recipient: string,
      overrides?: CallOverrides
    ): Promise<void>;

    withdrawTo(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      recipient: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "withdrawTo(uint256,uint256,address)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      recipient: string,
      overrides?: CallOverrides
    ): Promise<void>;

    escape(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      assetId: BigNumberish,
      quantizedAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "escape(uint256,uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      assetId: BigNumberish,
      quantizedAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    getLastBatchId(overrides?: CallOverrides): Promise<BigNumber>;

    "getLastBatchId()"(overrides?: CallOverrides): Promise<BigNumber>;

    getOrderRoot(overrides?: CallOverrides): Promise<BigNumber>;

    "getOrderRoot()"(overrides?: CallOverrides): Promise<BigNumber>;

    getOrderTreeHeight(overrides?: CallOverrides): Promise<BigNumber>;

    "getOrderTreeHeight()"(overrides?: CallOverrides): Promise<BigNumber>;

    getSequenceNumber(overrides?: CallOverrides): Promise<BigNumber>;

    "getSequenceNumber()"(overrides?: CallOverrides): Promise<BigNumber>;

    getVaultRoot(overrides?: CallOverrides): Promise<BigNumber>;

    "getVaultRoot()"(overrides?: CallOverrides): Promise<BigNumber>;

    getVaultTreeHeight(overrides?: CallOverrides): Promise<BigNumber>;

    "getVaultTreeHeight()"(overrides?: CallOverrides): Promise<BigNumber>;

    updateState(
      publicInput: BigNumberish[],
      applicationData: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;

    "updateState(uint256[],uint256[])"(
      publicInput: BigNumberish[],
      applicationData: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    LogFrozen(): EventFilter;

    LogNewGovernorAccepted(acceptedGovernor: null): EventFilter;

    LogNominatedGovernor(nominatedGovernor: null): EventFilter;

    LogNominationCancelled(): EventFilter;

    LogRemovedGovernor(removedGovernor: null): EventFilter;

    LogUnFrozen(): EventFilter;

    LogDeposit(
      depositorEthKey: null,
      starkKey: null,
      vaultId: null,
      assetType: null,
      nonQuantizedAmount: null,
      quantizedAmount: null
    ): EventFilter;

    LogDepositCancel(starkKey: null, vaultId: null, assetId: null): EventFilter;

    LogDepositCancelReclaimed(
      starkKey: null,
      vaultId: null,
      assetType: null,
      nonQuantizedAmount: null,
      quantizedAmount: null
    ): EventFilter;

    LogDepositNftCancelReclaimed(
      starkKey: null,
      vaultId: null,
      assetType: null,
      tokenId: null,
      assetId: null
    ): EventFilter;

    LogFullWithdrawalRequest(starkKey: null, vaultId: null): EventFilter;

    LogMintWithdrawalPerformed(
      starkKey: null,
      tokenId: null,
      nonQuantizedAmount: null,
      quantizedAmount: null,
      assetId: null
    ): EventFilter;

    LogMintableWithdrawalAllowed(
      starkKey: null,
      assetId: null,
      quantizedAmount: null
    ): EventFilter;

    LogNftDeposit(
      depositorEthKey: null,
      starkKey: null,
      vaultId: null,
      assetType: null,
      tokenId: null,
      assetId: null
    ): EventFilter;

    LogNftWithdrawalAllowed(starkKey: null, assetId: null): EventFilter;

    LogNftWithdrawalPerformed(
      starkKey: null,
      assetType: null,
      tokenId: null,
      assetId: null,
      recipient: null
    ): EventFilter;

    LogOperatorAdded(operator: null): EventFilter;

    LogOperatorRemoved(operator: null): EventFilter;

    LogTokenAdminAdded(tokenAdmin: null): EventFilter;

    LogTokenAdminRemoved(tokenAdmin: null): EventFilter;

    LogTokenRegistered(assetType: null, assetInfo: null): EventFilter;

    LogUserAdminAdded(userAdmin: null): EventFilter;

    LogUserAdminRemoved(userAdmin: null): EventFilter;

    LogUserRegistered(ethKey: null, starkKey: null, sender: null): EventFilter;

    LogWithdrawalAllowed(
      starkKey: null,
      assetType: null,
      nonQuantizedAmount: null,
      quantizedAmount: null
    ): EventFilter;

    LogWithdrawalPerformed(
      starkKey: null,
      assetType: null,
      nonQuantizedAmount: null,
      quantizedAmount: null,
      recipient: null
    ): EventFilter;

    LogRootUpdate(
      sequenceNumber: null,
      batchId: null,
      vaultRoot: null,
      orderRoot: null
    ): EventFilter;
  };

  estimateGas: {
    VERSION(overrides?: CallOverrides): Promise<BigNumber>;

    "VERSION()"(overrides?: CallOverrides): Promise<BigNumber>;

    initialize(data: BytesLike, overrides?: Overrides): Promise<BigNumber>;

    "initialize(bytes)"(
      data: BytesLike,
      overrides?: Overrides
    ): Promise<BigNumber>;

    DEPOSIT_CANCEL_DELAY(overrides?: CallOverrides): Promise<BigNumber>;

    "DEPOSIT_CANCEL_DELAY()"(overrides?: CallOverrides): Promise<BigNumber>;

    FREEZE_GRACE_PERIOD(overrides?: CallOverrides): Promise<BigNumber>;

    "FREEZE_GRACE_PERIOD()"(overrides?: CallOverrides): Promise<BigNumber>;

    MAIN_GOVERNANCE_INFO_TAG(overrides?: CallOverrides): Promise<BigNumber>;

    "MAIN_GOVERNANCE_INFO_TAG()"(overrides?: CallOverrides): Promise<BigNumber>;

    MAX_VERIFIER_COUNT(overrides?: CallOverrides): Promise<BigNumber>;

    "MAX_VERIFIER_COUNT()"(overrides?: CallOverrides): Promise<BigNumber>;

    UNFREEZE_DELAY(overrides?: CallOverrides): Promise<BigNumber>;

    "UNFREEZE_DELAY()"(overrides?: CallOverrides): Promise<BigNumber>;

    VERIFIER_REMOVAL_DELAY(overrides?: CallOverrides): Promise<BigNumber>;

    "VERIFIER_REMOVAL_DELAY()"(overrides?: CallOverrides): Promise<BigNumber>;

    announceAvailabilityVerifierRemovalIntent(
      verifier: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "announceAvailabilityVerifierRemovalIntent(address)"(
      verifier: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    announceVerifierRemovalIntent(
      verifier: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "announceVerifierRemovalIntent(address)"(
      verifier: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    getRegisteredAvailabilityVerifiers(
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getRegisteredAvailabilityVerifiers()"(
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getRegisteredVerifiers(overrides?: CallOverrides): Promise<BigNumber>;

    "getRegisteredVerifiers()"(overrides?: CallOverrides): Promise<BigNumber>;

    isAvailabilityVerifier(
      verifierAddress: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "isAvailabilityVerifier(address)"(
      verifierAddress: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isFrozen(overrides?: CallOverrides): Promise<BigNumber>;

    "isFrozen()"(overrides?: CallOverrides): Promise<BigNumber>;

    isVerifier(
      verifierAddress: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "isVerifier(address)"(
      verifierAddress: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    mainAcceptGovernance(overrides?: Overrides): Promise<BigNumber>;

    "mainAcceptGovernance()"(overrides?: Overrides): Promise<BigNumber>;

    mainCancelNomination(overrides?: Overrides): Promise<BigNumber>;

    "mainCancelNomination()"(overrides?: Overrides): Promise<BigNumber>;

    mainIsGovernor(
      testGovernor: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "mainIsGovernor(address)"(
      testGovernor: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    mainNominateNewGovernor(
      newGovernor: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "mainNominateNewGovernor(address)"(
      newGovernor: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    mainRemoveGovernor(
      governorForRemoval: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "mainRemoveGovernor(address)"(
      governorForRemoval: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    registerAvailabilityVerifier(
      verifier: string,
      identifier: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "registerAvailabilityVerifier(address,string)"(
      verifier: string,
      identifier: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    registerVerifier(
      verifier: string,
      identifier: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "registerVerifier(address,string)"(
      verifier: string,
      identifier: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    removeAvailabilityVerifier(
      verifier: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "removeAvailabilityVerifier(address)"(
      verifier: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    removeVerifier(verifier: string, overrides?: Overrides): Promise<BigNumber>;

    "removeVerifier(address)"(
      verifier: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    unFreeze(overrides?: Overrides): Promise<BigNumber>;

    "unFreeze()"(overrides?: Overrides): Promise<BigNumber>;

    "deposit(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      overrides?: PayableOverrides
    ): Promise<BigNumber>;

    "deposit(uint256,uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      quantizedAmount: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    depositCancel(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "depositCancel(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    depositNft(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "depositNft(uint256,uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    depositNftReclaim(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "depositNftReclaim(uint256,uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    depositReclaim(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "depositReclaim(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    freezeRequest(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "freezeRequest(uint256,uint256)"(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    fullWithdrawalRequest(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "fullWithdrawalRequest(uint256,uint256)"(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    getAssetInfo(
      assetType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getAssetInfo(uint256)"(
      assetType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getCancellationRequest(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getCancellationRequest(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getDepositBalance(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getDepositBalance(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getEthKey(
      starkKey: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getEthKey(uint256)"(
      starkKey: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getFullWithdrawalRequest(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getFullWithdrawalRequest(uint256,uint256)"(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getQuantizedDepositBalance(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getQuantizedDepositBalance(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getQuantum(
      presumedAssetType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getQuantum(uint256)"(
      presumedAssetType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getWithdrawalBalance(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getWithdrawalBalance(uint256,uint256)"(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isOperator(
      testedOperator: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "isOperator(address)"(
      testedOperator: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isTokenAdmin(
      testedAdmin: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "isTokenAdmin(address)"(
      testedAdmin: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isUserAdmin(
      testedAdmin: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "isUserAdmin(address)"(
      testedAdmin: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    onERC721Received(
      arg0: string,
      arg1: string,
      arg2: BigNumberish,
      arg3: BytesLike,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "onERC721Received(address,address,uint256,bytes)"(
      arg0: string,
      arg1: string,
      arg2: BigNumberish,
      arg3: BytesLike,
      overrides?: Overrides
    ): Promise<BigNumber>;

    registerOperator(
      newOperator: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "registerOperator(address)"(
      newOperator: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "registerToken(uint256,bytes)"(
      assetType: BigNumberish,
      assetInfo: BytesLike,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "registerToken(uint256,bytes,uint256)"(
      assetType: BigNumberish,
      assetInfo: BytesLike,
      quantum: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    registerTokenAdmin(
      newAdmin: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "registerTokenAdmin(address)"(
      newAdmin: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    registerUser(
      ethKey: string,
      starkKey: BigNumberish,
      signature: BytesLike,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "registerUser(address,uint256,bytes)"(
      ethKey: string,
      starkKey: BigNumberish,
      signature: BytesLike,
      overrides?: Overrides
    ): Promise<BigNumber>;

    registerUserAdmin(
      newAdmin: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "registerUserAdmin(address)"(
      newAdmin: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    unregisterOperator(
      removedOperator: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "unregisterOperator(address)"(
      removedOperator: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    unregisterTokenAdmin(
      oldAdmin: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "unregisterTokenAdmin(address)"(
      oldAdmin: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    unregisterUserAdmin(
      oldAdmin: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "unregisterUserAdmin(address)"(
      oldAdmin: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    withdraw(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "withdraw(uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    withdrawAndMint(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      mintingBlob: BytesLike,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "withdrawAndMint(uint256,uint256,bytes)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      mintingBlob: BytesLike,
      overrides?: Overrides
    ): Promise<BigNumber>;

    withdrawNft(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "withdrawNft(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    withdrawNftTo(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      tokenId: BigNumberish,
      recipient: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "withdrawNftTo(uint256,uint256,uint256,address)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      tokenId: BigNumberish,
      recipient: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    withdrawTo(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      recipient: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "withdrawTo(uint256,uint256,address)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      recipient: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    escape(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      assetId: BigNumberish,
      quantizedAmount: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "escape(uint256,uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      assetId: BigNumberish,
      quantizedAmount: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    getLastBatchId(overrides?: CallOverrides): Promise<BigNumber>;

    "getLastBatchId()"(overrides?: CallOverrides): Promise<BigNumber>;

    getOrderRoot(overrides?: CallOverrides): Promise<BigNumber>;

    "getOrderRoot()"(overrides?: CallOverrides): Promise<BigNumber>;

    getOrderTreeHeight(overrides?: CallOverrides): Promise<BigNumber>;

    "getOrderTreeHeight()"(overrides?: CallOverrides): Promise<BigNumber>;

    getSequenceNumber(overrides?: CallOverrides): Promise<BigNumber>;

    "getSequenceNumber()"(overrides?: CallOverrides): Promise<BigNumber>;

    getVaultRoot(overrides?: CallOverrides): Promise<BigNumber>;

    "getVaultRoot()"(overrides?: CallOverrides): Promise<BigNumber>;

    getVaultTreeHeight(overrides?: CallOverrides): Promise<BigNumber>;

    "getVaultTreeHeight()"(overrides?: CallOverrides): Promise<BigNumber>;

    updateState(
      publicInput: BigNumberish[],
      applicationData: BigNumberish[],
      overrides?: Overrides
    ): Promise<BigNumber>;

    "updateState(uint256[],uint256[])"(
      publicInput: BigNumberish[],
      applicationData: BigNumberish[],
      overrides?: Overrides
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    VERSION(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    "VERSION()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    initialize(
      data: BytesLike,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "initialize(bytes)"(
      data: BytesLike,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    DEPOSIT_CANCEL_DELAY(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "DEPOSIT_CANCEL_DELAY()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    FREEZE_GRACE_PERIOD(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "FREEZE_GRACE_PERIOD()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    MAIN_GOVERNANCE_INFO_TAG(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "MAIN_GOVERNANCE_INFO_TAG()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    MAX_VERIFIER_COUNT(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "MAX_VERIFIER_COUNT()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    UNFREEZE_DELAY(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    "UNFREEZE_DELAY()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    VERIFIER_REMOVAL_DELAY(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "VERIFIER_REMOVAL_DELAY()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    announceAvailabilityVerifierRemovalIntent(
      verifier: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "announceAvailabilityVerifierRemovalIntent(address)"(
      verifier: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    announceVerifierRemovalIntent(
      verifier: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "announceVerifierRemovalIntent(address)"(
      verifier: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    getRegisteredAvailabilityVerifiers(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getRegisteredAvailabilityVerifiers()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getRegisteredVerifiers(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getRegisteredVerifiers()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isAvailabilityVerifier(
      verifierAddress: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "isAvailabilityVerifier(address)"(
      verifierAddress: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isFrozen(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    "isFrozen()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    isVerifier(
      verifierAddress: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "isVerifier(address)"(
      verifierAddress: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    mainAcceptGovernance(overrides?: Overrides): Promise<PopulatedTransaction>;

    "mainAcceptGovernance()"(
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    mainCancelNomination(overrides?: Overrides): Promise<PopulatedTransaction>;

    "mainCancelNomination()"(
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    mainIsGovernor(
      testGovernor: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "mainIsGovernor(address)"(
      testGovernor: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    mainNominateNewGovernor(
      newGovernor: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "mainNominateNewGovernor(address)"(
      newGovernor: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    mainRemoveGovernor(
      governorForRemoval: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "mainRemoveGovernor(address)"(
      governorForRemoval: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    registerAvailabilityVerifier(
      verifier: string,
      identifier: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "registerAvailabilityVerifier(address,string)"(
      verifier: string,
      identifier: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    registerVerifier(
      verifier: string,
      identifier: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "registerVerifier(address,string)"(
      verifier: string,
      identifier: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    removeAvailabilityVerifier(
      verifier: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "removeAvailabilityVerifier(address)"(
      verifier: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    removeVerifier(
      verifier: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "removeVerifier(address)"(
      verifier: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    unFreeze(overrides?: Overrides): Promise<PopulatedTransaction>;

    "unFreeze()"(overrides?: Overrides): Promise<PopulatedTransaction>;

    "deposit(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      overrides?: PayableOverrides
    ): Promise<PopulatedTransaction>;

    "deposit(uint256,uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      quantizedAmount: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    depositCancel(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "depositCancel(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    depositNft(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "depositNft(uint256,uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    depositNftReclaim(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "depositNftReclaim(uint256,uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    depositReclaim(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "depositReclaim(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    freezeRequest(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "freezeRequest(uint256,uint256)"(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    fullWithdrawalRequest(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "fullWithdrawalRequest(uint256,uint256)"(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    getAssetInfo(
      assetType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getAssetInfo(uint256)"(
      assetType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getCancellationRequest(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getCancellationRequest(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getDepositBalance(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getDepositBalance(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getEthKey(
      starkKey: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getEthKey(uint256)"(
      starkKey: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getFullWithdrawalRequest(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getFullWithdrawalRequest(uint256,uint256)"(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getQuantizedDepositBalance(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getQuantizedDepositBalance(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      vaultId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getQuantum(
      presumedAssetType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getQuantum(uint256)"(
      presumedAssetType: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getWithdrawalBalance(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getWithdrawalBalance(uint256,uint256)"(
      starkKey: BigNumberish,
      assetId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isOperator(
      testedOperator: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "isOperator(address)"(
      testedOperator: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isTokenAdmin(
      testedAdmin: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "isTokenAdmin(address)"(
      testedAdmin: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isUserAdmin(
      testedAdmin: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "isUserAdmin(address)"(
      testedAdmin: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    onERC721Received(
      arg0: string,
      arg1: string,
      arg2: BigNumberish,
      arg3: BytesLike,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "onERC721Received(address,address,uint256,bytes)"(
      arg0: string,
      arg1: string,
      arg2: BigNumberish,
      arg3: BytesLike,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    registerOperator(
      newOperator: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "registerOperator(address)"(
      newOperator: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "registerToken(uint256,bytes)"(
      assetType: BigNumberish,
      assetInfo: BytesLike,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "registerToken(uint256,bytes,uint256)"(
      assetType: BigNumberish,
      assetInfo: BytesLike,
      quantum: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    registerTokenAdmin(
      newAdmin: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "registerTokenAdmin(address)"(
      newAdmin: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    registerUser(
      ethKey: string,
      starkKey: BigNumberish,
      signature: BytesLike,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "registerUser(address,uint256,bytes)"(
      ethKey: string,
      starkKey: BigNumberish,
      signature: BytesLike,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    registerUserAdmin(
      newAdmin: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "registerUserAdmin(address)"(
      newAdmin: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    unregisterOperator(
      removedOperator: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "unregisterOperator(address)"(
      removedOperator: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    unregisterTokenAdmin(
      oldAdmin: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "unregisterTokenAdmin(address)"(
      oldAdmin: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    unregisterUserAdmin(
      oldAdmin: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "unregisterUserAdmin(address)"(
      oldAdmin: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    withdraw(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "withdraw(uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    withdrawAndMint(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      mintingBlob: BytesLike,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "withdrawAndMint(uint256,uint256,bytes)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      mintingBlob: BytesLike,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    withdrawNft(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "withdrawNft(uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    withdrawNftTo(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      tokenId: BigNumberish,
      recipient: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "withdrawNftTo(uint256,uint256,uint256,address)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      tokenId: BigNumberish,
      recipient: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    withdrawTo(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      recipient: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "withdrawTo(uint256,uint256,address)"(
      starkKey: BigNumberish,
      assetType: BigNumberish,
      recipient: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    escape(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      assetId: BigNumberish,
      quantizedAmount: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "escape(uint256,uint256,uint256,uint256)"(
      starkKey: BigNumberish,
      vaultId: BigNumberish,
      assetId: BigNumberish,
      quantizedAmount: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    getLastBatchId(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    "getLastBatchId()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getOrderRoot(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    "getOrderRoot()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    getOrderTreeHeight(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getOrderTreeHeight()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getSequenceNumber(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    "getSequenceNumber()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getVaultRoot(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    "getVaultRoot()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    getVaultTreeHeight(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getVaultTreeHeight()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    updateState(
      publicInput: BigNumberish[],
      applicationData: BigNumberish[],
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "updateState(uint256[],uint256[])"(
      publicInput: BigNumberish[],
      applicationData: BigNumberish[],
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;
  };
}