/* 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 declare namespace TokenNetwork {
  export type WithdrawInputStruct = {
    participant: PromiseOrValue<string>;
    total_withdraw: PromiseOrValue<BigNumberish>;
    withdrawable_until: PromiseOrValue<BigNumberish>;
    participant_signature: PromiseOrValue<BytesLike>;
    partner_signature: PromiseOrValue<BytesLike>;
  };

  export type WithdrawInputStructOutput = [
    string,
    BigNumber,
    BigNumber,
    string,
    string
  ] & {
    participant: string;
    total_withdraw: BigNumber;
    withdrawable_until: BigNumber;
    participant_signature: string;
    partner_signature: string;
  };

  export type SettleInputStruct = {
    participant: PromiseOrValue<string>;
    transferred_amount: PromiseOrValue<BigNumberish>;
    locked_amount: PromiseOrValue<BigNumberish>;
    locksroot: PromiseOrValue<BytesLike>;
  };

  export type SettleInputStructOutput = [
    string,
    BigNumber,
    BigNumber,
    string
  ] & {
    participant: string;
    transferred_amount: BigNumber;
    locked_amount: BigNumber;
    locksroot: string;
  };
}

export interface TokenNetworkInterface extends utils.Interface {
  functions: {
    "chain_id()": FunctionFragment;
    "changeController(address)": FunctionFragment;
    "channel_counter()": FunctionFragment;
    "channel_participant_deposit_limit()": FunctionFragment;
    "channels(uint256)": FunctionFragment;
    "closeChannel(uint256,address,address,bytes32,uint256,bytes32,bytes,bytes)": FunctionFragment;
    "contractExists(address)": FunctionFragment;
    "controller()": FunctionFragment;
    "cooperativeSettle(uint256,(address,uint256,uint256,bytes,bytes),(address,uint256,uint256,bytes,bytes))": FunctionFragment;
    "deprecate()": FunctionFragment;
    "failsafe_addition(uint256,uint256)": FunctionFragment;
    "failsafe_subtract(uint256,uint256)": FunctionFragment;
    "getChannelIdentifier(address,address)": FunctionFragment;
    "getChannelParticipantInfo(uint256,address,address)": FunctionFragment;
    "getChannelState(uint256,address,address)": FunctionFragment;
    "getMaxPossibleReceivableAmount(uint256,uint256,uint256,uint256,uint256,uint256)": FunctionFragment;
    "getParticipantsHash(address,address)": FunctionFragment;
    "getUnlockIdentifier(uint256,address,address)": FunctionFragment;
    "max(uint256,uint256)": FunctionFragment;
    "min(uint256,uint256)": FunctionFragment;
    "openChannel(address,address)": FunctionFragment;
    "openChannelWithDeposit(address,address,uint256)": FunctionFragment;
    "participants_hash_to_channel_identifier(bytes32)": FunctionFragment;
    "removeLimits()": FunctionFragment;
    "safety_deprecation_switch()": FunctionFragment;
    "secret_registry()": FunctionFragment;
    "setTotalDeposit(uint256,address,uint256,address)": FunctionFragment;
    "setTotalWithdraw(uint256,address,uint256,uint256,bytes,bytes)": FunctionFragment;
    "setTotalWithdraw2(uint256,(address,uint256,uint256,bytes,bytes))": FunctionFragment;
    "settleChannel(uint256,address,uint256,uint256,bytes32,address,uint256,uint256,bytes32)": FunctionFragment;
    "settleChannel2(uint256,(address,uint256,uint256,bytes32),(address,uint256,uint256,bytes32))": FunctionFragment;
    "settle_timeout()": FunctionFragment;
    "settleable_after(uint256)": FunctionFragment;
    "signature_prefix()": FunctionFragment;
    "token()": FunctionFragment;
    "token_network_deposit_limit()": FunctionFragment;
    "unlock(uint256,address,address,bytes)": FunctionFragment;
    "updateNonClosingBalanceProof(uint256,address,address,bytes32,uint256,bytes32,bytes,bytes)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "chain_id"
      | "changeController"
      | "channel_counter"
      | "channel_participant_deposit_limit"
      | "channels"
      | "closeChannel"
      | "contractExists"
      | "controller"
      | "cooperativeSettle"
      | "deprecate"
      | "failsafe_addition"
      | "failsafe_subtract"
      | "getChannelIdentifier"
      | "getChannelParticipantInfo"
      | "getChannelState"
      | "getMaxPossibleReceivableAmount"
      | "getParticipantsHash"
      | "getUnlockIdentifier"
      | "max"
      | "min"
      | "openChannel"
      | "openChannelWithDeposit"
      | "participants_hash_to_channel_identifier"
      | "removeLimits"
      | "safety_deprecation_switch"
      | "secret_registry"
      | "setTotalDeposit"
      | "setTotalWithdraw"
      | "setTotalWithdraw2"
      | "settleChannel"
      | "settleChannel2"
      | "settle_timeout"
      | "settleable_after"
      | "signature_prefix"
      | "token"
      | "token_network_deposit_limit"
      | "unlock"
      | "updateNonClosingBalanceProof"
  ): FunctionFragment;

  encodeFunctionData(functionFragment: "chain_id", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "changeController",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "channel_counter",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "channel_participant_deposit_limit",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "channels",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "closeChannel",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "contractExists",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "controller",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "cooperativeSettle",
    values: [
      PromiseOrValue<BigNumberish>,
      TokenNetwork.WithdrawInputStruct,
      TokenNetwork.WithdrawInputStruct
    ]
  ): string;
  encodeFunctionData(functionFragment: "deprecate", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "failsafe_addition",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "failsafe_subtract",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "getChannelIdentifier",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getChannelParticipantInfo",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<string>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "getChannelState",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<string>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "getMaxPossibleReceivableAmount",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "getParticipantsHash",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getUnlockIdentifier",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<string>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "max",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "min",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "openChannel",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "openChannelWithDeposit",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "participants_hash_to_channel_identifier",
    values: [PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "removeLimits",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "safety_deprecation_switch",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "secret_registry",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setTotalDeposit",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "setTotalWithdraw",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "setTotalWithdraw2",
    values: [PromiseOrValue<BigNumberish>, TokenNetwork.WithdrawInputStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "settleChannel",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "settleChannel2",
    values: [
      PromiseOrValue<BigNumberish>,
      TokenNetwork.SettleInputStruct,
      TokenNetwork.SettleInputStruct
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "settle_timeout",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "settleable_after",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "signature_prefix",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "token", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "token_network_deposit_limit",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "unlock",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "updateNonClosingBalanceProof",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BytesLike>,
      PromiseOrValue<BytesLike>
    ]
  ): string;

  decodeFunctionResult(functionFragment: "chain_id", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "changeController",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "channel_counter",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "channel_participant_deposit_limit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "channels", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "closeChannel",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "contractExists",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "controller", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "cooperativeSettle",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "deprecate", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "failsafe_addition",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "failsafe_subtract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getChannelIdentifier",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getChannelParticipantInfo",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getChannelState",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getMaxPossibleReceivableAmount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getParticipantsHash",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getUnlockIdentifier",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "max", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "min", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "openChannel",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "openChannelWithDeposit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "participants_hash_to_channel_identifier",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "removeLimits",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "safety_deprecation_switch",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "secret_registry",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTotalDeposit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTotalWithdraw",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTotalWithdraw2",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "settleChannel",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "settleChannel2",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "settle_timeout",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "settleable_after",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "signature_prefix",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "token", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "token_network_deposit_limit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "unlock", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "updateNonClosingBalanceProof",
    data: BytesLike
  ): Result;

  events: {
    "ChannelClosed(uint256,address,uint256,bytes32)": EventFragment;
    "ChannelNewDeposit(uint256,address,uint256)": EventFragment;
    "ChannelOpened(uint256,address,address)": EventFragment;
    "ChannelSettled(uint256,address,uint256,bytes32,address,uint256,bytes32)": EventFragment;
    "ChannelUnlocked(uint256,address,address,bytes32,uint256,uint256)": EventFragment;
    "ChannelWithdraw(uint256,address,uint256)": EventFragment;
    "DeprecationSwitch(bool)": EventFragment;
    "NonClosingBalanceProofUpdated(uint256,address,uint256,bytes32)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "ChannelClosed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ChannelNewDeposit"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ChannelOpened"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ChannelSettled"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ChannelUnlocked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ChannelWithdraw"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DeprecationSwitch"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "NonClosingBalanceProofUpdated"
  ): EventFragment;
}

export interface ChannelClosedEventObject {
  channel_identifier: BigNumber;
  closing_participant: string;
  nonce: BigNumber;
  balance_hash: string;
}
export type ChannelClosedEvent = TypedEvent<
  [BigNumber, string, BigNumber, string],
  ChannelClosedEventObject
>;

export type ChannelClosedEventFilter = TypedEventFilter<ChannelClosedEvent>;

export interface ChannelNewDepositEventObject {
  channel_identifier: BigNumber;
  participant: string;
  total_deposit: BigNumber;
}
export type ChannelNewDepositEvent = TypedEvent<
  [BigNumber, string, BigNumber],
  ChannelNewDepositEventObject
>;

export type ChannelNewDepositEventFilter =
  TypedEventFilter<ChannelNewDepositEvent>;

export interface ChannelOpenedEventObject {
  channel_identifier: BigNumber;
  participant1: string;
  participant2: string;
}
export type ChannelOpenedEvent = TypedEvent<
  [BigNumber, string, string],
  ChannelOpenedEventObject
>;

export type ChannelOpenedEventFilter = TypedEventFilter<ChannelOpenedEvent>;

export interface ChannelSettledEventObject {
  channel_identifier: BigNumber;
  participant1: string;
  participant1_amount: BigNumber;
  participant1_locksroot: string;
  participant2: string;
  participant2_amount: BigNumber;
  participant2_locksroot: string;
}
export type ChannelSettledEvent = TypedEvent<
  [BigNumber, string, BigNumber, string, string, BigNumber, string],
  ChannelSettledEventObject
>;

export type ChannelSettledEventFilter = TypedEventFilter<ChannelSettledEvent>;

export interface ChannelUnlockedEventObject {
  channel_identifier: BigNumber;
  receiver: string;
  sender: string;
  locksroot: string;
  unlocked_amount: BigNumber;
  returned_tokens: BigNumber;
}
export type ChannelUnlockedEvent = TypedEvent<
  [BigNumber, string, string, string, BigNumber, BigNumber],
  ChannelUnlockedEventObject
>;

export type ChannelUnlockedEventFilter = TypedEventFilter<ChannelUnlockedEvent>;

export interface ChannelWithdrawEventObject {
  channel_identifier: BigNumber;
  participant: string;
  total_withdraw: BigNumber;
}
export type ChannelWithdrawEvent = TypedEvent<
  [BigNumber, string, BigNumber],
  ChannelWithdrawEventObject
>;

export type ChannelWithdrawEventFilter = TypedEventFilter<ChannelWithdrawEvent>;

export interface DeprecationSwitchEventObject {
  new_value: boolean;
}
export type DeprecationSwitchEvent = TypedEvent<
  [boolean],
  DeprecationSwitchEventObject
>;

export type DeprecationSwitchEventFilter =
  TypedEventFilter<DeprecationSwitchEvent>;

export interface NonClosingBalanceProofUpdatedEventObject {
  channel_identifier: BigNumber;
  closing_participant: string;
  nonce: BigNumber;
  balance_hash: string;
}
export type NonClosingBalanceProofUpdatedEvent = TypedEvent<
  [BigNumber, string, BigNumber, string],
  NonClosingBalanceProofUpdatedEventObject
>;

export type NonClosingBalanceProofUpdatedEventFilter =
  TypedEventFilter<NonClosingBalanceProofUpdatedEvent>;

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

  interface: TokenNetworkInterface;

  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: {
    chain_id(
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

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

    channels(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[number] & { state: number }>;

    closeChannel(
      channel_identifier: PromiseOrValue<BigNumberish>,
      non_closing_participant: PromiseOrValue<string>,
      closing_participant: PromiseOrValue<string>,
      balance_hash: PromiseOrValue<BytesLike>,
      nonce: PromiseOrValue<BigNumberish>,
      additional_hash: PromiseOrValue<BytesLike>,
      non_closing_signature: PromiseOrValue<BytesLike>,
      closing_signature: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

    cooperativeSettle(
      channel_identifier: PromiseOrValue<BigNumberish>,
      data1: TokenNetwork.WithdrawInputStruct,
      data2: TokenNetwork.WithdrawInputStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

    failsafe_addition(
      a: PromiseOrValue<BigNumberish>,
      b: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    failsafe_subtract(
      a: PromiseOrValue<BigNumberish>,
      b: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber]>;

    getChannelIdentifier(
      participant: PromiseOrValue<string>,
      partner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getChannelParticipantInfo(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant: PromiseOrValue<string>,
      partner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, boolean, string, BigNumber, string, BigNumber]
    >;

    getChannelState(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant1: PromiseOrValue<string>,
      participant2: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[number]>;

    getMaxPossibleReceivableAmount(
      participant1_deposit: PromiseOrValue<BigNumberish>,
      participant1_withdrawn: PromiseOrValue<BigNumberish>,
      participant1_transferred: PromiseOrValue<BigNumberish>,
      participant1_locked: PromiseOrValue<BigNumberish>,
      participant2_transferred: PromiseOrValue<BigNumberish>,
      participant2_locked: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getParticipantsHash(
      participant: PromiseOrValue<string>,
      partner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[string]>;

    getUnlockIdentifier(
      channel_identifier: PromiseOrValue<BigNumberish>,
      sender: PromiseOrValue<string>,
      receiver: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[string]>;

    max(
      a: PromiseOrValue<BigNumberish>,
      b: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    min(
      a: PromiseOrValue<BigNumberish>,
      b: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    openChannel(
      participant1: PromiseOrValue<string>,
      participant2: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    openChannelWithDeposit(
      participant1: PromiseOrValue<string>,
      participant2: PromiseOrValue<string>,
      participant1_total_deposit: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

    setTotalDeposit(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant: PromiseOrValue<string>,
      total_deposit: PromiseOrValue<BigNumberish>,
      partner: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setTotalWithdraw(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant: PromiseOrValue<string>,
      total_withdraw: PromiseOrValue<BigNumberish>,
      withdrawable_until: PromiseOrValue<BigNumberish>,
      participant_signature: PromiseOrValue<BytesLike>,
      partner_signature: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setTotalWithdraw2(
      channel_identifier: PromiseOrValue<BigNumberish>,
      withdraw_data: TokenNetwork.WithdrawInputStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    settleChannel(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant1: PromiseOrValue<string>,
      participant1_transferred_amount: PromiseOrValue<BigNumberish>,
      participant1_locked_amount: PromiseOrValue<BigNumberish>,
      participant1_locksroot: PromiseOrValue<BytesLike>,
      participant2: PromiseOrValue<string>,
      participant2_transferred_amount: PromiseOrValue<BigNumberish>,
      participant2_locked_amount: PromiseOrValue<BigNumberish>,
      participant2_locksroot: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    settleChannel2(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant1_settlement: TokenNetwork.SettleInputStruct,
      participant2_settlement: TokenNetwork.SettleInputStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

    unlock(
      channel_identifier: PromiseOrValue<BigNumberish>,
      receiver: PromiseOrValue<string>,
      sender: PromiseOrValue<string>,
      locks: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    updateNonClosingBalanceProof(
      channel_identifier: PromiseOrValue<BigNumberish>,
      closing_participant: PromiseOrValue<string>,
      non_closing_participant: PromiseOrValue<string>,
      balance_hash: PromiseOrValue<BytesLike>,
      nonce: PromiseOrValue<BigNumberish>,
      additional_hash: PromiseOrValue<BytesLike>,
      closing_signature: PromiseOrValue<BytesLike>,
      non_closing_signature: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;
  };

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

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

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

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

  channels(
    arg0: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<number>;

  closeChannel(
    channel_identifier: PromiseOrValue<BigNumberish>,
    non_closing_participant: PromiseOrValue<string>,
    closing_participant: PromiseOrValue<string>,
    balance_hash: PromiseOrValue<BytesLike>,
    nonce: PromiseOrValue<BigNumberish>,
    additional_hash: PromiseOrValue<BytesLike>,
    non_closing_signature: PromiseOrValue<BytesLike>,
    closing_signature: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  contractExists(
    contract_address: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

  cooperativeSettle(
    channel_identifier: PromiseOrValue<BigNumberish>,
    data1: TokenNetwork.WithdrawInputStruct,
    data2: TokenNetwork.WithdrawInputStruct,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

  failsafe_addition(
    a: PromiseOrValue<BigNumberish>,
    b: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  failsafe_subtract(
    a: PromiseOrValue<BigNumberish>,
    b: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<[BigNumber, BigNumber]>;

  getChannelIdentifier(
    participant: PromiseOrValue<string>,
    partner: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getChannelParticipantInfo(
    channel_identifier: PromiseOrValue<BigNumberish>,
    participant: PromiseOrValue<string>,
    partner: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, boolean, string, BigNumber, string, BigNumber]
  >;

  getChannelState(
    channel_identifier: PromiseOrValue<BigNumberish>,
    participant1: PromiseOrValue<string>,
    participant2: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<number>;

  getMaxPossibleReceivableAmount(
    participant1_deposit: PromiseOrValue<BigNumberish>,
    participant1_withdrawn: PromiseOrValue<BigNumberish>,
    participant1_transferred: PromiseOrValue<BigNumberish>,
    participant1_locked: PromiseOrValue<BigNumberish>,
    participant2_transferred: PromiseOrValue<BigNumberish>,
    participant2_locked: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getParticipantsHash(
    participant: PromiseOrValue<string>,
    partner: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<string>;

  getUnlockIdentifier(
    channel_identifier: PromiseOrValue<BigNumberish>,
    sender: PromiseOrValue<string>,
    receiver: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<string>;

  max(
    a: PromiseOrValue<BigNumberish>,
    b: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  min(
    a: PromiseOrValue<BigNumberish>,
    b: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  openChannel(
    participant1: PromiseOrValue<string>,
    participant2: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  openChannelWithDeposit(
    participant1: PromiseOrValue<string>,
    participant2: PromiseOrValue<string>,
    participant1_total_deposit: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

  setTotalDeposit(
    channel_identifier: PromiseOrValue<BigNumberish>,
    participant: PromiseOrValue<string>,
    total_deposit: PromiseOrValue<BigNumberish>,
    partner: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setTotalWithdraw(
    channel_identifier: PromiseOrValue<BigNumberish>,
    participant: PromiseOrValue<string>,
    total_withdraw: PromiseOrValue<BigNumberish>,
    withdrawable_until: PromiseOrValue<BigNumberish>,
    participant_signature: PromiseOrValue<BytesLike>,
    partner_signature: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setTotalWithdraw2(
    channel_identifier: PromiseOrValue<BigNumberish>,
    withdraw_data: TokenNetwork.WithdrawInputStruct,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  settleChannel(
    channel_identifier: PromiseOrValue<BigNumberish>,
    participant1: PromiseOrValue<string>,
    participant1_transferred_amount: PromiseOrValue<BigNumberish>,
    participant1_locked_amount: PromiseOrValue<BigNumberish>,
    participant1_locksroot: PromiseOrValue<BytesLike>,
    participant2: PromiseOrValue<string>,
    participant2_transferred_amount: PromiseOrValue<BigNumberish>,
    participant2_locked_amount: PromiseOrValue<BigNumberish>,
    participant2_locksroot: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  settleChannel2(
    channel_identifier: PromiseOrValue<BigNumberish>,
    participant1_settlement: TokenNetwork.SettleInputStruct,
    participant2_settlement: TokenNetwork.SettleInputStruct,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

  unlock(
    channel_identifier: PromiseOrValue<BigNumberish>,
    receiver: PromiseOrValue<string>,
    sender: PromiseOrValue<string>,
    locks: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  updateNonClosingBalanceProof(
    channel_identifier: PromiseOrValue<BigNumberish>,
    closing_participant: PromiseOrValue<string>,
    non_closing_participant: PromiseOrValue<string>,
    balance_hash: PromiseOrValue<BytesLike>,
    nonce: PromiseOrValue<BigNumberish>,
    additional_hash: PromiseOrValue<BytesLike>,
    closing_signature: PromiseOrValue<BytesLike>,
    non_closing_signature: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

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

    changeController(
      new_controller: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    channels(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<number>;

    closeChannel(
      channel_identifier: PromiseOrValue<BigNumberish>,
      non_closing_participant: PromiseOrValue<string>,
      closing_participant: PromiseOrValue<string>,
      balance_hash: PromiseOrValue<BytesLike>,
      nonce: PromiseOrValue<BigNumberish>,
      additional_hash: PromiseOrValue<BytesLike>,
      non_closing_signature: PromiseOrValue<BytesLike>,
      closing_signature: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    contractExists(
      contract_address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    cooperativeSettle(
      channel_identifier: PromiseOrValue<BigNumberish>,
      data1: TokenNetwork.WithdrawInputStruct,
      data2: TokenNetwork.WithdrawInputStruct,
      overrides?: CallOverrides
    ): Promise<void>;

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

    failsafe_addition(
      a: PromiseOrValue<BigNumberish>,
      b: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    failsafe_subtract(
      a: PromiseOrValue<BigNumberish>,
      b: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber, BigNumber]>;

    getChannelIdentifier(
      participant: PromiseOrValue<string>,
      partner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getChannelParticipantInfo(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant: PromiseOrValue<string>,
      partner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, boolean, string, BigNumber, string, BigNumber]
    >;

    getChannelState(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant1: PromiseOrValue<string>,
      participant2: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<number>;

    getMaxPossibleReceivableAmount(
      participant1_deposit: PromiseOrValue<BigNumberish>,
      participant1_withdrawn: PromiseOrValue<BigNumberish>,
      participant1_transferred: PromiseOrValue<BigNumberish>,
      participant1_locked: PromiseOrValue<BigNumberish>,
      participant2_transferred: PromiseOrValue<BigNumberish>,
      participant2_locked: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getParticipantsHash(
      participant: PromiseOrValue<string>,
      partner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<string>;

    getUnlockIdentifier(
      channel_identifier: PromiseOrValue<BigNumberish>,
      sender: PromiseOrValue<string>,
      receiver: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<string>;

    max(
      a: PromiseOrValue<BigNumberish>,
      b: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    min(
      a: PromiseOrValue<BigNumberish>,
      b: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    openChannel(
      participant1: PromiseOrValue<string>,
      participant2: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    openChannelWithDeposit(
      participant1: PromiseOrValue<string>,
      participant2: PromiseOrValue<string>,
      participant1_total_deposit: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    setTotalDeposit(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant: PromiseOrValue<string>,
      total_deposit: PromiseOrValue<BigNumberish>,
      partner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setTotalWithdraw(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant: PromiseOrValue<string>,
      total_withdraw: PromiseOrValue<BigNumberish>,
      withdrawable_until: PromiseOrValue<BigNumberish>,
      participant_signature: PromiseOrValue<BytesLike>,
      partner_signature: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    setTotalWithdraw2(
      channel_identifier: PromiseOrValue<BigNumberish>,
      withdraw_data: TokenNetwork.WithdrawInputStruct,
      overrides?: CallOverrides
    ): Promise<void>;

    settleChannel(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant1: PromiseOrValue<string>,
      participant1_transferred_amount: PromiseOrValue<BigNumberish>,
      participant1_locked_amount: PromiseOrValue<BigNumberish>,
      participant1_locksroot: PromiseOrValue<BytesLike>,
      participant2: PromiseOrValue<string>,
      participant2_transferred_amount: PromiseOrValue<BigNumberish>,
      participant2_locked_amount: PromiseOrValue<BigNumberish>,
      participant2_locksroot: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    settleChannel2(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant1_settlement: TokenNetwork.SettleInputStruct,
      participant2_settlement: TokenNetwork.SettleInputStruct,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

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

    unlock(
      channel_identifier: PromiseOrValue<BigNumberish>,
      receiver: PromiseOrValue<string>,
      sender: PromiseOrValue<string>,
      locks: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    updateNonClosingBalanceProof(
      channel_identifier: PromiseOrValue<BigNumberish>,
      closing_participant: PromiseOrValue<string>,
      non_closing_participant: PromiseOrValue<string>,
      balance_hash: PromiseOrValue<BytesLike>,
      nonce: PromiseOrValue<BigNumberish>,
      additional_hash: PromiseOrValue<BytesLike>,
      closing_signature: PromiseOrValue<BytesLike>,
      non_closing_signature: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "ChannelClosed(uint256,address,uint256,bytes32)"(
      channel_identifier?: PromiseOrValue<BigNumberish> | null,
      closing_participant?: PromiseOrValue<string> | null,
      nonce?: PromiseOrValue<BigNumberish> | null,
      balance_hash?: null
    ): ChannelClosedEventFilter;
    ChannelClosed(
      channel_identifier?: PromiseOrValue<BigNumberish> | null,
      closing_participant?: PromiseOrValue<string> | null,
      nonce?: PromiseOrValue<BigNumberish> | null,
      balance_hash?: null
    ): ChannelClosedEventFilter;

    "ChannelNewDeposit(uint256,address,uint256)"(
      channel_identifier?: PromiseOrValue<BigNumberish> | null,
      participant?: PromiseOrValue<string> | null,
      total_deposit?: null
    ): ChannelNewDepositEventFilter;
    ChannelNewDeposit(
      channel_identifier?: PromiseOrValue<BigNumberish> | null,
      participant?: PromiseOrValue<string> | null,
      total_deposit?: null
    ): ChannelNewDepositEventFilter;

    "ChannelOpened(uint256,address,address)"(
      channel_identifier?: PromiseOrValue<BigNumberish> | null,
      participant1?: PromiseOrValue<string> | null,
      participant2?: PromiseOrValue<string> | null
    ): ChannelOpenedEventFilter;
    ChannelOpened(
      channel_identifier?: PromiseOrValue<BigNumberish> | null,
      participant1?: PromiseOrValue<string> | null,
      participant2?: PromiseOrValue<string> | null
    ): ChannelOpenedEventFilter;

    "ChannelSettled(uint256,address,uint256,bytes32,address,uint256,bytes32)"(
      channel_identifier?: PromiseOrValue<BigNumberish> | null,
      participant1?: null,
      participant1_amount?: null,
      participant1_locksroot?: null,
      participant2?: null,
      participant2_amount?: null,
      participant2_locksroot?: null
    ): ChannelSettledEventFilter;
    ChannelSettled(
      channel_identifier?: PromiseOrValue<BigNumberish> | null,
      participant1?: null,
      participant1_amount?: null,
      participant1_locksroot?: null,
      participant2?: null,
      participant2_amount?: null,
      participant2_locksroot?: null
    ): ChannelSettledEventFilter;

    "ChannelUnlocked(uint256,address,address,bytes32,uint256,uint256)"(
      channel_identifier?: PromiseOrValue<BigNumberish> | null,
      receiver?: PromiseOrValue<string> | null,
      sender?: PromiseOrValue<string> | null,
      locksroot?: null,
      unlocked_amount?: null,
      returned_tokens?: null
    ): ChannelUnlockedEventFilter;
    ChannelUnlocked(
      channel_identifier?: PromiseOrValue<BigNumberish> | null,
      receiver?: PromiseOrValue<string> | null,
      sender?: PromiseOrValue<string> | null,
      locksroot?: null,
      unlocked_amount?: null,
      returned_tokens?: null
    ): ChannelUnlockedEventFilter;

    "ChannelWithdraw(uint256,address,uint256)"(
      channel_identifier?: PromiseOrValue<BigNumberish> | null,
      participant?: PromiseOrValue<string> | null,
      total_withdraw?: null
    ): ChannelWithdrawEventFilter;
    ChannelWithdraw(
      channel_identifier?: PromiseOrValue<BigNumberish> | null,
      participant?: PromiseOrValue<string> | null,
      total_withdraw?: null
    ): ChannelWithdrawEventFilter;

    "DeprecationSwitch(bool)"(new_value?: null): DeprecationSwitchEventFilter;
    DeprecationSwitch(new_value?: null): DeprecationSwitchEventFilter;

    "NonClosingBalanceProofUpdated(uint256,address,uint256,bytes32)"(
      channel_identifier?: PromiseOrValue<BigNumberish> | null,
      closing_participant?: PromiseOrValue<string> | null,
      nonce?: PromiseOrValue<BigNumberish> | null,
      balance_hash?: null
    ): NonClosingBalanceProofUpdatedEventFilter;
    NonClosingBalanceProofUpdated(
      channel_identifier?: PromiseOrValue<BigNumberish> | null,
      closing_participant?: PromiseOrValue<string> | null,
      nonce?: PromiseOrValue<BigNumberish> | null,
      balance_hash?: null
    ): NonClosingBalanceProofUpdatedEventFilter;
  };

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

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

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

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

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

    closeChannel(
      channel_identifier: PromiseOrValue<BigNumberish>,
      non_closing_participant: PromiseOrValue<string>,
      closing_participant: PromiseOrValue<string>,
      balance_hash: PromiseOrValue<BytesLike>,
      nonce: PromiseOrValue<BigNumberish>,
      additional_hash: PromiseOrValue<BytesLike>,
      non_closing_signature: PromiseOrValue<BytesLike>,
      closing_signature: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    contractExists(
      contract_address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    cooperativeSettle(
      channel_identifier: PromiseOrValue<BigNumberish>,
      data1: TokenNetwork.WithdrawInputStruct,
      data2: TokenNetwork.WithdrawInputStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

    failsafe_addition(
      a: PromiseOrValue<BigNumberish>,
      b: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    failsafe_subtract(
      a: PromiseOrValue<BigNumberish>,
      b: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getChannelIdentifier(
      participant: PromiseOrValue<string>,
      partner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getChannelParticipantInfo(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant: PromiseOrValue<string>,
      partner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getChannelState(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant1: PromiseOrValue<string>,
      participant2: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getMaxPossibleReceivableAmount(
      participant1_deposit: PromiseOrValue<BigNumberish>,
      participant1_withdrawn: PromiseOrValue<BigNumberish>,
      participant1_transferred: PromiseOrValue<BigNumberish>,
      participant1_locked: PromiseOrValue<BigNumberish>,
      participant2_transferred: PromiseOrValue<BigNumberish>,
      participant2_locked: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getParticipantsHash(
      participant: PromiseOrValue<string>,
      partner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getUnlockIdentifier(
      channel_identifier: PromiseOrValue<BigNumberish>,
      sender: PromiseOrValue<string>,
      receiver: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    max(
      a: PromiseOrValue<BigNumberish>,
      b: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    min(
      a: PromiseOrValue<BigNumberish>,
      b: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    openChannel(
      participant1: PromiseOrValue<string>,
      participant2: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    openChannelWithDeposit(
      participant1: PromiseOrValue<string>,
      participant2: PromiseOrValue<string>,
      participant1_total_deposit: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

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

    setTotalDeposit(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant: PromiseOrValue<string>,
      total_deposit: PromiseOrValue<BigNumberish>,
      partner: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setTotalWithdraw(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant: PromiseOrValue<string>,
      total_withdraw: PromiseOrValue<BigNumberish>,
      withdrawable_until: PromiseOrValue<BigNumberish>,
      participant_signature: PromiseOrValue<BytesLike>,
      partner_signature: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setTotalWithdraw2(
      channel_identifier: PromiseOrValue<BigNumberish>,
      withdraw_data: TokenNetwork.WithdrawInputStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    settleChannel(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant1: PromiseOrValue<string>,
      participant1_transferred_amount: PromiseOrValue<BigNumberish>,
      participant1_locked_amount: PromiseOrValue<BigNumberish>,
      participant1_locksroot: PromiseOrValue<BytesLike>,
      participant2: PromiseOrValue<string>,
      participant2_transferred_amount: PromiseOrValue<BigNumberish>,
      participant2_locked_amount: PromiseOrValue<BigNumberish>,
      participant2_locksroot: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    settleChannel2(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant1_settlement: TokenNetwork.SettleInputStruct,
      participant2_settlement: TokenNetwork.SettleInputStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

    unlock(
      channel_identifier: PromiseOrValue<BigNumberish>,
      receiver: PromiseOrValue<string>,
      sender: PromiseOrValue<string>,
      locks: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    updateNonClosingBalanceProof(
      channel_identifier: PromiseOrValue<BigNumberish>,
      closing_participant: PromiseOrValue<string>,
      non_closing_participant: PromiseOrValue<string>,
      balance_hash: PromiseOrValue<BytesLike>,
      nonce: PromiseOrValue<BigNumberish>,
      additional_hash: PromiseOrValue<BytesLike>,
      closing_signature: PromiseOrValue<BytesLike>,
      non_closing_signature: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;
  };

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

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

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

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

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

    closeChannel(
      channel_identifier: PromiseOrValue<BigNumberish>,
      non_closing_participant: PromiseOrValue<string>,
      closing_participant: PromiseOrValue<string>,
      balance_hash: PromiseOrValue<BytesLike>,
      nonce: PromiseOrValue<BigNumberish>,
      additional_hash: PromiseOrValue<BytesLike>,
      non_closing_signature: PromiseOrValue<BytesLike>,
      closing_signature: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    contractExists(
      contract_address: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    cooperativeSettle(
      channel_identifier: PromiseOrValue<BigNumberish>,
      data1: TokenNetwork.WithdrawInputStruct,
      data2: TokenNetwork.WithdrawInputStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

    failsafe_addition(
      a: PromiseOrValue<BigNumberish>,
      b: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    failsafe_subtract(
      a: PromiseOrValue<BigNumberish>,
      b: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getChannelIdentifier(
      participant: PromiseOrValue<string>,
      partner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getChannelParticipantInfo(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant: PromiseOrValue<string>,
      partner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getChannelState(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant1: PromiseOrValue<string>,
      participant2: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getMaxPossibleReceivableAmount(
      participant1_deposit: PromiseOrValue<BigNumberish>,
      participant1_withdrawn: PromiseOrValue<BigNumberish>,
      participant1_transferred: PromiseOrValue<BigNumberish>,
      participant1_locked: PromiseOrValue<BigNumberish>,
      participant2_transferred: PromiseOrValue<BigNumberish>,
      participant2_locked: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getParticipantsHash(
      participant: PromiseOrValue<string>,
      partner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getUnlockIdentifier(
      channel_identifier: PromiseOrValue<BigNumberish>,
      sender: PromiseOrValue<string>,
      receiver: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    max(
      a: PromiseOrValue<BigNumberish>,
      b: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    min(
      a: PromiseOrValue<BigNumberish>,
      b: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    openChannel(
      participant1: PromiseOrValue<string>,
      participant2: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    openChannelWithDeposit(
      participant1: PromiseOrValue<string>,
      participant2: PromiseOrValue<string>,
      participant1_total_deposit: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

    setTotalDeposit(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant: PromiseOrValue<string>,
      total_deposit: PromiseOrValue<BigNumberish>,
      partner: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setTotalWithdraw(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant: PromiseOrValue<string>,
      total_withdraw: PromiseOrValue<BigNumberish>,
      withdrawable_until: PromiseOrValue<BigNumberish>,
      participant_signature: PromiseOrValue<BytesLike>,
      partner_signature: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setTotalWithdraw2(
      channel_identifier: PromiseOrValue<BigNumberish>,
      withdraw_data: TokenNetwork.WithdrawInputStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    settleChannel(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant1: PromiseOrValue<string>,
      participant1_transferred_amount: PromiseOrValue<BigNumberish>,
      participant1_locked_amount: PromiseOrValue<BigNumberish>,
      participant1_locksroot: PromiseOrValue<BytesLike>,
      participant2: PromiseOrValue<string>,
      participant2_transferred_amount: PromiseOrValue<BigNumberish>,
      participant2_locked_amount: PromiseOrValue<BigNumberish>,
      participant2_locksroot: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    settleChannel2(
      channel_identifier: PromiseOrValue<BigNumberish>,
      participant1_settlement: TokenNetwork.SettleInputStruct,
      participant2_settlement: TokenNetwork.SettleInputStruct,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

    unlock(
      channel_identifier: PromiseOrValue<BigNumberish>,
      receiver: PromiseOrValue<string>,
      sender: PromiseOrValue<string>,
      locks: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    updateNonClosingBalanceProof(
      channel_identifier: PromiseOrValue<BigNumberish>,
      closing_participant: PromiseOrValue<string>,
      non_closing_participant: PromiseOrValue<string>,
      balance_hash: PromiseOrValue<BytesLike>,
      nonce: PromiseOrValue<BigNumberish>,
      additional_hash: PromiseOrValue<BytesLike>,
      closing_signature: PromiseOrValue<BytesLike>,
      non_closing_signature: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;
  };
}