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

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
  Contract,
  ContractTransaction,
  Overrides,
  PayableOverrides,
  CallOverrides,
  BytesLike,
  utils,
  providers
} from "ethers";
type FunctionFragment = utils.FunctionFragment;
type EventFragment = utils.EventFragment;
type Result = utils.Result;

type Listener = providers.Listener;
type Provider = providers.Provider;

interface ZkSyncInterface extends ethers.utils.Interface {
  functions: {
    "_transferERC20(address,address,uint128,uint128)": FunctionFragment;
    "activateExodusMode()": FunctionFragment;
    "authFacts(address,uint32)": FunctionFragment;
    "cancelOutstandingDepositsForExodusMode(uint64,bytes[])": FunctionFragment;
    "commitBlocks(tuple,tuple[])": FunctionFragment;
    "depositERC20(address,uint104,address)": FunctionFragment;
    "depositETH(address)": FunctionFragment;
    "executeBlocks(tuple[])": FunctionFragment;
    "exodusMode()": FunctionFragment;
    "getNoticePeriod()": FunctionFragment;
    "getPendingBalance(address,address)": FunctionFragment;
    "initialize(bytes)": FunctionFragment;
    "isReadyForUpgrade()": FunctionFragment;
    "proveBlocks(tuple[],tuple)": FunctionFragment;
    "requestFullExit(uint32,address)": FunctionFragment;
    "requestFullExitNFT(uint32,uint32)": FunctionFragment;
    "revertBlocks(tuple[])": FunctionFragment;
    "setAuthPubkeyHash(bytes,uint32)": FunctionFragment;
    "totalBlocksCommitted()": FunctionFragment;
    "totalBlocksExecuted()": FunctionFragment;
    "upgrade(bytes)": FunctionFragment;
    "upgradeCanceled()": FunctionFragment;
    "upgradeFinishes()": FunctionFragment;
    "upgradeNoticePeriodStarted()": FunctionFragment;
    "upgradePreparationStarted()": FunctionFragment;
    "withdrawPendingBalance(address,address,uint128)": FunctionFragment;
    "withdrawPendingNFTBalance(uint32)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "_transferERC20",
    values: [string, string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "activateExodusMode",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "authFacts",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "cancelOutstandingDepositsForExodusMode",
    values: [BigNumberish, BytesLike[]]
  ): string;
  encodeFunctionData(
    functionFragment: "commitBlocks",
    values: [
      {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      },
      {
        newStateHash: BytesLike;
        publicData: BytesLike;
        timestamp: BigNumberish;
        onchainOperations: {
          ethWitness: BytesLike;
          publicDataOffset: BigNumberish;
        }[];
        blockNumber: BigNumberish;
        feeAccount: BigNumberish;
      }[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "depositERC20",
    values: [string, BigNumberish, string]
  ): string;
  encodeFunctionData(functionFragment: "depositETH", values: [string]): string;
  encodeFunctionData(
    functionFragment: "executeBlocks",
    values: [
      {
        storedBlock: {
          blockNumber: BigNumberish;
          priorityOperations: BigNumberish;
          pendingOnchainOperationsHash: BytesLike;
          timestamp: BigNumberish;
          stateHash: BytesLike;
          commitment: BytesLike;
        };
        pendingOnchainOpsPubdata: BytesLike[];
      }[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "exodusMode",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getNoticePeriod",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getPendingBalance",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "isReadyForUpgrade",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "proveBlocks",
    values: [
      {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      }[],
      {
        recursiveInput: BigNumberish[];
        proof: BigNumberish[];
        commitments: BigNumberish[];
        vkIndexes: BigNumberish[];
        subproofsLimbs: [
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish
        ];
      }
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "requestFullExit",
    values: [BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "requestFullExitNFT",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "revertBlocks",
    values: [
      {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      }[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "setAuthPubkeyHash",
    values: [BytesLike, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "totalBlocksCommitted",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalBlocksExecuted",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "upgrade", values: [BytesLike]): string;
  encodeFunctionData(
    functionFragment: "upgradeCanceled",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "upgradeFinishes",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "upgradeNoticePeriodStarted",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "upgradePreparationStarted",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawPendingBalance",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawPendingNFTBalance",
    values: [BigNumberish]
  ): string;

  decodeFunctionResult(
    functionFragment: "_transferERC20",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "activateExodusMode",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "authFacts", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "cancelOutstandingDepositsForExodusMode",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "commitBlocks",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "depositERC20",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "depositETH", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "executeBlocks",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "exodusMode", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getNoticePeriod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPendingBalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isReadyForUpgrade",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "proveBlocks",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "requestFullExit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "requestFullExitNFT",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "revertBlocks",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setAuthPubkeyHash",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalBlocksCommitted",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalBlocksExecuted",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "upgrade", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "upgradeCanceled",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "upgradeFinishes",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "upgradeNoticePeriodStarted",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "upgradePreparationStarted",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawPendingBalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawPendingNFTBalance",
    data: BytesLike
  ): Result;

  events: {
    "BlockCommit(uint32)": EventFragment;
    "BlockVerification(uint32)": EventFragment;
    "BlocksRevert(uint32,uint32)": EventFragment;
    "Deposit(uint16,uint128)": EventFragment;
    "DepositCommit(uint32,uint32,address,uint16,uint128)": EventFragment;
    "ExodusMode()": EventFragment;
    "FactAuth(address,uint32,bytes)": EventFragment;
    "FullExitCommit(uint32,uint32,address,uint16,uint128)": EventFragment;
    "NewPriorityRequest(address,uint64,uint8,bytes,uint256)": EventFragment;
    "Withdrawal(uint16,uint128)": EventFragment;
    "WithdrawalNFT(uint32)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "BlockCommit"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "BlockVerification"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "BlocksRevert"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DepositCommit"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ExodusMode"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "FactAuth"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "FullExitCommit"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewPriorityRequest"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Withdrawal"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "WithdrawalNFT"): EventFragment;
}

export class ZkSync 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: ZkSyncInterface;

  functions: {
    _transferERC20(
      _token: string,
      _to: string,
      _amount: BigNumberish,
      _maxAmount: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "_transferERC20(address,address,uint128,uint128)"(
      _token: string,
      _to: string,
      _amount: BigNumberish,
      _maxAmount: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

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

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

    authFacts(
      arg0: string,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      0: string;
    }>;

    "authFacts(address,uint32)"(
      arg0: string,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      0: string;
    }>;

    cancelOutstandingDepositsForExodusMode(
      _n: BigNumberish,
      _depositsPubdata: BytesLike[],
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "cancelOutstandingDepositsForExodusMode(uint64,bytes[])"(
      _n: BigNumberish,
      _depositsPubdata: BytesLike[],
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    commitBlocks(
      _lastCommittedBlockData: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      },
      _newBlocksData: {
        newStateHash: BytesLike;
        publicData: BytesLike;
        timestamp: BigNumberish;
        onchainOperations: {
          ethWitness: BytesLike;
          publicDataOffset: BigNumberish;
        }[];
        blockNumber: BigNumberish;
        feeAccount: BigNumberish;
      }[],
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "commitBlocks(tuple,tuple[])"(
      _lastCommittedBlockData: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      },
      _newBlocksData: {
        newStateHash: BytesLike;
        publicData: BytesLike;
        timestamp: BigNumberish;
        onchainOperations: {
          ethWitness: BytesLike;
          publicDataOffset: BigNumberish;
        }[];
        blockNumber: BigNumberish;
        feeAccount: BigNumberish;
      }[],
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    depositERC20(
      _token: string,
      _amount: BigNumberish,
      _zkSyncAddress: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "depositERC20(address,uint104,address)"(
      _token: string,
      _amount: BigNumberish,
      _zkSyncAddress: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    depositETH(
      _zkSyncAddress: string,
      overrides?: PayableOverrides
    ): Promise<ContractTransaction>;

    "depositETH(address)"(
      _zkSyncAddress: string,
      overrides?: PayableOverrides
    ): Promise<ContractTransaction>;

    executeBlocks(
      _blocksData: {
        storedBlock: {
          blockNumber: BigNumberish;
          priorityOperations: BigNumberish;
          pendingOnchainOperationsHash: BytesLike;
          timestamp: BigNumberish;
          stateHash: BytesLike;
          commitment: BytesLike;
        };
        pendingOnchainOpsPubdata: BytesLike[];
      }[],
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "executeBlocks(tuple[])"(
      _blocksData: {
        storedBlock: {
          blockNumber: BigNumberish;
          priorityOperations: BigNumberish;
          pendingOnchainOperationsHash: BytesLike;
          timestamp: BigNumberish;
          stateHash: BytesLike;
          commitment: BytesLike;
        };
        pendingOnchainOpsPubdata: BytesLike[];
      }[],
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    exodusMode(
      overrides?: CallOverrides
    ): Promise<{
      0: boolean;
    }>;

    "exodusMode()"(
      overrides?: CallOverrides
    ): Promise<{
      0: boolean;
    }>;

    getNoticePeriod(
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    "getNoticePeriod()"(
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    getPendingBalance(
      _address: string,
      _token: string,
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    "getPendingBalance(address,address)"(
      _address: string,
      _token: string,
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

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

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

    isReadyForUpgrade(
      overrides?: CallOverrides
    ): Promise<{
      0: boolean;
    }>;

    "isReadyForUpgrade()"(
      overrides?: CallOverrides
    ): Promise<{
      0: boolean;
    }>;

    proveBlocks(
      _committedBlocks: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      }[],
      _proof: {
        recursiveInput: BigNumberish[];
        proof: BigNumberish[];
        commitments: BigNumberish[];
        vkIndexes: BigNumberish[];
        subproofsLimbs: [
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish
        ];
      },
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "proveBlocks(tuple[],tuple)"(
      _committedBlocks: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      }[],
      _proof: {
        recursiveInput: BigNumberish[];
        proof: BigNumberish[];
        commitments: BigNumberish[];
        vkIndexes: BigNumberish[];
        subproofsLimbs: [
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish
        ];
      },
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    requestFullExit(
      _accountId: BigNumberish,
      _token: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "requestFullExit(uint32,address)"(
      _accountId: BigNumberish,
      _token: string,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    requestFullExitNFT(
      _accountId: BigNumberish,
      _tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "requestFullExitNFT(uint32,uint32)"(
      _accountId: BigNumberish,
      _tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    revertBlocks(
      _blocksToRevert: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      }[],
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "revertBlocks(tuple[])"(
      _blocksToRevert: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      }[],
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    setAuthPubkeyHash(
      _pubkeyHash: BytesLike,
      _nonce: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "setAuthPubkeyHash(bytes,uint32)"(
      _pubkeyHash: BytesLike,
      _nonce: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    totalBlocksCommitted(
      overrides?: CallOverrides
    ): Promise<{
      0: number;
    }>;

    "totalBlocksCommitted()"(
      overrides?: CallOverrides
    ): Promise<{
      0: number;
    }>;

    totalBlocksExecuted(
      overrides?: CallOverrides
    ): Promise<{
      0: number;
    }>;

    "totalBlocksExecuted()"(
      overrides?: CallOverrides
    ): Promise<{
      0: number;
    }>;

    upgrade(
      upgradeParameters: BytesLike,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "upgrade(bytes)"(
      upgradeParameters: BytesLike,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

    withdrawPendingBalance(
      _owner: string,
      _token: string,
      _amount: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "withdrawPendingBalance(address,address,uint128)"(
      _owner: string,
      _token: string,
      _amount: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    withdrawPendingNFTBalance(
      _tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "withdrawPendingNFTBalance(uint32)"(
      _tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;
  };

  _transferERC20(
    _token: string,
    _to: string,
    _amount: BigNumberish,
    _maxAmount: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "_transferERC20(address,address,uint128,uint128)"(
    _token: string,
    _to: string,
    _amount: BigNumberish,
    _maxAmount: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

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

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

  authFacts(
    arg0: string,
    arg1: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  "authFacts(address,uint32)"(
    arg0: string,
    arg1: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  cancelOutstandingDepositsForExodusMode(
    _n: BigNumberish,
    _depositsPubdata: BytesLike[],
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "cancelOutstandingDepositsForExodusMode(uint64,bytes[])"(
    _n: BigNumberish,
    _depositsPubdata: BytesLike[],
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  commitBlocks(
    _lastCommittedBlockData: {
      blockNumber: BigNumberish;
      priorityOperations: BigNumberish;
      pendingOnchainOperationsHash: BytesLike;
      timestamp: BigNumberish;
      stateHash: BytesLike;
      commitment: BytesLike;
    },
    _newBlocksData: {
      newStateHash: BytesLike;
      publicData: BytesLike;
      timestamp: BigNumberish;
      onchainOperations: {
        ethWitness: BytesLike;
        publicDataOffset: BigNumberish;
      }[];
      blockNumber: BigNumberish;
      feeAccount: BigNumberish;
    }[],
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "commitBlocks(tuple,tuple[])"(
    _lastCommittedBlockData: {
      blockNumber: BigNumberish;
      priorityOperations: BigNumberish;
      pendingOnchainOperationsHash: BytesLike;
      timestamp: BigNumberish;
      stateHash: BytesLike;
      commitment: BytesLike;
    },
    _newBlocksData: {
      newStateHash: BytesLike;
      publicData: BytesLike;
      timestamp: BigNumberish;
      onchainOperations: {
        ethWitness: BytesLike;
        publicDataOffset: BigNumberish;
      }[];
      blockNumber: BigNumberish;
      feeAccount: BigNumberish;
    }[],
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  depositERC20(
    _token: string,
    _amount: BigNumberish,
    _zkSyncAddress: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "depositERC20(address,uint104,address)"(
    _token: string,
    _amount: BigNumberish,
    _zkSyncAddress: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  depositETH(
    _zkSyncAddress: string,
    overrides?: PayableOverrides
  ): Promise<ContractTransaction>;

  "depositETH(address)"(
    _zkSyncAddress: string,
    overrides?: PayableOverrides
  ): Promise<ContractTransaction>;

  executeBlocks(
    _blocksData: {
      storedBlock: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      };
      pendingOnchainOpsPubdata: BytesLike[];
    }[],
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "executeBlocks(tuple[])"(
    _blocksData: {
      storedBlock: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      };
      pendingOnchainOpsPubdata: BytesLike[];
    }[],
    overrides?: Overrides
  ): Promise<ContractTransaction>;

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

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

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

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

  getPendingBalance(
    _address: string,
    _token: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "getPendingBalance(address,address)"(
    _address: string,
    _token: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

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

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

  proveBlocks(
    _committedBlocks: {
      blockNumber: BigNumberish;
      priorityOperations: BigNumberish;
      pendingOnchainOperationsHash: BytesLike;
      timestamp: BigNumberish;
      stateHash: BytesLike;
      commitment: BytesLike;
    }[],
    _proof: {
      recursiveInput: BigNumberish[];
      proof: BigNumberish[];
      commitments: BigNumberish[];
      vkIndexes: BigNumberish[];
      subproofsLimbs: [
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish
      ];
    },
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "proveBlocks(tuple[],tuple)"(
    _committedBlocks: {
      blockNumber: BigNumberish;
      priorityOperations: BigNumberish;
      pendingOnchainOperationsHash: BytesLike;
      timestamp: BigNumberish;
      stateHash: BytesLike;
      commitment: BytesLike;
    }[],
    _proof: {
      recursiveInput: BigNumberish[];
      proof: BigNumberish[];
      commitments: BigNumberish[];
      vkIndexes: BigNumberish[];
      subproofsLimbs: [
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish,
        BigNumberish
      ];
    },
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  requestFullExit(
    _accountId: BigNumberish,
    _token: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "requestFullExit(uint32,address)"(
    _accountId: BigNumberish,
    _token: string,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  requestFullExitNFT(
    _accountId: BigNumberish,
    _tokenId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "requestFullExitNFT(uint32,uint32)"(
    _accountId: BigNumberish,
    _tokenId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  revertBlocks(
    _blocksToRevert: {
      blockNumber: BigNumberish;
      priorityOperations: BigNumberish;
      pendingOnchainOperationsHash: BytesLike;
      timestamp: BigNumberish;
      stateHash: BytesLike;
      commitment: BytesLike;
    }[],
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "revertBlocks(tuple[])"(
    _blocksToRevert: {
      blockNumber: BigNumberish;
      priorityOperations: BigNumberish;
      pendingOnchainOperationsHash: BytesLike;
      timestamp: BigNumberish;
      stateHash: BytesLike;
      commitment: BytesLike;
    }[],
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  setAuthPubkeyHash(
    _pubkeyHash: BytesLike,
    _nonce: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "setAuthPubkeyHash(bytes,uint32)"(
    _pubkeyHash: BytesLike,
    _nonce: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  totalBlocksCommitted(overrides?: CallOverrides): Promise<number>;

  "totalBlocksCommitted()"(overrides?: CallOverrides): Promise<number>;

  totalBlocksExecuted(overrides?: CallOverrides): Promise<number>;

  "totalBlocksExecuted()"(overrides?: CallOverrides): Promise<number>;

  upgrade(
    upgradeParameters: BytesLike,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "upgrade(bytes)"(
    upgradeParameters: BytesLike,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

  withdrawPendingBalance(
    _owner: string,
    _token: string,
    _amount: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "withdrawPendingBalance(address,address,uint128)"(
    _owner: string,
    _token: string,
    _amount: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  withdrawPendingNFTBalance(
    _tokenId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "withdrawPendingNFTBalance(uint32)"(
    _tokenId: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  callStatic: {
    _transferERC20(
      _token: string,
      _to: string,
      _amount: BigNumberish,
      _maxAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "_transferERC20(address,address,uint128,uint128)"(
      _token: string,
      _to: string,
      _amount: BigNumberish,
      _maxAmount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    authFacts(
      arg0: string,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    "authFacts(address,uint32)"(
      arg0: string,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    cancelOutstandingDepositsForExodusMode(
      _n: BigNumberish,
      _depositsPubdata: BytesLike[],
      overrides?: CallOverrides
    ): Promise<void>;

    "cancelOutstandingDepositsForExodusMode(uint64,bytes[])"(
      _n: BigNumberish,
      _depositsPubdata: BytesLike[],
      overrides?: CallOverrides
    ): Promise<void>;

    commitBlocks(
      _lastCommittedBlockData: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      },
      _newBlocksData: {
        newStateHash: BytesLike;
        publicData: BytesLike;
        timestamp: BigNumberish;
        onchainOperations: {
          ethWitness: BytesLike;
          publicDataOffset: BigNumberish;
        }[];
        blockNumber: BigNumberish;
        feeAccount: BigNumberish;
      }[],
      overrides?: CallOverrides
    ): Promise<void>;

    "commitBlocks(tuple,tuple[])"(
      _lastCommittedBlockData: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      },
      _newBlocksData: {
        newStateHash: BytesLike;
        publicData: BytesLike;
        timestamp: BigNumberish;
        onchainOperations: {
          ethWitness: BytesLike;
          publicDataOffset: BigNumberish;
        }[];
        blockNumber: BigNumberish;
        feeAccount: BigNumberish;
      }[],
      overrides?: CallOverrides
    ): Promise<void>;

    depositERC20(
      _token: string,
      _amount: BigNumberish,
      _zkSyncAddress: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "depositERC20(address,uint104,address)"(
      _token: string,
      _amount: BigNumberish,
      _zkSyncAddress: string,
      overrides?: CallOverrides
    ): Promise<void>;

    depositETH(
      _zkSyncAddress: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "depositETH(address)"(
      _zkSyncAddress: string,
      overrides?: CallOverrides
    ): Promise<void>;

    executeBlocks(
      _blocksData: {
        storedBlock: {
          blockNumber: BigNumberish;
          priorityOperations: BigNumberish;
          pendingOnchainOperationsHash: BytesLike;
          timestamp: BigNumberish;
          stateHash: BytesLike;
          commitment: BytesLike;
        };
        pendingOnchainOpsPubdata: BytesLike[];
      }[],
      overrides?: CallOverrides
    ): Promise<void>;

    "executeBlocks(tuple[])"(
      _blocksData: {
        storedBlock: {
          blockNumber: BigNumberish;
          priorityOperations: BigNumberish;
          pendingOnchainOperationsHash: BytesLike;
          timestamp: BigNumberish;
          stateHash: BytesLike;
          commitment: BytesLike;
        };
        pendingOnchainOpsPubdata: BytesLike[];
      }[],
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

    getPendingBalance(
      _address: string,
      _token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getPendingBalance(address,address)"(
      _address: string,
      _token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    proveBlocks(
      _committedBlocks: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      }[],
      _proof: {
        recursiveInput: BigNumberish[];
        proof: BigNumberish[];
        commitments: BigNumberish[];
        vkIndexes: BigNumberish[];
        subproofsLimbs: [
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish
        ];
      },
      overrides?: CallOverrides
    ): Promise<void>;

    "proveBlocks(tuple[],tuple)"(
      _committedBlocks: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      }[],
      _proof: {
        recursiveInput: BigNumberish[];
        proof: BigNumberish[];
        commitments: BigNumberish[];
        vkIndexes: BigNumberish[];
        subproofsLimbs: [
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish
        ];
      },
      overrides?: CallOverrides
    ): Promise<void>;

    requestFullExit(
      _accountId: BigNumberish,
      _token: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "requestFullExit(uint32,address)"(
      _accountId: BigNumberish,
      _token: string,
      overrides?: CallOverrides
    ): Promise<void>;

    requestFullExitNFT(
      _accountId: BigNumberish,
      _tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "requestFullExitNFT(uint32,uint32)"(
      _accountId: BigNumberish,
      _tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    revertBlocks(
      _blocksToRevert: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      }[],
      overrides?: CallOverrides
    ): Promise<void>;

    "revertBlocks(tuple[])"(
      _blocksToRevert: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      }[],
      overrides?: CallOverrides
    ): Promise<void>;

    setAuthPubkeyHash(
      _pubkeyHash: BytesLike,
      _nonce: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "setAuthPubkeyHash(bytes,uint32)"(
      _pubkeyHash: BytesLike,
      _nonce: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    totalBlocksCommitted(overrides?: CallOverrides): Promise<number>;

    "totalBlocksCommitted()"(overrides?: CallOverrides): Promise<number>;

    totalBlocksExecuted(overrides?: CallOverrides): Promise<number>;

    "totalBlocksExecuted()"(overrides?: CallOverrides): Promise<number>;

    upgrade(
      upgradeParameters: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    "upgrade(bytes)"(
      upgradeParameters: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

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

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

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

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

    withdrawPendingBalance(
      _owner: string,
      _token: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "withdrawPendingBalance(address,address,uint128)"(
      _owner: string,
      _token: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    withdrawPendingNFTBalance(
      _tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "withdrawPendingNFTBalance(uint32)"(
      _tokenId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    BlockCommit(blockNumber: BigNumberish | null): EventFilter;

    BlockVerification(blockNumber: BigNumberish | null): EventFilter;

    BlocksRevert(
      totalBlocksVerified: null,
      totalBlocksCommitted: null
    ): EventFilter;

    Deposit(tokenId: BigNumberish | null, amount: null): EventFilter;

    DepositCommit(
      zkSyncBlockId: BigNumberish | null,
      accountId: BigNumberish | null,
      owner: null,
      tokenId: BigNumberish | null,
      amount: null
    ): EventFilter;

    ExodusMode(): EventFilter;

    FactAuth(sender: string | null, nonce: null, fact: null): EventFilter;

    FullExitCommit(
      zkSyncBlockId: BigNumberish | null,
      accountId: BigNumberish | null,
      owner: null,
      tokenId: BigNumberish | null,
      amount: null
    ): EventFilter;

    NewPriorityRequest(
      sender: null,
      serialId: null,
      opType: null,
      pubData: null,
      expirationBlock: null
    ): EventFilter;

    Withdrawal(tokenId: BigNumberish | null, amount: null): EventFilter;

    WithdrawalNFT(tokenId: BigNumberish | null): EventFilter;
  };

  estimateGas: {
    _transferERC20(
      _token: string,
      _to: string,
      _amount: BigNumberish,
      _maxAmount: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "_transferERC20(address,address,uint128,uint128)"(
      _token: string,
      _to: string,
      _amount: BigNumberish,
      _maxAmount: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

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

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

    authFacts(
      arg0: string,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "authFacts(address,uint32)"(
      arg0: string,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    cancelOutstandingDepositsForExodusMode(
      _n: BigNumberish,
      _depositsPubdata: BytesLike[],
      overrides?: Overrides
    ): Promise<BigNumber>;

    "cancelOutstandingDepositsForExodusMode(uint64,bytes[])"(
      _n: BigNumberish,
      _depositsPubdata: BytesLike[],
      overrides?: Overrides
    ): Promise<BigNumber>;

    commitBlocks(
      _lastCommittedBlockData: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      },
      _newBlocksData: {
        newStateHash: BytesLike;
        publicData: BytesLike;
        timestamp: BigNumberish;
        onchainOperations: {
          ethWitness: BytesLike;
          publicDataOffset: BigNumberish;
        }[];
        blockNumber: BigNumberish;
        feeAccount: BigNumberish;
      }[],
      overrides?: Overrides
    ): Promise<BigNumber>;

    "commitBlocks(tuple,tuple[])"(
      _lastCommittedBlockData: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      },
      _newBlocksData: {
        newStateHash: BytesLike;
        publicData: BytesLike;
        timestamp: BigNumberish;
        onchainOperations: {
          ethWitness: BytesLike;
          publicDataOffset: BigNumberish;
        }[];
        blockNumber: BigNumberish;
        feeAccount: BigNumberish;
      }[],
      overrides?: Overrides
    ): Promise<BigNumber>;

    depositERC20(
      _token: string,
      _amount: BigNumberish,
      _zkSyncAddress: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "depositERC20(address,uint104,address)"(
      _token: string,
      _amount: BigNumberish,
      _zkSyncAddress: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    depositETH(
      _zkSyncAddress: string,
      overrides?: PayableOverrides
    ): Promise<BigNumber>;

    "depositETH(address)"(
      _zkSyncAddress: string,
      overrides?: PayableOverrides
    ): Promise<BigNumber>;

    executeBlocks(
      _blocksData: {
        storedBlock: {
          blockNumber: BigNumberish;
          priorityOperations: BigNumberish;
          pendingOnchainOperationsHash: BytesLike;
          timestamp: BigNumberish;
          stateHash: BytesLike;
          commitment: BytesLike;
        };
        pendingOnchainOpsPubdata: BytesLike[];
      }[],
      overrides?: Overrides
    ): Promise<BigNumber>;

    "executeBlocks(tuple[])"(
      _blocksData: {
        storedBlock: {
          blockNumber: BigNumberish;
          priorityOperations: BigNumberish;
          pendingOnchainOperationsHash: BytesLike;
          timestamp: BigNumberish;
          stateHash: BytesLike;
          commitment: BytesLike;
        };
        pendingOnchainOpsPubdata: BytesLike[];
      }[],
      overrides?: Overrides
    ): Promise<BigNumber>;

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

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

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

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

    getPendingBalance(
      _address: string,
      _token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getPendingBalance(address,address)"(
      _address: string,
      _token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    proveBlocks(
      _committedBlocks: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      }[],
      _proof: {
        recursiveInput: BigNumberish[];
        proof: BigNumberish[];
        commitments: BigNumberish[];
        vkIndexes: BigNumberish[];
        subproofsLimbs: [
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish
        ];
      },
      overrides?: Overrides
    ): Promise<BigNumber>;

    "proveBlocks(tuple[],tuple)"(
      _committedBlocks: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      }[],
      _proof: {
        recursiveInput: BigNumberish[];
        proof: BigNumberish[];
        commitments: BigNumberish[];
        vkIndexes: BigNumberish[];
        subproofsLimbs: [
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish
        ];
      },
      overrides?: Overrides
    ): Promise<BigNumber>;

    requestFullExit(
      _accountId: BigNumberish,
      _token: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "requestFullExit(uint32,address)"(
      _accountId: BigNumberish,
      _token: string,
      overrides?: Overrides
    ): Promise<BigNumber>;

    requestFullExitNFT(
      _accountId: BigNumberish,
      _tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "requestFullExitNFT(uint32,uint32)"(
      _accountId: BigNumberish,
      _tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    revertBlocks(
      _blocksToRevert: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      }[],
      overrides?: Overrides
    ): Promise<BigNumber>;

    "revertBlocks(tuple[])"(
      _blocksToRevert: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      }[],
      overrides?: Overrides
    ): Promise<BigNumber>;

    setAuthPubkeyHash(
      _pubkeyHash: BytesLike,
      _nonce: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "setAuthPubkeyHash(bytes,uint32)"(
      _pubkeyHash: BytesLike,
      _nonce: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

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

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

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

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

    upgrade(
      upgradeParameters: BytesLike,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "upgrade(bytes)"(
      upgradeParameters: BytesLike,
      overrides?: Overrides
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

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

    withdrawPendingBalance(
      _owner: string,
      _token: string,
      _amount: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "withdrawPendingBalance(address,address,uint128)"(
      _owner: string,
      _token: string,
      _amount: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    withdrawPendingNFTBalance(
      _tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "withdrawPendingNFTBalance(uint32)"(
      _tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    _transferERC20(
      _token: string,
      _to: string,
      _amount: BigNumberish,
      _maxAmount: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "_transferERC20(address,address,uint128,uint128)"(
      _token: string,
      _to: string,
      _amount: BigNumberish,
      _maxAmount: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

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

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

    authFacts(
      arg0: string,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "authFacts(address,uint32)"(
      arg0: string,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    cancelOutstandingDepositsForExodusMode(
      _n: BigNumberish,
      _depositsPubdata: BytesLike[],
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "cancelOutstandingDepositsForExodusMode(uint64,bytes[])"(
      _n: BigNumberish,
      _depositsPubdata: BytesLike[],
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    commitBlocks(
      _lastCommittedBlockData: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      },
      _newBlocksData: {
        newStateHash: BytesLike;
        publicData: BytesLike;
        timestamp: BigNumberish;
        onchainOperations: {
          ethWitness: BytesLike;
          publicDataOffset: BigNumberish;
        }[];
        blockNumber: BigNumberish;
        feeAccount: BigNumberish;
      }[],
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "commitBlocks(tuple,tuple[])"(
      _lastCommittedBlockData: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      },
      _newBlocksData: {
        newStateHash: BytesLike;
        publicData: BytesLike;
        timestamp: BigNumberish;
        onchainOperations: {
          ethWitness: BytesLike;
          publicDataOffset: BigNumberish;
        }[];
        blockNumber: BigNumberish;
        feeAccount: BigNumberish;
      }[],
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    depositERC20(
      _token: string,
      _amount: BigNumberish,
      _zkSyncAddress: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "depositERC20(address,uint104,address)"(
      _token: string,
      _amount: BigNumberish,
      _zkSyncAddress: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    depositETH(
      _zkSyncAddress: string,
      overrides?: PayableOverrides
    ): Promise<PopulatedTransaction>;

    "depositETH(address)"(
      _zkSyncAddress: string,
      overrides?: PayableOverrides
    ): Promise<PopulatedTransaction>;

    executeBlocks(
      _blocksData: {
        storedBlock: {
          blockNumber: BigNumberish;
          priorityOperations: BigNumberish;
          pendingOnchainOperationsHash: BytesLike;
          timestamp: BigNumberish;
          stateHash: BytesLike;
          commitment: BytesLike;
        };
        pendingOnchainOpsPubdata: BytesLike[];
      }[],
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "executeBlocks(tuple[])"(
      _blocksData: {
        storedBlock: {
          blockNumber: BigNumberish;
          priorityOperations: BigNumberish;
          pendingOnchainOperationsHash: BytesLike;
          timestamp: BigNumberish;
          stateHash: BytesLike;
          commitment: BytesLike;
        };
        pendingOnchainOpsPubdata: BytesLike[];
      }[],
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

    getPendingBalance(
      _address: string,
      _token: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getPendingBalance(address,address)"(
      _address: string,
      _token: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

    proveBlocks(
      _committedBlocks: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      }[],
      _proof: {
        recursiveInput: BigNumberish[];
        proof: BigNumberish[];
        commitments: BigNumberish[];
        vkIndexes: BigNumberish[];
        subproofsLimbs: [
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish
        ];
      },
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "proveBlocks(tuple[],tuple)"(
      _committedBlocks: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      }[],
      _proof: {
        recursiveInput: BigNumberish[];
        proof: BigNumberish[];
        commitments: BigNumberish[];
        vkIndexes: BigNumberish[];
        subproofsLimbs: [
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish,
          BigNumberish
        ];
      },
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    requestFullExit(
      _accountId: BigNumberish,
      _token: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "requestFullExit(uint32,address)"(
      _accountId: BigNumberish,
      _token: string,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    requestFullExitNFT(
      _accountId: BigNumberish,
      _tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "requestFullExitNFT(uint32,uint32)"(
      _accountId: BigNumberish,
      _tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    revertBlocks(
      _blocksToRevert: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      }[],
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "revertBlocks(tuple[])"(
      _blocksToRevert: {
        blockNumber: BigNumberish;
        priorityOperations: BigNumberish;
        pendingOnchainOperationsHash: BytesLike;
        timestamp: BigNumberish;
        stateHash: BytesLike;
        commitment: BytesLike;
      }[],
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    setAuthPubkeyHash(
      _pubkeyHash: BytesLike,
      _nonce: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "setAuthPubkeyHash(bytes,uint32)"(
      _pubkeyHash: BytesLike,
      _nonce: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

    upgrade(
      upgradeParameters: BytesLike,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "upgrade(bytes)"(
      upgradeParameters: BytesLike,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

    withdrawPendingBalance(
      _owner: string,
      _token: string,
      _amount: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "withdrawPendingBalance(address,address,uint128)"(
      _owner: string,
      _token: string,
      _amount: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    withdrawPendingNFTBalance(
      _tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "withdrawPendingNFTBalance(uint32)"(
      _tokenId: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;
  };
}