sdk-monorepo/test/deth/RelayerRegistry.ts

/* 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 RelayerRegistryInterface 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 RelayerRegistry extends BaseContract {
  contractName: "RelayerRegistry";

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

  interface: RelayerRegistryInterface;

  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>;
  };
}