nova-ui/_contracts/L2BridgeLimits.d.ts

/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
  BaseContract,
  ContractTransaction,
  Overrides,
  CallOverrides,
} from "ethers";
import { BytesLike } from "@ethersproject/bytes";
import { Listener, Provider } from "@ethersproject/providers";
import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
import { TypedEventFilter, TypedEvent, TypedListener } from "./commons";

interface L2BridgeLimitsInterface extends ethers.utils.Interface {
  functions: {
    "bridgeContract()": FunctionFragment;
    "bridgedTokenAddress(address)": FunctionFragment;
    "claimTokens(address,address)": FunctionFragment;
    "claimTokensFromTokenContract(address,address,address)": FunctionFragment;
    "dailyLimit(address)": FunctionFragment;
    "deployAndHandleBridgedTokens(address,string,string,uint8,address,uint256)": FunctionFragment;
    "deployAndHandleBridgedTokensAndCall(address,string,string,uint8,address,uint256,bytes)": FunctionFragment;
    "executionDailyLimit(address)": FunctionFragment;
    "executionMaxPerTx(address)": FunctionFragment;
    "feeManager()": FunctionFragment;
    "fixFailedMessage(bytes32)": FunctionFragment;
    "fixMediatorBalance(address,address)": FunctionFragment;
    "foreignTokenAddress(address)": FunctionFragment;
    "forwardingRulesManager()": FunctionFragment;
    "gasLimitManager()": FunctionFragment;
    "getBridgeInterfacesVersion()": FunctionFragment;
    "getBridgeMode()": FunctionFragment;
    "getCurrentDay()": FunctionFragment;
    "handleBridgedTokens(address,address,uint256)": FunctionFragment;
    "handleBridgedTokensAndCall(address,address,uint256,bytes)": FunctionFragment;
    "handleNativeTokens(address,address,uint256)": FunctionFragment;
    "handleNativeTokensAndCall(address,address,uint256,bytes)": FunctionFragment;
    "homeTokenAddress(address)": FunctionFragment;
    "initialize(address,address,uint256[3],uint256[2],address,address,address,address,address)": FunctionFragment;
    "isBridgedTokenDeployAcknowledged(address)": FunctionFragment;
    "isInitialized()": FunctionFragment;
    "isRegisteredAsNativeToken(address)": FunctionFragment;
    "isTokenRegistered(address)": FunctionFragment;
    "maxAvailablePerTx(address)": FunctionFragment;
    "maxPerTx(address)": FunctionFragment;
    "mediatorBalance(address)": FunctionFragment;
    "mediatorContractOnOtherSide()": FunctionFragment;
    "messageFixed(bytes32)": FunctionFragment;
    "migrateTo_3_3_0(address,address,address,address)": FunctionFragment;
    "minPerTx(address)": FunctionFragment;
    "nativeTokenAddress(address)": FunctionFragment;
    "onTokenTransfer(address,uint256,bytes)": FunctionFragment;
    "owner()": FunctionFragment;
    "relayTokens(address,uint256)": FunctionFragment;
    "relayTokensAndCall(address,address,uint256,bytes)": FunctionFragment;
    "requestFailedMessageFix(bytes32)": FunctionFragment;
    "setBridgeContract(address)": FunctionFragment;
    "setCustomTokenAddressPair(address,address)": FunctionFragment;
    "setDailyLimit(address,uint256)": FunctionFragment;
    "setExecutionDailyLimit(address,uint256)": FunctionFragment;
    "setExecutionMaxPerTx(address,uint256)": FunctionFragment;
    "setFeeManager(address)": FunctionFragment;
    "setForwardingRulesManager(address)": FunctionFragment;
    "setGasLimitManager(address)": FunctionFragment;
    "setMaxPerTx(address,uint256)": FunctionFragment;
    "setMediatorContractOnOtherSide(address)": FunctionFragment;
    "setMinPerTx(address,uint256)": FunctionFragment;
    "setTokenFactory(address)": FunctionFragment;
    "tokenFactory()": FunctionFragment;
    "totalExecutedPerDay(address,uint256)": FunctionFragment;
    "totalSpentPerDay(address,uint256)": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "withinExecutionLimit(address,uint256)": FunctionFragment;
    "withinLimit(address,uint256)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "bridgeContract",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "bridgedTokenAddress",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "claimTokens",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "claimTokensFromTokenContract",
    values: [string, string, string]
  ): string;
  encodeFunctionData(functionFragment: "dailyLimit", values: [string]): string;
  encodeFunctionData(
    functionFragment: "deployAndHandleBridgedTokens",
    values: [string, string, string, BigNumberish, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "deployAndHandleBridgedTokensAndCall",
    values: [
      string,
      string,
      string,
      BigNumberish,
      string,
      BigNumberish,
      BytesLike
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "executionDailyLimit",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "executionMaxPerTx",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "feeManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "fixFailedMessage",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "fixMediatorBalance",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "foreignTokenAddress",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "forwardingRulesManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "gasLimitManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getBridgeInterfacesVersion",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getBridgeMode",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getCurrentDay",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "handleBridgedTokens",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "handleBridgedTokensAndCall",
    values: [string, string, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "handleNativeTokens",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "handleNativeTokensAndCall",
    values: [string, string, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "homeTokenAddress",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [
      string,
      string,
      [BigNumberish, BigNumberish, BigNumberish],
      [BigNumberish, BigNumberish],
      string,
      string,
      string,
      string,
      string
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "isBridgedTokenDeployAcknowledged",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "isInitialized",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "isRegisteredAsNativeToken",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "isTokenRegistered",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "maxAvailablePerTx",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "maxPerTx", values: [string]): string;
  encodeFunctionData(
    functionFragment: "mediatorBalance",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "mediatorContractOnOtherSide",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "messageFixed",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "migrateTo_3_3_0",
    values: [string, string, string, string]
  ): string;
  encodeFunctionData(functionFragment: "minPerTx", values: [string]): string;
  encodeFunctionData(
    functionFragment: "nativeTokenAddress",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "onTokenTransfer",
    values: [string, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "relayTokens",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "relayTokensAndCall",
    values: [string, string, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "requestFailedMessageFix",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "setBridgeContract",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setCustomTokenAddressPair",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "setDailyLimit",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setExecutionDailyLimit",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setExecutionMaxPerTx",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setFeeManager",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setForwardingRulesManager",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setGasLimitManager",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setMaxPerTx",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setMediatorContractOnOtherSide",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setMinPerTx",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setTokenFactory",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "tokenFactory",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "totalExecutedPerDay",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "totalSpentPerDay",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "withinExecutionLimit",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "withinLimit",
    values: [string, BigNumberish]
  ): string;

  decodeFunctionResult(
    functionFragment: "bridgeContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "bridgedTokenAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimTokensFromTokenContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "dailyLimit", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "deployAndHandleBridgedTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "deployAndHandleBridgedTokensAndCall",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "executionDailyLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "executionMaxPerTx",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "feeManager", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "fixFailedMessage",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "fixMediatorBalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "foreignTokenAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "forwardingRulesManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "gasLimitManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getBridgeInterfacesVersion",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getBridgeMode",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getCurrentDay",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "handleBridgedTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "handleBridgedTokensAndCall",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "handleNativeTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "handleNativeTokensAndCall",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "homeTokenAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isBridgedTokenDeployAcknowledged",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isInitialized",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isRegisteredAsNativeToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isTokenRegistered",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "maxAvailablePerTx",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "maxPerTx", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "mediatorBalance",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "mediatorContractOnOtherSide",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "messageFixed",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "migrateTo_3_3_0",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "minPerTx", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "nativeTokenAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "onTokenTransfer",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "relayTokens",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "relayTokensAndCall",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "requestFailedMessageFix",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setBridgeContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setCustomTokenAddressPair",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setDailyLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setExecutionDailyLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setExecutionMaxPerTx",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setFeeManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setForwardingRulesManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setGasLimitManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMaxPerTx",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMediatorContractOnOtherSide",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMinPerTx",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTokenFactory",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "tokenFactory",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalExecutedPerDay",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalSpentPerDay",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withinExecutionLimit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withinLimit",
    data: BytesLike
  ): Result;

  events: {
    "DailyLimitChanged(address,uint256)": EventFragment;
    "ExecutionDailyLimitChanged(address,uint256)": EventFragment;
    "FailedMessageFixed(bytes32,address,address,uint256)": EventFragment;
    "FeeDistributed(uint256,address,bytes32)": EventFragment;
    "FeeDistributionFailed(address,uint256)": EventFragment;
    "NewTokenRegistered(address,address)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "TokensBridged(address,address,uint256,bytes32)": EventFragment;
    "TokensBridgingInitiated(address,address,uint256,bytes32)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "DailyLimitChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ExecutionDailyLimitChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "FailedMessageFixed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "FeeDistributed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "FeeDistributionFailed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewTokenRegistered"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokensBridged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TokensBridgingInitiated"): EventFragment;
}

export type DailyLimitChangedEvent = TypedEvent<
  [string, BigNumber] & { token: string; newLimit: BigNumber }
>;

export type ExecutionDailyLimitChangedEvent = TypedEvent<
  [string, BigNumber] & { token: string; newLimit: BigNumber }
>;

export type FailedMessageFixedEvent = TypedEvent<
  [string, string, string, BigNumber] & {
    messageId: string;
    token: string;
    recipient: string;
    value: BigNumber;
  }
>;

export type FeeDistributedEvent = TypedEvent<
  [BigNumber, string, string] & {
    fee: BigNumber;
    token: string;
    messageId: string;
  }
>;

export type FeeDistributionFailedEvent = TypedEvent<
  [string, BigNumber] & { token: string; fee: BigNumber }
>;

export type NewTokenRegisteredEvent = TypedEvent<
  [string, string] & { nativeToken: string; bridgedToken: string }
>;

export type OwnershipTransferredEvent = TypedEvent<
  [string, string] & { previousOwner: string; newOwner: string }
>;

export type TokensBridgedEvent = TypedEvent<
  [string, string, BigNumber, string] & {
    token: string;
    recipient: string;
    value: BigNumber;
    messageId: string;
  }
>;

export type TokensBridgingInitiatedEvent = TypedEvent<
  [string, string, BigNumber, string] & {
    token: string;
    sender: string;
    value: BigNumber;
    messageId: string;
  }
>;

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

  listeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter?: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): Array<TypedListener<EventArgsArray, EventArgsObject>>;
  off<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  on<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  once<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeListener<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeAllListeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): this;

  listeners(eventName?: string): Array<Listener>;
  off(eventName: string, listener: Listener): this;
  on(eventName: string, listener: Listener): this;
  once(eventName: string, listener: Listener): this;
  removeListener(eventName: string, listener: Listener): this;
  removeAllListeners(eventName?: string): this;

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

  interface: L2BridgeLimitsInterface;

  functions: {
    bridgeContract(overrides?: CallOverrides): Promise<[string]>;

    bridgedTokenAddress(
      _nativeToken: string,
      overrides?: CallOverrides
    ): Promise<[string]>;

    claimTokens(
      _token: string,
      _to: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    claimTokensFromTokenContract(
      _bridgedToken: string,
      _token: string,
      _to: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    dailyLimit(_token: string, overrides?: CallOverrides): Promise<[BigNumber]>;

    deployAndHandleBridgedTokens(
      _token: string,
      _name: string,
      _symbol: string,
      _decimals: BigNumberish,
      _recipient: string,
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    deployAndHandleBridgedTokensAndCall(
      _token: string,
      _name: string,
      _symbol: string,
      _decimals: BigNumberish,
      _recipient: string,
      _value: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    executionDailyLimit(
      _token: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    executionMaxPerTx(
      _token: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    fixFailedMessage(
      _messageId: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    fixMediatorBalance(
      _token: string,
      _receiver: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    foreignTokenAddress(
      _homeToken: string,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

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

    getBridgeInterfacesVersion(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        major: BigNumber;
        minor: BigNumber;
        patch: BigNumber;
      }
    >;

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

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

    handleBridgedTokens(
      _token: string,
      _recipient: string,
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    handleBridgedTokensAndCall(
      _token: string,
      _recipient: string,
      _value: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    handleNativeTokens(
      _token: string,
      _recipient: string,
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    handleNativeTokensAndCall(
      _token: string,
      _recipient: string,
      _value: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    homeTokenAddress(
      _foreignToken: string,
      overrides?: CallOverrides
    ): Promise<[string]>;

    initialize(
      _bridgeContract: string,
      _mediatorContract: string,
      _dailyLimitMaxPerTxMinPerTxArray: [
        BigNumberish,
        BigNumberish,
        BigNumberish
      ],
      _executionDailyLimitExecutionMaxPerTxArray: [BigNumberish, BigNumberish],
      _gasLimitManager: string,
      _owner: string,
      _tokenFactory: string,
      _feeManager: string,
      _forwardingRulesManager: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    isBridgedTokenDeployAcknowledged(
      _token: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

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

    isRegisteredAsNativeToken(
      _token: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    isTokenRegistered(
      _token: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    maxAvailablePerTx(
      _token: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    maxPerTx(_token: string, overrides?: CallOverrides): Promise<[BigNumber]>;

    mediatorBalance(
      _token: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    messageFixed(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    migrateTo_3_3_0(
      _tokenFactory: string,
      _forwardingRulesManager: string,
      _gasLimitManager: string,
      _feeManager: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    minPerTx(_token: string, overrides?: CallOverrides): Promise<[BigNumber]>;

    nativeTokenAddress(
      _bridgedToken: string,
      overrides?: CallOverrides
    ): Promise<[string]>;

    onTokenTransfer(
      _from: string,
      _value: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    "relayTokens(address,uint256)"(
      token: string,
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "relayTokens(address,address,uint256)"(
      token: string,
      _receiver: string,
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    relayTokensAndCall(
      token: string,
      _receiver: string,
      _value: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    requestFailedMessageFix(
      _messageId: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setBridgeContract(
      _bridgeContract: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setCustomTokenAddressPair(
      _nativeToken: string,
      _bridgedToken: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setDailyLimit(
      _token: string,
      _dailyLimit: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setExecutionDailyLimit(
      _token: string,
      _dailyLimit: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setExecutionMaxPerTx(
      _token: string,
      _maxPerTx: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setFeeManager(
      _feeManager: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setForwardingRulesManager(
      _manager: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setGasLimitManager(
      _manager: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setMaxPerTx(
      _token: string,
      _maxPerTx: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setMediatorContractOnOtherSide(
      _mediatorContract: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setMinPerTx(
      _token: string,
      _minPerTx: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setTokenFactory(
      _tokenFactory: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    totalExecutedPerDay(
      _token: string,
      _day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    totalSpentPerDay(
      _token: string,
      _day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    withinExecutionLimit(
      _token: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    withinLimit(
      _token: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean]>;
  };

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

  bridgedTokenAddress(
    _nativeToken: string,
    overrides?: CallOverrides
  ): Promise<string>;

  claimTokens(
    _token: string,
    _to: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  claimTokensFromTokenContract(
    _bridgedToken: string,
    _token: string,
    _to: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  dailyLimit(_token: string, overrides?: CallOverrides): Promise<BigNumber>;

  deployAndHandleBridgedTokens(
    _token: string,
    _name: string,
    _symbol: string,
    _decimals: BigNumberish,
    _recipient: string,
    _value: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  deployAndHandleBridgedTokensAndCall(
    _token: string,
    _name: string,
    _symbol: string,
    _decimals: BigNumberish,
    _recipient: string,
    _value: BigNumberish,
    _data: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  executionDailyLimit(
    _token: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  executionMaxPerTx(
    _token: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  fixFailedMessage(
    _messageId: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  fixMediatorBalance(
    _token: string,
    _receiver: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  foreignTokenAddress(
    _homeToken: string,
    overrides?: CallOverrides
  ): Promise<string>;

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

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

  getBridgeInterfacesVersion(
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber] & {
      major: BigNumber;
      minor: BigNumber;
      patch: BigNumber;
    }
  >;

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

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

  handleBridgedTokens(
    _token: string,
    _recipient: string,
    _value: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  handleBridgedTokensAndCall(
    _token: string,
    _recipient: string,
    _value: BigNumberish,
    _data: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  handleNativeTokens(
    _token: string,
    _recipient: string,
    _value: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  handleNativeTokensAndCall(
    _token: string,
    _recipient: string,
    _value: BigNumberish,
    _data: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  homeTokenAddress(
    _foreignToken: string,
    overrides?: CallOverrides
  ): Promise<string>;

  initialize(
    _bridgeContract: string,
    _mediatorContract: string,
    _dailyLimitMaxPerTxMinPerTxArray: [
      BigNumberish,
      BigNumberish,
      BigNumberish
    ],
    _executionDailyLimitExecutionMaxPerTxArray: [BigNumberish, BigNumberish],
    _gasLimitManager: string,
    _owner: string,
    _tokenFactory: string,
    _feeManager: string,
    _forwardingRulesManager: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  isBridgedTokenDeployAcknowledged(
    _token: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

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

  isRegisteredAsNativeToken(
    _token: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isTokenRegistered(
    _token: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  maxAvailablePerTx(
    _token: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  maxPerTx(_token: string, overrides?: CallOverrides): Promise<BigNumber>;

  mediatorBalance(
    _token: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  messageFixed(
    _messageId: BytesLike,
    overrides?: CallOverrides
  ): Promise<boolean>;

  migrateTo_3_3_0(
    _tokenFactory: string,
    _forwardingRulesManager: string,
    _gasLimitManager: string,
    _feeManager: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  minPerTx(_token: string, overrides?: CallOverrides): Promise<BigNumber>;

  nativeTokenAddress(
    _bridgedToken: string,
    overrides?: CallOverrides
  ): Promise<string>;

  onTokenTransfer(
    _from: string,
    _value: BigNumberish,
    _data: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  "relayTokens(address,uint256)"(
    token: string,
    _value: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "relayTokens(address,address,uint256)"(
    token: string,
    _receiver: string,
    _value: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  relayTokensAndCall(
    token: string,
    _receiver: string,
    _value: BigNumberish,
    _data: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  requestFailedMessageFix(
    _messageId: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setBridgeContract(
    _bridgeContract: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setCustomTokenAddressPair(
    _nativeToken: string,
    _bridgedToken: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setDailyLimit(
    _token: string,
    _dailyLimit: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setExecutionDailyLimit(
    _token: string,
    _dailyLimit: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setExecutionMaxPerTx(
    _token: string,
    _maxPerTx: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setFeeManager(
    _feeManager: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setForwardingRulesManager(
    _manager: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setGasLimitManager(
    _manager: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setMaxPerTx(
    _token: string,
    _maxPerTx: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setMediatorContractOnOtherSide(
    _mediatorContract: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setMinPerTx(
    _token: string,
    _minPerTx: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setTokenFactory(
    _tokenFactory: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  totalExecutedPerDay(
    _token: string,
    _day: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  totalSpentPerDay(
    _token: string,
    _day: BigNumberish,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

  withinExecutionLimit(
    _token: string,
    _amount: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

  withinLimit(
    _token: string,
    _amount: BigNumberish,
    overrides?: CallOverrides
  ): Promise<boolean>;

  callStatic: {
    bridgeContract(overrides?: CallOverrides): Promise<string>;

    bridgedTokenAddress(
      _nativeToken: string,
      overrides?: CallOverrides
    ): Promise<string>;

    claimTokens(
      _token: string,
      _to: string,
      overrides?: CallOverrides
    ): Promise<void>;

    claimTokensFromTokenContract(
      _bridgedToken: string,
      _token: string,
      _to: string,
      overrides?: CallOverrides
    ): Promise<void>;

    dailyLimit(_token: string, overrides?: CallOverrides): Promise<BigNumber>;

    deployAndHandleBridgedTokens(
      _token: string,
      _name: string,
      _symbol: string,
      _decimals: BigNumberish,
      _recipient: string,
      _value: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    deployAndHandleBridgedTokensAndCall(
      _token: string,
      _name: string,
      _symbol: string,
      _decimals: BigNumberish,
      _recipient: string,
      _value: BigNumberish,
      _data: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    executionDailyLimit(
      _token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    executionMaxPerTx(
      _token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    fixFailedMessage(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    fixMediatorBalance(
      _token: string,
      _receiver: string,
      overrides?: CallOverrides
    ): Promise<void>;

    foreignTokenAddress(
      _homeToken: string,
      overrides?: CallOverrides
    ): Promise<string>;

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

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

    getBridgeInterfacesVersion(
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber] & {
        major: BigNumber;
        minor: BigNumber;
        patch: BigNumber;
      }
    >;

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

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

    handleBridgedTokens(
      _token: string,
      _recipient: string,
      _value: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    handleBridgedTokensAndCall(
      _token: string,
      _recipient: string,
      _value: BigNumberish,
      _data: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    handleNativeTokens(
      _token: string,
      _recipient: string,
      _value: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    handleNativeTokensAndCall(
      _token: string,
      _recipient: string,
      _value: BigNumberish,
      _data: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    homeTokenAddress(
      _foreignToken: string,
      overrides?: CallOverrides
    ): Promise<string>;

    initialize(
      _bridgeContract: string,
      _mediatorContract: string,
      _dailyLimitMaxPerTxMinPerTxArray: [
        BigNumberish,
        BigNumberish,
        BigNumberish
      ],
      _executionDailyLimitExecutionMaxPerTxArray: [BigNumberish, BigNumberish],
      _gasLimitManager: string,
      _owner: string,
      _tokenFactory: string,
      _feeManager: string,
      _forwardingRulesManager: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isBridgedTokenDeployAcknowledged(
      _token: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    isRegisteredAsNativeToken(
      _token: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isTokenRegistered(
      _token: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    maxAvailablePerTx(
      _token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    maxPerTx(_token: string, overrides?: CallOverrides): Promise<BigNumber>;

    mediatorBalance(
      _token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    messageFixed(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<boolean>;

    migrateTo_3_3_0(
      _tokenFactory: string,
      _forwardingRulesManager: string,
      _gasLimitManager: string,
      _feeManager: string,
      overrides?: CallOverrides
    ): Promise<void>;

    minPerTx(_token: string, overrides?: CallOverrides): Promise<BigNumber>;

    nativeTokenAddress(
      _bridgedToken: string,
      overrides?: CallOverrides
    ): Promise<string>;

    onTokenTransfer(
      _from: string,
      _value: BigNumberish,
      _data: BytesLike,
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    "relayTokens(address,uint256)"(
      token: string,
      _value: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "relayTokens(address,address,uint256)"(
      token: string,
      _receiver: string,
      _value: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    relayTokensAndCall(
      token: string,
      _receiver: string,
      _value: BigNumberish,
      _data: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    requestFailedMessageFix(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    setBridgeContract(
      _bridgeContract: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setCustomTokenAddressPair(
      _nativeToken: string,
      _bridgedToken: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setDailyLimit(
      _token: string,
      _dailyLimit: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setExecutionDailyLimit(
      _token: string,
      _dailyLimit: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setExecutionMaxPerTx(
      _token: string,
      _maxPerTx: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setFeeManager(
      _feeManager: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setForwardingRulesManager(
      _manager: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setGasLimitManager(
      _manager: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setMaxPerTx(
      _token: string,
      _maxPerTx: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setMediatorContractOnOtherSide(
      _mediatorContract: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setMinPerTx(
      _token: string,
      _minPerTx: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setTokenFactory(
      _tokenFactory: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

    totalExecutedPerDay(
      _token: string,
      _day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    totalSpentPerDay(
      _token: string,
      _day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    withinExecutionLimit(
      _token: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    withinLimit(
      _token: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;
  };

  filters: {
    "DailyLimitChanged(address,uint256)"(
      token?: string | null,
      newLimit?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { token: string; newLimit: BigNumber }
    >;

    DailyLimitChanged(
      token?: string | null,
      newLimit?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { token: string; newLimit: BigNumber }
    >;

    "ExecutionDailyLimitChanged(address,uint256)"(
      token?: string | null,
      newLimit?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { token: string; newLimit: BigNumber }
    >;

    ExecutionDailyLimitChanged(
      token?: string | null,
      newLimit?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { token: string; newLimit: BigNumber }
    >;

    "FailedMessageFixed(bytes32,address,address,uint256)"(
      messageId?: BytesLike | null,
      token?: null,
      recipient?: null,
      value?: null
    ): TypedEventFilter<
      [string, string, string, BigNumber],
      { messageId: string; token: string; recipient: string; value: BigNumber }
    >;

    FailedMessageFixed(
      messageId?: BytesLike | null,
      token?: null,
      recipient?: null,
      value?: null
    ): TypedEventFilter<
      [string, string, string, BigNumber],
      { messageId: string; token: string; recipient: string; value: BigNumber }
    >;

    "FeeDistributed(uint256,address,bytes32)"(
      fee?: null,
      token?: string | null,
      messageId?: BytesLike | null
    ): TypedEventFilter<
      [BigNumber, string, string],
      { fee: BigNumber; token: string; messageId: string }
    >;

    FeeDistributed(
      fee?: null,
      token?: string | null,
      messageId?: BytesLike | null
    ): TypedEventFilter<
      [BigNumber, string, string],
      { fee: BigNumber; token: string; messageId: string }
    >;

    "FeeDistributionFailed(address,uint256)"(
      token?: string | null,
      fee?: null
    ): TypedEventFilter<[string, BigNumber], { token: string; fee: BigNumber }>;

    FeeDistributionFailed(
      token?: string | null,
      fee?: null
    ): TypedEventFilter<[string, BigNumber], { token: string; fee: BigNumber }>;

    "NewTokenRegistered(address,address)"(
      nativeToken?: string | null,
      bridgedToken?: string | null
    ): TypedEventFilter<
      [string, string],
      { nativeToken: string; bridgedToken: string }
    >;

    NewTokenRegistered(
      nativeToken?: string | null,
      bridgedToken?: string | null
    ): TypedEventFilter<
      [string, string],
      { nativeToken: string; bridgedToken: string }
    >;

    "OwnershipTransferred(address,address)"(
      previousOwner?: null,
      newOwner?: null
    ): TypedEventFilter<
      [string, string],
      { previousOwner: string; newOwner: string }
    >;

    OwnershipTransferred(
      previousOwner?: null,
      newOwner?: null
    ): TypedEventFilter<
      [string, string],
      { previousOwner: string; newOwner: string }
    >;

    "TokensBridged(address,address,uint256,bytes32)"(
      token?: string | null,
      recipient?: string | null,
      value?: null,
      messageId?: BytesLike | null
    ): TypedEventFilter<
      [string, string, BigNumber, string],
      { token: string; recipient: string; value: BigNumber; messageId: string }
    >;

    TokensBridged(
      token?: string | null,
      recipient?: string | null,
      value?: null,
      messageId?: BytesLike | null
    ): TypedEventFilter<
      [string, string, BigNumber, string],
      { token: string; recipient: string; value: BigNumber; messageId: string }
    >;

    "TokensBridgingInitiated(address,address,uint256,bytes32)"(
      token?: string | null,
      sender?: string | null,
      value?: null,
      messageId?: BytesLike | null
    ): TypedEventFilter<
      [string, string, BigNumber, string],
      { token: string; sender: string; value: BigNumber; messageId: string }
    >;

    TokensBridgingInitiated(
      token?: string | null,
      sender?: string | null,
      value?: null,
      messageId?: BytesLike | null
    ): TypedEventFilter<
      [string, string, BigNumber, string],
      { token: string; sender: string; value: BigNumber; messageId: string }
    >;
  };

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

    bridgedTokenAddress(
      _nativeToken: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    claimTokens(
      _token: string,
      _to: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    claimTokensFromTokenContract(
      _bridgedToken: string,
      _token: string,
      _to: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    dailyLimit(_token: string, overrides?: CallOverrides): Promise<BigNumber>;

    deployAndHandleBridgedTokens(
      _token: string,
      _name: string,
      _symbol: string,
      _decimals: BigNumberish,
      _recipient: string,
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    deployAndHandleBridgedTokensAndCall(
      _token: string,
      _name: string,
      _symbol: string,
      _decimals: BigNumberish,
      _recipient: string,
      _value: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    executionDailyLimit(
      _token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    executionMaxPerTx(
      _token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    fixFailedMessage(
      _messageId: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    fixMediatorBalance(
      _token: string,
      _receiver: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    foreignTokenAddress(
      _homeToken: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

    handleBridgedTokens(
      _token: string,
      _recipient: string,
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    handleBridgedTokensAndCall(
      _token: string,
      _recipient: string,
      _value: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    handleNativeTokens(
      _token: string,
      _recipient: string,
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    handleNativeTokensAndCall(
      _token: string,
      _recipient: string,
      _value: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    homeTokenAddress(
      _foreignToken: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    initialize(
      _bridgeContract: string,
      _mediatorContract: string,
      _dailyLimitMaxPerTxMinPerTxArray: [
        BigNumberish,
        BigNumberish,
        BigNumberish
      ],
      _executionDailyLimitExecutionMaxPerTxArray: [BigNumberish, BigNumberish],
      _gasLimitManager: string,
      _owner: string,
      _tokenFactory: string,
      _feeManager: string,
      _forwardingRulesManager: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    isBridgedTokenDeployAcknowledged(
      _token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    isRegisteredAsNativeToken(
      _token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isTokenRegistered(
      _token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    maxAvailablePerTx(
      _token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    maxPerTx(_token: string, overrides?: CallOverrides): Promise<BigNumber>;

    mediatorBalance(
      _token: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    messageFixed(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    migrateTo_3_3_0(
      _tokenFactory: string,
      _forwardingRulesManager: string,
      _gasLimitManager: string,
      _feeManager: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    minPerTx(_token: string, overrides?: CallOverrides): Promise<BigNumber>;

    nativeTokenAddress(
      _bridgedToken: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    onTokenTransfer(
      _from: string,
      _value: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    "relayTokens(address,uint256)"(
      token: string,
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "relayTokens(address,address,uint256)"(
      token: string,
      _receiver: string,
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    relayTokensAndCall(
      token: string,
      _receiver: string,
      _value: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    requestFailedMessageFix(
      _messageId: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setBridgeContract(
      _bridgeContract: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setCustomTokenAddressPair(
      _nativeToken: string,
      _bridgedToken: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setDailyLimit(
      _token: string,
      _dailyLimit: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setExecutionDailyLimit(
      _token: string,
      _dailyLimit: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setExecutionMaxPerTx(
      _token: string,
      _maxPerTx: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setFeeManager(
      _feeManager: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setForwardingRulesManager(
      _manager: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setGasLimitManager(
      _manager: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setMaxPerTx(
      _token: string,
      _maxPerTx: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setMediatorContractOnOtherSide(
      _mediatorContract: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setMinPerTx(
      _token: string,
      _minPerTx: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setTokenFactory(
      _tokenFactory: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    totalExecutedPerDay(
      _token: string,
      _day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    totalSpentPerDay(
      _token: string,
      _day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    withinExecutionLimit(
      _token: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    withinLimit(
      _token: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;
  };

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

    bridgedTokenAddress(
      _nativeToken: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    claimTokens(
      _token: string,
      _to: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    claimTokensFromTokenContract(
      _bridgedToken: string,
      _token: string,
      _to: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    dailyLimit(
      _token: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    deployAndHandleBridgedTokens(
      _token: string,
      _name: string,
      _symbol: string,
      _decimals: BigNumberish,
      _recipient: string,
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    deployAndHandleBridgedTokensAndCall(
      _token: string,
      _name: string,
      _symbol: string,
      _decimals: BigNumberish,
      _recipient: string,
      _value: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    executionDailyLimit(
      _token: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    executionMaxPerTx(
      _token: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    fixFailedMessage(
      _messageId: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    fixMediatorBalance(
      _token: string,
      _receiver: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    foreignTokenAddress(
      _homeToken: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

    handleBridgedTokens(
      _token: string,
      _recipient: string,
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    handleBridgedTokensAndCall(
      _token: string,
      _recipient: string,
      _value: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    handleNativeTokens(
      _token: string,
      _recipient: string,
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    handleNativeTokensAndCall(
      _token: string,
      _recipient: string,
      _value: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    homeTokenAddress(
      _foreignToken: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    initialize(
      _bridgeContract: string,
      _mediatorContract: string,
      _dailyLimitMaxPerTxMinPerTxArray: [
        BigNumberish,
        BigNumberish,
        BigNumberish
      ],
      _executionDailyLimitExecutionMaxPerTxArray: [BigNumberish, BigNumberish],
      _gasLimitManager: string,
      _owner: string,
      _tokenFactory: string,
      _feeManager: string,
      _forwardingRulesManager: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    isBridgedTokenDeployAcknowledged(
      _token: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    isRegisteredAsNativeToken(
      _token: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isTokenRegistered(
      _token: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    maxAvailablePerTx(
      _token: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    maxPerTx(
      _token: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    mediatorBalance(
      _token: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    messageFixed(
      _messageId: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    migrateTo_3_3_0(
      _tokenFactory: string,
      _forwardingRulesManager: string,
      _gasLimitManager: string,
      _feeManager: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    minPerTx(
      _token: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    nativeTokenAddress(
      _bridgedToken: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    onTokenTransfer(
      _from: string,
      _value: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    "relayTokens(address,uint256)"(
      token: string,
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "relayTokens(address,address,uint256)"(
      token: string,
      _receiver: string,
      _value: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    relayTokensAndCall(
      token: string,
      _receiver: string,
      _value: BigNumberish,
      _data: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    requestFailedMessageFix(
      _messageId: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setBridgeContract(
      _bridgeContract: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setCustomTokenAddressPair(
      _nativeToken: string,
      _bridgedToken: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setDailyLimit(
      _token: string,
      _dailyLimit: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setExecutionDailyLimit(
      _token: string,
      _dailyLimit: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setExecutionMaxPerTx(
      _token: string,
      _maxPerTx: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setFeeManager(
      _feeManager: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setForwardingRulesManager(
      _manager: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setGasLimitManager(
      _manager: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setMaxPerTx(
      _token: string,
      _maxPerTx: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setMediatorContractOnOtherSide(
      _mediatorContract: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setMinPerTx(
      _token: string,
      _minPerTx: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setTokenFactory(
      _tokenFactory: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    totalExecutedPerDay(
      _token: string,
      _day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    totalSpentPerDay(
      _token: string,
      _day: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    withinExecutionLimit(
      _token: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    withinLimit(
      _token: string,
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;
  };
}