/* 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 P2PIXInterface extends utils.Interface {
  functions: {
    "WAD()": FunctionFragment;
    "_castAddrToKey(address)": FunctionFragment;
    "_castKeyToAddr(uint256)": FunctionFragment;
    "allowedERC20s(address)": FunctionFragment;
    "defaultLockBlocks()": FunctionFragment;
    "deposit(address,uint96,uint160,bool,bytes32)": FunctionFragment;
    "getBalance(address,address)": FunctionFragment;
    "getBalances(address[],address)": FunctionFragment;
    "getLocksStatus(uint256[])": FunctionFragment;
    "getPixTarget(address,address)": FunctionFragment;
    "getValid(address,address)": FunctionFragment;
    "lock(address,address,address,address,uint256,uint256,bytes32[],uint256[])": FunctionFragment;
    "lockCounter()": FunctionFragment;
    "mapLocks(uint256)": FunctionFragment;
    "owner()": FunctionFragment;
    "release(uint256,address,bytes32,bytes32,bytes32,uint8)": FunctionFragment;
    "reputation()": FunctionFragment;
    "sellerAllowList(uint256)": FunctionFragment;
    "sellerBalance(uint256,address)": FunctionFragment;
    "setDefaultLockBlocks(uint256)": FunctionFragment;
    "setOwner(address)": FunctionFragment;
    "setReputation(address)": FunctionFragment;
    "setRoot(address,bytes32)": FunctionFragment;
    "setValidSigners(address[])": FunctionFragment;
    "setValidState(address,bool)": FunctionFragment;
    "tokenSettings(address[],bool[])": FunctionFragment;
    "unlockExpired(uint256[])": FunctionFragment;
    "usedTransactions(bytes32)": FunctionFragment;
    "userRecord(uint256)": FunctionFragment;
    "validBacenSigners(uint256)": FunctionFragment;
    "withdraw(address,uint256,uint256[])": FunctionFragment;
    "withdrawBalance()": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "WAD"
      | "_castAddrToKey"
      | "_castKeyToAddr"
      | "allowedERC20s"
      | "defaultLockBlocks"
      | "deposit"
      | "getBalance"
      | "getBalances"
      | "getLocksStatus"
      | "getPixTarget"
      | "getValid"
      | "lock"
      | "lockCounter"
      | "mapLocks"
      | "owner"
      | "release"
      | "reputation"
      | "sellerAllowList"
      | "sellerBalance"
      | "setDefaultLockBlocks"
      | "setOwner"
      | "setReputation"
      | "setRoot"
      | "setValidSigners"
      | "setValidState"
      | "tokenSettings"
      | "unlockExpired"
      | "usedTransactions"
      | "userRecord"
      | "validBacenSigners"
      | "withdraw"
      | "withdrawBalance"
  ): FunctionFragment;

  encodeFunctionData(functionFragment: "WAD", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "_castAddrToKey",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "_castKeyToAddr",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "allowedERC20s",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "defaultLockBlocks",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "deposit",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<boolean>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "getBalance",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getBalances",
    values: [PromiseOrValue<string>[], PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getLocksStatus",
    values: [PromiseOrValue<BigNumberish>[]]
  ): string;
  encodeFunctionData(
    functionFragment: "getPixTarget",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getValid",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "lock",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>[],
      PromiseOrValue<BigNumberish>[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "lockCounter",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "mapLocks",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "release",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "reputation",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "sellerAllowList",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "sellerBalance",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setDefaultLockBlocks",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setOwner",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setReputation",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setRoot",
    values: [PromiseOrValue<string>, PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "setValidSigners",
    values: [PromiseOrValue<string>[]]
  ): string;
  encodeFunctionData(
    functionFragment: "setValidState",
    values: [PromiseOrValue<string>, PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "tokenSettings",
    values: [PromiseOrValue<string>[], PromiseOrValue<boolean>[]]
  ): string;
  encodeFunctionData(
    functionFragment: "unlockExpired",
    values: [PromiseOrValue<BigNumberish>[]]
  ): string;
  encodeFunctionData(
    functionFragment: "usedTransactions",
    values: [PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "userRecord",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "validBacenSigners",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "withdraw",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawBalance",
    values?: undefined
  ): string;

  decodeFunctionResult(functionFragment: "WAD", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "_castAddrToKey",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "_castKeyToAddr",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "allowedERC20s",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "defaultLockBlocks",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "getBalance", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getBalances",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getLocksStatus",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPixTarget",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getValid", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "lock", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "lockCounter",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "mapLocks", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "release", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "reputation", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "sellerAllowList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "sellerBalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDefaultLockBlocks",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setOwner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setReputation",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setRoot", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setValidSigners",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setValidState",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "tokenSettings",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "unlockExpired",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "usedTransactions",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "userRecord", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "validBacenSigners",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "withdrawBalance",
    data: BytesLike
  ): Result;

  events: {
    "AllowedERC20Updated(address,bool)": EventFragment;
    "DepositAdded(address,address,uint256)": EventFragment;
    "DepositWithdrawn(address,address,uint256)": EventFragment;
    "FundsWithdrawn(address,uint256)": EventFragment;
    "LockAdded(address,uint256,uint256,uint256)": EventFragment;
    "LockBlocksUpdated(uint256)": EventFragment;
    "LockReleased(address,uint256,uint256)": EventFragment;
    "LockReturned(address,uint256)": EventFragment;
    "OwnerUpdated(address,address)": EventFragment;
    "ReputationUpdated(address)": EventFragment;
    "RootUpdated(address,bytes32)": EventFragment;
    "ValidSet(address,address,bool)": EventFragment;
    "ValidSignersUpdated(address[])": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "AllowedERC20Updated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DepositAdded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DepositWithdrawn"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "FundsWithdrawn"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LockAdded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LockBlocksUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LockReleased"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LockReturned"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnerUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ReputationUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RootUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ValidSet"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ValidSignersUpdated"): EventFragment;
}

export interface AllowedERC20UpdatedEventObject {
  token: string;
  state: boolean;
}
export type AllowedERC20UpdatedEvent = TypedEvent<
  [string, boolean],
  AllowedERC20UpdatedEventObject
>;

export type AllowedERC20UpdatedEventFilter =
  TypedEventFilter<AllowedERC20UpdatedEvent>;

export interface DepositAddedEventObject {
  seller: string;
  token: string;
  amount: BigNumber;
}
export type DepositAddedEvent = TypedEvent<
  [string, string, BigNumber],
  DepositAddedEventObject
>;

export type DepositAddedEventFilter = TypedEventFilter<DepositAddedEvent>;

export interface DepositWithdrawnEventObject {
  seller: string;
  token: string;
  amount: BigNumber;
}
export type DepositWithdrawnEvent = TypedEvent<
  [string, string, BigNumber],
  DepositWithdrawnEventObject
>;

export type DepositWithdrawnEventFilter =
  TypedEventFilter<DepositWithdrawnEvent>;

export interface FundsWithdrawnEventObject {
  owner: string;
  amount: BigNumber;
}
export type FundsWithdrawnEvent = TypedEvent<
  [string, BigNumber],
  FundsWithdrawnEventObject
>;

export type FundsWithdrawnEventFilter = TypedEventFilter<FundsWithdrawnEvent>;

export interface LockAddedEventObject {
  buyer: string;
  lockID: BigNumber;
  seller: BigNumber;
  amount: BigNumber;
}
export type LockAddedEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber],
  LockAddedEventObject
>;

export type LockAddedEventFilter = TypedEventFilter<LockAddedEvent>;

export interface LockBlocksUpdatedEventObject {
  blocks: BigNumber;
}
export type LockBlocksUpdatedEvent = TypedEvent<
  [BigNumber],
  LockBlocksUpdatedEventObject
>;

export type LockBlocksUpdatedEventFilter =
  TypedEventFilter<LockBlocksUpdatedEvent>;

export interface LockReleasedEventObject {
  buyer: string;
  lockId: BigNumber;
  amount: BigNumber;
}
export type LockReleasedEvent = TypedEvent<
  [string, BigNumber, BigNumber],
  LockReleasedEventObject
>;

export type LockReleasedEventFilter = TypedEventFilter<LockReleasedEvent>;

export interface LockReturnedEventObject {
  buyer: string;
  lockId: BigNumber;
}
export type LockReturnedEvent = TypedEvent<
  [string, BigNumber],
  LockReturnedEventObject
>;

export type LockReturnedEventFilter = TypedEventFilter<LockReturnedEvent>;

export interface OwnerUpdatedEventObject {
  user: string;
  newOwner: string;
}
export type OwnerUpdatedEvent = TypedEvent<
  [string, string],
  OwnerUpdatedEventObject
>;

export type OwnerUpdatedEventFilter = TypedEventFilter<OwnerUpdatedEvent>;

export interface ReputationUpdatedEventObject {
  reputation: string;
}
export type ReputationUpdatedEvent = TypedEvent<
  [string],
  ReputationUpdatedEventObject
>;

export type ReputationUpdatedEventFilter =
  TypedEventFilter<ReputationUpdatedEvent>;

export interface RootUpdatedEventObject {
  seller: string;
  merkleRoot: string;
}
export type RootUpdatedEvent = TypedEvent<
  [string, string],
  RootUpdatedEventObject
>;

export type RootUpdatedEventFilter = TypedEventFilter<RootUpdatedEvent>;

export interface ValidSetEventObject {
  seller: string;
  token: string;
  state: boolean;
}
export type ValidSetEvent = TypedEvent<
  [string, string, boolean],
  ValidSetEventObject
>;

export type ValidSetEventFilter = TypedEventFilter<ValidSetEvent>;

export interface ValidSignersUpdatedEventObject {
  signers: string[];
}
export type ValidSignersUpdatedEvent = TypedEvent<
  [string[]],
  ValidSignersUpdatedEventObject
>;

export type ValidSignersUpdatedEventFilter =
  TypedEventFilter<ValidSignersUpdatedEvent>;

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

  interface: P2PIXInterface;

  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: {
    WAD(overrides?: CallOverrides): Promise<[BigNumber]>;

    _castAddrToKey(
      _addr: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { _key: BigNumber }>;

    _castKeyToAddr(
      _key: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[string] & { _addr: string }>;

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

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

    deposit(
      _token: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      _pixTarget: PromiseOrValue<BigNumberish>,
      _valid: PromiseOrValue<boolean>,
      allowlistRoot: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    getBalance(
      seller: PromiseOrValue<string>,
      token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { bal: BigNumber }>;

    getBalances(
      sellers: PromiseOrValue<string>[],
      token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber[]]>;

    getLocksStatus(
      ids: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<[BigNumber[], number[]]>;

    getPixTarget(
      seller: PromiseOrValue<string>,
      token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { pixTarget: BigNumber }>;

    getValid(
      seller: PromiseOrValue<string>,
      token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[boolean] & { valid: boolean }>;

    lock(
      _seller: PromiseOrValue<string>,
      _token: PromiseOrValue<string>,
      _buyerAddress: PromiseOrValue<string>,
      _relayerTarget: PromiseOrValue<string>,
      _relayerPremium: PromiseOrValue<BigNumberish>,
      _amount: PromiseOrValue<BigNumberish>,
      merkleProof: PromiseOrValue<BytesLike>[],
      expiredLocks: PromiseOrValue<BigNumberish>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

    mapLocks(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        string,
        string,
        string,
        string
      ] & {
        sellerKey: BigNumber;
        counter: BigNumber;
        relayerPremium: BigNumber;
        amount: BigNumber;
        expirationBlock: BigNumber;
        pixTarget: BigNumber;
        buyerAddress: string;
        relayerTarget: string;
        relayerAddress: string;
        token: string;
      }
    >;

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

    release(
      lockID: PromiseOrValue<BigNumberish>,
      _relayerTarget: PromiseOrValue<string>,
      pixTimestamp: PromiseOrValue<BytesLike>,
      r: PromiseOrValue<BytesLike>,
      s: PromiseOrValue<BytesLike>,
      v: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

    sellerBalance(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

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

    setRoot(
      addr: PromiseOrValue<string>,
      merkleroot: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setValidSigners(
      _validSigners: PromiseOrValue<string>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setValidState(
      token: PromiseOrValue<string>,
      state: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    tokenSettings(
      _tokens: PromiseOrValue<string>[],
      _states: PromiseOrValue<boolean>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    unlockExpired(
      lockIDs: PromiseOrValue<BigNumberish>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    usedTransactions(
      arg0: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

    validBacenSigners(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    withdraw(
      token: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      expiredLocks: PromiseOrValue<BigNumberish>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

  _castAddrToKey(
    _addr: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  _castKeyToAddr(
    _key: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<string>;

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

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

  deposit(
    _token: PromiseOrValue<string>,
    _amount: PromiseOrValue<BigNumberish>,
    _pixTarget: PromiseOrValue<BigNumberish>,
    _valid: PromiseOrValue<boolean>,
    allowlistRoot: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  getBalance(
    seller: PromiseOrValue<string>,
    token: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getBalances(
    sellers: PromiseOrValue<string>[],
    token: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber[]>;

  getLocksStatus(
    ids: PromiseOrValue<BigNumberish>[],
    overrides?: CallOverrides
  ): Promise<[BigNumber[], number[]]>;

  getPixTarget(
    seller: PromiseOrValue<string>,
    token: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getValid(
    seller: PromiseOrValue<string>,
    token: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  lock(
    _seller: PromiseOrValue<string>,
    _token: PromiseOrValue<string>,
    _buyerAddress: PromiseOrValue<string>,
    _relayerTarget: PromiseOrValue<string>,
    _relayerPremium: PromiseOrValue<BigNumberish>,
    _amount: PromiseOrValue<BigNumberish>,
    merkleProof: PromiseOrValue<BytesLike>[],
    expiredLocks: PromiseOrValue<BigNumberish>[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

  mapLocks(
    arg0: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<
    [
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      BigNumber,
      string,
      string,
      string,
      string
    ] & {
      sellerKey: BigNumber;
      counter: BigNumber;
      relayerPremium: BigNumber;
      amount: BigNumber;
      expirationBlock: BigNumber;
      pixTarget: BigNumber;
      buyerAddress: string;
      relayerTarget: string;
      relayerAddress: string;
      token: string;
    }
  >;

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

  release(
    lockID: PromiseOrValue<BigNumberish>,
    _relayerTarget: PromiseOrValue<string>,
    pixTimestamp: PromiseOrValue<BytesLike>,
    r: PromiseOrValue<BytesLike>,
    s: PromiseOrValue<BytesLike>,
    v: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

  sellerBalance(
    arg0: PromiseOrValue<BigNumberish>,
    arg1: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

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

  setRoot(
    addr: PromiseOrValue<string>,
    merkleroot: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setValidSigners(
    _validSigners: PromiseOrValue<string>[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setValidState(
    token: PromiseOrValue<string>,
    state: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  tokenSettings(
    _tokens: PromiseOrValue<string>[],
    _states: PromiseOrValue<boolean>[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  unlockExpired(
    lockIDs: PromiseOrValue<BigNumberish>[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  usedTransactions(
    arg0: PromiseOrValue<BytesLike>,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

  validBacenSigners(
    arg0: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  withdraw(
    token: PromiseOrValue<string>,
    amount: PromiseOrValue<BigNumberish>,
    expiredLocks: PromiseOrValue<BigNumberish>[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

    _castAddrToKey(
      _addr: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    _castKeyToAddr(
      _key: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string>;

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

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

    deposit(
      _token: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      _pixTarget: PromiseOrValue<BigNumberish>,
      _valid: PromiseOrValue<boolean>,
      allowlistRoot: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    getBalance(
      seller: PromiseOrValue<string>,
      token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getBalances(
      sellers: PromiseOrValue<string>[],
      token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber[]>;

    getLocksStatus(
      ids: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<[BigNumber[], number[]]>;

    getPixTarget(
      seller: PromiseOrValue<string>,
      token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getValid(
      seller: PromiseOrValue<string>,
      token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    lock(
      _seller: PromiseOrValue<string>,
      _token: PromiseOrValue<string>,
      _buyerAddress: PromiseOrValue<string>,
      _relayerTarget: PromiseOrValue<string>,
      _relayerPremium: PromiseOrValue<BigNumberish>,
      _amount: PromiseOrValue<BigNumberish>,
      merkleProof: PromiseOrValue<BytesLike>[],
      expiredLocks: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    mapLocks(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<
      [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        string,
        string,
        string,
        string
      ] & {
        sellerKey: BigNumber;
        counter: BigNumber;
        relayerPremium: BigNumber;
        amount: BigNumber;
        expirationBlock: BigNumber;
        pixTarget: BigNumber;
        buyerAddress: string;
        relayerTarget: string;
        relayerAddress: string;
        token: string;
      }
    >;

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

    release(
      lockID: PromiseOrValue<BigNumberish>,
      _relayerTarget: PromiseOrValue<string>,
      pixTimestamp: PromiseOrValue<BytesLike>,
      r: PromiseOrValue<BytesLike>,
      s: PromiseOrValue<BytesLike>,
      v: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    sellerBalance(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    setDefaultLockBlocks(
      _blocks: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setOwner(
      newOwner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setReputation(
      _reputation: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setRoot(
      addr: PromiseOrValue<string>,
      merkleroot: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    setValidSigners(
      _validSigners: PromiseOrValue<string>[],
      overrides?: CallOverrides
    ): Promise<void>;

    setValidState(
      token: PromiseOrValue<string>,
      state: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<void>;

    tokenSettings(
      _tokens: PromiseOrValue<string>[],
      _states: PromiseOrValue<boolean>[],
      overrides?: CallOverrides
    ): Promise<void>;

    unlockExpired(
      lockIDs: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<void>;

    usedTransactions(
      arg0: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    validBacenSigners(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    withdraw(
      token: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      expiredLocks: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<void>;

    withdrawBalance(overrides?: CallOverrides): Promise<void>;
  };

  filters: {
    "AllowedERC20Updated(address,bool)"(
      token?: PromiseOrValue<string> | null,
      state?: PromiseOrValue<boolean> | null
    ): AllowedERC20UpdatedEventFilter;
    AllowedERC20Updated(
      token?: PromiseOrValue<string> | null,
      state?: PromiseOrValue<boolean> | null
    ): AllowedERC20UpdatedEventFilter;

    "DepositAdded(address,address,uint256)"(
      seller?: PromiseOrValue<string> | null,
      token?: null,
      amount?: null
    ): DepositAddedEventFilter;
    DepositAdded(
      seller?: PromiseOrValue<string> | null,
      token?: null,
      amount?: null
    ): DepositAddedEventFilter;

    "DepositWithdrawn(address,address,uint256)"(
      seller?: PromiseOrValue<string> | null,
      token?: null,
      amount?: null
    ): DepositWithdrawnEventFilter;
    DepositWithdrawn(
      seller?: PromiseOrValue<string> | null,
      token?: null,
      amount?: null
    ): DepositWithdrawnEventFilter;

    "FundsWithdrawn(address,uint256)"(
      owner?: null,
      amount?: null
    ): FundsWithdrawnEventFilter;
    FundsWithdrawn(owner?: null, amount?: null): FundsWithdrawnEventFilter;

    "LockAdded(address,uint256,uint256,uint256)"(
      buyer?: PromiseOrValue<string> | null,
      lockID?: PromiseOrValue<BigNumberish> | null,
      seller?: null,
      amount?: null
    ): LockAddedEventFilter;
    LockAdded(
      buyer?: PromiseOrValue<string> | null,
      lockID?: PromiseOrValue<BigNumberish> | null,
      seller?: null,
      amount?: null
    ): LockAddedEventFilter;

    "LockBlocksUpdated(uint256)"(blocks?: null): LockBlocksUpdatedEventFilter;
    LockBlocksUpdated(blocks?: null): LockBlocksUpdatedEventFilter;

    "LockReleased(address,uint256,uint256)"(
      buyer?: PromiseOrValue<string> | null,
      lockId?: null,
      amount?: null
    ): LockReleasedEventFilter;
    LockReleased(
      buyer?: PromiseOrValue<string> | null,
      lockId?: null,
      amount?: null
    ): LockReleasedEventFilter;

    "LockReturned(address,uint256)"(
      buyer?: PromiseOrValue<string> | null,
      lockId?: null
    ): LockReturnedEventFilter;
    LockReturned(
      buyer?: PromiseOrValue<string> | null,
      lockId?: null
    ): LockReturnedEventFilter;

    "OwnerUpdated(address,address)"(
      user?: PromiseOrValue<string> | null,
      newOwner?: PromiseOrValue<string> | null
    ): OwnerUpdatedEventFilter;
    OwnerUpdated(
      user?: PromiseOrValue<string> | null,
      newOwner?: PromiseOrValue<string> | null
    ): OwnerUpdatedEventFilter;

    "ReputationUpdated(address)"(
      reputation?: null
    ): ReputationUpdatedEventFilter;
    ReputationUpdated(reputation?: null): ReputationUpdatedEventFilter;

    "RootUpdated(address,bytes32)"(
      seller?: null,
      merkleRoot?: null
    ): RootUpdatedEventFilter;
    RootUpdated(seller?: null, merkleRoot?: null): RootUpdatedEventFilter;

    "ValidSet(address,address,bool)"(
      seller?: PromiseOrValue<string> | null,
      token?: null,
      state?: null
    ): ValidSetEventFilter;
    ValidSet(
      seller?: PromiseOrValue<string> | null,
      token?: null,
      state?: null
    ): ValidSetEventFilter;

    "ValidSignersUpdated(address[])"(
      signers?: null
    ): ValidSignersUpdatedEventFilter;
    ValidSignersUpdated(signers?: null): ValidSignersUpdatedEventFilter;
  };

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

    _castAddrToKey(
      _addr: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    _castKeyToAddr(
      _key: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    deposit(
      _token: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      _pixTarget: PromiseOrValue<BigNumberish>,
      _valid: PromiseOrValue<boolean>,
      allowlistRoot: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    getBalance(
      seller: PromiseOrValue<string>,
      token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getBalances(
      sellers: PromiseOrValue<string>[],
      token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getLocksStatus(
      ids: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getPixTarget(
      seller: PromiseOrValue<string>,
      token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getValid(
      seller: PromiseOrValue<string>,
      token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    lock(
      _seller: PromiseOrValue<string>,
      _token: PromiseOrValue<string>,
      _buyerAddress: PromiseOrValue<string>,
      _relayerTarget: PromiseOrValue<string>,
      _relayerPremium: PromiseOrValue<BigNumberish>,
      _amount: PromiseOrValue<BigNumberish>,
      merkleProof: PromiseOrValue<BytesLike>[],
      expiredLocks: PromiseOrValue<BigNumberish>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

    release(
      lockID: PromiseOrValue<BigNumberish>,
      _relayerTarget: PromiseOrValue<string>,
      pixTimestamp: PromiseOrValue<BytesLike>,
      r: PromiseOrValue<BytesLike>,
      s: PromiseOrValue<BytesLike>,
      v: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

    sellerBalance(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    setRoot(
      addr: PromiseOrValue<string>,
      merkleroot: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setValidSigners(
      _validSigners: PromiseOrValue<string>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setValidState(
      token: PromiseOrValue<string>,
      state: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    tokenSettings(
      _tokens: PromiseOrValue<string>[],
      _states: PromiseOrValue<boolean>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    unlockExpired(
      lockIDs: PromiseOrValue<BigNumberish>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    usedTransactions(
      arg0: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    withdraw(
      token: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      expiredLocks: PromiseOrValue<BigNumberish>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

    _castAddrToKey(
      _addr: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    _castKeyToAddr(
      _key: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    deposit(
      _token: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      _pixTarget: PromiseOrValue<BigNumberish>,
      _valid: PromiseOrValue<boolean>,
      allowlistRoot: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    getBalance(
      seller: PromiseOrValue<string>,
      token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getBalances(
      sellers: PromiseOrValue<string>[],
      token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getLocksStatus(
      ids: PromiseOrValue<BigNumberish>[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getPixTarget(
      seller: PromiseOrValue<string>,
      token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getValid(
      seller: PromiseOrValue<string>,
      token: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    lock(
      _seller: PromiseOrValue<string>,
      _token: PromiseOrValue<string>,
      _buyerAddress: PromiseOrValue<string>,
      _relayerTarget: PromiseOrValue<string>,
      _relayerPremium: PromiseOrValue<BigNumberish>,
      _amount: PromiseOrValue<BigNumberish>,
      merkleProof: PromiseOrValue<BytesLike>[],
      expiredLocks: PromiseOrValue<BigNumberish>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

    release(
      lockID: PromiseOrValue<BigNumberish>,
      _relayerTarget: PromiseOrValue<string>,
      pixTimestamp: PromiseOrValue<BytesLike>,
      r: PromiseOrValue<BytesLike>,
      s: PromiseOrValue<BytesLike>,
      v: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

    sellerBalance(
      arg0: PromiseOrValue<BigNumberish>,
      arg1: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    setRoot(
      addr: PromiseOrValue<string>,
      merkleroot: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setValidSigners(
      _validSigners: PromiseOrValue<string>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setValidState(
      token: PromiseOrValue<string>,
      state: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    tokenSettings(
      _tokens: PromiseOrValue<string>[],
      _states: PromiseOrValue<boolean>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    unlockExpired(
      lockIDs: PromiseOrValue<BigNumberish>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    usedTransactions(
      arg0: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    withdraw(
      token: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      expiredLocks: PromiseOrValue<BigNumberish>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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