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

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

interface XRaydiumBridgeInterface extends ethers.utils.Interface {
  functions: {
    "abort(uint64)": FunctionFragment;
    "addressArrayToBytesArray(address[])": FunctionFragment;
    "encodeAddressArray(address[])": FunctionFragment;
    "encodeBytesArray(bytes32[])": FunctionFragment;
    "encodeHeader((bytes32,uint64,tuple[],tuple[],bytes,bool,bytes32))": FunctionFragment;
    "encodeXTokenLocator((bytes32,uint16))": FunctionFragment;
    "encodeXTokenLocatorArray(tuple[])": FunctionFragment;
    "globalId()": FunctionFragment;
    "initialize(address,address,uint64,bytes32,uint256)": FunctionFragment;
    "owner()": FunctionFragment;
    "proxiableUUID()": FunctionFragment;
    "relayerFee()": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "reverse16(uint16)": FunctionFragment;
    "reverse32(uint32)": FunctionFragment;
    "reverse64(uint64)": FunctionFragment;
    "setRelayerFee(uint256)": FunctionFragment;
    "swap((bytes32,uint16),(bytes32,uint16),uint64,uint64,bytes32,bytes32)": FunctionFragment;
    "swapFromEth((bytes32,uint16),uint64,bytes32,bytes32)": FunctionFragment;
    "sweepFees()": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "upgradeTo(address)": FunctionFragment;
    "upgradeToAndCall(address,bytes)": FunctionFragment;
    "weth()": FunctionFragment;
    "wormholeCoreBridge()": FunctionFragment;
    "wormholeTokenBridge()": FunctionFragment;
    "wsol()": FunctionFragment;
  };

