/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */
import type {
  BaseContract,
  BigNumber,
  BigNumberish,
  BytesLike,
  CallOverrides,
  ContractTransaction,
  Overrides,
  PopulatedTransaction,
  Signer,
  utils,
} from "ethers";
import type {
  FunctionFragment,
  Result,
  EventFragment,
} from "@ethersproject/abi";
import type { Listener, Provider } from "@ethersproject/providers";
import type {
  TypedEventFilter,
  TypedEvent,
  TypedListener,
  OnEvent,
  PromiseOrValue,
} from "../../common";

export interface PoodleIRHPInterface extends utils.Interface {
  functions: {
    "CHALLENGE_FEE()": FunctionFragment;
    "CHALLENGING_TIME()": FunctionFragment;
    "CONTESTING_TIME()": FunctionFragment;
    "ECO_ASSOCIATION1()": FunctionFragment;
    "ECO_ASSOCIATION2()": FunctionFragment;
    "ECO_INC()": FunctionFragment;
    "FEE_COLLECTION_TIME()": FunctionFragment;
    "GENERATION_START()": FunctionFragment;
    "MIN_GENERATION_DURATION()": FunctionFragment;
    "POOL_ADDRESS()": FunctionFragment;
    "PROPOSER_FEE()": FunctionFragment;
    "acceptedAmountOfAccounts()": FunctionFragment;
    "acceptedRootHash()": FunctionFragment;
    "acceptedTotalSum()": FunctionFragment;
    "blockNumber()": FunctionFragment;
    "canImplementInterfaceForAddress(bytes32,address)": FunctionFragment;
    "challengeRootHashRequestAccount(address,uint256)": FunctionFragment;
    "checkRootHashStatus(address)": FunctionFragment;
    "claimFee(address)": FunctionFragment;
    "claimFeeFor(address,address)": FunctionFragment;
    "claimMissingAccount(address,uint256,address)": FunctionFragment;
    "clone()": FunctionFragment;
    "configure(uint256)": FunctionFragment;
    "destruct()": FunctionFragment;
    "ecoToken()": FunctionFragment;
    "feeCollectionEnds()": FunctionFragment;
    "implementation()": FunctionFragment;
    "initialize(address)": FunctionFragment;
    "policy()": FunctionFragment;
    "policyCommand(address,bytes)": FunctionFragment;
    "proposeRootHash(bytes32,uint256,uint256)": FunctionFragment;
    "provePoodles()": FunctionFragment;
    "respondToChallenge(address,bytes32[],address,uint256,uint256,uint256)": FunctionFragment;
    "rootHashProposals(address)": FunctionFragment;
    "setExpectedInterfaceSet(address)": FunctionFragment;
    "verifyClaimSubmission(address,bytes32[],uint256,uint256)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "CHALLENGE_FEE"
      | "CHALLENGING_TIME"
      | "CONTESTING_TIME"
      | "ECO_ASSOCIATION1"
      | "ECO_ASSOCIATION2"
      | "ECO_INC"
      | "FEE_COLLECTION_TIME"
      | "GENERATION_START"
      | "MIN_GENERATION_DURATION"
      | "POOL_ADDRESS"
      | "PROPOSER_FEE"
      | "acceptedAmountOfAccounts"
      | "acceptedRootHash"
      | "acceptedTotalSum"
      | "blockNumber"
      | "canImplementInterfaceForAddress"
      | "challengeRootHashRequestAccount"
      | "checkRootHashStatus"
      | "claimFee"
      | "claimFeeFor"
      | "claimMissingAccount"
      | "clone"
      | "configure"
      | "destruct"
      | "ecoToken"
      | "feeCollectionEnds"
      | "implementation"
      | "initialize"
      | "policy"
      | "policyCommand"
      | "proposeRootHash"
      | "provePoodles"
      | "respondToChallenge"
      | "rootHashProposals"
      | "setExpectedInterfaceSet"
      | "verifyClaimSubmission"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "CHALLENGE_FEE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "CHALLENGING_TIME",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "CONTESTING_TIME",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "ECO_ASSOCIATION1",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "ECO_ASSOCIATION2",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "ECO_INC", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "FEE_COLLECTION_TIME",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "GENERATION_START",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "MIN_GENERATION_DURATION",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "POOL_ADDRESS",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "PROPOSER_FEE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "acceptedAmountOfAccounts",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "acceptedRootHash",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "acceptedTotalSum",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "blockNumber",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "canImplementInterfaceForAddress",
    values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "challengeRootHashRequestAccount",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "checkRootHashStatus",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "claimFee",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "claimFeeFor",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "claimMissingAccount",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>
    ]
  ): string;
  encodeFunctionData(functionFragment: "clone", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "configure",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(functionFragment: "destruct", values?: undefined): string;
  encodeFunctionData(functionFragment: "ecoToken", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "feeCollectionEnds",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "implementation",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(functionFragment: "policy", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "policyCommand",
    values: [PromiseOrValue<string>, PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "proposeRootHash",
    values: [
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "provePoodles",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "respondToChallenge",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BytesLike>[],
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "rootHashProposals",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setExpectedInterfaceSet",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "verifyClaimSubmission",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BytesLike>[],
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;

  decodeFunctionResult(
    functionFragment: "CHALLENGE_FEE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "CHALLENGING_TIME",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "CONTESTING_TIME",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "ECO_ASSOCIATION1",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "ECO_ASSOCIATION2",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "ECO_INC", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "FEE_COLLECTION_TIME",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "GENERATION_START",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "MIN_GENERATION_DURATION",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "POOL_ADDRESS",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "PROPOSER_FEE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "acceptedAmountOfAccounts",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "acceptedRootHash",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "acceptedTotalSum",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "blockNumber",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "canImplementInterfaceForAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "challengeRootHashRequestAccount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "checkRootHashStatus",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "claimFee", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "claimFeeFor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimMissingAccount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "clone", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "configure", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "destruct", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "ecoToken", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "feeCollectionEnds",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "implementation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "policy", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "policyCommand",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "proposeRootHash",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "provePoodles",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "respondToChallenge",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "rootHashProposals",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setExpectedInterfaceSet",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "verifyClaimSubmission",
    data: BytesLike
  ): Result;

  events: {
    "ChallengeMissingAccountSuccess(address,address,address,uint256)": EventFragment;
    "ChallengeSuccessResponse(address,address,address,uint256,uint256,uint256)": EventFragment;
    "ConfigureBlock(uint256)": EventFragment;
    "RootHashAcceptance(address,uint256,uint256)": EventFragment;
    "RootHashChallengeIndexRequest(address,address,uint256)": EventFragment;
    "RootHashPost(address,bytes32,uint256,uint256)": EventFragment;
    "RootHashRejection(address)": EventFragment;
  };

  getEvent(
    nameOrSignatureOrTopic: "ChallengeMissingAccountSuccess"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ChallengeSuccessResponse"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ConfigureBlock"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RootHashAcceptance"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "RootHashChallengeIndexRequest"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RootHashPost"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RootHashRejection"): EventFragment;
}

export interface ChallengeMissingAccountSuccessEventObject {
  proposer: string;
  challenger: string;
  missingAccount: string;
  index: BigNumber;
}
export type ChallengeMissingAccountSuccessEvent = TypedEvent<
  [string, string, string, BigNumber],
  ChallengeMissingAccountSuccessEventObject
>;

export type ChallengeMissingAccountSuccessEventFilter =
  TypedEventFilter<ChallengeMissingAccountSuccessEvent>;

export interface ChallengeSuccessResponseEventObject {
  proposer: string;
  challenger: string;
  account: string;
  balance: BigNumber;
  sum: BigNumber;
  index: BigNumber;
}
export type ChallengeSuccessResponseEvent = TypedEvent<
  [string, string, string, BigNumber, BigNumber, BigNumber],
  ChallengeSuccessResponseEventObject
>;

export type ChallengeSuccessResponseEventFilter =
  TypedEventFilter<ChallengeSuccessResponseEvent>;

export interface ConfigureBlockEventObject {
  _blockNumber: BigNumber;
}
export type ConfigureBlockEvent = TypedEvent<
  [BigNumber],
  ConfigureBlockEventObject
>;

export type ConfigureBlockEventFilter = TypedEventFilter<ConfigureBlockEvent>;

export interface RootHashAcceptanceEventObject {
  proposer: string;
  totalSum: BigNumber;
  amountOfAccounts: BigNumber;
}
export type RootHashAcceptanceEvent = TypedEvent<
  [string, BigNumber, BigNumber],
  RootHashAcceptanceEventObject
>;

export type RootHashAcceptanceEventFilter =
  TypedEventFilter<RootHashAcceptanceEvent>;

export interface RootHashChallengeIndexRequestEventObject {
  proposer: string;
  challenger: string;
  index: BigNumber;
}
export type RootHashChallengeIndexRequestEvent = TypedEvent<
  [string, string, BigNumber],
  RootHashChallengeIndexRequestEventObject
>;

export type RootHashChallengeIndexRequestEventFilter =
  TypedEventFilter<RootHashChallengeIndexRequestEvent>;

export interface RootHashPostEventObject {
  proposer: string;
  proposedRootHash: string;
  totalSum: BigNumber;
  amountOfAccounts: BigNumber;
}
export type RootHashPostEvent = TypedEvent<
  [string, string, BigNumber, BigNumber],
  RootHashPostEventObject
>;

export type RootHashPostEventFilter = TypedEventFilter<RootHashPostEvent>;

export interface RootHashRejectionEventObject {
  proposer: string;
}
export type RootHashRejectionEvent = TypedEvent<
  [string],
  RootHashRejectionEventObject
>;

export type RootHashRejectionEventFilter =
  TypedEventFilter<RootHashRejectionEvent>;

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

  interface: PoodleIRHPInterface;

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

  listeners<TEvent extends TypedEvent>(
    eventFilter?: TypedEventFilter<TEvent>
  ): Array<TypedListener<TEvent>>;
  listeners(eventName?: string): Array<Listener>;
  removeAllListeners<TEvent extends TypedEvent>(
    eventFilter: TypedEventFilter<TEvent>
  ): this;
  removeAllListeners(eventName?: string): this;
  off: OnEvent<this>;
  on: OnEvent<this>;
  once: OnEvent<this>;
  removeListener: OnEvent<this>;

  functions: {
    CHALLENGE_FEE(overrides?: CallOverrides): Promise<[BigNumber]>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    canImplementInterfaceForAddress(
      arg0: PromiseOrValue<BytesLike>,
      _addr: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[string]>;

    challengeRootHashRequestAccount(
      _proposer: PromiseOrValue<string>,
      _index: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    checkRootHashStatus(
      _proposer: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    claimFee(
      _proposer: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    claimFeeFor(
      _who: PromiseOrValue<string>,
      _proposer: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    claimMissingAccount(
      _proposer: PromiseOrValue<string>,
      _index: PromiseOrValue<BigNumberish>,
      _account: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

    configure(
      _blockNumber: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

    initialize(
      _self: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

    policyCommand(
      _delegate: PromiseOrValue<string>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    proposeRootHash(
      _proposedRootHash: PromiseOrValue<BytesLike>,
      _totalSum: PromiseOrValue<BigNumberish>,
      _amountOfAccounts: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    provePoodles(overrides?: CallOverrides): Promise<[boolean]>;

    respondToChallenge(
      _challenger: PromiseOrValue<string>,
      _proof: PromiseOrValue<BytesLike>[],
      _account: PromiseOrValue<string>,
      _claimedBalance: PromiseOrValue<BigNumberish>,
      _sum: PromiseOrValue<BigNumberish>,
      _index: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    rootHashProposals(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [
        boolean,
        string,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        number
      ] & {
        initialized: boolean;
        rootHash: string;
        totalSum: BigNumber;
        amountOfAccounts: BigNumber;
        lastLiveChallenge: BigNumber;
        amountPendingChallenges: BigNumber;
        totalChallenges: BigNumber;
        stakedAmount: BigNumber;
        newChallengerSubmissionEnds: BigNumber;
        status: number;
      }
    >;

    setExpectedInterfaceSet(
      _addr: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    verifyClaimSubmission(
      _who: PromiseOrValue<string>,
      _proof: PromiseOrValue<BytesLike>[],
      _sum: PromiseOrValue<BigNumberish>,
      _index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;
  };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  canImplementInterfaceForAddress(
    arg0: PromiseOrValue<BytesLike>,
    _addr: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<string>;

  challengeRootHashRequestAccount(
    _proposer: PromiseOrValue<string>,
    _index: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  checkRootHashStatus(
    _proposer: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  claimFee(
    _proposer: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  claimFeeFor(
    _who: PromiseOrValue<string>,
    _proposer: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  claimMissingAccount(
    _proposer: PromiseOrValue<string>,
    _index: PromiseOrValue<BigNumberish>,
    _account: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

  configure(
    _blockNumber: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

  initialize(
    _self: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

  policyCommand(
    _delegate: PromiseOrValue<string>,
    _data: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  proposeRootHash(
    _proposedRootHash: PromiseOrValue<BytesLike>,
    _totalSum: PromiseOrValue<BigNumberish>,
    _amountOfAccounts: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

  respondToChallenge(
    _challenger: PromiseOrValue<string>,
    _proof: PromiseOrValue<BytesLike>[],
    _account: PromiseOrValue<string>,
    _claimedBalance: PromiseOrValue<BigNumberish>,
    _sum: PromiseOrValue<BigNumberish>,
    _index: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  rootHashProposals(
    arg0: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<
    [
      boolean,
      string,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      number
    ] & {
      initialized: boolean;
      rootHash: string;
      totalSum: BigNumber;
      amountOfAccounts: BigNumber;
      lastLiveChallenge: BigNumber;
      amountPendingChallenges: BigNumber;
      totalChallenges: BigNumber;
      stakedAmount: BigNumber;
      newChallengerSubmissionEnds: BigNumber;
      status: number;
    }
  >;

  setExpectedInterfaceSet(
    _addr: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  verifyClaimSubmission(
    _who: PromiseOrValue<string>,
    _proof: PromiseOrValue<BytesLike>[],
    _sum: PromiseOrValue<BigNumberish>,
    _index: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  callStatic: {
    CHALLENGE_FEE(overrides?: CallOverrides): Promise<BigNumber>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    canImplementInterfaceForAddress(
      arg0: PromiseOrValue<BytesLike>,
      _addr: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<string>;

    challengeRootHashRequestAccount(
      _proposer: PromiseOrValue<string>,
      _index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    checkRootHashStatus(
      _proposer: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    claimFee(
      _proposer: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    claimFeeFor(
      _who: PromiseOrValue<string>,
      _proposer: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    claimMissingAccount(
      _proposer: PromiseOrValue<string>,
      _index: PromiseOrValue<BigNumberish>,
      _account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

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

    configure(
      _blockNumber: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

    initialize(
      _self: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

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

    policyCommand(
      _delegate: PromiseOrValue<string>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    proposeRootHash(
      _proposedRootHash: PromiseOrValue<BytesLike>,
      _totalSum: PromiseOrValue<BigNumberish>,
      _amountOfAccounts: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

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

    respondToChallenge(
      _challenger: PromiseOrValue<string>,
      _proof: PromiseOrValue<BytesLike>[],
      _account: PromiseOrValue<string>,
      _claimedBalance: PromiseOrValue<BigNumberish>,
      _sum: PromiseOrValue<BigNumberish>,
      _index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    rootHashProposals(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [
        boolean,
        string,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        number
      ] & {
        initialized: boolean;
        rootHash: string;
        totalSum: BigNumber;
        amountOfAccounts: BigNumber;
        lastLiveChallenge: BigNumber;
        amountPendingChallenges: BigNumber;
        totalChallenges: BigNumber;
        stakedAmount: BigNumber;
        newChallengerSubmissionEnds: BigNumber;
        status: number;
      }
    >;

    setExpectedInterfaceSet(
      _addr: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    verifyClaimSubmission(
      _who: PromiseOrValue<string>,
      _proof: PromiseOrValue<BytesLike>[],
      _sum: PromiseOrValue<BigNumberish>,
      _index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<boolean>;
  };

  filters: {
    "ChallengeMissingAccountSuccess(address,address,address,uint256)"(
      proposer?: PromiseOrValue<string> | null,
      challenger?: null,
      missingAccount?: null,
      index?: PromiseOrValue<BigNumberish> | null
    ): ChallengeMissingAccountSuccessEventFilter;
    ChallengeMissingAccountSuccess(
      proposer?: PromiseOrValue<string> | null,
      challenger?: null,
      missingAccount?: null,
      index?: PromiseOrValue<BigNumberish> | null
    ): ChallengeMissingAccountSuccessEventFilter;

    "ChallengeSuccessResponse(address,address,address,uint256,uint256,uint256)"(
      proposer?: PromiseOrValue<string> | null,
      challenger?: null,
      account?: null,
      balance?: null,
      sum?: null,
      index?: PromiseOrValue<BigNumberish> | null
    ): ChallengeSuccessResponseEventFilter;
    ChallengeSuccessResponse(
      proposer?: PromiseOrValue<string> | null,
      challenger?: null,
      account?: null,
      balance?: null,
      sum?: null,
      index?: PromiseOrValue<BigNumberish> | null
    ): ChallengeSuccessResponseEventFilter;

    "ConfigureBlock(uint256)"(_blockNumber?: null): ConfigureBlockEventFilter;
    ConfigureBlock(_blockNumber?: null): ConfigureBlockEventFilter;

    "RootHashAcceptance(address,uint256,uint256)"(
      proposer?: PromiseOrValue<string> | null,
      totalSum?: null,
      amountOfAccounts?: null
    ): RootHashAcceptanceEventFilter;
    RootHashAcceptance(
      proposer?: PromiseOrValue<string> | null,
      totalSum?: null,
      amountOfAccounts?: null
    ): RootHashAcceptanceEventFilter;

    "RootHashChallengeIndexRequest(address,address,uint256)"(
      proposer?: PromiseOrValue<string> | null,
      challenger?: null,
      index?: PromiseOrValue<BigNumberish> | null
    ): RootHashChallengeIndexRequestEventFilter;
    RootHashChallengeIndexRequest(
      proposer?: PromiseOrValue<string> | null,
      challenger?: null,
      index?: PromiseOrValue<BigNumberish> | null
    ): RootHashChallengeIndexRequestEventFilter;

    "RootHashPost(address,bytes32,uint256,uint256)"(
      proposer?: PromiseOrValue<string> | null,
      proposedRootHash?: PromiseOrValue<BytesLike> | null,
      totalSum?: null,
      amountOfAccounts?: null
    ): RootHashPostEventFilter;
    RootHashPost(
      proposer?: PromiseOrValue<string> | null,
      proposedRootHash?: PromiseOrValue<BytesLike> | null,
      totalSum?: null,
      amountOfAccounts?: null
    ): RootHashPostEventFilter;

    "RootHashRejection(address)"(
      proposer?: PromiseOrValue<string> | null
    ): RootHashRejectionEventFilter;
    RootHashRejection(
      proposer?: PromiseOrValue<string> | null
    ): RootHashRejectionEventFilter;
  };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    canImplementInterfaceForAddress(
      arg0: PromiseOrValue<BytesLike>,
      _addr: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    challengeRootHashRequestAccount(
      _proposer: PromiseOrValue<string>,
      _index: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    checkRootHashStatus(
      _proposer: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    claimFee(
      _proposer: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    claimFeeFor(
      _who: PromiseOrValue<string>,
      _proposer: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    claimMissingAccount(
      _proposer: PromiseOrValue<string>,
      _index: PromiseOrValue<BigNumberish>,
      _account: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

    configure(
      _blockNumber: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

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

    initialize(
      _self: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

    policyCommand(
      _delegate: PromiseOrValue<string>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    proposeRootHash(
      _proposedRootHash: PromiseOrValue<BytesLike>,
      _totalSum: PromiseOrValue<BigNumberish>,
      _amountOfAccounts: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

    respondToChallenge(
      _challenger: PromiseOrValue<string>,
      _proof: PromiseOrValue<BytesLike>[],
      _account: PromiseOrValue<string>,
      _claimedBalance: PromiseOrValue<BigNumberish>,
      _sum: PromiseOrValue<BigNumberish>,
      _index: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

    setExpectedInterfaceSet(
      _addr: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    verifyClaimSubmission(
      _who: PromiseOrValue<string>,
      _proof: PromiseOrValue<BytesLike>[],
      _sum: PromiseOrValue<BigNumberish>,
      _index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;
  };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    canImplementInterfaceForAddress(
      arg0: PromiseOrValue<BytesLike>,
      _addr: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    challengeRootHashRequestAccount(
      _proposer: PromiseOrValue<string>,
      _index: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    checkRootHashStatus(
      _proposer: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    claimFee(
      _proposer: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    claimFeeFor(
      _who: PromiseOrValue<string>,
      _proposer: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    claimMissingAccount(
      _proposer: PromiseOrValue<string>,
      _index: PromiseOrValue<BigNumberish>,
      _account: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

    configure(
      _blockNumber: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

    initialize(
      _self: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

    policyCommand(
      _delegate: PromiseOrValue<string>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    proposeRootHash(
      _proposedRootHash: PromiseOrValue<BytesLike>,
      _totalSum: PromiseOrValue<BigNumberish>,
      _amountOfAccounts: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

    respondToChallenge(
      _challenger: PromiseOrValue<string>,
      _proof: PromiseOrValue<BytesLike>[],
      _account: PromiseOrValue<string>,
      _claimedBalance: PromiseOrValue<BigNumberish>,
      _sum: PromiseOrValue<BigNumberish>,
      _index: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

    setExpectedInterfaceSet(
      _addr: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    verifyClaimSubmission(
      _who: PromiseOrValue<string>,
      _proof: PromiseOrValue<BytesLike>[],
      _sum: PromiseOrValue<BigNumberish>,
      _index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;
  };
}
