/* 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 RelayerRegistryAbiInterface extends utils.Interface {
  functions: {
    'bulkResolve(bytes32[])': FunctionFragment
    'burn(address,address,address)': FunctionFragment
    'ens()': FunctionFragment
    'feeManager()': FunctionFragment
    'getRelayerBalance(address)': FunctionFragment
    'getRelayerEnsHash(address)': FunctionFragment
    'governance()': FunctionFragment
    'initialize(bytes32)': FunctionFragment
    'isRelayer(address)': FunctionFragment
    'isRelayerRegistered(address,address)': FunctionFragment
    'minStakeAmount()': FunctionFragment
    'nullifyBalance(address)': FunctionFragment
    'register(string,uint256,address[])': FunctionFragment
    'registerPermit(string,uint256,address[],address,uint256,uint8,bytes32,bytes32)': FunctionFragment
    'registerWorker(address,address)': FunctionFragment
    'relayers(address)': FunctionFragment
    'resolve(bytes32)': FunctionFragment
    'setMinStakeAmount(uint256)': FunctionFragment
    'setTornadoRouter(address)': FunctionFragment
    'stakeToRelayer(address,uint256)': FunctionFragment
    'stakeToRelayerPermit(address,uint256,address,uint256,uint8,bytes32,bytes32)': FunctionFragment
    'staking()': FunctionFragment
    'torn()': FunctionFragment
    'tornadoRouter()': FunctionFragment
    'unregisterWorker(address)': FunctionFragment
    'workers(address)': FunctionFragment
  }

  getFunction(
    nameOrSignatureOrTopic:
      | 'bulkResolve'
      | 'burn'
      | 'ens'
      | 'feeManager'
      | 'getRelayerBalance'
      | 'getRelayerEnsHash'
      | 'governance'
      | 'initialize'
      | 'isRelayer'
      | 'isRelayerRegistered'
      | 'minStakeAmount'
      | 'nullifyBalance'
      | 'register'
      | 'registerPermit'
      | 'registerWorker'
      | 'relayers'
      | 'resolve'
      | 'setMinStakeAmount'
      | 'setTornadoRouter'
      | 'stakeToRelayer'
      | 'stakeToRelayerPermit'
      | 'staking'
      | 'torn'
      | 'tornadoRouter'
      | 'unregisterWorker'
      | 'workers'
  ): FunctionFragment

  encodeFunctionData(functionFragment: 'bulkResolve', values: [PromiseOrValue<BytesLike>[]]): string
  encodeFunctionData(
    functionFragment: 'burn',
    values: [PromiseOrValue<string>, PromiseOrValue<string>, PromiseOrValue<string>]
  ): string
  encodeFunctionData(functionFragment: 'ens', values?: undefined): string
  encodeFunctionData(functionFragment: 'feeManager', values?: undefined): string
  encodeFunctionData(functionFragment: 'getRelayerBalance', values: [PromiseOrValue<string>]): string
  encodeFunctionData(functionFragment: 'getRelayerEnsHash', values: [PromiseOrValue<string>]): string
  encodeFunctionData(functionFragment: 'governance', values?: undefined): string
  encodeFunctionData(functionFragment: 'initialize', values: [PromiseOrValue<BytesLike>]): string
  encodeFunctionData(functionFragment: 'isRelayer', values: [PromiseOrValue<string>]): string
  encodeFunctionData(
    functionFragment: 'isRelayerRegistered',
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string
  encodeFunctionData(functionFragment: 'minStakeAmount', values?: undefined): string
  encodeFunctionData(functionFragment: 'nullifyBalance', values: [PromiseOrValue<string>]): string
  encodeFunctionData(
    functionFragment: 'register',
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>, PromiseOrValue<string>[]]
  ): string
  encodeFunctionData(
    functionFragment: 'registerPermit',
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>[],
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BytesLike>
    ]
  ): string
  encodeFunctionData(
    functionFragment: 'registerWorker',
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string
  encodeFunctionData(functionFragment: 'relayers', values: [PromiseOrValue<string>]): string
  encodeFunctionData(functionFragment: 'resolve', values: [PromiseOrValue<BytesLike>]): string
  encodeFunctionData(functionFragment: 'setMinStakeAmount', values: [PromiseOrValue<BigNumberish>]): string
  encodeFunctionData(functionFragment: 'setTornadoRouter', values: [PromiseOrValue<string>]): string
  encodeFunctionData(
    functionFragment: 'stakeToRelayer',
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string
  encodeFunctionData(
    functionFragment: 'stakeToRelayerPermit',
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BytesLike>
    ]
  ): string
  encodeFunctionData(functionFragment: 'staking', values?: undefined): string
  encodeFunctionData(functionFragment: 'torn', values?: undefined): string
  encodeFunctionData(functionFragment: 'tornadoRouter', values?: undefined): string
  encodeFunctionData(functionFragment: 'unregisterWorker', values: [PromiseOrValue<string>]): string
  encodeFunctionData(functionFragment: 'workers', values: [PromiseOrValue<string>]): string

  decodeFunctionResult(functionFragment: 'bulkResolve', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'burn', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'ens', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'feeManager', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'getRelayerBalance', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'getRelayerEnsHash', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'governance', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'initialize', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'isRelayer', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'isRelayerRegistered', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'minStakeAmount', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'nullifyBalance', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'register', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'registerPermit', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'registerWorker', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'relayers', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'resolve', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'setMinStakeAmount', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'setTornadoRouter', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'stakeToRelayer', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'stakeToRelayerPermit', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'staking', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'torn', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'tornadoRouter', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'unregisterWorker', data: BytesLike): Result
  decodeFunctionResult(functionFragment: 'workers', data: BytesLike): Result

  events: {
    'MinimumStakeAmount(uint256)': EventFragment
    'RelayerBalanceNullified(address)': EventFragment
    'RelayerRegistered(bytes32,string,address,uint256)': EventFragment
    'RouterRegistered(address)': EventFragment
    'StakeAddedToRelayer(address,uint256)': EventFragment
    'StakeBurned(address,uint256)': EventFragment
    'WorkerRegistered(address,address)': EventFragment
    'WorkerUnregistered(address,address)': EventFragment
  }

  getEvent(nameOrSignatureOrTopic: 'MinimumStakeAmount'): EventFragment
  getEvent(nameOrSignatureOrTopic: 'RelayerBalanceNullified'): EventFragment
  getEvent(nameOrSignatureOrTopic: 'RelayerRegistered'): EventFragment
  getEvent(nameOrSignatureOrTopic: 'RouterRegistered'): EventFragment
  getEvent(nameOrSignatureOrTopic: 'StakeAddedToRelayer'): EventFragment
  getEvent(nameOrSignatureOrTopic: 'StakeBurned'): EventFragment
  getEvent(nameOrSignatureOrTopic: 'WorkerRegistered'): EventFragment
  getEvent(nameOrSignatureOrTopic: 'WorkerUnregistered'): EventFragment
}

export interface MinimumStakeAmountEventObject {
  minStakeAmount: BigNumber
}
export type MinimumStakeAmountEvent = TypedEvent<[BigNumber], MinimumStakeAmountEventObject>

export type MinimumStakeAmountEventFilter = TypedEventFilter<MinimumStakeAmountEvent>

export interface RelayerBalanceNullifiedEventObject {
  relayer: string
}
export type RelayerBalanceNullifiedEvent = TypedEvent<[string], RelayerBalanceNullifiedEventObject>

export type RelayerBalanceNullifiedEventFilter = TypedEventFilter<RelayerBalanceNullifiedEvent>

export interface RelayerRegisteredEventObject {
  relayer: string
  ensName: string
  relayerAddress: string
  stakedAmount: BigNumber
}
export type RelayerRegisteredEvent = TypedEvent<
  [string, string, string, BigNumber],
  RelayerRegisteredEventObject
>

export type RelayerRegisteredEventFilter = TypedEventFilter<RelayerRegisteredEvent>

export interface RouterRegisteredEventObject {
  tornadoRouter: string
}
export type RouterRegisteredEvent = TypedEvent<[string], RouterRegisteredEventObject>

export type RouterRegisteredEventFilter = TypedEventFilter<RouterRegisteredEvent>

export interface StakeAddedToRelayerEventObject {
  relayer: string
  amountStakeAdded: BigNumber
}
export type StakeAddedToRelayerEvent = TypedEvent<[string, BigNumber], StakeAddedToRelayerEventObject>

export type StakeAddedToRelayerEventFilter = TypedEventFilter<StakeAddedToRelayerEvent>

export interface StakeBurnedEventObject {
  relayer: string
  amountBurned: BigNumber
}
export type StakeBurnedEvent = TypedEvent<[string, BigNumber], StakeBurnedEventObject>

export type StakeBurnedEventFilter = TypedEventFilter<StakeBurnedEvent>

export interface WorkerRegisteredEventObject {
  relayer: string
  worker: string
}
export type WorkerRegisteredEvent = TypedEvent<[string, string], WorkerRegisteredEventObject>

export type WorkerRegisteredEventFilter = TypedEventFilter<WorkerRegisteredEvent>

export interface WorkerUnregisteredEventObject {
  relayer: string
  worker: string
}
export type WorkerUnregisteredEvent = TypedEvent<[string, string], WorkerUnregisteredEventObject>

export type WorkerUnregisteredEventFilter = TypedEventFilter<WorkerUnregisteredEvent>

export interface RelayerRegistryAbi extends BaseContract {
  contractName: 'RelayerRegistryAbi'

  connect(signerOrProvider: Signer | Provider | string): this
  attach(addressOrName: string): this
  deployed(): Promise<this>

  interface: RelayerRegistryAbiInterface

  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: {
    bulkResolve(
      domains: PromiseOrValue<BytesLike>[],
      overrides?: CallOverrides
    ): Promise<[string[]] & { result: string[] }>

    burn(
      sender: PromiseOrValue<string>,
      relayer: PromiseOrValue<string>,
      pool: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>

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

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

    getRelayerBalance(relayer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>

    getRelayerEnsHash(relayer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[string]>

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

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

    isRelayer(toResolve: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>

    isRelayerRegistered(
      relayer: PromiseOrValue<string>,
      toResolve: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[boolean]>

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

    nullifyBalance(
      relayer: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>

    register(
      ensName: PromiseOrValue<string>,
      stake: PromiseOrValue<BigNumberish>,
      workersToRegister: PromiseOrValue<string>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>

    registerPermit(
      ensName: PromiseOrValue<string>,
      stake: PromiseOrValue<BigNumberish>,
      workersToRegister: PromiseOrValue<string>[],
      relayer: PromiseOrValue<string>,
      deadline: PromiseOrValue<BigNumberish>,
      v: PromiseOrValue<BigNumberish>,
      r: PromiseOrValue<BytesLike>,
      s: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>

    registerWorker(
      relayer: PromiseOrValue<string>,
      worker: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>

    relayers(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber, string] & { balance: BigNumber; ensHash: string }>

    resolve(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string]>

    setMinStakeAmount(
      minAmount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>

    setTornadoRouter(
      tornadoRouterAddress: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>

    stakeToRelayer(
      relayer: PromiseOrValue<string>,
      stake: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>

    stakeToRelayerPermit(
      relayer: PromiseOrValue<string>,
      stake: PromiseOrValue<BigNumberish>,
      staker: PromiseOrValue<string>,
      deadline: PromiseOrValue<BigNumberish>,
      v: PromiseOrValue<BigNumberish>,
      r: PromiseOrValue<BytesLike>,
      s: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>

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

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

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

    unregisterWorker(
      worker: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>

    workers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[string]>
  }

  bulkResolve(domains: PromiseOrValue<BytesLike>[], overrides?: CallOverrides): Promise<string[]>

  burn(
    sender: PromiseOrValue<string>,
    relayer: PromiseOrValue<string>,
    pool: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>

  ens(overrides?: CallOverrides): Promise<string>

  feeManager(overrides?: CallOverrides): Promise<string>

  getRelayerBalance(relayer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>

  getRelayerEnsHash(relayer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>

  governance(overrides?: CallOverrides): Promise<string>

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

  isRelayer(toResolve: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>

  isRelayerRegistered(
    relayer: PromiseOrValue<string>,
    toResolve: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>

  minStakeAmount(overrides?: CallOverrides): Promise<BigNumber>

  nullifyBalance(
    relayer: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>

  register(
    ensName: PromiseOrValue<string>,
    stake: PromiseOrValue<BigNumberish>,
    workersToRegister: PromiseOrValue<string>[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>

  registerPermit(
    ensName: PromiseOrValue<string>,
    stake: PromiseOrValue<BigNumberish>,
    workersToRegister: PromiseOrValue<string>[],
    relayer: PromiseOrValue<string>,
    deadline: PromiseOrValue<BigNumberish>,
    v: PromiseOrValue<BigNumberish>,
    r: PromiseOrValue<BytesLike>,
    s: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>

  registerWorker(
    relayer: PromiseOrValue<string>,
    worker: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>

  relayers(
    arg0: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<[BigNumber, string] & { balance: BigNumber; ensHash: string }>

  resolve(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>

  setMinStakeAmount(
    minAmount: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>

  setTornadoRouter(
    tornadoRouterAddress: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>

  stakeToRelayer(
    relayer: PromiseOrValue<string>,
    stake: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>

  stakeToRelayerPermit(
    relayer: PromiseOrValue<string>,
    stake: PromiseOrValue<BigNumberish>,
    staker: PromiseOrValue<string>,
    deadline: PromiseOrValue<BigNumberish>,
    v: PromiseOrValue<BigNumberish>,
    r: PromiseOrValue<BytesLike>,
    s: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>

  staking(overrides?: CallOverrides): Promise<string>

  torn(overrides?: CallOverrides): Promise<string>

  tornadoRouter(overrides?: CallOverrides): Promise<string>

  unregisterWorker(
    worker: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>

  workers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>

  callStatic: {
    bulkResolve(domains: PromiseOrValue<BytesLike>[], overrides?: CallOverrides): Promise<string[]>

    burn(
      sender: PromiseOrValue<string>,
      relayer: PromiseOrValue<string>,
      pool: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>

    ens(overrides?: CallOverrides): Promise<string>

    feeManager(overrides?: CallOverrides): Promise<string>

    getRelayerBalance(relayer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>

    getRelayerEnsHash(relayer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>

    governance(overrides?: CallOverrides): Promise<string>

    initialize(_tornadoRouter: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>

    isRelayer(toResolve: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>

    isRelayerRegistered(
      relayer: PromiseOrValue<string>,
      toResolve: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>

    minStakeAmount(overrides?: CallOverrides): Promise<BigNumber>

    nullifyBalance(relayer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>

    register(
      ensName: PromiseOrValue<string>,
      stake: PromiseOrValue<BigNumberish>,
      workersToRegister: PromiseOrValue<string>[],
      overrides?: CallOverrides
    ): Promise<void>

    registerPermit(
      ensName: PromiseOrValue<string>,
      stake: PromiseOrValue<BigNumberish>,
      workersToRegister: PromiseOrValue<string>[],
      relayer: PromiseOrValue<string>,
      deadline: PromiseOrValue<BigNumberish>,
      v: PromiseOrValue<BigNumberish>,
      r: PromiseOrValue<BytesLike>,
      s: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>

    registerWorker(
      relayer: PromiseOrValue<string>,
      worker: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>

    relayers(
      arg0: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber, string] & { balance: BigNumber; ensHash: string }>

    resolve(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>

    setMinStakeAmount(minAmount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>

    setTornadoRouter(tornadoRouterAddress: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>

    stakeToRelayer(
      relayer: PromiseOrValue<string>,
      stake: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>

    stakeToRelayerPermit(
      relayer: PromiseOrValue<string>,
      stake: PromiseOrValue<BigNumberish>,
      staker: PromiseOrValue<string>,
      deadline: PromiseOrValue<BigNumberish>,
      v: PromiseOrValue<BigNumberish>,
      r: PromiseOrValue<BytesLike>,
      s: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>

    staking(overrides?: CallOverrides): Promise<string>

    torn(overrides?: CallOverrides): Promise<string>

    tornadoRouter(overrides?: CallOverrides): Promise<string>

    unregisterWorker(worker: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>

    workers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>
  }

  filters: {
    'MinimumStakeAmount(uint256)'(minStakeAmount?: null): MinimumStakeAmountEventFilter
    MinimumStakeAmount(minStakeAmount?: null): MinimumStakeAmountEventFilter

    'RelayerBalanceNullified(address)'(relayer?: null): RelayerBalanceNullifiedEventFilter
    RelayerBalanceNullified(relayer?: null): RelayerBalanceNullifiedEventFilter

    'RelayerRegistered(bytes32,string,address,uint256)'(
      relayer?: null,
      ensName?: null,
      relayerAddress?: null,
      stakedAmount?: null
    ): RelayerRegisteredEventFilter
    RelayerRegistered(
      relayer?: null,
      ensName?: null,
      relayerAddress?: null,
      stakedAmount?: null
    ): RelayerRegisteredEventFilter

    'RouterRegistered(address)'(tornadoRouter?: null): RouterRegisteredEventFilter
    RouterRegistered(tornadoRouter?: null): RouterRegisteredEventFilter

    'StakeAddedToRelayer(address,uint256)'(
      relayer?: null,
      amountStakeAdded?: null
    ): StakeAddedToRelayerEventFilter
    StakeAddedToRelayer(relayer?: null, amountStakeAdded?: null): StakeAddedToRelayerEventFilter

    'StakeBurned(address,uint256)'(relayer?: null, amountBurned?: null): StakeBurnedEventFilter
    StakeBurned(relayer?: null, amountBurned?: null): StakeBurnedEventFilter

    'WorkerRegistered(address,address)'(relayer?: null, worker?: null): WorkerRegisteredEventFilter
    WorkerRegistered(relayer?: null, worker?: null): WorkerRegisteredEventFilter

    'WorkerUnregistered(address,address)'(relayer?: null, worker?: null): WorkerUnregisteredEventFilter
    WorkerUnregistered(relayer?: null, worker?: null): WorkerUnregisteredEventFilter
  }

  estimateGas: {
    bulkResolve(domains: PromiseOrValue<BytesLike>[], overrides?: CallOverrides): Promise<BigNumber>

    burn(
      sender: PromiseOrValue<string>,
      relayer: PromiseOrValue<string>,
      pool: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>

    ens(overrides?: CallOverrides): Promise<BigNumber>

    feeManager(overrides?: CallOverrides): Promise<BigNumber>

    getRelayerBalance(relayer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>

    getRelayerEnsHash(relayer: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>

    governance(overrides?: CallOverrides): Promise<BigNumber>

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

    isRelayer(toResolve: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>

    isRelayerRegistered(
      relayer: PromiseOrValue<string>,
      toResolve: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>

    minStakeAmount(overrides?: CallOverrides): Promise<BigNumber>

    nullifyBalance(
      relayer: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>

    register(
      ensName: PromiseOrValue<string>,
      stake: PromiseOrValue<BigNumberish>,
      workersToRegister: PromiseOrValue<string>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>

    registerPermit(
      ensName: PromiseOrValue<string>,
      stake: PromiseOrValue<BigNumberish>,
      workersToRegister: PromiseOrValue<string>[],
      relayer: PromiseOrValue<string>,
      deadline: PromiseOrValue<BigNumberish>,
      v: PromiseOrValue<BigNumberish>,
      r: PromiseOrValue<BytesLike>,
      s: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>

    registerWorker(
      relayer: PromiseOrValue<string>,
      worker: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>

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

    resolve(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>

    setMinStakeAmount(
      minAmount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>

    setTornadoRouter(
      tornadoRouterAddress: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>

    stakeToRelayer(
      relayer: PromiseOrValue<string>,
      stake: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>

    stakeToRelayerPermit(
      relayer: PromiseOrValue<string>,
      stake: PromiseOrValue<BigNumberish>,
      staker: PromiseOrValue<string>,
      deadline: PromiseOrValue<BigNumberish>,
      v: PromiseOrValue<BigNumberish>,
      r: PromiseOrValue<BytesLike>,
      s: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>

    staking(overrides?: CallOverrides): Promise<BigNumber>

    torn(overrides?: CallOverrides): Promise<BigNumber>

    tornadoRouter(overrides?: CallOverrides): Promise<BigNumber>

    unregisterWorker(
      worker: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>

    workers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>
  }

  populateTransaction: {
    bulkResolve(
      domains: PromiseOrValue<BytesLike>[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>

    burn(
      sender: PromiseOrValue<string>,
      relayer: PromiseOrValue<string>,
      pool: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>

    ens(overrides?: CallOverrides): Promise<PopulatedTransaction>

    feeManager(overrides?: CallOverrides): Promise<PopulatedTransaction>

    getRelayerBalance(
      relayer: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>

    getRelayerEnsHash(
      relayer: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>

    governance(overrides?: CallOverrides): Promise<PopulatedTransaction>

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

    isRelayer(toResolve: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>

    isRelayerRegistered(
      relayer: PromiseOrValue<string>,
      toResolve: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>

    minStakeAmount(overrides?: CallOverrides): Promise<PopulatedTransaction>

    nullifyBalance(
      relayer: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>

    register(
      ensName: PromiseOrValue<string>,
      stake: PromiseOrValue<BigNumberish>,
      workersToRegister: PromiseOrValue<string>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>

    registerPermit(
      ensName: PromiseOrValue<string>,
      stake: PromiseOrValue<BigNumberish>,
      workersToRegister: PromiseOrValue<string>[],
      relayer: PromiseOrValue<string>,
      deadline: PromiseOrValue<BigNumberish>,
      v: PromiseOrValue<BigNumberish>,
      r: PromiseOrValue<BytesLike>,
      s: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>

    registerWorker(
      relayer: PromiseOrValue<string>,
      worker: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>

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

    resolve(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>

    setMinStakeAmount(
      minAmount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>

    setTornadoRouter(
      tornadoRouterAddress: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>

    stakeToRelayer(
      relayer: PromiseOrValue<string>,
      stake: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>

    stakeToRelayerPermit(
      relayer: PromiseOrValue<string>,
      stake: PromiseOrValue<BigNumberish>,
      staker: PromiseOrValue<string>,
      deadline: PromiseOrValue<BigNumberish>,
      v: PromiseOrValue<BigNumberish>,
      r: PromiseOrValue<BytesLike>,
      s: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>

    staking(overrides?: CallOverrides): Promise<PopulatedTransaction>

    torn(overrides?: CallOverrides): Promise<PopulatedTransaction>

    tornadoRouter(overrides?: CallOverrides): Promise<PopulatedTransaction>

    unregisterWorker(
      worker: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>

    workers(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>
  }
}