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

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
  BaseContract,
  ContractTransaction,
  Overrides,
  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 MVMVerifierInterface extends ethers.utils.Interface {
  functions: {
    "CONFIG_OWNER_KEY()": FunctionFragment;
    "absence_strikes(address)": FunctionFragment;
    "activeChallenges()": FunctionFragment;
    "chain_under_challenge(uint256)": FunctionFragment;
    "challenges(uint256)": FunctionFragment;
    "claim()": FunctionFragment;
    "consensus_strikes(address)": FunctionFragment;
    "decrypt(bytes,bytes)": FunctionFragment;
    "depositSeqStake(uint256)": FunctionFragment;
    "disableWhiteList()": FunctionFragment;
    "encrypt(bytes,bytes)": FunctionFragment;
    "getMerkleRoot(bytes32[])": FunctionFragment;
    "isSufficientlyStaked(address)": FunctionFragment;
    "isWhiteListed(address)": FunctionFragment;
    "libAddressManager()": FunctionFragment;
    "metis()": FunctionFragment;
    "minStake()": FunctionFragment;
    "newChallenge(uint256,(uint256,bytes32,uint256,uint256,bytes),bytes,bytes)": FunctionFragment;
    "numQualifiedVerifiers()": FunctionFragment;
    "resolve(string)": FunctionFragment;
    "rewards(address)": FunctionFragment;
    "seqStake()": FunctionFragment;
    "setMinStake(uint256)": FunctionFragment;
    "setThreshold(uint256,uint256)": FunctionFragment;
    "setVerifyWindow(uint256)": FunctionFragment;
    "setWhiteList(address,bool)": FunctionFragment;
    "verifierStake(uint256)": FunctionFragment;
    "verifier_stakes(address)": FunctionFragment;
    "verifiers(uint256)": FunctionFragment;
    "verify1(uint256,bytes,bytes)": FunctionFragment;
    "verify2(uint256,bytes)": FunctionFragment;
    "verifyWindow()": FunctionFragment;
    "whitelist(address)": FunctionFragment;
    "withdraw(uint256)": FunctionFragment;
    "withdrawSeqStake(address)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "CONFIG_OWNER_KEY",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "absence_strikes",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "activeChallenges",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "chain_under_challenge",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "challenges",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "claim", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "consensus_strikes",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "decrypt",
    values: [BytesLike, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "depositSeqStake",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "disableWhiteList",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "encrypt",
    values: [BytesLike, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "getMerkleRoot",
    values: [BytesLike[]]
  ): string;
  encodeFunctionData(
    functionFragment: "isSufficientlyStaked",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "isWhiteListed",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "libAddressManager",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "metis", values?: undefined): string;
  encodeFunctionData(functionFragment: "minStake", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "newChallenge",
    values: [
      BigNumberish,
      {
        batchIndex: BigNumberish;
        batchRoot: BytesLike;
        batchSize: BigNumberish;
        prevTotalElements: BigNumberish;
        extraData: BytesLike;
      },
      BytesLike,
      BytesLike
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "numQualifiedVerifiers",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "resolve", values: [string]): string;
  encodeFunctionData(functionFragment: "rewards", values: [string]): string;
  encodeFunctionData(functionFragment: "seqStake", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "setMinStake",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setThreshold",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setVerifyWindow",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setWhiteList",
    values: [string, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "verifierStake",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "verifier_stakes",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "verifiers",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "verify1",
    values: [BigNumberish, BytesLike, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "verify2",
    values: [BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "verifyWindow",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "whitelist", values: [string]): string;
  encodeFunctionData(
    functionFragment: "withdraw",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawSeqStake",
    values: [string]
  ): string;

  decodeFunctionResult(
    functionFragment: "CONFIG_OWNER_KEY",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "absence_strikes",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "activeChallenges",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "chain_under_challenge",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "challenges", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "consensus_strikes",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "decrypt", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "depositSeqStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "disableWhiteList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "encrypt", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getMerkleRoot",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isSufficientlyStaked",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isWhiteListed",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "libAddressManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "metis", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "minStake", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "newChallenge",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "numQualifiedVerifiers",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "resolve", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "rewards", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "seqStake", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setMinStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setThreshold",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setVerifyWindow",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setWhiteList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "verifierStake",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "verifier_stakes",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "verifiers", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "verify1", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "verify2", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "verifyWindow",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "whitelist", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "withdrawSeqStake",
    data: BytesLike
  ): Result;

  events: {
    "Claim(address,uint256)": EventFragment;
    "Finalize(uint256,address,uint8)": EventFragment;
    "NewChallenge(uint256,uint256,tuple,uint256)": EventFragment;
    "Penalize(address,uint256)": EventFragment;
    "Reward(address,uint256)": EventFragment;
    "SlashSequencer(uint256,address)": EventFragment;
    "Stake(address,uint256)": EventFragment;
    "Verify1(uint256,address)": EventFragment;
    "Verify2(uint256,address)": EventFragment;
    "Withdraw(address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Claim"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Finalize"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewChallenge"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Penalize"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Reward"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SlashSequencer"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Stake"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Verify1"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Verify2"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment;
}

export type ClaimEvent = TypedEvent<
  [string, BigNumber] & { sender: string; amount: BigNumber }
>;

export type FinalizeEvent = TypedEvent<
  [BigNumber, string, number] & {
    cIndex: BigNumber;
    sender: string;
    result: number;
  }
>;

export type NewChallengeEvent = TypedEvent<
  [
    BigNumber,
    BigNumber,
    [BigNumber, string, BigNumber, BigNumber, string] & {
      batchIndex: BigNumber;
      batchRoot: string;
      batchSize: BigNumber;
      prevTotalElements: BigNumber;
      extraData: string;
    },
    BigNumber
  ] & {
    cIndex: BigNumber;
    chainID: BigNumber;
    header: [BigNumber, string, BigNumber, BigNumber, string] & {
      batchIndex: BigNumber;
      batchRoot: string;
      batchSize: BigNumber;
      prevTotalElements: BigNumber;
      extraData: string;
    };
    timestamp: BigNumber;
  }
>;

export type PenalizeEvent = TypedEvent<
  [string, BigNumber] & { sender: string; stakeLost: BigNumber }
>;

export type RewardEvent = TypedEvent<
  [string, BigNumber] & { target: string; amount: BigNumber }
>;

export type SlashSequencerEvent = TypedEvent<
  [BigNumber, string] & { chainID: BigNumber; seq: string }
>;

export type StakeEvent = TypedEvent<
  [string, BigNumber] & { verifier: string; amount: BigNumber }
>;

export type Verify1Event = TypedEvent<
  [BigNumber, string] & { cIndex: BigNumber; verifier: string }
>;

export type Verify2Event = TypedEvent<
  [BigNumber, string] & { cIndex: BigNumber; verifier: string }
>;

export type WithdrawEvent = TypedEvent<
  [string, BigNumber] & { sender: string; amount: BigNumber }
>;

export class MVMVerifier 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: MVMVerifierInterface;

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

    absence_strikes(arg0: string, overrides?: CallOverrides): Promise<[number]>;

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

    chain_under_challenge(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    challenges(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        string,
        BigNumber,
        BigNumber,
        [BigNumber, string, BigNumber, BigNumber, string] & {
          batchIndex: BigNumber;
          batchRoot: string;
          batchSize: BigNumber;
          prevTotalElements: BigNumber;
          extraData: string;
        },
        BigNumber,
        BigNumber,
        BigNumber,
        boolean
      ] & {
        challenger: string;
        chainID: BigNumber;
        index: BigNumber;
        header: [BigNumber, string, BigNumber, BigNumber, string] & {
          batchIndex: BigNumber;
          batchRoot: string;
          batchSize: BigNumber;
          prevTotalElements: BigNumber;
          extraData: string;
        };
        timestamp: BigNumber;
        numQualifiedVerifiers: BigNumber;
        numVerifiers: BigNumber;
        done: boolean;
      }
    >;

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

    consensus_strikes(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<[number]>;

    decrypt(
      data: BytesLike,
      key: BytesLike,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

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

    encrypt(
      data: BytesLike,
      key: BytesLike,
      overrides?: CallOverrides
    ): Promise<[string]>;

    getMerkleRoot(
      elements: BytesLike[],
      overrides?: CallOverrides
    ): Promise<[string]>;

    isSufficientlyStaked(
      target: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

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

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

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

    newChallenge(
      chainID: BigNumberish,
      header: {
        batchIndex: BigNumberish;
        batchRoot: BytesLike;
        batchSize: BigNumberish;
        prevTotalElements: BigNumberish;
        extraData: BytesLike;
      },
      proposedHash: BytesLike,
      keyhash: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    rewards(arg0: string, overrides?: CallOverrides): Promise<[BigNumber]>;

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

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

    setThreshold(
      absence_threshold: BigNumberish,
      fail_threshold: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

    verifier_stakes(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    verifiers(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;

    verify1(
      cIndex: BigNumberish,
      hash: BytesLike,
      keyhash: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    verify2(
      cIndex: BigNumberish,
      key: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

  absence_strikes(arg0: string, overrides?: CallOverrides): Promise<number>;

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

  chain_under_challenge(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  challenges(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<
    [
      string,
      BigNumber,
      BigNumber,
      [BigNumber, string, BigNumber, BigNumber, string] & {
        batchIndex: BigNumber;
        batchRoot: string;
        batchSize: BigNumber;
        prevTotalElements: BigNumber;
        extraData: string;
      },
      BigNumber,
      BigNumber,
      BigNumber,
      boolean
    ] & {
      challenger: string;
      chainID: BigNumber;
      index: BigNumber;
      header: [BigNumber, string, BigNumber, BigNumber, string] & {
        batchIndex: BigNumber;
        batchRoot: string;
        batchSize: BigNumber;
        prevTotalElements: BigNumber;
        extraData: string;
      };
      timestamp: BigNumber;
      numQualifiedVerifiers: BigNumber;
      numVerifiers: BigNumber;
      done: boolean;
    }
  >;

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

  consensus_strikes(arg0: string, overrides?: CallOverrides): Promise<number>;

  decrypt(
    data: BytesLike,
    key: BytesLike,
    overrides?: CallOverrides
  ): Promise<string>;

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

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

  encrypt(
    data: BytesLike,
    key: BytesLike,
    overrides?: CallOverrides
  ): Promise<string>;

  getMerkleRoot(
    elements: BytesLike[],
    overrides?: CallOverrides
  ): Promise<string>;

  isSufficientlyStaked(
    target: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

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

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

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

  newChallenge(
    chainID: BigNumberish,
    header: {
      batchIndex: BigNumberish;
      batchRoot: BytesLike;
      batchSize: BigNumberish;
      prevTotalElements: BigNumberish;
      extraData: BytesLike;
    },
    proposedHash: BytesLike,
    keyhash: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

  setThreshold(
    absence_threshold: BigNumberish,
    fail_threshold: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

  verify1(
    cIndex: BigNumberish,
    hash: BytesLike,
    keyhash: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  verify2(
    cIndex: BigNumberish,
    key: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

    absence_strikes(arg0: string, overrides?: CallOverrides): Promise<number>;

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

    chain_under_challenge(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    challenges(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        string,
        BigNumber,
        BigNumber,
        [BigNumber, string, BigNumber, BigNumber, string] & {
          batchIndex: BigNumber;
          batchRoot: string;
          batchSize: BigNumber;
          prevTotalElements: BigNumber;
          extraData: string;
        },
        BigNumber,
        BigNumber,
        BigNumber,
        boolean
      ] & {
        challenger: string;
        chainID: BigNumber;
        index: BigNumber;
        header: [BigNumber, string, BigNumber, BigNumber, string] & {
          batchIndex: BigNumber;
          batchRoot: string;
          batchSize: BigNumber;
          prevTotalElements: BigNumber;
          extraData: string;
        };
        timestamp: BigNumber;
        numQualifiedVerifiers: BigNumber;
        numVerifiers: BigNumber;
        done: boolean;
      }
    >;

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

    consensus_strikes(arg0: string, overrides?: CallOverrides): Promise<number>;

    decrypt(
      data: BytesLike,
      key: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

    depositSeqStake(
      amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

    encrypt(
      data: BytesLike,
      key: BytesLike,
      overrides?: CallOverrides
    ): Promise<string>;

    getMerkleRoot(
      elements: BytesLike[],
      overrides?: CallOverrides
    ): Promise<string>;

    isSufficientlyStaked(
      target: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

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

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

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

    newChallenge(
      chainID: BigNumberish,
      header: {
        batchIndex: BigNumberish;
        batchRoot: BytesLike;
        batchSize: BigNumberish;
        prevTotalElements: BigNumberish;
        extraData: BytesLike;
      },
      proposedHash: BytesLike,
      keyhash: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

    setMinStake(
      _minStake: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setThreshold(
      absence_threshold: BigNumberish,
      fail_threshold: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setVerifyWindow(
      window: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setWhiteList(
      verifier: string,
      allowed: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    verifierStake(
      stake: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    verify1(
      cIndex: BigNumberish,
      hash: BytesLike,
      keyhash: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    verify2(
      cIndex: BigNumberish,
      key: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

    withdrawSeqStake(to: string, overrides?: CallOverrides): Promise<void>;
  };

  filters: {
    "Claim(address,uint256)"(
      sender?: null,
      amount?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { sender: string; amount: BigNumber }
    >;

    Claim(
      sender?: null,
      amount?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { sender: string; amount: BigNumber }
    >;

    "Finalize(uint256,address,uint8)"(
      cIndex?: null,
      sender?: null,
      result?: null
    ): TypedEventFilter<
      [BigNumber, string, number],
      { cIndex: BigNumber; sender: string; result: number }
    >;

    Finalize(
      cIndex?: null,
      sender?: null,
      result?: null
    ): TypedEventFilter<
      [BigNumber, string, number],
      { cIndex: BigNumber; sender: string; result: number }
    >;

    "NewChallenge(uint256,uint256,tuple,uint256)"(
      cIndex?: null,
      chainID?: null,
      header?: null,
      timestamp?: null
    ): TypedEventFilter<
      [
        BigNumber,
        BigNumber,
        [BigNumber, string, BigNumber, BigNumber, string] & {
          batchIndex: BigNumber;
          batchRoot: string;
          batchSize: BigNumber;
          prevTotalElements: BigNumber;
          extraData: string;
        },
        BigNumber
      ],
      {
        cIndex: BigNumber;
        chainID: BigNumber;
        header: [BigNumber, string, BigNumber, BigNumber, string] & {
          batchIndex: BigNumber;
          batchRoot: string;
          batchSize: BigNumber;
          prevTotalElements: BigNumber;
          extraData: string;
        };
        timestamp: BigNumber;
      }
    >;

    NewChallenge(
      cIndex?: null,
      chainID?: null,
      header?: null,
      timestamp?: null
    ): TypedEventFilter<
      [
        BigNumber,
        BigNumber,
        [BigNumber, string, BigNumber, BigNumber, string] & {
          batchIndex: BigNumber;
          batchRoot: string;
          batchSize: BigNumber;
          prevTotalElements: BigNumber;
          extraData: string;
        },
        BigNumber
      ],
      {
        cIndex: BigNumber;
        chainID: BigNumber;
        header: [BigNumber, string, BigNumber, BigNumber, string] & {
          batchIndex: BigNumber;
          batchRoot: string;
          batchSize: BigNumber;
          prevTotalElements: BigNumber;
          extraData: string;
        };
        timestamp: BigNumber;
      }
    >;

    "Penalize(address,uint256)"(
      sender?: null,
      stakeLost?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { sender: string; stakeLost: BigNumber }
    >;

    Penalize(
      sender?: null,
      stakeLost?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { sender: string; stakeLost: BigNumber }
    >;

    "Reward(address,uint256)"(
      target?: null,
      amount?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { target: string; amount: BigNumber }
    >;

    Reward(
      target?: null,
      amount?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { target: string; amount: BigNumber }
    >;

    "SlashSequencer(uint256,address)"(
      chainID?: null,
      seq?: null
    ): TypedEventFilter<
      [BigNumber, string],
      { chainID: BigNumber; seq: string }
    >;

    SlashSequencer(
      chainID?: null,
      seq?: null
    ): TypedEventFilter<
      [BigNumber, string],
      { chainID: BigNumber; seq: string }
    >;

    "Stake(address,uint256)"(
      verifier?: null,
      amount?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { verifier: string; amount: BigNumber }
    >;

    Stake(
      verifier?: null,
      amount?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { verifier: string; amount: BigNumber }
    >;

    "Verify1(uint256,address)"(
      cIndex?: null,
      verifier?: null
    ): TypedEventFilter<
      [BigNumber, string],
      { cIndex: BigNumber; verifier: string }
    >;

    Verify1(
      cIndex?: null,
      verifier?: null
    ): TypedEventFilter<
      [BigNumber, string],
      { cIndex: BigNumber; verifier: string }
    >;

    "Verify2(uint256,address)"(
      cIndex?: null,
      verifier?: null
    ): TypedEventFilter<
      [BigNumber, string],
      { cIndex: BigNumber; verifier: string }
    >;

    Verify2(
      cIndex?: null,
      verifier?: null
    ): TypedEventFilter<
      [BigNumber, string],
      { cIndex: BigNumber; verifier: string }
    >;

    "Withdraw(address,uint256)"(
      sender?: null,
      amount?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { sender: string; amount: BigNumber }
    >;

    Withdraw(
      sender?: null,
      amount?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { sender: string; amount: BigNumber }
    >;
  };

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

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

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

    chain_under_challenge(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    challenges(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    decrypt(
      data: BytesLike,
      key: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    encrypt(
      data: BytesLike,
      key: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getMerkleRoot(
      elements: BytesLike[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isSufficientlyStaked(
      target: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    newChallenge(
      chainID: BigNumberish,
      header: {
        batchIndex: BigNumberish;
        batchRoot: BytesLike;
        batchSize: BigNumberish;
        prevTotalElements: BigNumberish;
        extraData: BytesLike;
      },
      proposedHash: BytesLike,
      keyhash: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

    setThreshold(
      absence_threshold: BigNumberish,
      fail_threshold: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

    verifiers(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    verify1(
      cIndex: BigNumberish,
      hash: BytesLike,
      keyhash: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    verify2(
      cIndex: BigNumberish,
      key: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

    chain_under_challenge(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    challenges(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    decrypt(
      data: BytesLike,
      key: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    encrypt(
      data: BytesLike,
      key: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getMerkleRoot(
      elements: BytesLike[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isSufficientlyStaked(
      target: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

    newChallenge(
      chainID: BigNumberish,
      header: {
        batchIndex: BigNumberish;
        batchRoot: BytesLike;
        batchSize: BigNumberish;
        prevTotalElements: BigNumberish;
        extraData: BytesLike;
      },
      proposedHash: BytesLike,
      keyhash: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

    setThreshold(
      absence_threshold: BigNumberish,
      fail_threshold: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

    verifiers(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    verify1(
      cIndex: BigNumberish,
      hash: BytesLike,
      keyhash: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    verify2(
      cIndex: BigNumberish,
      key: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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