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

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
  BaseContract,
  ContractTransaction,
  Overrides,
  PayableOverrides,
  CallOverrides,
} from "ethers";
import { BytesLike } from "@ethersproject/bytes";
import { Listener, Provider } from "@ethersproject/providers";
import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
import type { TypedEventFilter, TypedEvent, TypedListener } from "./common";

interface MVMCanonicalTransactionInterface extends ethers.utils.Interface {
  functions: {
    "CONFIG_OWNER_KEY()": FunctionFragment;
    "TXDATA_SUBMIT_TIMEOUT()": FunctionFragment;
    "appendSequencerBatchByChainId()": FunctionFragment;
    "checkBatchTxHash(uint256,uint256,uint256,bytes)": FunctionFragment;
    "disableWhiteList()": FunctionFragment;
    "getBatchTxData(uint256,uint256,uint256)": FunctionFragment;
    "getStakeBaseCost()": FunctionFragment;
    "getStakeCostByBatch(uint256,uint256)": FunctionFragment;
    "getStakeSeqSeconds()": FunctionFragment;
    "getStakeUnitCost()": FunctionFragment;
    "getTxBatchSize()": FunctionFragment;
    "getTxDataSliceCount()": FunctionFragment;
    "getTxDataSliceSize()": FunctionFragment;
    "isWhiteListed(address)": FunctionFragment;
    "libAddressManager()": FunctionFragment;
    "resolve(string)": FunctionFragment;
    "setBatchTxDataForStake(uint256,uint256,uint256,bytes,uint256,uint256,bytes32[])": FunctionFragment;
    "setBatchTxDataForVerifier(uint256,uint256,uint256,bytes)": FunctionFragment;
    "setBatchTxDataVerified(uint256,uint256,uint256,bool)": FunctionFragment;
    "setStakeBaseCost(uint256)": FunctionFragment;
    "setStakeSeqSeconds(uint256)": FunctionFragment;
    "setStakeUnitCost(uint256)": FunctionFragment;
    "setTxBatchSize(uint256)": FunctionFragment;
    "setTxDataSliceCount(uint256)": FunctionFragment;
    "setTxDataSliceSize(uint256)": FunctionFragment;
    "setWhiteList(address,bool)": FunctionFragment;
    "stakeBaseCost()": FunctionFragment;
    "stakeSeqSeconds()": FunctionFragment;
    "stakeUnitCost()": FunctionFragment;
    "txBatchSize()": FunctionFragment;
    "txDataSliceCount()": FunctionFragment;
    "txDataSliceSize()": FunctionFragment;
    "verifierStake(uint256,uint256,uint256)": FunctionFragment;
    "whitelist(address)": FunctionFragment;
    "withdrawStake(uint256,uint256,uint256)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "CONFIG_OWNER_KEY",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "TXDATA_SUBMIT_TIMEOUT",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "appendSequencerBatchByChainId",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "checkBatchTxHash",
    values: [BigNumberish, BigNumberish, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "disableWhiteList",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getBatchTxData",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getStakeBaseCost",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getStakeCostByBatch",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getStakeSeqSeconds",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getStakeUnitCost",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getTxBatchSize",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getTxDataSliceCount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getTxDataSliceSize",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "isWhiteListed",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "libAddressManager",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "resolve", values: [string]): string;
  encodeFunctionData(
    functionFragment: "setBatchTxDataForStake",
    values: [
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BytesLike,
      BigNumberish,
      BigNumberish,
      BytesLike[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "setBatchTxDataForVerifier",
    values: [BigNumberish, BigNumberish, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "setBatchTxDataVerified",
    values: [BigNumberish, BigNumberish, BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "setStakeBaseCost",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setStakeSeqSeconds",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setStakeUnitCost",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setTxBatchSize",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setTxDataSliceCount",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setTxDataSliceSize",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setWhiteList",
    values: [string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "stakeBaseCost",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "stakeSeqSeconds",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "stakeUnitCost",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "txBatchSize",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "txDataSliceCount",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "txDataSliceSize",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "verifierStake",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "whitelist", values: [string]): string;
  encodeFunctionData(
    functionFragment: "withdrawStake",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;

  decodeFunctionResult(
    functionFragment: "CONFIG_OWNER_KEY",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "TXDATA_SUBMIT_TIMEOUT",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "appendSequencerBatchByChainId",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "checkBatchTxHash",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "disableWhiteList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getBatchTxData",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getStakeBaseCost",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getStakeCostByBatch",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getStakeSeqSeconds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getStakeUnitCost",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTxBatchSize",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTxDataSliceCount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTxDataSliceSize",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isWhiteListed",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "libAddressManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "resolve", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setBatchTxDataForStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setBatchTxDataForVerifier",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setBatchTxDataVerified",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setStakeBaseCost",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setStakeSeqSeconds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setStakeUnitCost",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTxBatchSize",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTxDataSliceCount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTxDataSliceSize",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setWhiteList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "stakeBaseCost",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "stakeSeqSeconds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "stakeUnitCost",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "txBatchSize",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "txDataSliceCount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "txDataSliceSize",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "verifierStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "whitelist", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "withdrawStake",
    data: BytesLike
  ): Result;

  events: {
    "AppendBatchElement(uint256,uint256,uint40,uint24,uint256,uint256,bytes32)": EventFragment;
    "SetBatchTxData(address,uint256,uint256,uint256,uint256,bool,bool)": EventFragment;
    "VerifierStake(address,uint256,uint256,uint256,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "AppendBatchElement"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetBatchTxData"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "VerifierStake"): EventFragment;
}

export type AppendBatchElementEvent = TypedEvent<
  [BigNumber, BigNumber, number, number, BigNumber, BigNumber, string] & {
    _chainId: BigNumber;
    _batchIndex: BigNumber;
    _shouldStartAtElement: number;
    _totalElementsToAppend: number;
    _txBatchSize: BigNumber;
    _txBatchTime: BigNumber;
    _root: string;
  }
>;

export type SetBatchTxDataEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber, BigNumber, boolean, boolean] & {
    _sender: string;
    _chainId: BigNumber;
    _batchIndex: BigNumber;
    _blockNumber: BigNumber;
    _stakeAmount: BigNumber;
    _verified: boolean;
    _sequencer: boolean;
  }
>;

export type VerifierStakeEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber, BigNumber] & {
    _sender: string;
    _chainId: BigNumber;
    _batchIndex: BigNumber;
    _blockNumber: BigNumber;
    _amount: BigNumber;
  }
>;

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

  listeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter?: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): Array<TypedListener<EventArgsArray, EventArgsObject>>;
  off<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  on<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  once<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeListener<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeAllListeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): this;

  listeners(eventName?: string): Array<Listener>;
  off(eventName: string, listener: Listener): this;
  on(eventName: string, listener: Listener): this;
  once(eventName: string, listener: Listener): this;
  removeListener(eventName: string, listener: Listener): this;
  removeAllListeners(eventName?: string): this;

  queryFilter<EventArgsArray extends Array<any>, EventArgsObject>(
    event: TypedEventFilter<EventArgsArray, EventArgsObject>,
    fromBlockOrBlockhash?: string | number | undefined,
    toBlock?: string | number | undefined
  ): Promise<Array<TypedEvent<EventArgsArray & EventArgsObject>>>;

  interface: MVMCanonicalTransactionInterface;

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

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

    appendSequencerBatchByChainId(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    checkBatchTxHash(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      _data: BytesLike,
      overrides?: CallOverrides
    ): Promise<[string, boolean] & { txHash: string; verified: boolean }>;

    disableWhiteList(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    getBatchTxData(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string, boolean] & { txData: string; verified: boolean }>;

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

    getStakeCostByBatch(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

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

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

    isWhiteListed(
      _verifier: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

    resolve(_name: string, overrides?: CallOverrides): Promise<[string]>;

    setBatchTxDataForStake(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      _data: BytesLike,
      _leafIndex: BigNumberish,
      _totalLeaves: BigNumberish,
      _proof: BytesLike[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setBatchTxDataForVerifier(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setBatchTxDataVerified(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      _verified: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setStakeBaseCost(
      _stakeBaseCost: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setStakeSeqSeconds(
      _seconds: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setStakeUnitCost(
      _stakeUnitCost: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setTxBatchSize(
      _size: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setTxDataSliceCount(
      _count: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setTxDataSliceSize(
      _size: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setWhiteList(
      _verifier: string,
      _allowed: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

    verifierStake(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    whitelist(arg0: string, overrides?: CallOverrides): Promise<[boolean]>;

    withdrawStake(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;
  };

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

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

  appendSequencerBatchByChainId(
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  checkBatchTxHash(
    _chainId: BigNumberish,
    _batchIndex: BigNumberish,
    _blockNumber: BigNumberish,
    _data: BytesLike,
    overrides?: CallOverrides
  ): Promise<[string, boolean] & { txHash: string; verified: boolean }>;

  disableWhiteList(
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  getBatchTxData(
    _chainId: BigNumberish,
    _batchIndex: BigNumberish,
    _blockNumber: BigNumberish,
    overrides?: CallOverrides
  ): Promise<[string, boolean] & { txData: string; verified: boolean }>;

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

  getStakeCostByBatch(
    _chainId: BigNumberish,
    _batchIndex: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

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

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

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

  isWhiteListed(_verifier: string, overrides?: CallOverrides): Promise<boolean>;

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

  resolve(_name: string, overrides?: CallOverrides): Promise<string>;

  setBatchTxDataForStake(
    _chainId: BigNumberish,
    _batchIndex: BigNumberish,
    _blockNumber: BigNumberish,
    _data: BytesLike,
    _leafIndex: BigNumberish,
    _totalLeaves: BigNumberish,
    _proof: BytesLike[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setBatchTxDataForVerifier(
    _chainId: BigNumberish,
    _batchIndex: BigNumberish,
    _blockNumber: BigNumberish,
    _data: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setBatchTxDataVerified(
    _chainId: BigNumberish,
    _batchIndex: BigNumberish,
    _blockNumber: BigNumberish,
    _verified: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setStakeBaseCost(
    _stakeBaseCost: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setStakeSeqSeconds(
    _seconds: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setStakeUnitCost(
    _stakeUnitCost: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setTxBatchSize(
    _size: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setTxDataSliceCount(
    _count: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setTxDataSliceSize(
    _size: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setWhiteList(
    _verifier: string,
    _allowed: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

  verifierStake(
    _chainId: BigNumberish,
    _batchIndex: BigNumberish,
    _blockNumber: BigNumberish,
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  whitelist(arg0: string, overrides?: CallOverrides): Promise<boolean>;

  withdrawStake(
    _chainId: BigNumberish,
    _batchIndex: BigNumberish,
    _blockNumber: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

    checkBatchTxHash(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      _data: BytesLike,
      overrides?: CallOverrides
    ): Promise<[string, boolean] & { txHash: string; verified: boolean }>;

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

    getBatchTxData(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string, boolean] & { txData: string; verified: boolean }>;

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

    getStakeCostByBatch(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

    isWhiteListed(
      _verifier: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    resolve(_name: string, overrides?: CallOverrides): Promise<string>;

    setBatchTxDataForStake(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      _data: BytesLike,
      _leafIndex: BigNumberish,
      _totalLeaves: BigNumberish,
      _proof: BytesLike[],
      overrides?: CallOverrides
    ): Promise<void>;

    setBatchTxDataForVerifier(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      _data: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    setBatchTxDataVerified(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      _verified: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    setStakeBaseCost(
      _stakeBaseCost: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setStakeSeqSeconds(
      _seconds: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setStakeUnitCost(
      _stakeUnitCost: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setTxBatchSize(
      _size: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setTxDataSliceCount(
      _count: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setTxDataSliceSize(
      _size: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setWhiteList(
      _verifier: string,
      _allowed: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

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

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

    verifierStake(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    whitelist(arg0: string, overrides?: CallOverrides): Promise<boolean>;

    withdrawStake(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "AppendBatchElement(uint256,uint256,uint40,uint24,uint256,uint256,bytes32)"(
      _chainId?: null,
      _batchIndex?: null,
      _shouldStartAtElement?: null,
      _totalElementsToAppend?: null,
      _txBatchSize?: null,
      _txBatchTime?: null,
      _root?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber, number, number, BigNumber, BigNumber, string],
      {
        _chainId: BigNumber;
        _batchIndex: BigNumber;
        _shouldStartAtElement: number;
        _totalElementsToAppend: number;
        _txBatchSize: BigNumber;
        _txBatchTime: BigNumber;
        _root: string;
      }
    >;

    AppendBatchElement(
      _chainId?: null,
      _batchIndex?: null,
      _shouldStartAtElement?: null,
      _totalElementsToAppend?: null,
      _txBatchSize?: null,
      _txBatchTime?: null,
      _root?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber, number, number, BigNumber, BigNumber, string],
      {
        _chainId: BigNumber;
        _batchIndex: BigNumber;
        _shouldStartAtElement: number;
        _totalElementsToAppend: number;
        _txBatchSize: BigNumber;
        _txBatchTime: BigNumber;
        _root: string;
      }
    >;

    "SetBatchTxData(address,uint256,uint256,uint256,uint256,bool,bool)"(
      _sender?: null,
      _chainId?: null,
      _batchIndex?: null,
      _blockNumber?: null,
      _stakeAmount?: null,
      _verified?: null,
      _sequencer?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber, BigNumber, boolean, boolean],
      {
        _sender: string;
        _chainId: BigNumber;
        _batchIndex: BigNumber;
        _blockNumber: BigNumber;
        _stakeAmount: BigNumber;
        _verified: boolean;
        _sequencer: boolean;
      }
    >;

    SetBatchTxData(
      _sender?: null,
      _chainId?: null,
      _batchIndex?: null,
      _blockNumber?: null,
      _stakeAmount?: null,
      _verified?: null,
      _sequencer?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber, BigNumber, boolean, boolean],
      {
        _sender: string;
        _chainId: BigNumber;
        _batchIndex: BigNumber;
        _blockNumber: BigNumber;
        _stakeAmount: BigNumber;
        _verified: boolean;
        _sequencer: boolean;
      }
    >;

    "VerifierStake(address,uint256,uint256,uint256,uint256)"(
      _sender?: null,
      _chainId?: null,
      _batchIndex?: null,
      _blockNumber?: null,
      _amount?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber, BigNumber],
      {
        _sender: string;
        _chainId: BigNumber;
        _batchIndex: BigNumber;
        _blockNumber: BigNumber;
        _amount: BigNumber;
      }
    >;

    VerifierStake(
      _sender?: null,
      _chainId?: null,
      _batchIndex?: null,
      _blockNumber?: null,
      _amount?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber, BigNumber, BigNumber],
      {
        _sender: string;
        _chainId: BigNumber;
        _batchIndex: BigNumber;
        _blockNumber: BigNumber;
        _amount: BigNumber;
      }
    >;
  };

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

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

    appendSequencerBatchByChainId(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    checkBatchTxHash(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      _data: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    disableWhiteList(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    getBatchTxData(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getStakeCostByBatch(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

    isWhiteListed(
      _verifier: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    resolve(_name: string, overrides?: CallOverrides): Promise<BigNumber>;

    setBatchTxDataForStake(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      _data: BytesLike,
      _leafIndex: BigNumberish,
      _totalLeaves: BigNumberish,
      _proof: BytesLike[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setBatchTxDataForVerifier(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setBatchTxDataVerified(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      _verified: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setStakeBaseCost(
      _stakeBaseCost: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setStakeSeqSeconds(
      _seconds: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setStakeUnitCost(
      _stakeUnitCost: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setTxBatchSize(
      _size: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setTxDataSliceCount(
      _count: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setTxDataSliceSize(
      _size: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setWhiteList(
      _verifier: string,
      _allowed: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

    verifierStake(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    whitelist(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;

    withdrawStake(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;
  };

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

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

    appendSequencerBatchByChainId(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    checkBatchTxHash(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      _data: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    disableWhiteList(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    getBatchTxData(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    getStakeCostByBatch(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

    isWhiteListed(
      _verifier: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    resolve(
      _name: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    setBatchTxDataForStake(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      _data: BytesLike,
      _leafIndex: BigNumberish,
      _totalLeaves: BigNumberish,
      _proof: BytesLike[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setBatchTxDataForVerifier(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setBatchTxDataVerified(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      _verified: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setStakeBaseCost(
      _stakeBaseCost: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setStakeSeqSeconds(
      _seconds: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setStakeUnitCost(
      _stakeUnitCost: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setTxBatchSize(
      _size: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setTxDataSliceCount(
      _count: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setTxDataSliceSize(
      _size: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setWhiteList(
      _verifier: string,
      _allowed: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

    verifierStake(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    whitelist(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    withdrawStake(
      _chainId: BigNumberish,
      _batchIndex: BigNumberish,
      _blockNumber: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;
  };
}