  encodeFunctionData(functionFragment: "abort", values: [BigNumberish]): string;
  encodeFunctionData(
    functionFragment: "addressArrayToBytesArray",
    values: [string[]]
  ): string;
  encodeFunctionData(
    functionFragment: "encodeAddressArray",
    values: [string[]]
  ): string;
  encodeFunctionData(
    functionFragment: "encodeBytesArray",
    values: [BytesLike[]]
  ): string;
  encodeFunctionData(
    functionFragment: "encodeHeader",
    values: [
      {
        sender: BytesLike;
        id: BigNumberish;
        inputTokens: { tokenAddr: BytesLike; chainId: BigNumberish }[];
        outputTokens: { tokenAddr: BytesLike; chainId: BigNumberish }[];
        operation: BytesLike;
        solanaReceiver: boolean;
        receiver: BytesLike;
      }
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "encodeXTokenLocator",
    values: [{ tokenAddr: BytesLike; chainId: BigNumberish }]
  ): string;
  encodeFunctionData(
    functionFragment: "encodeXTokenLocatorArray",
    values: [{ tokenAddr: BytesLike; chainId: BigNumberish }[]]
  ): string;
  encodeFunctionData(functionFragment: "globalId", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [string, string, BigNumberish, BytesLike, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "proxiableUUID",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "relayerFee",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "reverse16",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "reverse32",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "reverse64",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "setRelayerFee",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "swap",
    values: [
      { tokenAddr: BytesLike; chainId: BigNumberish },
      { tokenAddr: BytesLike; chainId: BigNumberish },
      BigNumberish,
      BigNumberish,
      BytesLike,
      BytesLike
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "swapFromEth",
    values: [
      { tokenAddr: BytesLike; chainId: BigNumberish },
      BigNumberish,
      BytesLike,
      BytesLike
    ]
  ): string;
  encodeFunctionData(functionFragment: "sweepFees", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "upgradeTo", values: [string]): string;
  encodeFunctionData(
    functionFragment: "upgradeToAndCall",
    values: [string, BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "weth", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "wormholeCoreBridge",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "wormholeTokenBridge",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "wsol", values?: undefined): string;

  decodeFunctionResult(functionFragment: "abort", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "addressArrayToBytesArray",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "encodeAddressArray",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "encodeBytesArray",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "encodeHeader",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "encodeXTokenLocator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "encodeXTokenLocatorArray",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "globalId", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "proxiableUUID",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "relayerFee", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "reverse16", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "reverse32", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "reverse64", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setRelayerFee",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "swap", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "swapFromEth",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "sweepFees", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "upgradeToAndCall",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "weth", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "wormholeCoreBridge",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "wormholeTokenBridge",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "wsol", data: BytesLike): Result;

  events: {
    "AdminChanged(address,address)": EventFragment;
    "BeaconUpgraded(address)": EventFragment;
    "Initialized(uint8)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "SweepFees(address,uint256)": EventFragment;
    "Upgraded(address)": EventFragment;
    "XTxID(address,uint64,uint64)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SweepFees"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "XTxID"): EventFragment;
}

export type AdminChangedEvent = TypedEvent<
  [string, string] & { previousAdmin: string; newAdmin: string }
>;

export type BeaconUpgradedEvent = TypedEvent<[string] & { beacon: string }>;

export type InitializedEvent = TypedEvent<[number] & { version: number }>;

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

export type SweepFeesEvent = TypedEvent<
  [string, BigNumber] & { owner: string; feesSwept: BigNumber }
>;

export type UpgradedEvent = TypedEvent<[string] & { implementation: string }>;

export type XTxIDEvent = TypedEvent<
  [string, BigNumber, BigNumber] & {
    sender: string;
    id: BigNumber;
    seq: BigNumber;
  }
>;

export class XRaydiumBridge 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: XRaydiumBridgeInterface;

  functions: {
    abort(
      id: BigNumberish,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    addressArrayToBytesArray(
      x: string[],
      overrides?: CallOverrides
    ): Promise<[string[]]>;

    encodeAddressArray(
      x: string[],
      overrides?: CallOverrides
    ): Promise<[string] & { data: string }>;

    encodeBytesArray(
      x: BytesLike[],
      overrides?: CallOverrides
    ): Promise<[string] & { data: string }>;

    encodeHeader(
      header: {
        sender: BytesLike;
        id: BigNumberish;
        inputTokens: { tokenAddr: BytesLike; chainId: BigNumberish }[];
        outputTokens: { tokenAddr: BytesLike; chainId: BigNumberish }[];
        operation: BytesLike;
        solanaReceiver: boolean;
        receiver: BytesLike;
      },
      overrides?: CallOverrides
    ): Promise<[string] & { encoded: string }>;

    encodeXTokenLocator(
      x: { tokenAddr: BytesLike; chainId: BigNumberish },
      overrides?: CallOverrides
    ): Promise<[string] & { data: string }>;

    encodeXTokenLocatorArray(
      xs: { tokenAddr: BytesLike; chainId: BigNumberish }[],
      overrides?: CallOverrides
    ): Promise<[string] & { data: string }>;

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

    initialize(
      _wormholeTokenBridge: string,
      _wormholeCoreBridge: string,
      _initialId: BigNumberish,
      _wsol: BytesLike,
      _relayerFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

    reverse16(
      input: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[number] & { v: number }>;

    reverse32(
      input: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[number] & { v: number }>;

    reverse64(
      input: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { v: BigNumber }>;

    setRelayerFee(
      _relayerFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    swap(
      input: { tokenAddr: BytesLike; chainId: BigNumberish },
      output: { tokenAddr: BytesLike; chainId: BigNumberish },
      amount: BigNumberish,
      minAmtOut: BigNumberish,
      solanaProxyAddr: BytesLike,
      optionalSolanaRecipient: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    swapFromEth(
      output: { tokenAddr: BytesLike; chainId: BigNumberish },
      minAmtOut: BigNumberish,
      solanaProxyAddr: BytesLike,
      optionalSolanaRecipient: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

    upgradeToAndCall(
      newImplementation: string,
      data: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

    wsol(
      overrides?: CallOverrides
    ): Promise<[string, number] & { tokenAddr: string; chainId: number }>;
  };

  abort(
    id: BigNumberish,
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  addressArrayToBytesArray(
    x: string[],
    overrides?: CallOverrides
  ): Promise<string[]>;

  encodeAddressArray(x: string[], overrides?: CallOverrides): Promise<string>;

  encodeBytesArray(x: BytesLike[], overrides?: CallOverrides): Promise<string>;

  encodeHeader(
    header: {
      sender: BytesLike;
      id: BigNumberish;
      inputTokens: { tokenAddr: BytesLike; chainId: BigNumberish }[];
      outputTokens: { tokenAddr: BytesLike; chainId: BigNumberish }[];
      operation: BytesLike;
      solanaReceiver: boolean;
      receiver: BytesLike;
    },
    overrides?: CallOverrides
  ): Promise<string>;

  encodeXTokenLocator(
    x: { tokenAddr: BytesLike; chainId: BigNumberish },
    overrides?: CallOverrides
  ): Promise<string>;

  encodeXTokenLocatorArray(
    xs: { tokenAddr: BytesLike; chainId: BigNumberish }[],
    overrides?: CallOverrides
  ): Promise<string>;

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

  initialize(
    _wormholeTokenBridge: string,
    _wormholeCoreBridge: string,
    _initialId: BigNumberish,
    _wsol: BytesLike,
    _relayerFee: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

  reverse16(input: BigNumberish, overrides?: CallOverrides): Promise<number>;

  reverse32(input: BigNumberish, overrides?: CallOverrides): Promise<number>;

  reverse64(input: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;

  setRelayerFee(
    _relayerFee: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  swap(
    input: { tokenAddr: BytesLike; chainId: BigNumberish },
    output: { tokenAddr: BytesLike; chainId: BigNumberish },
    amount: BigNumberish,
    minAmtOut: BigNumberish,
    solanaProxyAddr: BytesLike,
    optionalSolanaRecipient: BytesLike,
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  swapFromEth(
    output: { tokenAddr: BytesLike; chainId: BigNumberish },
    minAmtOut: BigNumberish,
    solanaProxyAddr: BytesLike,
    optionalSolanaRecipient: BytesLike,
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

  upgradeToAndCall(
    newImplementation: string,
    data: BytesLike,
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

  wsol(
    overrides?: CallOverrides
  ): Promise<[string, number] & { tokenAddr: string; chainId: number }>;

  callStatic: {
    abort(id: BigNumberish, overrides?: CallOverrides): Promise<void>;

    addressArrayToBytesArray(
      x: string[],
      overrides?: CallOverrides
    ): Promise<string[]>;

    encodeAddressArray(x: string[], overrides?: CallOverrides): Promise<string>;

    encodeBytesArray(
      x: BytesLike[],
      overrides?: CallOverrides
    ): Promise<string>;

    encodeHeader(
      header: {
        sender: BytesLike;
        id: BigNumberish;
        inputTokens: { tokenAddr: BytesLike; chainId: BigNumberish }[];
        outputTokens: { tokenAddr: BytesLike; chainId: BigNumberish }[];
        operation: BytesLike;
        solanaReceiver: boolean;
        receiver: BytesLike;
      },
      overrides?: CallOverrides
    ): Promise<string>;

    encodeXTokenLocator(
      x: { tokenAddr: BytesLike; chainId: BigNumberish },
      overrides?: CallOverrides
    ): Promise<string>;

    encodeXTokenLocatorArray(
      xs: { tokenAddr: BytesLike; chainId: BigNumberish }[],
      overrides?: CallOverrides
    ): Promise<string>;

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

    initialize(
      _wormholeTokenBridge: string,
      _wormholeCoreBridge: string,
      _initialId: BigNumberish,
      _wsol: BytesLike,
      _relayerFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

    reverse16(input: BigNumberish, overrides?: CallOverrides): Promise<number>;

    reverse32(input: BigNumberish, overrides?: CallOverrides): Promise<number>;

    reverse64(
      input: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    setRelayerFee(
      _relayerFee: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    swap(
      input: { tokenAddr: BytesLike; chainId: BigNumberish },
      output: { tokenAddr: BytesLike; chainId: BigNumberish },
      amount: BigNumberish,
      minAmtOut: BigNumberish,
      solanaProxyAddr: BytesLike,
      optionalSolanaRecipient: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

    swapFromEth(
      output: { tokenAddr: BytesLike; chainId: BigNumberish },
      minAmtOut: BigNumberish,
      solanaProxyAddr: BytesLike,
      optionalSolanaRecipient: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

    upgradeTo(
      newImplementation: string,
      overrides?: CallOverrides
    ): Promise<void>;

    upgradeToAndCall(
      newImplementation: string,
      data: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

    wsol(
      overrides?: CallOverrides
    ): Promise<[string, number] & { tokenAddr: string; chainId: number }>;
  };

  filters: {
    "AdminChanged(address,address)"(
      previousAdmin?: null,
      newAdmin?: null
    ): TypedEventFilter<
      [string, string],
      { previousAdmin: string; newAdmin: string }
    >;

    AdminChanged(
      previousAdmin?: null,
      newAdmin?: null
    ): TypedEventFilter<
      [string, string],
      { previousAdmin: string; newAdmin: string }
    >;

    "BeaconUpgraded(address)"(
      beacon?: string | null
    ): TypedEventFilter<[string], { beacon: string }>;

    BeaconUpgraded(
      beacon?: string | null
    ): TypedEventFilter<[string], { beacon: string }>;

    "Initialized(uint8)"(
      version?: null
    ): TypedEventFilter<[number], { version: number }>;

    Initialized(
      version?: null
    ): TypedEventFilter<[number], { version: number }>;

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

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

    "SweepFees(address,uint256)"(
      owner?: string | null,
      feesSwept?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { owner: string; feesSwept: BigNumber }
    >;

    SweepFees(
      owner?: string | null,
      feesSwept?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { owner: string; feesSwept: BigNumber }
    >;

    "Upgraded(address)"(
      implementation?: string | null
    ): TypedEventFilter<[string], { implementation: string }>;

    Upgraded(
      implementation?: string | null
    ): TypedEventFilter<[string], { implementation: string }>;

    "XTxID(address,uint64,uint64)"(
      sender?: string | null,
      id?: BigNumberish | null,
      seq?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      { sender: string; id: BigNumber; seq: BigNumber }
    >;

    XTxID(
      sender?: string | null,
      id?: BigNumberish | null,
      seq?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      { sender: string; id: BigNumber; seq: BigNumber }
    >;
  };

  estimateGas: {
    abort(
      id: BigNumberish,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    addressArrayToBytesArray(
      x: string[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    encodeAddressArray(
      x: string[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    encodeBytesArray(
      x: BytesLike[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    encodeHeader(
      header: {
        sender: BytesLike;
        id: BigNumberish;
        inputTokens: { tokenAddr: BytesLike; chainId: BigNumberish }[];
        outputTokens: { tokenAddr: BytesLike; chainId: BigNumberish }[];
        operation: BytesLike;
        solanaReceiver: boolean;
        receiver: BytesLike;
      },
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    encodeXTokenLocator(
      x: { tokenAddr: BytesLike; chainId: BigNumberish },
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    encodeXTokenLocatorArray(
      xs: { tokenAddr: BytesLike; chainId: BigNumberish }[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    initialize(
      _wormholeTokenBridge: string,
      _wormholeCoreBridge: string,
      _initialId: BigNumberish,
      _wsol: BytesLike,
      _relayerFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

    reverse16(
      input: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    reverse32(
      input: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    reverse64(
      input: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    setRelayerFee(
      _relayerFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    swap(
      input: { tokenAddr: BytesLike; chainId: BigNumberish },
      output: { tokenAddr: BytesLike; chainId: BigNumberish },
      amount: BigNumberish,
      minAmtOut: BigNumberish,
      solanaProxyAddr: BytesLike,
      optionalSolanaRecipient: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    swapFromEth(
      output: { tokenAddr: BytesLike; chainId: BigNumberish },
      minAmtOut: BigNumberish,
      solanaProxyAddr: BytesLike,
      optionalSolanaRecipient: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

    upgradeToAndCall(
      newImplementation: string,
      data: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

    wsol(overrides?: CallOverrides): Promise<BigNumber>;
  };

  populateTransaction: {
    abort(
      id: BigNumberish,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    addressArrayToBytesArray(
      x: string[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    encodeAddressArray(
      x: string[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    encodeBytesArray(
      x: BytesLike[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    encodeHeader(
      header: {
        sender: BytesLike;
        id: BigNumberish;
        inputTokens: { tokenAddr: BytesLike; chainId: BigNumberish }[];
        outputTokens: { tokenAddr: BytesLike; chainId: BigNumberish }[];
        operation: BytesLike;
        solanaReceiver: boolean;
        receiver: BytesLike;
      },
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    encodeXTokenLocator(
      x: { tokenAddr: BytesLike; chainId: BigNumberish },
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    encodeXTokenLocatorArray(
      xs: { tokenAddr: BytesLike; chainId: BigNumberish }[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    initialize(
      _wormholeTokenBridge: string,
      _wormholeCoreBridge: string,
      _initialId: BigNumberish,
      _wsol: BytesLike,
      _relayerFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

    reverse16(
      input: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    reverse32(
      input: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    reverse64(
      input: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    setRelayerFee(
      _relayerFee: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    swap(
      input: { tokenAddr: BytesLike; chainId: BigNumberish },
      output: { tokenAddr: BytesLike; chainId: BigNumberish },
      amount: BigNumberish,
      minAmtOut: BigNumberish,
      solanaProxyAddr: BytesLike,
      optionalSolanaRecipient: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    swapFromEth(
      output: { tokenAddr: BytesLike; chainId: BigNumberish },
      minAmtOut: BigNumberish,
      solanaProxyAddr: BytesLike,
      optionalSolanaRecipient: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

    upgradeToAndCall(
      newImplementation: string,
      data: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

    wsol(overrides?: CallOverrides): Promise<PopulatedTransaction>;
  };
}