symbiosis-js-sdk 3.7.5 → 3.7.6

package/dist/crosschain/contracts/KavaRouter.d.ts

@@ -0,0 +1,629 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
+export declare namespace Router {
+    type RouteStruct = {
+        from: string;
+        to: string;
+        stable: boolean;
+    };
+    type RouteStructOutput = [string, string, boolean] & {
+        from: string;
+        to: string;
+        stable: boolean;
+    };
+}
+export interface KavaRouterInterface extends utils.Interface {
+    functions: {
+        "UNSAFE_swapExactTokensForTokens(uint256[],(address,address,bool)[],address,uint256)": FunctionFragment;
+        "addLiquidity(address,address,bool,uint256,uint256,uint256,uint256,address,uint256)": FunctionFragment;
+        "addLiquidityETH(address,bool,uint256,uint256,uint256,address,uint256)": FunctionFragment;
+        "factory()": FunctionFragment;
+        "getAmountOut(uint256,address,address)": FunctionFragment;
+        "getAmountsOut(uint256,(address,address,bool)[])": FunctionFragment;
+        "getReserves(address,address,bool)": FunctionFragment;
+        "isPair(address)": FunctionFragment;
+        "pairFor(address,address,bool)": FunctionFragment;
+        "quoteAddLiquidity(address,address,bool,uint256,uint256)": FunctionFragment;
+        "quoteRemoveLiquidity(address,address,bool,uint256)": FunctionFragment;
+        "removeLiquidity(address,address,bool,uint256,uint256,uint256,address,uint256)": FunctionFragment;
+        "removeLiquidityETH(address,bool,uint256,uint256,uint256,address,uint256)": FunctionFragment;
+        "removeLiquidityETHSupportingFeeOnTransferTokens(address,bool,uint256,uint256,uint256,address,uint256)": FunctionFragment;
+        "removeLiquidityETHWithPermit(address,bool,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)": FunctionFragment;
+        "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address,bool,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)": FunctionFragment;
+        "removeLiquidityWithPermit(address,address,bool,uint256,uint256,uint256,address,uint256,bool,uint8,bytes32,bytes32)": FunctionFragment;
+        "sortTokens(address,address)": FunctionFragment;
+        "swapExactETHForTokens(uint256,(address,address,bool)[],address,uint256)": FunctionFragment;
+        "swapExactETHForTokensSupportingFeeOnTransferTokens(uint256,(address,address,bool)[],address,uint256)": FunctionFragment;
+        "swapExactTokensForETH(uint256,uint256,(address,address,bool)[],address,uint256)": FunctionFragment;
+        "swapExactTokensForETHSupportingFeeOnTransferTokens(uint256,uint256,(address,address,bool)[],address,uint256)": FunctionFragment;
+        "swapExactTokensForTokens(uint256,uint256,(address,address,bool)[],address,uint256)": FunctionFragment;
+        "swapExactTokensForTokensSimple(uint256,uint256,address,address,bool,address,uint256)": FunctionFragment;
+        "swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256,uint256,(address,address,bool)[],address,uint256)": FunctionFragment;
+        "weth()": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "UNSAFE_swapExactTokensForTokens" | "addLiquidity" | "addLiquidityETH" | "factory" | "getAmountOut" | "getAmountsOut" | "getReserves" | "isPair" | "pairFor" | "quoteAddLiquidity" | "quoteRemoveLiquidity" | "removeLiquidity" | "removeLiquidityETH" | "removeLiquidityETHSupportingFeeOnTransferTokens" | "removeLiquidityETHWithPermit" | "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens" | "removeLiquidityWithPermit" | "sortTokens" | "swapExactETHForTokens" | "swapExactETHForTokensSupportingFeeOnTransferTokens" | "swapExactTokensForETH" | "swapExactTokensForETHSupportingFeeOnTransferTokens" | "swapExactTokensForTokens" | "swapExactTokensForTokensSimple" | "swapExactTokensForTokensSupportingFeeOnTransferTokens" | "weth"): FunctionFragment;
+    encodeFunctionData(functionFragment: "UNSAFE_swapExactTokensForTokens", values: [BigNumberish[], Router.RouteStruct[], string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "addLiquidity", values: [
+        string,
+        string,
+        boolean,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        string,
+        BigNumberish
+    ]): string;
+    encodeFunctionData(functionFragment: "addLiquidityETH", values: [
+        string,
+        boolean,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        string,
+        BigNumberish
+    ]): string;
+    encodeFunctionData(functionFragment: "factory", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getAmountOut", values: [BigNumberish, string, string]): string;
+    encodeFunctionData(functionFragment: "getAmountsOut", values: [BigNumberish, Router.RouteStruct[]]): string;
+    encodeFunctionData(functionFragment: "getReserves", values: [string, string, boolean]): string;
+    encodeFunctionData(functionFragment: "isPair", values: [string]): string;
+    encodeFunctionData(functionFragment: "pairFor", values: [string, string, boolean]): string;
+    encodeFunctionData(functionFragment: "quoteAddLiquidity", values: [string, string, boolean, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "quoteRemoveLiquidity", values: [string, string, boolean, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "removeLiquidity", values: [
+        string,
+        string,
+        boolean,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        string,
+        BigNumberish
+    ]): string;
+    encodeFunctionData(functionFragment: "removeLiquidityETH", values: [
+        string,
+        boolean,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        string,
+        BigNumberish
+    ]): string;
+    encodeFunctionData(functionFragment: "removeLiquidityETHSupportingFeeOnTransferTokens", values: [
+        string,
+        boolean,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        string,
+        BigNumberish
+    ]): string;
+    encodeFunctionData(functionFragment: "removeLiquidityETHWithPermit", values: [
+        string,
+        boolean,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        string,
+        BigNumberish,
+        boolean,
+        BigNumberish,
+        BytesLike,
+        BytesLike
+    ]): string;
+    encodeFunctionData(functionFragment: "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens", values: [
+        string,
+        boolean,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        string,
+        BigNumberish,
+        boolean,
+        BigNumberish,
+        BytesLike,
+        BytesLike
+    ]): string;
+    encodeFunctionData(functionFragment: "removeLiquidityWithPermit", values: [
+        string,
+        string,
+        boolean,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        string,
+        BigNumberish,
+        boolean,
+        BigNumberish,
+        BytesLike,
+        BytesLike
+    ]): string;
+    encodeFunctionData(functionFragment: "sortTokens", values: [string, string]): string;
+    encodeFunctionData(functionFragment: "swapExactETHForTokens", values: [BigNumberish, Router.RouteStruct[], string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "swapExactETHForTokensSupportingFeeOnTransferTokens", values: [BigNumberish, Router.RouteStruct[], string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "swapExactTokensForETH", values: [
+        BigNumberish,
+        BigNumberish,
+        Router.RouteStruct[],
+        string,
+        BigNumberish
+    ]): string;
+    encodeFunctionData(functionFragment: "swapExactTokensForETHSupportingFeeOnTransferTokens", values: [
+        BigNumberish,
+        BigNumberish,
+        Router.RouteStruct[],
+        string,
+        BigNumberish
+    ]): string;
+    encodeFunctionData(functionFragment: "swapExactTokensForTokens", values: [
+        BigNumberish,
+        BigNumberish,
+        Router.RouteStruct[],
+        string,
+        BigNumberish
+    ]): string;
+    encodeFunctionData(functionFragment: "swapExactTokensForTokensSimple", values: [
+        BigNumberish,
+        BigNumberish,
+        string,
+        string,
+        boolean,
+        string,
+        BigNumberish
+    ]): string;
+    encodeFunctionData(functionFragment: "swapExactTokensForTokensSupportingFeeOnTransferTokens", values: [
+        BigNumberish,
+        BigNumberish,
+        Router.RouteStruct[],
+        string,
+        BigNumberish
+    ]): string;
+    encodeFunctionData(functionFragment: "weth", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "UNSAFE_swapExactTokensForTokens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "addLiquidity", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "addLiquidityETH", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "factory", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getAmountOut", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getAmountsOut", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getReserves", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isPair", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "pairFor", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "quoteAddLiquidity", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "quoteRemoveLiquidity", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "removeLiquidity", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "removeLiquidityETH", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "removeLiquidityETHSupportingFeeOnTransferTokens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "removeLiquidityETHWithPermit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "removeLiquidityWithPermit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "sortTokens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "swapExactETHForTokens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "swapExactETHForTokensSupportingFeeOnTransferTokens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "swapExactTokensForETH", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "swapExactTokensForETHSupportingFeeOnTransferTokens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "swapExactTokensForTokens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "swapExactTokensForTokensSimple", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "swapExactTokensForTokensSupportingFeeOnTransferTokens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "weth", data: BytesLike): Result;
+    events: {};
+}
+export interface KavaRouter extends BaseContract {
+    contractName: "KavaRouter";
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: KavaRouterInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        UNSAFE_swapExactTokensForTokens(amounts: BigNumberish[], routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        addLiquidity(tokenA: string, tokenB: string, stable: boolean, amountADesired: BigNumberish, amountBDesired: BigNumberish, amountAMin: BigNumberish, amountBMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        addLiquidityETH(token: string, stable: boolean, amountTokenDesired: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        factory(overrides?: CallOverrides): Promise<[string]>;
+        getAmountOut(amountIn: BigNumberish, tokenIn: string, tokenOut: string, overrides?: CallOverrides): Promise<[BigNumber, boolean] & {
+            amount: BigNumber;
+            stable: boolean;
+        }>;
+        getAmountsOut(amountIn: BigNumberish, routes: Router.RouteStruct[], overrides?: CallOverrides): Promise<[BigNumber[]] & {
+            amounts: BigNumber[];
+        }>;
+        getReserves(tokenA: string, tokenB: string, stable: boolean, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber
+        ] & {
+            reserveA: BigNumber;
+            reserveB: BigNumber;
+        }>;
+        isPair(pair: string, overrides?: CallOverrides): Promise<[boolean]>;
+        pairFor(tokenA: string, tokenB: string, stable: boolean, overrides?: CallOverrides): Promise<[string] & {
+            pair: string;
+        }>;
+        quoteAddLiquidity(tokenA: string, tokenB: string, stable: boolean, amountADesired: BigNumberish, amountBDesired: BigNumberish, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber,
+            BigNumber
+        ] & {
+            amountA: BigNumber;
+            amountB: BigNumber;
+            liquidity: BigNumber;
+        }>;
+        quoteRemoveLiquidity(tokenA: string, tokenB: string, stable: boolean, liquidity: BigNumberish, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber
+        ] & {
+            amountA: BigNumber;
+            amountB: BigNumber;
+        }>;
+        removeLiquidity(tokenA: string, tokenB: string, stable: boolean, liquidity: BigNumberish, amountAMin: BigNumberish, amountBMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        removeLiquidityETH(token: string, stable: boolean, liquidity: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        removeLiquidityETHSupportingFeeOnTransferTokens(token: string, stable: boolean, liquidity: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        removeLiquidityETHWithPermit(token: string, stable: boolean, liquidity: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, approveMax: boolean, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(token: string, stable: boolean, liquidity: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, approveMax: boolean, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        removeLiquidityWithPermit(tokenA: string, tokenB: string, stable: boolean, liquidity: BigNumberish, amountAMin: BigNumberish, amountBMin: BigNumberish, to: string, deadline: BigNumberish, approveMax: boolean, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        sortTokens(tokenA: string, tokenB: string, overrides?: CallOverrides): Promise<[string, string] & {
+            token0: string;
+            token1: string;
+        }>;
+        swapExactETHForTokens(amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        swapExactETHForTokensSupportingFeeOnTransferTokens(amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        swapExactTokensForETH(amountIn: BigNumberish, amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        swapExactTokensForETHSupportingFeeOnTransferTokens(amountIn: BigNumberish, amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        swapExactTokensForTokens(amountIn: BigNumberish, amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        swapExactTokensForTokensSimple(amountIn: BigNumberish, amountOutMin: BigNumberish, tokenFrom: string, tokenTo: string, stable: boolean, to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        swapExactTokensForTokensSupportingFeeOnTransferTokens(amountIn: BigNumberish, amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        weth(overrides?: CallOverrides): Promise<[string]>;
+    };
+    UNSAFE_swapExactTokensForTokens(amounts: BigNumberish[], routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    addLiquidity(tokenA: string, tokenB: string, stable: boolean, amountADesired: BigNumberish, amountBDesired: BigNumberish, amountAMin: BigNumberish, amountBMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    addLiquidityETH(token: string, stable: boolean, amountTokenDesired: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: PayableOverrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    factory(overrides?: CallOverrides): Promise<string>;
+    getAmountOut(amountIn: BigNumberish, tokenIn: string, tokenOut: string, overrides?: CallOverrides): Promise<[BigNumber, boolean] & {
+        amount: BigNumber;
+        stable: boolean;
+    }>;
+    getAmountsOut(amountIn: BigNumberish, routes: Router.RouteStruct[], overrides?: CallOverrides): Promise<BigNumber[]>;
+    getReserves(tokenA: string, tokenB: string, stable: boolean, overrides?: CallOverrides): Promise<[
+        BigNumber,
+        BigNumber
+    ] & {
+        reserveA: BigNumber;
+        reserveB: BigNumber;
+    }>;
+    isPair(pair: string, overrides?: CallOverrides): Promise<boolean>;
+    pairFor(tokenA: string, tokenB: string, stable: boolean, overrides?: CallOverrides): Promise<string>;
+    quoteAddLiquidity(tokenA: string, tokenB: string, stable: boolean, amountADesired: BigNumberish, amountBDesired: BigNumberish, overrides?: CallOverrides): Promise<[
+        BigNumber,
+        BigNumber,
+        BigNumber
+    ] & {
+        amountA: BigNumber;
+        amountB: BigNumber;
+        liquidity: BigNumber;
+    }>;
+    quoteRemoveLiquidity(tokenA: string, tokenB: string, stable: boolean, liquidity: BigNumberish, overrides?: CallOverrides): Promise<[
+        BigNumber,
+        BigNumber
+    ] & {
+        amountA: BigNumber;
+        amountB: BigNumber;
+    }>;
+    removeLiquidity(tokenA: string, tokenB: string, stable: boolean, liquidity: BigNumberish, amountAMin: BigNumberish, amountBMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    removeLiquidityETH(token: string, stable: boolean, liquidity: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    removeLiquidityETHSupportingFeeOnTransferTokens(token: string, stable: boolean, liquidity: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    removeLiquidityETHWithPermit(token: string, stable: boolean, liquidity: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, approveMax: boolean, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(token: string, stable: boolean, liquidity: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, approveMax: boolean, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    removeLiquidityWithPermit(tokenA: string, tokenB: string, stable: boolean, liquidity: BigNumberish, amountAMin: BigNumberish, amountBMin: BigNumberish, to: string, deadline: BigNumberish, approveMax: boolean, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    sortTokens(tokenA: string, tokenB: string, overrides?: CallOverrides): Promise<[string, string] & {
+        token0: string;
+        token1: string;
+    }>;
+    swapExactETHForTokens(amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: PayableOverrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    swapExactETHForTokensSupportingFeeOnTransferTokens(amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: PayableOverrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    swapExactTokensForETH(amountIn: BigNumberish, amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    swapExactTokensForETHSupportingFeeOnTransferTokens(amountIn: BigNumberish, amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    swapExactTokensForTokens(amountIn: BigNumberish, amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    swapExactTokensForTokensSimple(amountIn: BigNumberish, amountOutMin: BigNumberish, tokenFrom: string, tokenTo: string, stable: boolean, to: string, deadline: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    swapExactTokensForTokensSupportingFeeOnTransferTokens(amountIn: BigNumberish, amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    weth(overrides?: CallOverrides): Promise<string>;
+    callStatic: {
+        UNSAFE_swapExactTokensForTokens(amounts: BigNumberish[], routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: CallOverrides): Promise<BigNumber[]>;
+        addLiquidity(tokenA: string, tokenB: string, stable: boolean, amountADesired: BigNumberish, amountBDesired: BigNumberish, amountAMin: BigNumberish, amountBMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber,
+            BigNumber
+        ] & {
+            amountA: BigNumber;
+            amountB: BigNumber;
+            liquidity: BigNumber;
+        }>;
+        addLiquidityETH(token: string, stable: boolean, amountTokenDesired: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber,
+            BigNumber
+        ] & {
+            amountToken: BigNumber;
+            amountETH: BigNumber;
+            liquidity: BigNumber;
+        }>;
+        factory(overrides?: CallOverrides): Promise<string>;
+        getAmountOut(amountIn: BigNumberish, tokenIn: string, tokenOut: string, overrides?: CallOverrides): Promise<[BigNumber, boolean] & {
+            amount: BigNumber;
+            stable: boolean;
+        }>;
+        getAmountsOut(amountIn: BigNumberish, routes: Router.RouteStruct[], overrides?: CallOverrides): Promise<BigNumber[]>;
+        getReserves(tokenA: string, tokenB: string, stable: boolean, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber
+        ] & {
+            reserveA: BigNumber;
+            reserveB: BigNumber;
+        }>;
+        isPair(pair: string, overrides?: CallOverrides): Promise<boolean>;
+        pairFor(tokenA: string, tokenB: string, stable: boolean, overrides?: CallOverrides): Promise<string>;
+        quoteAddLiquidity(tokenA: string, tokenB: string, stable: boolean, amountADesired: BigNumberish, amountBDesired: BigNumberish, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber,
+            BigNumber
+        ] & {
+            amountA: BigNumber;
+            amountB: BigNumber;
+            liquidity: BigNumber;
+        }>;
+        quoteRemoveLiquidity(tokenA: string, tokenB: string, stable: boolean, liquidity: BigNumberish, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber
+        ] & {
+            amountA: BigNumber;
+            amountB: BigNumber;
+        }>;
+        removeLiquidity(tokenA: string, tokenB: string, stable: boolean, liquidity: BigNumberish, amountAMin: BigNumberish, amountBMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber
+        ] & {
+            amountA: BigNumber;
+            amountB: BigNumber;
+        }>;
+        removeLiquidityETH(token: string, stable: boolean, liquidity: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber
+        ] & {
+            amountToken: BigNumber;
+            amountETH: BigNumber;
+        }>;
+        removeLiquidityETHSupportingFeeOnTransferTokens(token: string, stable: boolean, liquidity: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber
+        ] & {
+            amountToken: BigNumber;
+            amountETH: BigNumber;
+        }>;
+        removeLiquidityETHWithPermit(token: string, stable: boolean, liquidity: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, approveMax: boolean, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber
+        ] & {
+            amountToken: BigNumber;
+            amountETH: BigNumber;
+        }>;
+        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(token: string, stable: boolean, liquidity: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, approveMax: boolean, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber
+        ] & {
+            amountToken: BigNumber;
+            amountETH: BigNumber;
+        }>;
+        removeLiquidityWithPermit(tokenA: string, tokenB: string, stable: boolean, liquidity: BigNumberish, amountAMin: BigNumberish, amountBMin: BigNumberish, to: string, deadline: BigNumberish, approveMax: boolean, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber
+        ] & {
+            amountA: BigNumber;
+            amountB: BigNumber;
+        }>;
+        sortTokens(tokenA: string, tokenB: string, overrides?: CallOverrides): Promise<[string, string] & {
+            token0: string;
+            token1: string;
+        }>;
+        swapExactETHForTokens(amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: CallOverrides): Promise<BigNumber[]>;
+        swapExactETHForTokensSupportingFeeOnTransferTokens(amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        swapExactTokensForETH(amountIn: BigNumberish, amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: CallOverrides): Promise<BigNumber[]>;
+        swapExactTokensForETHSupportingFeeOnTransferTokens(amountIn: BigNumberish, amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        swapExactTokensForTokens(amountIn: BigNumberish, amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: CallOverrides): Promise<BigNumber[]>;
+        swapExactTokensForTokensSimple(amountIn: BigNumberish, amountOutMin: BigNumberish, tokenFrom: string, tokenTo: string, stable: boolean, to: string, deadline: BigNumberish, overrides?: CallOverrides): Promise<BigNumber[]>;
+        swapExactTokensForTokensSupportingFeeOnTransferTokens(amountIn: BigNumberish, amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        weth(overrides?: CallOverrides): Promise<string>;
+    };
+    filters: {};
+    estimateGas: {
+        UNSAFE_swapExactTokensForTokens(amounts: BigNumberish[], routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        addLiquidity(tokenA: string, tokenB: string, stable: boolean, amountADesired: BigNumberish, amountBDesired: BigNumberish, amountAMin: BigNumberish, amountBMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        addLiquidityETH(token: string, stable: boolean, amountTokenDesired: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        factory(overrides?: CallOverrides): Promise<BigNumber>;
+        getAmountOut(amountIn: BigNumberish, tokenIn: string, tokenOut: string, overrides?: CallOverrides): Promise<BigNumber>;
+        getAmountsOut(amountIn: BigNumberish, routes: Router.RouteStruct[], overrides?: CallOverrides): Promise<BigNumber>;
+        getReserves(tokenA: string, tokenB: string, stable: boolean, overrides?: CallOverrides): Promise<BigNumber>;
+        isPair(pair: string, overrides?: CallOverrides): Promise<BigNumber>;
+        pairFor(tokenA: string, tokenB: string, stable: boolean, overrides?: CallOverrides): Promise<BigNumber>;
+        quoteAddLiquidity(tokenA: string, tokenB: string, stable: boolean, amountADesired: BigNumberish, amountBDesired: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        quoteRemoveLiquidity(tokenA: string, tokenB: string, stable: boolean, liquidity: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        removeLiquidity(tokenA: string, tokenB: string, stable: boolean, liquidity: BigNumberish, amountAMin: BigNumberish, amountBMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        removeLiquidityETH(token: string, stable: boolean, liquidity: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        removeLiquidityETHSupportingFeeOnTransferTokens(token: string, stable: boolean, liquidity: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        removeLiquidityETHWithPermit(token: string, stable: boolean, liquidity: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, approveMax: boolean, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(token: string, stable: boolean, liquidity: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, approveMax: boolean, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        removeLiquidityWithPermit(tokenA: string, tokenB: string, stable: boolean, liquidity: BigNumberish, amountAMin: BigNumberish, amountBMin: BigNumberish, to: string, deadline: BigNumberish, approveMax: boolean, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        sortTokens(tokenA: string, tokenB: string, overrides?: CallOverrides): Promise<BigNumber>;
+        swapExactETHForTokens(amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        swapExactETHForTokensSupportingFeeOnTransferTokens(amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        swapExactTokensForETH(amountIn: BigNumberish, amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        swapExactTokensForETHSupportingFeeOnTransferTokens(amountIn: BigNumberish, amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        swapExactTokensForTokens(amountIn: BigNumberish, amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        swapExactTokensForTokensSimple(amountIn: BigNumberish, amountOutMin: BigNumberish, tokenFrom: string, tokenTo: string, stable: boolean, to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        swapExactTokensForTokensSupportingFeeOnTransferTokens(amountIn: BigNumberish, amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        weth(overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        UNSAFE_swapExactTokensForTokens(amounts: BigNumberish[], routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        addLiquidity(tokenA: string, tokenB: string, stable: boolean, amountADesired: BigNumberish, amountBDesired: BigNumberish, amountAMin: BigNumberish, amountBMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        addLiquidityETH(token: string, stable: boolean, amountTokenDesired: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        factory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getAmountOut(amountIn: BigNumberish, tokenIn: string, tokenOut: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getAmountsOut(amountIn: BigNumberish, routes: Router.RouteStruct[], overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getReserves(tokenA: string, tokenB: string, stable: boolean, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isPair(pair: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        pairFor(tokenA: string, tokenB: string, stable: boolean, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        quoteAddLiquidity(tokenA: string, tokenB: string, stable: boolean, amountADesired: BigNumberish, amountBDesired: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        quoteRemoveLiquidity(tokenA: string, tokenB: string, stable: boolean, liquidity: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        removeLiquidity(tokenA: string, tokenB: string, stable: boolean, liquidity: BigNumberish, amountAMin: BigNumberish, amountBMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        removeLiquidityETH(token: string, stable: boolean, liquidity: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        removeLiquidityETHSupportingFeeOnTransferTokens(token: string, stable: boolean, liquidity: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        removeLiquidityETHWithPermit(token: string, stable: boolean, liquidity: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, approveMax: boolean, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(token: string, stable: boolean, liquidity: BigNumberish, amountTokenMin: BigNumberish, amountETHMin: BigNumberish, to: string, deadline: BigNumberish, approveMax: boolean, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        removeLiquidityWithPermit(tokenA: string, tokenB: string, stable: boolean, liquidity: BigNumberish, amountAMin: BigNumberish, amountBMin: BigNumberish, to: string, deadline: BigNumberish, approveMax: boolean, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        sortTokens(tokenA: string, tokenB: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        swapExactETHForTokens(amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        swapExactETHForTokensSupportingFeeOnTransferTokens(amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: PayableOverrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        swapExactTokensForETH(amountIn: BigNumberish, amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        swapExactTokensForETHSupportingFeeOnTransferTokens(amountIn: BigNumberish, amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        swapExactTokensForTokens(amountIn: BigNumberish, amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        swapExactTokensForTokensSimple(amountIn: BigNumberish, amountOutMin: BigNumberish, tokenFrom: string, tokenTo: string, stable: boolean, to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        swapExactTokensForTokensSupportingFeeOnTransferTokens(amountIn: BigNumberish, amountOutMin: BigNumberish, routes: Router.RouteStruct[], to: string, deadline: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        weth(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/dist/crosschain/contracts/KavaRouter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=KavaRouter.js.map

package/dist/crosschain/contracts/KavaRouter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KavaRouter.js","sourceRoot":"","sources":["../../../src/crosschain/contracts/KavaRouter.ts"],"names":[],"mappings":""}