@tcswap/sdk 4.2.16

package/dist/types/index.d.ts

@@ -0,0 +1,2501 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+import { type USwapConfigState } from "@tcswap/core";
+import type { createPlugin } from "@tcswap/plugins";
+import type { createWallet } from "@tcswap/wallets";
+import { bitgetWallet } from "@tcswap/wallets/bitget";
+import { coinbaseWallet } from "@tcswap/wallets/coinbase";
+import { ctrlWallet } from "@tcswap/wallets/ctrl";
+import { evmWallet } from "@tcswap/wallets/evm-extensions";
+import { keepkeyWallet } from "@tcswap/wallets/keepkey";
+import { keepkeyBexWallet } from "@tcswap/wallets/keepkey-bex";
+import { keplrWallet } from "@tcswap/wallets/keplr";
+import { keystoreWallet } from "@tcswap/wallets/keystore";
+import { ledgerWallet } from "@tcswap/wallets/ledger";
+import { walletSelectorWallet } from "@tcswap/wallets/near-wallet-selector";
+import { okxWallet } from "@tcswap/wallets/okx";
+import { onekeyWallet } from "@tcswap/wallets/onekey";
+import { passkeysWallet } from "@tcswap/wallets/passkeys";
+import { phantomWallet } from "@tcswap/wallets/phantom";
+import { polkadotWallet } from "@tcswap/wallets/polkadotjs";
+import { radixWallet } from "@tcswap/wallets/radix";
+import { talismanWallet } from "@tcswap/wallets/talisman";
+import { trezorWallet } from "@tcswap/wallets/trezor";
+import { tronlinkWallet } from "@tcswap/wallets/tronlink";
+import { vultisigWallet } from "@tcswap/wallets/vultisig";
+import { walletconnectWallet } from "@tcswap/wallets/walletconnect";
+import { xamanWallet } from "@tcswap/wallets/xaman";
+export * from "@tcswap/core";
+export * from "@tcswap/helpers";
+export * from "@tcswap/helpers/api";
+export * from "@tcswap/plugins";
+export * from "@tcswap/plugins/chainflip";
+export * from "@tcswap/plugins/evm";
+export * from "@tcswap/plugins/near";
+export * from "@tcswap/plugins/radix";
+export * from "@tcswap/plugins/solana";
+export * from "@tcswap/plugins/thorchain";
+export * from "@tcswap/toolboxes";
+export * from "@tcswap/toolboxes/cosmos";
+export * from "@tcswap/toolboxes/evm";
+export * from "@tcswap/toolboxes/radix";
+export * from "@tcswap/toolboxes/solana";
+export * from "@tcswap/toolboxes/substrate";
+export * from "@tcswap/toolboxes/utxo";
+export * from "@tcswap/wallets";
+declare const exodusWallet: {
+    connectExodusWallet: {
+        connectWallet: (connectParams: {
+            addChain: import("@tcswap/helpers").AddChainType;
+        }) => (chains: import("@tcswap/types").Chain[], paramWallet?: import("@passkeys/core").Wallet | undefined) => Promise<boolean>;
+        supportedChains: (import("@tcswap/types").Chain.Arbitrum | import("@tcswap/types").Chain.Aurora | import("@tcswap/types").Chain.Avalanche | import("@tcswap/types").Chain.Base | import("@tcswap/types").Chain.Berachain | import("@tcswap/types").Chain.BinanceSmartChain | import("@tcswap/types").Chain.Bitcoin | import("@tcswap/types").Chain.Botanix | import("@tcswap/types").Chain.Core | import("@tcswap/types").Chain.Corn | import("@tcswap/types").Chain.Cronos | import("@tcswap/types").Chain.Ethereum | import("@tcswap/types").Chain.Gnosis | import("@tcswap/types").Chain.Hyperevm | import("@tcswap/types").Chain.Monad | import("@tcswap/types").Chain.Optimism | import("@tcswap/types").Chain.Polygon | import("@tcswap/types").Chain.Solana | import("@tcswap/types").Chain.Sonic | import("@tcswap/types").Chain.Unichain | import("@tcswap/types").Chain.XLayer)[];
+    };
+    connectPasskeys: {
+        connectWallet: (connectParams: {
+            addChain: import("@tcswap/helpers").AddChainType;
+        }) => (chains: import("@tcswap/types").Chain[], paramWallet?: import("@passkeys/core").Wallet | undefined) => Promise<boolean>;
+        supportedChains: (import("@tcswap/types").Chain.Arbitrum | import("@tcswap/types").Chain.Aurora | import("@tcswap/types").Chain.Avalanche | import("@tcswap/types").Chain.Base | import("@tcswap/types").Chain.Berachain | import("@tcswap/types").Chain.BinanceSmartChain | import("@tcswap/types").Chain.Bitcoin | import("@tcswap/types").Chain.Botanix | import("@tcswap/types").Chain.Core | import("@tcswap/types").Chain.Corn | import("@tcswap/types").Chain.Cronos | import("@tcswap/types").Chain.Ethereum | import("@tcswap/types").Chain.Gnosis | import("@tcswap/types").Chain.Hyperevm | import("@tcswap/types").Chain.Monad | import("@tcswap/types").Chain.Optimism | import("@tcswap/types").Chain.Polygon | import("@tcswap/types").Chain.Solana | import("@tcswap/types").Chain.Sonic | import("@tcswap/types").Chain.Unichain | import("@tcswap/types").Chain.XLayer)[];
+    };
+};
+export { bitgetWallet, coinbaseWallet, ctrlWallet, evmWallet, exodusWallet, keepkeyBexWallet, keepkeyWallet, keplrWallet, keystoreWallet, ledgerWallet, okxWallet, onekeyWallet, passkeysWallet, phantomWallet, polkadotWallet, radixWallet, talismanWallet, trezorWallet, tronlinkWallet, vultisigWallet, walletSelectorWallet, walletconnectWallet, xamanWallet, };
+export declare const defaultPlugins: {
+    garden: (pluginParams: import("@tcswap/plugins").SwapKitPluginParams) => {
+        supportedUSwapProviders: readonly [import("@tcswap/helpers").ProviderName.GARDEN];
+    } & {
+        approveAssetValue: ({ assetValue, spenderAddress }: {
+            spenderAddress: string;
+            assetValue: import("@tcswap/helpers").AssetValue;
+        }) => Promise<string> | Promise<boolean>;
+        isAssetValueApproved: ({ assetValue, spenderAddress }: {
+            spenderAddress: string;
+            assetValue: import("@tcswap/helpers").AssetValue;
+        }) => Promise<string> | Promise<boolean>;
+        swap: ({ route }: import("@tcswap/helpers").SwapParams<"garden", import("@tcswap/server").QuoteResponseRoute>) => Promise<string>;
+    };
+    near: (pluginParams: import("@tcswap/plugins").SwapKitPluginParams) => {
+        supportedUSwapProviders: readonly [import("@tcswap/helpers").ProviderName.NEAR];
+    } & {
+        nearNames: {
+            getInfo(name: string): Promise<import("@tcswap/plugins/near").NearAccountInfo | null>;
+            isAvailable(name: string): Promise<boolean>;
+            lookupNames(accountId: string): Promise<string[]>;
+            register(params: import("@tcswap/plugins/near").NearNameRegistrationParams): Promise<string>;
+            resolve(name: string): Promise<string | null>;
+            transfer(name: string, newOwner: string): Promise<string>;
+        };
+        swap(swapParams: import("@tcswap/helpers").SwapParams<"near", import("@tcswap/server").QuoteResponseRoute>): Promise<any>;
+    };
+    solana: (pluginParams: import("@tcswap/plugins").SwapKitPluginParams) => {
+        supportedUSwapProviders: readonly [import("@tcswap/helpers").ProviderName.JUPITER];
+    } & {
+        swap: ({ route }: import("@tcswap/helpers").SwapParams<"solana", import("@tcswap/server").QuoteResponseRoute>) => Promise<string>;
+    };
+    radix: (pluginParams: import("@tcswap/plugins").SwapKitPluginParams) => {
+        supportedUSwapProviders: readonly [import("@tcswap/helpers").ProviderName.CAVIAR_V1];
+    } & {
+        swap: ({ route: { tx, sellAmount, sellAsset } }: import("@tcswap/helpers").SwapParams<"radix", import("@tcswap/server").QuoteResponseRoute>) => Promise<string>;
+    };
+    thorchain: (pluginParams: import("@tcswap/plugins").SwapKitPluginParams) => {
+        supportedUSwapProviders: readonly [import("@tcswap/helpers").ProviderName.THORCHAIN, import("@tcswap/helpers").ProviderName.THORCHAIN_STREAMING];
+    } & {
+        addLiquidity: ({ baseAssetValue, assetValue, baseAssetAddr, assetAddr, isPendingSymmAsset, mode, }: import("@tcswap/plugins").AddLiquidityParams) => Promise<{
+            assetTx: string | undefined;
+            baseAssetTx: string | undefined;
+        }>;
+        addLiquidityPart: ({ assetValue, poolAddress, address, symmetric }: import("@tcswap/plugins").AddLiquidityPartParams) => Promise<string>;
+        approveAssetValue: ({ assetValue }: {
+            assetValue: import("@tcswap/helpers").AssetValue;
+        }) => Promise<string | boolean | Promise<string>>;
+        claimTcy: ({ chain, thorAddress }: {
+            chain: import("@tcswap/types").Chain;
+            thorAddress: string;
+        }) => Promise<string>;
+        createLiquidity: ({ baseAssetValue, assetValue }: import("@tcswap/plugins").CreateLiquidityParams) => Promise<{
+            assetTx: string | undefined;
+            baseAssetTx: string | undefined;
+        }>;
+        deposit: ({ assetValue, recipient, router, ...rest }: import("@tcswap/plugins").CoreTxParams & {
+            router?: string;
+        }) => Promise<string>;
+        depositToPool: ({ assetValue, memo, feeOptionKey, }: {
+            assetValue: import("@tcswap/helpers").AssetValue;
+            memo: string;
+            feeOptionKey?: import("@tcswap/helpers").FeeOption;
+        }) => Promise<string>;
+        getInboundDataByChain: <T extends import("@tcswap/types").Chain>(chain: T) => Promise<import("@tcswap/server").InboundAddressesItem>;
+        isAssetValueApproved: ({ assetValue }: {
+            assetValue: import("@tcswap/helpers").AssetValue;
+        }) => Promise<string | boolean | Promise<boolean>>;
+        nodeAction: ({ type, assetValue, address }: import("@tcswap/plugins").NodeActionParams) => Promise<string>;
+        registerName: ({ assetValue, ...params }: import("@tcswap/plugins").RegisterThornameParams) => Promise<string>;
+        registerPreferredAsset: ({ assetValue, payoutAddress, name, ownerAddress, }: {
+            assetValue: import("@tcswap/helpers").AssetValue;
+            payoutAddress?: string;
+            name: string;
+            ownerAddress: string;
+        }) => Promise<string>;
+        stakeTcyAction: (params: {
+            type: "unstake";
+            unstakeBps: number;
+        } | {
+            type: "stake";
+            assetValue: import("@tcswap/helpers").AssetValue;
+        }) => Promise<string>;
+        swap: ({ feeOptionKey, route }: import("@tcswap/helpers").SwapParams<"thorchain" | "mayachain", import("@tcswap/server").QuoteResponseRoute>) => Promise<string>;
+        withdraw: ({ memo, assetValue, percent, from, to }: import("@tcswap/plugins").WithdrawParams) => Promise<string>;
+    };
+    mayachain: (pluginParams: import("@tcswap/plugins").SwapKitPluginParams) => {
+        supportedUSwapProviders: readonly [import("@tcswap/helpers").ProviderName.MAYACHAIN, import("@tcswap/helpers").ProviderName.MAYACHAIN_STREAMING];
+    } & {
+        addLiquidity: ({ baseAssetValue, assetValue, baseAssetAddr, assetAddr, isPendingSymmAsset, mode, }: import("@tcswap/plugins").AddLiquidityParams) => Promise<{
+            assetTx: string | undefined;
+            baseAssetTx: string | undefined;
+        }>;
+        addLiquidityPart: ({ assetValue, poolAddress, address, symmetric }: import("@tcswap/plugins").AddLiquidityPartParams) => Promise<string>;
+        approveAssetValue: ({ assetValue }: {
+            assetValue: import("@tcswap/helpers").AssetValue;
+        }) => Promise<string | boolean | Promise<string>>;
+        claimTcy: ({ chain, thorAddress }: {
+            chain: import("@tcswap/types").Chain;
+            thorAddress: string;
+        }) => Promise<string>;
+        createLiquidity: ({ baseAssetValue, assetValue }: import("@tcswap/plugins").CreateLiquidityParams) => Promise<{
+            assetTx: string | undefined;
+            baseAssetTx: string | undefined;
+        }>;
+        deposit: ({ assetValue, recipient, router, ...rest }: import("@tcswap/plugins").CoreTxParams & {
+            router?: string;
+        }) => Promise<string>;
+        depositToPool: ({ assetValue, memo, feeOptionKey, }: {
+            assetValue: import("@tcswap/helpers").AssetValue;
+            memo: string;
+            feeOptionKey?: import("@tcswap/helpers").FeeOption;
+        }) => Promise<string>;
+        getInboundDataByChain: <T extends import("@tcswap/types").Chain>(chain: T) => Promise<import("@tcswap/server").InboundAddressesItem>;
+        isAssetValueApproved: ({ assetValue }: {
+            assetValue: import("@tcswap/helpers").AssetValue;
+        }) => Promise<string | boolean | Promise<boolean>>;
+        nodeAction: ({ type, assetValue, address }: import("@tcswap/plugins").NodeActionParams) => Promise<string>;
+        registerName: ({ assetValue, ...params }: import("@tcswap/plugins").RegisterThornameParams) => Promise<string>;
+        registerPreferredAsset: ({ assetValue, payoutAddress, name, ownerAddress, }: {
+            assetValue: import("@tcswap/helpers").AssetValue;
+            payoutAddress?: string;
+            name: string;
+            ownerAddress: string;
+        }) => Promise<string>;
+        stakeTcyAction: (params: {
+            type: "unstake";
+            unstakeBps: number;
+        } | {
+            type: "stake";
+            assetValue: import("@tcswap/helpers").AssetValue;
+        }) => Promise<string>;
+        swap: ({ feeOptionKey, route }: import("@tcswap/helpers").SwapParams<"thorchain" | "mayachain", import("@tcswap/server").QuoteResponseRoute>) => Promise<string>;
+        withdraw: ({ memo, assetValue, percent, from, to }: import("@tcswap/plugins").WithdrawParams) => Promise<string>;
+    };
+    evm: (pluginParams: import("@tcswap/plugins").SwapKitPluginParams) => {
+        supportedUSwapProviders: readonly [import("@tcswap/helpers").ProviderName.CAMELOT_V3, import("@tcswap/helpers").ProviderName.OPENOCEAN_V2, import("@tcswap/helpers").ProviderName.OKX, import("@tcswap/helpers").ProviderName.ONEINCH, import("@tcswap/helpers").ProviderName.PANCAKESWAP, import("@tcswap/helpers").ProviderName.PANGOLIN_V1, import("@tcswap/helpers").ProviderName.SUSHISWAP_V2, import("@tcswap/helpers").ProviderName.TRADERJOE_V2, import("@tcswap/helpers").ProviderName.UNISWAP_V2, import("@tcswap/helpers").ProviderName.UNISWAP_V3];
+    } & {
+        approveAssetValue: ({ assetValue, spenderAddress }: {
+            spenderAddress: string;
+            assetValue: import("@tcswap/helpers").AssetValue;
+        }) => Promise<string> | Promise<boolean>;
+        isAssetValueApproved: ({ assetValue, spenderAddress }: {
+            spenderAddress: string;
+            assetValue: import("@tcswap/helpers").AssetValue;
+        }) => Promise<string> | Promise<boolean>;
+        swap: ({ route: { tx, sellAsset }, feeOptionKey }: import("@tcswap/helpers").SwapParams<"evm", import("@tcswap/server").QuoteResponseRoute>) => Promise<string>;
+    };
+    chainflip: (pluginParams: import("@tcswap/plugins").SwapKitPluginParams) => {
+        supportedUSwapProviders: readonly [import("@tcswap/helpers").ProviderName.CHAINFLIP, import("@tcswap/helpers").ProviderName.CHAINFLIP_STREAMING];
+    } & {
+        swap: (swapParams: import("@tcswap/plugins").RequestSwapDepositAddressParams) => Promise<any>;
+    };
+};
+export declare const defaultWallets: ReturnType<typeof createWallet>;
+export declare function createUSwap<Plugins extends ReturnType<typeof createPlugin>, Wallets extends ReturnType<typeof createWallet>>({ config, plugins, wallets }?: {
+    config?: USwapConfigState;
+    plugins?: Plugins;
+    wallets?: Wallets;
+}): {
+    garden: {
+        supportedUSwapProviders: readonly [import("@tcswap/helpers").ProviderName.GARDEN];
+    } & {
+        approveAssetValue: ({ assetValue, spenderAddress }: {
+            spenderAddress: string;
+            assetValue: import("@tcswap/helpers").AssetValue;
+        }) => Promise<string> | Promise<boolean>;
+        isAssetValueApproved: ({ assetValue, spenderAddress }: {
+            spenderAddress: string;
+            assetValue: import("@tcswap/helpers").AssetValue;
+        }) => Promise<string> | Promise<boolean>;
+        swap: ({ route }: import("@tcswap/helpers").SwapParams<"garden", import("@tcswap/server").QuoteResponseRoute>) => Promise<string>;
+    };
+    near: {
+        supportedUSwapProviders: readonly [import("@tcswap/helpers").ProviderName.NEAR];
+    } & {
+        nearNames: {
+            getInfo(name: string): Promise<import("@tcswap/plugins/near").NearAccountInfo | null>;
+            isAvailable(name: string): Promise<boolean>;
+            lookupNames(accountId: string): Promise<string[]>;
+            register(params: import("@tcswap/plugins/near").NearNameRegistrationParams): Promise<string>;
+            resolve(name: string): Promise<string | null>;
+            transfer(name: string, newOwner: string): Promise<string>;
+        };
+        swap(swapParams: import("@tcswap/helpers").SwapParams<"near", import("@tcswap/server").QuoteResponseRoute>): Promise<any>;
+    };
+    solana: {
+        supportedUSwapProviders: readonly [import("@tcswap/helpers").ProviderName.JUPITER];
+    } & {
+        swap: ({ route }: import("@tcswap/helpers").SwapParams<"solana", import("@tcswap/server").QuoteResponseRoute>) => Promise<string>;
+    };
+    radix: {
+        supportedUSwapProviders: readonly [import("@tcswap/helpers").ProviderName.CAVIAR_V1];
+    } & {
+        swap: ({ route: { tx, sellAmount, sellAsset } }: import("@tcswap/helpers").SwapParams<"radix", import("@tcswap/server").QuoteResponseRoute>) => Promise<string>;
+    };
+    thorchain: {
+        supportedUSwapProviders: readonly [import("@tcswap/helpers").ProviderName.THORCHAIN, import("@tcswap/helpers").ProviderName.THORCHAIN_STREAMING];
+    } & {
+        addLiquidity: ({ baseAssetValue, assetValue, baseAssetAddr, assetAddr, isPendingSymmAsset, mode, }: import("@tcswap/plugins").AddLiquidityParams) => Promise<{
+            assetTx: string | undefined;
+            baseAssetTx: string | undefined;
+        }>;
+        addLiquidityPart: ({ assetValue, poolAddress, address, symmetric }: import("@tcswap/plugins").AddLiquidityPartParams) => Promise<string>;
+        approveAssetValue: ({ assetValue }: {
+            assetValue: import("@tcswap/helpers").AssetValue;
+        }) => Promise<string | boolean | Promise<string>>;
+        claimTcy: ({ chain, thorAddress }: {
+            chain: import("@tcswap/types").Chain;
+            thorAddress: string;
+        }) => Promise<string>;
+        createLiquidity: ({ baseAssetValue, assetValue }: import("@tcswap/plugins").CreateLiquidityParams) => Promise<{
+            assetTx: string | undefined;
+            baseAssetTx: string | undefined;
+        }>;
+        deposit: ({ assetValue, recipient, router, ...rest }: import("@tcswap/plugins").CoreTxParams & {
+            router?: string;
+        }) => Promise<string>;
+        depositToPool: ({ assetValue, memo, feeOptionKey, }: {
+            assetValue: import("@tcswap/helpers").AssetValue;
+            memo: string;
+            feeOptionKey?: import("@tcswap/helpers").FeeOption;
+        }) => Promise<string>;
+        getInboundDataByChain: <T extends import("@tcswap/types").Chain>(chain: T) => Promise<import("@tcswap/server").InboundAddressesItem>;
+        isAssetValueApproved: ({ assetValue }: {
+            assetValue: import("@tcswap/helpers").AssetValue;
+        }) => Promise<string | boolean | Promise<boolean>>;
+        nodeAction: ({ type, assetValue, address }: import("@tcswap/plugins").NodeActionParams) => Promise<string>;
+        registerName: ({ assetValue, ...params }: import("@tcswap/plugins").RegisterThornameParams) => Promise<string>;
+        registerPreferredAsset: ({ assetValue, payoutAddress, name, ownerAddress, }: {
+            assetValue: import("@tcswap/helpers").AssetValue;
+            payoutAddress?: string;
+            name: string;
+            ownerAddress: string;
+        }) => Promise<string>;
+        stakeTcyAction: (params: {
+            type: "unstake";
+            unstakeBps: number;
+        } | {
+            type: "stake";
+            assetValue: import("@tcswap/helpers").AssetValue;
+        }) => Promise<string>;
+        swap: ({ feeOptionKey, route }: import("@tcswap/helpers").SwapParams<"thorchain" | "mayachain", import("@tcswap/server").QuoteResponseRoute>) => Promise<string>;
+        withdraw: ({ memo, assetValue, percent, from, to }: import("@tcswap/plugins").WithdrawParams) => Promise<string>;
+    };
+    mayachain: {
+        supportedUSwapProviders: readonly [import("@tcswap/helpers").ProviderName.MAYACHAIN, import("@tcswap/helpers").ProviderName.MAYACHAIN_STREAMING];
+    } & {
+        addLiquidity: ({ baseAssetValue, assetValue, baseAssetAddr, assetAddr, isPendingSymmAsset, mode, }: import("@tcswap/plugins").AddLiquidityParams) => Promise<{
+            assetTx: string | undefined;
+            baseAssetTx: string | undefined;
+        }>;
+        addLiquidityPart: ({ assetValue, poolAddress, address, symmetric }: import("@tcswap/plugins").AddLiquidityPartParams) => Promise<string>;
+        approveAssetValue: ({ assetValue }: {
+            assetValue: import("@tcswap/helpers").AssetValue;
+        }) => Promise<string | boolean | Promise<string>>;
+        claimTcy: ({ chain, thorAddress }: {
+            chain: import("@tcswap/types").Chain;
+            thorAddress: string;
+        }) => Promise<string>;
+        createLiquidity: ({ baseAssetValue, assetValue }: import("@tcswap/plugins").CreateLiquidityParams) => Promise<{
+            assetTx: string | undefined;
+            baseAssetTx: string | undefined;
+        }>;
+        deposit: ({ assetValue, recipient, router, ...rest }: import("@tcswap/plugins").CoreTxParams & {
+            router?: string;
+        }) => Promise<string>;
+        depositToPool: ({ assetValue, memo, feeOptionKey, }: {
+            assetValue: import("@tcswap/helpers").AssetValue;
+            memo: string;
+            feeOptionKey?: import("@tcswap/helpers").FeeOption;
+        }) => Promise<string>;
+        getInboundDataByChain: <T extends import("@tcswap/types").Chain>(chain: T) => Promise<import("@tcswap/server").InboundAddressesItem>;
+        isAssetValueApproved: ({ assetValue }: {
+            assetValue: import("@tcswap/helpers").AssetValue;
+        }) => Promise<string | boolean | Promise<boolean>>;
+        nodeAction: ({ type, assetValue, address }: import("@tcswap/plugins").NodeActionParams) => Promise<string>;
+        registerName: ({ assetValue, ...params }: import("@tcswap/plugins").RegisterThornameParams) => Promise<string>;
+        registerPreferredAsset: ({ assetValue, payoutAddress, name, ownerAddress, }: {
+            assetValue: import("@tcswap/helpers").AssetValue;
+            payoutAddress?: string;
+            name: string;
+            ownerAddress: string;
+        }) => Promise<string>;
+        stakeTcyAction: (params: {
+            type: "unstake";
+            unstakeBps: number;
+        } | {
+            type: "stake";
+            assetValue: import("@tcswap/helpers").AssetValue;
+        }) => Promise<string>;
+        swap: ({ feeOptionKey, route }: import("@tcswap/helpers").SwapParams<"thorchain" | "mayachain", import("@tcswap/server").QuoteResponseRoute>) => Promise<string>;
+        withdraw: ({ memo, assetValue, percent, from, to }: import("@tcswap/plugins").WithdrawParams) => Promise<string>;
+    };
+    evm: {
+        supportedUSwapProviders: readonly [import("@tcswap/helpers").ProviderName.CAMELOT_V3, import("@tcswap/helpers").ProviderName.OPENOCEAN_V2, import("@tcswap/helpers").ProviderName.OKX, import("@tcswap/helpers").ProviderName.ONEINCH, import("@tcswap/helpers").ProviderName.PANCAKESWAP, import("@tcswap/helpers").ProviderName.PANGOLIN_V1, import("@tcswap/helpers").ProviderName.SUSHISWAP_V2, import("@tcswap/helpers").ProviderName.TRADERJOE_V2, import("@tcswap/helpers").ProviderName.UNISWAP_V2, import("@tcswap/helpers").ProviderName.UNISWAP_V3];
+    } & {
+        approveAssetValue: ({ assetValue, spenderAddress }: {
+            spenderAddress: string;
+            assetValue: import("@tcswap/helpers").AssetValue;
+        }) => Promise<string> | Promise<boolean>;
+        isAssetValueApproved: ({ assetValue, spenderAddress }: {
+            spenderAddress: string;
+            assetValue: import("@tcswap/helpers").AssetValue;
+        }) => Promise<string> | Promise<boolean>;
+        swap: ({ route: { tx, sellAsset }, feeOptionKey }: import("@tcswap/helpers").SwapParams<"evm", import("@tcswap/server").QuoteResponseRoute>) => Promise<string>;
+    };
+    chainflip: {
+        supportedUSwapProviders: readonly [import("@tcswap/helpers").ProviderName.CHAINFLIP, import("@tcswap/helpers").ProviderName.CHAINFLIP_STREAMING];
+    } & {
+        swap: (swapParams: import("@tcswap/plugins").RequestSwapDepositAddressParams) => Promise<any>;
+    };
+} & {
+    [x: string]: (...params: any[]) => Promise<boolean>;
+} & {
+    approveAssetValue: (assetValue: import("@tcswap/helpers").AssetValue, contractAddress: string) => Promise<string>;
+    disconnectAll: () => void;
+    disconnectChain: <T_1 extends import("@tcswap/types").Chain>(chain: T_1) => void;
+    estimateTransactionFee: <P extends "garden" | "near" | "solana" | "radix" | "thorchain" | "mayachain" | "evm" | "chainflip", T_1 extends "transfer" | "approve" | "swap">({ type, feeOptionKey, params, }: {
+        type: T_1;
+        params: {
+            transfer: import("@tcswap/server").EVMTransferParams | (import("@tcswap/helpers").GenericTransferParams & {
+                sender?: string;
+            });
+            approve: {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                contractAddress: string;
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            };
+            swap: import("@tcswap/helpers").GenericSwapParams<{
+                buyAsset: string;
+                expectedBuyAmount: string;
+                fees: {
+                    amount: string;
+                    asset: string;
+                    chain: string;
+                    protocol: import("@tcswap/helpers").ProviderName;
+                    type: import("@tcswap/helpers").FeeTypeEnum;
+                }[];
+                providers: import("@tcswap/helpers").ProviderName[];
+                sellAmount: string;
+                sellAsset: string;
+                destinationAddress?: string | undefined;
+                estimatedTime?: {
+                    total: number;
+                    inbound?: number | undefined;
+                    outbound?: number | undefined;
+                    swap?: number | undefined;
+                } | undefined;
+                expectedBuyAmountMaxSlippage?: string | undefined;
+                expiration?: string | undefined;
+                inboundAddress?: string | undefined;
+                legs?: {
+                    buyAmount: string;
+                    buyAmountMaxSlippage: string;
+                    buyAsset: string;
+                    provider: import("@tcswap/helpers").ProviderName;
+                    sellAmount: string;
+                    sellAsset: string;
+                    fees?: {
+                        amount: string;
+                        asset: string;
+                        chain: string;
+                        protocol: import("@tcswap/helpers").ProviderName;
+                        type: import("@tcswap/helpers").FeeTypeEnum;
+                    }[] | undefined;
+                }[] | undefined;
+                memo?: string | undefined;
+                meta?: {
+                    assets?: {
+                        asset: string;
+                        image: string;
+                        price: number;
+                    }[] | undefined;
+                    maxStreamingQuantity?: number | undefined;
+                    streamingInterval?: number | undefined;
+                    tags?: import("@tcswap/server").PriorityLabel[] | undefined;
+                    affiliate?: string | undefined;
+                    affiliateFee?: string | undefined;
+                    approvalAddress?: string | undefined;
+                    chainflip?: {
+                        destinationAddress: string;
+                        buyAsset: {
+                            asset: string;
+                            chain: string;
+                        };
+                        sellAsset: {
+                            asset: string;
+                            chain: string;
+                        };
+                        affiliateFees?: {
+                            brokerAddress: string;
+                            feeBps: number;
+                        }[] | undefined;
+                        brokerCommissionBps?: number | undefined;
+                        channelMetadata?: {
+                            cfParameters?: string | undefined;
+                            gasBudget?: string | undefined;
+                            message?: string | undefined;
+                        } | undefined;
+                        dcaParameters?: {
+                            chunkInterval?: number | undefined;
+                            numberOfChunks?: number | undefined;
+                        } | undefined;
+                        maxBoostFeeBps?: number | undefined;
+                        refundParameters?: {
+                            minPrice?: string | undefined;
+                            refundAddress?: string | undefined;
+                            retryDuration?: number | undefined;
+                        } | undefined;
+                    } | undefined;
+                    garden?: {
+                        destinationAddress: string;
+                        buyAsset: string;
+                        sellAmount: string;
+                        sellAsset: string;
+                        slippage: number;
+                        sourceAddress: string;
+                        affiliateFees?: {
+                            feeBps: number;
+                            nearId: string;
+                        } | undefined;
+                    } | undefined;
+                    near?: {
+                        destinationAddress: string;
+                        buyAsset: string;
+                        sellAmount: string;
+                        sellAsset: string;
+                        slippage: number;
+                        sourceAddress: string;
+                        affiliateFees?: {
+                            feeBps: number;
+                            nearId: string;
+                        } | undefined;
+                    } | undefined;
+                    priceImpact?: number | undefined;
+                    referrer?: string | undefined;
+                    txType?: import("@tcswap/server").RouteQuoteTxType | undefined;
+                } | undefined;
+                refundAddress?: string | undefined;
+                sourceAddress?: string | undefined;
+                targetAddress?: string | undefined;
+                tx?: string | {
+                    data: string;
+                    from: string;
+                    to: string;
+                    value: string;
+                } | {
+                    accountNumber: number;
+                    chainId: import("@tcswap/types").ChainId;
+                    fee: {
+                        amount: {
+                            amount: string;
+                            denom: string;
+                        }[];
+                        gas: string;
+                    };
+                    memo: string;
+                    msgs: {
+                        typeUrl: string;
+                        value: unknown;
+                    }[];
+                    sequence: number;
+                } | undefined;
+                txType?: import("@tcswap/server").RouteQuoteTxType | undefined;
+                warnings?: {
+                    code: import("@tcswap/helpers").WarningCodeEnum;
+                    display: string;
+                    tooltip?: string | undefined;
+                }[] | undefined;
+            }> & {
+                pluginName?: P | undefined;
+            } & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+            };
+        }[T_1];
+        feeOptionKey: import("@tcswap/helpers").FeeOption;
+    }) => Promise<import("@tcswap/helpers").AssetValue | undefined>;
+    getAddress: <T_1 extends import("@tcswap/types").Chain>(chain: T_1) => string;
+    getAllWallets: () => {
+        ARB: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Arbitrum> & {
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/server").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/server").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/server").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/server").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+            createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+            createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").CallParams) => Promise<import("ethers").ContractTransaction>;
+            createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/server").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/server").EVMTransferParams & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@tcswap/server").EVMTxParams;
+                data?: string;
+            }) => Promise<bigint>;
+            estimateGasPrices: () => Promise<{ [key_2 in import("@tcswap/helpers").FeeOption]: {
+                l1GasPrice?: bigint;
+                gasPrice?: bigint;
+                maxFeePerGas?: bigint;
+                maxPriorityFeePerGas?: bigint;
+            }; }>;
+            estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/server").EIP1559TxParams & {
+                feeOption: import("@tcswap/helpers").FeeOption;
+                chain: import("@tcswap/types").EVMChain;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string> | undefined;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
+            isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/server").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/server").EVMTxParams & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            }) => Promise<string>;
+            signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/server").EVMTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        AURORA: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Aurora> & {
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/server").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/server").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/server").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/server").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+            createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+            createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").CallParams) => Promise<import("ethers").ContractTransaction>;
+            createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/server").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/server").EVMTransferParams & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@tcswap/server").EVMTxParams;
+                data?: string;
+            }) => Promise<bigint>;
+            estimateGasPrices: () => Promise<{ [key_2 in import("@tcswap/helpers").FeeOption]: {
+                l1GasPrice?: bigint;
+                gasPrice?: bigint;
+                maxFeePerGas?: bigint;
+                maxPriorityFeePerGas?: bigint;
+            }; }>;
+            estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/server").EIP1559TxParams & {
+                feeOption: import("@tcswap/helpers").FeeOption;
+                chain: import("@tcswap/types").EVMChain;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string> | undefined;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
+            isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/server").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/server").EVMTxParams & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            }) => Promise<string>;
+            signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/server").EVMTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        AVAX: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Avalanche> & {
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/server").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/server").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/server").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/server").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+            createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+            createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").CallParams) => Promise<import("ethers").ContractTransaction>;
+            createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/server").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/server").EVMTransferParams & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@tcswap/server").EVMTxParams;
+                data?: string;
+            }) => Promise<bigint>;
+            estimateGasPrices: () => Promise<{ [key_2 in import("@tcswap/helpers").FeeOption]: {
+                l1GasPrice?: bigint;
+                gasPrice?: bigint;
+                maxFeePerGas?: bigint;
+                maxPriorityFeePerGas?: bigint;
+            }; }>;
+            estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/server").EIP1559TxParams & {
+                feeOption: import("@tcswap/helpers").FeeOption;
+                chain: import("@tcswap/types").EVMChain;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string> | undefined;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
+            isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/server").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/server").EVMTxParams & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            }) => Promise<string>;
+            signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/server").EVMTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        BASE: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Base> & {
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/server").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/server").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/server").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/server").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+            createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+            createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").CallParams) => Promise<import("ethers").ContractTransaction>;
+            createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/server").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/server").EVMTransferParams & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@tcswap/server").EVMTxParams;
+                data?: string;
+            }) => Promise<bigint>;
+            estimateGasPrices: () => Promise<{ [key_2 in import("@tcswap/helpers").FeeOption]: {
+                l1GasPrice?: bigint;
+                gasPrice?: bigint;
+                maxFeePerGas?: bigint;
+                maxPriorityFeePerGas?: bigint;
+            }; }>;
+            estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/server").EIP1559TxParams & {
+                feeOption: import("@tcswap/helpers").FeeOption;
+                chain: import("@tcswap/types").EVMChain;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string> | undefined;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
+            isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/server").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/server").EVMTxParams & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            }) => Promise<string>;
+            signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/server").EVMTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        BERA: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Berachain> & {
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/server").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/server").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/server").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/server").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+            createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+            createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").CallParams) => Promise<import("ethers").ContractTransaction>;
+            createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/server").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/server").EVMTransferParams & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@tcswap/server").EVMTxParams;
+                data?: string;
+            }) => Promise<bigint>;
+            estimateGasPrices: () => Promise<{ [key_2 in import("@tcswap/helpers").FeeOption]: {
+                l1GasPrice?: bigint;
+                gasPrice?: bigint;
+                maxFeePerGas?: bigint;
+                maxPriorityFeePerGas?: bigint;
+            }; }>;
+            estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/server").EIP1559TxParams & {
+                feeOption: import("@tcswap/helpers").FeeOption;
+                chain: import("@tcswap/types").EVMChain;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string> | undefined;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
+            isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/server").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/server").EVMTxParams & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            }) => Promise<string>;
+            signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/server").EVMTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        BSC: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.BinanceSmartChain> & {
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/server").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/server").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/server").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/server").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+            createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+            createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").CallParams) => Promise<import("ethers").ContractTransaction>;
+            createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/server").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/server").EVMTransferParams & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@tcswap/server").EVMTxParams;
+                data?: string;
+            }) => Promise<bigint>;
+            estimateGasPrices: () => Promise<{ [key_2 in import("@tcswap/helpers").FeeOption]: {
+                l1GasPrice?: bigint;
+                gasPrice?: bigint;
+                maxFeePerGas?: bigint;
+                maxPriorityFeePerGas?: bigint;
+            }; }>;
+            estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/server").EIP1559TxParams & {
+                feeOption: import("@tcswap/helpers").FeeOption;
+                chain: import("@tcswap/types").EVMChain;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string> | undefined;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
+            isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/server").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/server").EVMTxParams & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            }) => Promise<string>;
+            signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/server").EVMTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        BTC: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Bitcoin> & {
+            accumulative: typeof import("@tcswap/server").accumulative;
+            broadcastTx: (txHash: string) => Promise<string>;
+            calculateTxSize: ({ inputs, outputs, feeRate }: import("@tcswap/server").UTXOCalculateTxSizeParams) => number;
+            createKeysForPath: (params: {
+                wif?: string;
+                phrase?: string;
+                derivationPath?: string;
+            }) => import("ecpair").ECPairInterface;
+            createTransaction: ({ assetValue, recipient, memo, feeRate, sender, fetchTxHex, }: import("@tcswap/server").UTXOBuildTxParams) => Promise<{
+                psbt: import("bitcoinjs-lib").Psbt;
+                utxos: import("@tcswap/server").UTXOType[];
+                inputs: import("@tcswap/server").UTXOType[];
+            }>;
+            estimateMaxSendableAmount: ({ from, memo, feeRate, feeOptionKey, recipients, }: {
+                from: string;
+                memo?: string;
+                feeRate?: number;
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+                recipients?: number | import("@tcswap/server").TargetOutput[];
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            estimateTransactionFee: (params: {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                recipient: string;
+                sender: string;
+                memo?: string;
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+                feeRate?: number;
+                fetchTxHex?: boolean;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => Promise<string | undefined>;
+            getAddressFromKeys: (keys: import("ecpair").ECPairInterface | import("@tcswap/server").BchECPair) => string;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getFeeRates: () => Promise<{
+                average: number;
+                fast: number;
+                fastest: number;
+            }>;
+            getInputsOutputsFee: ({ assetValue, feeOptionKey, feeRate, memo, sender, recipient, }: Omit<import("@tcswap/server").UTXOBuildTxParams, "feeRate"> & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+                feeRate?: number;
+            }) => Promise<{
+                fee: number;
+                inputs: (import("@tcswap/server").UTXOType | import("@tcswap/server").UTXOInputWithScriptType)[];
+                outputs: import("@tcswap/server").TargetOutput[];
+            } | {
+                fee: number;
+                inputs?: undefined;
+                outputs?: undefined;
+            }>;
+            getPrivateKeyFromMnemonic: (params: {
+                phrase: string;
+                derivationPath: string;
+            }) => string;
+            transfer: ({ memo, recipient, feeOptionKey, feeRate, assetValue }: import("@tcswap/server").UTXOTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        BCH: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.BitcoinCash> & {
+            broadcastTx: (txHash: string) => Promise<string>;
+            buildTx: ({ assetValue, recipient, memo, feeRate, sender, setSigHashType, }: import("@tcswap/server").UTXOBuildTxParams & {
+                setSigHashType?: boolean;
+            }) => Promise<{
+                inputs: import("@tcswap/server").UTXOType[];
+                psbt: import("bitcoinjs-lib").Psbt;
+                utxos: {
+                    address: string;
+                    hash: string;
+                    index: number;
+                    txHex: string | undefined;
+                    value: number;
+                    witnessUtxo: {
+                        script: Buffer<ArrayBuffer>;
+                        value: number;
+                    };
+                }[];
+            }>;
+            createTransaction: ({ assetValue, recipient, memo, feeRate, sender }: import("@tcswap/server").UTXOBuildTxParams) => Promise<{
+                builder: import("@tcswap/server").TransactionBuilderType;
+                utxos: (import("@tcswap/server").UTXOType | import("@tcswap/server").UTXOInputWithScriptType)[];
+            }>;
+            getAddress: () => Promise<string | undefined>;
+            getAddressFromKeys: (keys: {
+                getAddress: (index?: number) => string;
+            }) => string;
+            getBalance: (address: string, _scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getFeeRates: () => Promise<{
+                average: number;
+                fast: number;
+                fastest: number;
+            }>;
+            stripPrefix: typeof import("@tcswap/server").stripPrefix;
+            stripToCashAddress: typeof import("@tcswap/server").stripToCashAddress;
+            transfer: ({ recipient, assetValue, feeOptionKey, ...rest }: import("@tcswap/server").UTXOTransferParams) => Promise<string>;
+            validateAddress: typeof import("@tcswap/server").bchValidateAddress;
+            accumulative: typeof import("@tcswap/server").accumulative;
+            calculateTxSize: ({ inputs, outputs, feeRate }: import("@tcswap/server").UTXOCalculateTxSizeParams) => number;
+            createKeysForPath: (params: {
+                wif?: string;
+                phrase?: string;
+                derivationPath?: string;
+            }) => import("@tcswap/server").BchECPair;
+            estimateMaxSendableAmount: ({ from, memo, feeRate, feeOptionKey, recipients, }: {
+                from: string;
+                memo?: string;
+                feeRate?: number;
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+                recipients?: number | import("@tcswap/server").TargetOutput[];
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            estimateTransactionFee: (params: {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                recipient: string;
+                sender: string;
+                memo?: string;
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+                feeRate?: number;
+                fetchTxHex?: boolean;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getInputsOutputsFee: ({ assetValue, feeOptionKey, feeRate, memo, sender, recipient, }: Omit<import("@tcswap/server").UTXOBuildTxParams, "feeRate"> & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+                feeRate?: number;
+            }) => Promise<{
+                fee: number;
+                inputs: (import("@tcswap/server").UTXOType | import("@tcswap/server").UTXOInputWithScriptType)[];
+                outputs: import("@tcswap/server").TargetOutput[];
+            } | {
+                fee: number;
+                inputs?: undefined;
+                outputs?: undefined;
+            }>;
+            getPrivateKeyFromMnemonic: (params: {
+                phrase: string;
+                derivationPath: string;
+            }) => string;
+        };
+        BOTANIX: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Botanix> & {
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/server").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/server").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/server").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/server").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+            createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+            createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").CallParams) => Promise<import("ethers").ContractTransaction>;
+            createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/server").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/server").EVMTransferParams & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@tcswap/server").EVMTxParams;
+                data?: string;
+            }) => Promise<bigint>;
+            estimateGasPrices: () => Promise<{ [key_2 in import("@tcswap/helpers").FeeOption]: {
+                l1GasPrice?: bigint;
+                gasPrice?: bigint;
+                maxFeePerGas?: bigint;
+                maxPriorityFeePerGas?: bigint;
+            }; }>;
+            estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/server").EIP1559TxParams & {
+                feeOption: import("@tcswap/helpers").FeeOption;
+                chain: import("@tcswap/types").EVMChain;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string> | undefined;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
+            isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/server").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/server").EVMTxParams & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            }) => Promise<string>;
+            signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/server").EVMTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        ADA: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Cardano> & {
+            createTransaction: ({ recipient, assetValue, memo, }: {
+                recipient: string;
+                assetValue: import("@tcswap/helpers").AssetValue;
+                memo?: string;
+            }) => Promise<{
+                tx: import("@meshsdk/core").Transaction;
+                unsignedTx: string;
+            }>;
+            estimateTransactionFee: () => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string;
+            getBalance: (addressParam?: string) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            signTransaction: (txParams: string) => Promise<string>;
+            transfer: ({ recipient, assetValue, memo, }: {
+                recipient: string;
+                assetValue: import("@tcswap/helpers").AssetValue;
+                memo?: string;
+            }) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        FLIP: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Chainflip> & {
+            api: import("@polkadot/api").ApiPromise;
+            broadcast: (tx: import("@polkadot/api/types").SubmittableExtrinsic<"promise">, callback?: import("@polkadot/types/types").Callback<import("@polkadot/types/types").ISubmittableResult>) => Promise<string | (() => void)>;
+            convertAddress: (address: string, newPrefix: number) => string;
+            createKeyring: (phrase: string) => Promise<import("@polkadot/keyring/types").KeyringPair>;
+            createTransaction: (params: import("@tcswap/helpers").GenericCreateTransactionParams) => import("@polkadot/api/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | undefined;
+            decodeAddress: (address: string, networkPrefix?: number) => Uint8Array<ArrayBufferLike>;
+            encodeAddress: (address: Uint8Array, encoding?: "ss58" | "hex", networkPrefix?: number) => string;
+            estimateTransactionFee: (params: import("@tcswap/server").SubstrateTransferParams) => Promise<import("@tcswap/helpers").AssetValue | undefined>;
+            gasAsset: import("@tcswap/helpers").AssetValue;
+            getAddress: (keyring?: import("@polkadot/types/types").IKeyringPair | import("@polkadot/types/types").Signer) => string | undefined;
+            getBalance: (address: string) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            network: import("@tcswap/server").SubstrateNetwork;
+            sign: (tx: import("@polkadot/api/types").SubmittableExtrinsic<"promise">) => Promise<import("@polkadot/api/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+            signAndBroadcast: ({ tx, callback, address, }: {
+                tx: import("@polkadot/api/types").SubmittableExtrinsic<"promise">;
+                callback?: import("@polkadot/types/types").Callback<import("@polkadot/types/types").ISubmittableResult>;
+                address?: string;
+            }) => string | Promise<string> | Promise<() => void>;
+            transfer: (params: import("@tcswap/server").SubstrateTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        CORE: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Core> & {
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/server").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/server").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/server").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/server").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+            createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+            createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").CallParams) => Promise<import("ethers").ContractTransaction>;
+            createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/server").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/server").EVMTransferParams & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@tcswap/server").EVMTxParams;
+                data?: string;
+            }) => Promise<bigint>;
+            estimateGasPrices: () => Promise<{ [key_2 in import("@tcswap/helpers").FeeOption]: {
+                l1GasPrice?: bigint;
+                gasPrice?: bigint;
+                maxFeePerGas?: bigint;
+                maxPriorityFeePerGas?: bigint;
+            }; }>;
+            estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/server").EIP1559TxParams & {
+                feeOption: import("@tcswap/helpers").FeeOption;
+                chain: import("@tcswap/types").EVMChain;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string> | undefined;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
+            isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/server").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/server").EVMTxParams & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            }) => Promise<string>;
+            signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/server").EVMTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        CORN: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Corn> & {
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/server").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/server").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/server").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/server").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+            createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+            createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").CallParams) => Promise<import("ethers").ContractTransaction>;
+            createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/server").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/server").EVMTransferParams & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@tcswap/server").EVMTxParams;
+                data?: string;
+            }) => Promise<bigint>;
+            estimateGasPrices: () => Promise<{ [key_2 in import("@tcswap/helpers").FeeOption]: {
+                l1GasPrice?: bigint;
+                gasPrice?: bigint;
+                maxFeePerGas?: bigint;
+                maxPriorityFeePerGas?: bigint;
+            }; }>;
+            estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/server").EIP1559TxParams & {
+                feeOption: import("@tcswap/helpers").FeeOption;
+                chain: import("@tcswap/types").EVMChain;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string> | undefined;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
+            isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/server").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/server").EVMTxParams & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            }) => Promise<string>;
+            signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/server").EVMTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        GAIA: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Cosmos> & {
+            createPrivateKeyFromPhrase: (phrase: string) => Promise<Uint8Array<ArrayBufferLike>>;
+            createTransaction: typeof import("@tcswap/server").cosmosCreateTransaction;
+            fetchFeeRateFromSwapKit: typeof import("@tcswap/server").fetchFeeRateFromSwapKit;
+            getAccount: (address: string) => Promise<import("@cosmjs/stargate/build").Account | null>;
+            getAddress: () => Promise<string | undefined>;
+            getBalance: (address: string, _potentialScamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getBalanceAsDenoms: (address: string) => Promise<{
+                denom: string;
+                amount: string;
+            }[]>;
+            getFees: () => Promise<{
+                average: import("@tcswap/helpers").USwapNumber;
+                fast: import("@tcswap/helpers").USwapNumber;
+                fastest: import("@tcswap/helpers").USwapNumber;
+            }>;
+            getPubKey: () => Promise<string>;
+            getSignerFromPhrase: ({ phrase, derivationPath }: {
+                phrase: string;
+                derivationPath: import("@tcswap/helpers").DerivationPathArray;
+            }) => Promise<import("@cosmjs/proto-signing/build").DirectSecp256k1HdWallet>;
+            getSignerFromPrivateKey: (privateKey: Uint8Array) => Promise<import("@cosmjs/proto-signing/build").DirectSecp256k1Wallet>;
+            signTransaction: ({ recipient, assetValue, memo, feeRate, feeOptionKey, }: import("@tcswap/helpers").GenericTransferParams) => Promise<string>;
+            transfer: ({ recipient, assetValue, memo, feeRate, feeOptionKey, dryRun, }: import("@tcswap/helpers").GenericTransferParams & {
+                dryRun?: boolean;
+            }) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+            verifySignature: ({ signature, message, address, }: {
+                signature: string;
+                message: string;
+                address: string;
+            }) => Promise<boolean>;
+        };
+        CRO: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Cronos> & {
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/server").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/server").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/server").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/server").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+            createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+            createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").CallParams) => Promise<import("ethers").ContractTransaction>;
+            createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/server").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/server").EVMTransferParams & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@tcswap/server").EVMTxParams;
+                data?: string;
+            }) => Promise<bigint>;
+            estimateGasPrices: () => Promise<{ [key_2 in import("@tcswap/helpers").FeeOption]: {
+                l1GasPrice?: bigint;
+                gasPrice?: bigint;
+                maxFeePerGas?: bigint;
+                maxPriorityFeePerGas?: bigint;
+            }; }>;
+            estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/server").EIP1559TxParams & {
+                feeOption: import("@tcswap/helpers").FeeOption;
+                chain: import("@tcswap/types").EVMChain;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string> | undefined;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
+            isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/server").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/server").EVMTxParams & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            }) => Promise<string>;
+            signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/server").EVMTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        DASH: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Dash> & {
+            accumulative: typeof import("@tcswap/server").accumulative;
+            broadcastTx: (txHash: string) => Promise<string>;
+            calculateTxSize: ({ inputs, outputs, feeRate }: import("@tcswap/server").UTXOCalculateTxSizeParams) => number;
+            createKeysForPath: (params: {
+                wif?: string;
+                phrase?: string;
+                derivationPath?: string;
+            }) => import("ecpair").ECPairInterface;
+            createTransaction: ({ assetValue, recipient, memo, feeRate, sender, fetchTxHex, }: import("@tcswap/server").UTXOBuildTxParams) => Promise<{
+                psbt: import("bitcoinjs-lib").Psbt;
+                utxos: import("@tcswap/server").UTXOType[];
+                inputs: import("@tcswap/server").UTXOType[];
+            }>;
+            estimateMaxSendableAmount: ({ from, memo, feeRate, feeOptionKey, recipients, }: {
+                from: string;
+                memo?: string;
+                feeRate?: number;
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+                recipients?: number | import("@tcswap/server").TargetOutput[];
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            estimateTransactionFee: (params: {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                recipient: string;
+                sender: string;
+                memo?: string;
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+                feeRate?: number;
+                fetchTxHex?: boolean;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => Promise<string | undefined>;
+            getAddressFromKeys: (keys: import("ecpair").ECPairInterface | import("@tcswap/server").BchECPair) => string;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getFeeRates: () => Promise<{
+                average: number;
+                fast: number;
+                fastest: number;
+            }>;
+            getInputsOutputsFee: ({ assetValue, feeOptionKey, feeRate, memo, sender, recipient, }: Omit<import("@tcswap/server").UTXOBuildTxParams, "feeRate"> & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+                feeRate?: number;
+            }) => Promise<{
+                fee: number;
+                inputs: (import("@tcswap/server").UTXOType | import("@tcswap/server").UTXOInputWithScriptType)[];
+                outputs: import("@tcswap/server").TargetOutput[];
+            } | {
+                fee: number;
+                inputs?: undefined;
+                outputs?: undefined;
+            }>;
+            getPrivateKeyFromMnemonic: (params: {
+                phrase: string;
+                derivationPath: string;
+            }) => string;
+            transfer: ({ memo, recipient, feeOptionKey, feeRate, assetValue }: import("@tcswap/server").UTXOTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        DOGE: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Dogecoin> & {
+            accumulative: typeof import("@tcswap/server").accumulative;
+            broadcastTx: (txHash: string) => Promise<string>;
+            calculateTxSize: ({ inputs, outputs, feeRate }: import("@tcswap/server").UTXOCalculateTxSizeParams) => number;
+            createKeysForPath: (params: {
+                wif?: string;
+                phrase?: string;
+                derivationPath?: string;
+            }) => import("ecpair").ECPairInterface;
+            createTransaction: ({ assetValue, recipient, memo, feeRate, sender, fetchTxHex, }: import("@tcswap/server").UTXOBuildTxParams) => Promise<{
+                psbt: import("bitcoinjs-lib").Psbt;
+                utxos: import("@tcswap/server").UTXOType[];
+                inputs: import("@tcswap/server").UTXOType[];
+            }>;
+            estimateMaxSendableAmount: ({ from, memo, feeRate, feeOptionKey, recipients, }: {
+                from: string;
+                memo?: string;
+                feeRate?: number;
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+                recipients?: number | import("@tcswap/server").TargetOutput[];
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            estimateTransactionFee: (params: {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                recipient: string;
+                sender: string;
+                memo?: string;
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+                feeRate?: number;
+                fetchTxHex?: boolean;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => Promise<string | undefined>;
+            getAddressFromKeys: (keys: import("ecpair").ECPairInterface | import("@tcswap/server").BchECPair) => string;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getFeeRates: () => Promise<{
+                average: number;
+                fast: number;
+                fastest: number;
+            }>;
+            getInputsOutputsFee: ({ assetValue, feeOptionKey, feeRate, memo, sender, recipient, }: Omit<import("@tcswap/server").UTXOBuildTxParams, "feeRate"> & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+                feeRate?: number;
+            }) => Promise<{
+                fee: number;
+                inputs: (import("@tcswap/server").UTXOType | import("@tcswap/server").UTXOInputWithScriptType)[];
+                outputs: import("@tcswap/server").TargetOutput[];
+            } | {
+                fee: number;
+                inputs?: undefined;
+                outputs?: undefined;
+            }>;
+            getPrivateKeyFromMnemonic: (params: {
+                phrase: string;
+                derivationPath: string;
+            }) => string;
+            transfer: ({ memo, recipient, feeOptionKey, feeRate, assetValue }: import("@tcswap/server").UTXOTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        ETH: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Ethereum> & {
+            multicall: (callTuples: {
+                address: string;
+                data: string;
+            }[], multicallAddress?: string, funcName?: string, feeOptionKey?: import("@tcswap/helpers").FeeOption) => Promise<string>;
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/server").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/server").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/server").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/server").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+            createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+            createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").CallParams) => Promise<import("ethers").ContractTransaction>;
+            createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/server").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/server").EVMTransferParams & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@tcswap/server").EVMTxParams;
+                data?: string;
+            }) => Promise<bigint>;
+            estimateGasPrices: () => Promise<{ [key_2 in import("@tcswap/helpers").FeeOption]: {
+                l1GasPrice?: bigint;
+                gasPrice?: bigint;
+                maxFeePerGas?: bigint;
+                maxPriorityFeePerGas?: bigint;
+            }; }>;
+            estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/server").EIP1559TxParams & {
+                feeOption: import("@tcswap/helpers").FeeOption;
+                chain: import("@tcswap/types").EVMChain;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string> | undefined;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
+            isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/server").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/server").EVMTxParams & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            }) => Promise<string>;
+            signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/server").EVMTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        GNO: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Gnosis> & {
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/server").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/server").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/server").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/server").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+            createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+            createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").CallParams) => Promise<import("ethers").ContractTransaction>;
+            createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/server").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/server").EVMTransferParams & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@tcswap/server").EVMTxParams;
+                data?: string;
+            }) => Promise<bigint>;
+            estimateGasPrices: () => Promise<{ [key_2 in import("@tcswap/helpers").FeeOption]: {
+                l1GasPrice?: bigint;
+                gasPrice?: bigint;
+                maxFeePerGas?: bigint;
+                maxPriorityFeePerGas?: bigint;
+            }; }>;
+            estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/server").EIP1559TxParams & {
+                feeOption: import("@tcswap/helpers").FeeOption;
+                chain: import("@tcswap/types").EVMChain;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string> | undefined;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
+            isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/server").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/server").EVMTxParams & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            }) => Promise<string>;
+            signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/server").EVMTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        HARBOR: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Harbor> & {
+            createPrivateKeyFromPhrase: (phrase: string) => Promise<Uint8Array<ArrayBufferLike>>;
+            createTransaction: typeof import("@tcswap/server").cosmosCreateTransaction;
+            fetchFeeRateFromSwapKit: typeof import("@tcswap/server").fetchFeeRateFromSwapKit;
+            getAccount: (address: string) => Promise<import("@cosmjs/stargate/build").Account | null>;
+            getAddress: () => Promise<string | undefined>;
+            getBalance: (address: string, _potentialScamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getBalanceAsDenoms: (address: string) => Promise<{
+                denom: string;
+                amount: string;
+            }[]>;
+            getFees: () => Promise<{
+                average: import("@tcswap/helpers").USwapNumber;
+                fast: import("@tcswap/helpers").USwapNumber;
+                fastest: import("@tcswap/helpers").USwapNumber;
+            }>;
+            getPubKey: () => Promise<string>;
+            getSignerFromPhrase: ({ phrase, derivationPath }: {
+                phrase: string;
+                derivationPath: import("@tcswap/helpers").DerivationPathArray;
+            }) => Promise<import("@cosmjs/proto-signing/build").DirectSecp256k1HdWallet>;
+            getSignerFromPrivateKey: (privateKey: Uint8Array) => Promise<import("@cosmjs/proto-signing/build").DirectSecp256k1Wallet>;
+            signTransaction: ({ recipient, assetValue, memo, feeRate, feeOptionKey, }: import("@tcswap/helpers").GenericTransferParams) => Promise<string>;
+            transfer: ({ recipient, assetValue, memo, feeRate, feeOptionKey, dryRun, }: import("@tcswap/helpers").GenericTransferParams & {
+                dryRun?: boolean;
+            }) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+            verifySignature: ({ signature, message, address, }: {
+                signature: string;
+                message: string;
+                address: string;
+            }) => Promise<boolean>;
+        };
+        HYPEREVM: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Hyperevm> & {
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/server").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/server").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/server").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/server").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+            createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+            createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").CallParams) => Promise<import("ethers").ContractTransaction>;
+            createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/server").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/server").EVMTransferParams & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@tcswap/server").EVMTxParams;
+                data?: string;
+            }) => Promise<bigint>;
+            estimateGasPrices: () => Promise<{ [key_2 in import("@tcswap/helpers").FeeOption]: {
+                l1GasPrice?: bigint;
+                gasPrice?: bigint;
+                maxFeePerGas?: bigint;
+                maxPriorityFeePerGas?: bigint;
+            }; }>;
+            estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/server").EIP1559TxParams & {
+                feeOption: import("@tcswap/helpers").FeeOption;
+                chain: import("@tcswap/types").EVMChain;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string> | undefined;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
+            isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/server").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/server").EVMTxParams & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            }) => Promise<string>;
+            signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/server").EVMTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        KUJI: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Kujira> & {
+            createPrivateKeyFromPhrase: (phrase: string) => Promise<Uint8Array<ArrayBufferLike>>;
+            createTransaction: typeof import("@tcswap/server").cosmosCreateTransaction;
+            fetchFeeRateFromSwapKit: typeof import("@tcswap/server").fetchFeeRateFromSwapKit;
+            getAccount: (address: string) => Promise<import("@cosmjs/stargate/build").Account | null>;
+            getAddress: () => Promise<string | undefined>;
+            getBalance: (address: string, _potentialScamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getBalanceAsDenoms: (address: string) => Promise<{
+                denom: string;
+                amount: string;
+            }[]>;
+            getFees: () => Promise<{
+                average: import("@tcswap/helpers").USwapNumber;
+                fast: import("@tcswap/helpers").USwapNumber;
+                fastest: import("@tcswap/helpers").USwapNumber;
+            }>;
+            getPubKey: () => Promise<string>;
+            getSignerFromPhrase: ({ phrase, derivationPath }: {
+                phrase: string;
+                derivationPath: import("@tcswap/helpers").DerivationPathArray;
+            }) => Promise<import("@cosmjs/proto-signing/build").DirectSecp256k1HdWallet>;
+            getSignerFromPrivateKey: (privateKey: Uint8Array) => Promise<import("@cosmjs/proto-signing/build").DirectSecp256k1Wallet>;
+            signTransaction: ({ recipient, assetValue, memo, feeRate, feeOptionKey, }: import("@tcswap/helpers").GenericTransferParams) => Promise<string>;
+            transfer: ({ recipient, assetValue, memo, feeRate, feeOptionKey, dryRun, }: import("@tcswap/helpers").GenericTransferParams & {
+                dryRun?: boolean;
+            }) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+            verifySignature: ({ signature, message, address, }: {
+                signature: string;
+                message: string;
+                address: string;
+            }) => Promise<boolean>;
+        };
+        LTC: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Litecoin> & {
+            accumulative: typeof import("@tcswap/server").accumulative;
+            broadcastTx: (txHash: string) => Promise<string>;
+            calculateTxSize: ({ inputs, outputs, feeRate }: import("@tcswap/server").UTXOCalculateTxSizeParams) => number;
+            createKeysForPath: (params: {
+                wif?: string;
+                phrase?: string;
+                derivationPath?: string;
+            }) => import("ecpair").ECPairInterface;
+            createTransaction: ({ assetValue, recipient, memo, feeRate, sender, fetchTxHex, }: import("@tcswap/server").UTXOBuildTxParams) => Promise<{
+                psbt: import("bitcoinjs-lib").Psbt;
+                utxos: import("@tcswap/server").UTXOType[];
+                inputs: import("@tcswap/server").UTXOType[];
+            }>;
+            estimateMaxSendableAmount: ({ from, memo, feeRate, feeOptionKey, recipients, }: {
+                from: string;
+                memo?: string;
+                feeRate?: number;
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+                recipients?: number | import("@tcswap/server").TargetOutput[];
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            estimateTransactionFee: (params: {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                recipient: string;
+                sender: string;
+                memo?: string;
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+                feeRate?: number;
+                fetchTxHex?: boolean;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => Promise<string | undefined>;
+            getAddressFromKeys: (keys: import("ecpair").ECPairInterface | import("@tcswap/server").BchECPair) => string;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getFeeRates: () => Promise<{
+                average: number;
+                fast: number;
+                fastest: number;
+            }>;
+            getInputsOutputsFee: ({ assetValue, feeOptionKey, feeRate, memo, sender, recipient, }: Omit<import("@tcswap/server").UTXOBuildTxParams, "feeRate"> & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+                feeRate?: number;
+            }) => Promise<{
+                fee: number;
+                inputs: (import("@tcswap/server").UTXOType | import("@tcswap/server").UTXOInputWithScriptType)[];
+                outputs: import("@tcswap/server").TargetOutput[];
+            } | {
+                fee: number;
+                inputs?: undefined;
+                outputs?: undefined;
+            }>;
+            getPrivateKeyFromMnemonic: (params: {
+                phrase: string;
+                derivationPath: string;
+            }) => string;
+            transfer: ({ memo, recipient, feeOptionKey, feeRate, assetValue }: import("@tcswap/server").UTXOTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        MAYA: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Maya> & {
+            broadcastMultisigTx: (tx: string, signers: import("@tcswap/server").MultiSigSigner[], membersPubKeys: string[], threshold: number, bodyBytes: Uint8Array) => Promise<string>;
+            buildAminoMsg: ({ sender, recipient, assetValue, memo, }: {
+                sender: string;
+                recipient?: string;
+                assetValue: import("@tcswap/helpers").AssetValue;
+                memo?: string;
+            }) => {
+                type: "thorchain/MsgDeposit" | "mayachain/MsgDeposit";
+                value: {
+                    coins: {
+                        amount: string;
+                        asset: string;
+                    }[];
+                    memo: string;
+                    signer: string;
+                };
+            } | {
+                type: "thorchain/MsgSend" | "mayachain/MsgSend";
+                value: {
+                    amount: {
+                        amount: string;
+                        denom: string;
+                    }[];
+                    from_address: string;
+                    to_address: string | undefined;
+                };
+            };
+            buildEncodedTxBody: typeof import("@tcswap/server").buildEncodedTxBody;
+            convertToSignable: (msg: {
+                type: "thorchain/MsgSend" | "mayachain/MsgSend";
+                value: {
+                    amount: {
+                        amount: string;
+                        denom: string;
+                    }[];
+                    from_address: string;
+                    to_address: string | undefined;
+                };
+            } | {
+                type: "thorchain/MsgDeposit" | "mayachain/MsgDeposit";
+                value: {
+                    coins: {
+                        amount: string;
+                        asset: string;
+                    }[];
+                    memo: string;
+                    signer: string;
+                };
+            }, chain: import("@tcswap/types").TCLikeChain) => Promise<import("@cosmjs/proto-signing/build").EncodeObject>;
+            createDefaultAminoTypes: () => Promise<import("@cosmjs/stargate/build").AminoTypes>;
+            createDefaultRegistry: typeof import("@tcswap/server").createDefaultRegistry;
+            createMultisig: (pubKeys: string[], threshold: number, noSortPubKeys?: boolean) => Promise<import("@cosmjs/amino/build").MultisigThresholdPubkey>;
+            createTransaction: (params: import("@tcswap/server").ThorchainCreateTransactionParams) => Promise<{
+                accountNumber: number;
+                chainId: import("@tcswap/types").ChainId.Maya | import("@tcswap/types").ChainId.THORChain;
+                fee: {
+                    amount: {
+                        amount: string;
+                        denom: string;
+                    }[];
+                    gas: string;
+                };
+                memo: string;
+                msgs: (import("@cosmjs/proto-signing/build").EncodeObject | {
+                    type: "thorchain/MsgSend" | "mayachain/MsgSend";
+                    value: {
+                        amount: {
+                            amount: string;
+                            denom: string;
+                        }[];
+                        from_address: string;
+                        to_address: string | undefined;
+                    };
+                })[];
+                sequence: number;
+            }> | Promise<{
+                accountNumber: number;
+                chainId: import("@tcswap/types").ChainId.Maya | import("@tcswap/types").ChainId.THORChain;
+                fee: {
+                    amount: {
+                        amount: string;
+                        denom: string;
+                    }[];
+                    gas: string;
+                };
+                memo: string;
+                msgs: (import("@cosmjs/proto-signing/build").EncodeObject | {
+                    type: "thorchain/MsgDeposit" | "mayachain/MsgDeposit";
+                    value: {
+                        coins: {
+                            amount: string;
+                            asset: string;
+                        }[];
+                        memo: string;
+                        signer: string;
+                    };
+                })[];
+                sequence: number;
+            }>;
+            deposit: ({ assetValue, memo, recipient, }: Omit<import("@tcswap/helpers").GenericTransferParams, "recipient"> & {
+                recipient?: string;
+            }) => Promise<string>;
+            getFees: () => Promise<{
+                average: import("@tcswap/helpers").USwapNumber;
+                fast: import("@tcswap/helpers").USwapNumber;
+                fastest: import("@tcswap/helpers").USwapNumber;
+            }>;
+            importSignature: (signature: string) => Uint8Array<ArrayBufferLike>;
+            parseAminoMessageForDirectSigning: typeof import("@tcswap/server").parseAminoMessageForDirectSigning;
+            pubkeyToAddress: (pubkey: import("@cosmjs/amino/build").Pubkey) => Promise<string>;
+            secp256k1HdWalletFromMnemonic: (mnemonic: string, index?: number) => Promise<import("@cosmjs/amino/build").Secp256k1HdWallet>;
+            signMultisigTx: ({ wallet, tx }: {
+                wallet: import("@cosmjs/amino/build").Secp256k1HdWallet;
+                tx: string | import("@tcswap/server").MultisigTx;
+            }) => Promise<{
+                bodyBytes: Uint8Array<ArrayBufferLike>;
+                signature: string;
+            }>;
+            signWithPrivateKey: ({ privateKey, message }: {
+                privateKey: Uint8Array;
+                message: string;
+            }) => Promise<string>;
+            transfer: ({ assetValue, memo, recipient, }: Omit<import("@tcswap/helpers").GenericTransferParams, "recipient"> & {
+                recipient?: string;
+            }) => Promise<string>;
+            createPrivateKeyFromPhrase: (phrase: string) => Promise<Uint8Array<ArrayBufferLike>>;
+            fetchFeeRateFromSwapKit: typeof import("@tcswap/server").fetchFeeRateFromSwapKit;
+            getAccount: (address: string) => Promise<import("@cosmjs/stargate/build").Account | null>;
+            getAddress: () => Promise<string | undefined>;
+            getBalance: (address: string, _potentialScamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getBalanceAsDenoms: (address: string) => Promise<{
+                denom: string;
+                amount: string;
+            }[]>;
+            getPubKey: () => Promise<string>;
+            getSignerFromPhrase: ({ phrase, derivationPath }: {
+                phrase: string;
+                derivationPath: import("@tcswap/helpers").DerivationPathArray;
+            }) => Promise<import("@cosmjs/proto-signing/build").DirectSecp256k1HdWallet>;
+            getSignerFromPrivateKey: (privateKey: Uint8Array) => Promise<import("@cosmjs/proto-signing/build").DirectSecp256k1Wallet>;
+            signTransaction: ({ recipient, assetValue, memo, feeRate, feeOptionKey, }: import("@tcswap/helpers").GenericTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+            verifySignature: ({ signature, message, address, }: {
+                signature: string;
+                message: string;
+                address: string;
+            }) => Promise<boolean>;
+        };
+        MEGAETH: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.MegaETH> & {
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/server").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/server").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/server").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/server").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+            createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+            createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").CallParams) => Promise<import("ethers").ContractTransaction>;
+            createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/server").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/server").EVMTransferParams & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@tcswap/server").EVMTxParams;
+                data?: string;
+            }) => Promise<bigint>;
+            estimateGasPrices: () => Promise<{ [key_2 in import("@tcswap/helpers").FeeOption]: {
+                l1GasPrice?: bigint;
+                gasPrice?: bigint;
+                maxFeePerGas?: bigint;
+                maxPriorityFeePerGas?: bigint;
+            }; }>;
+            estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/server").EIP1559TxParams & {
+                feeOption: import("@tcswap/helpers").FeeOption;
+                chain: import("@tcswap/types").EVMChain;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string> | undefined;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
+            isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/server").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/server").EVMTxParams & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            }) => Promise<string>;
+            signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/server").EVMTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        MONAD: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Monad> & {
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/server").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/server").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/server").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/server").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+            createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+            createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").CallParams) => Promise<import("ethers").ContractTransaction>;
+            createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/server").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/server").EVMTransferParams & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@tcswap/server").EVMTxParams;
+                data?: string;
+            }) => Promise<bigint>;
+            estimateGasPrices: () => Promise<{ [key_2 in import("@tcswap/helpers").FeeOption]: {
+                l1GasPrice?: bigint;
+                gasPrice?: bigint;
+                maxFeePerGas?: bigint;
+                maxPriorityFeePerGas?: bigint;
+            }; }>;
+            estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/server").EIP1559TxParams & {
+                feeOption: import("@tcswap/helpers").FeeOption;
+                chain: import("@tcswap/types").EVMChain;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string> | undefined;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
+            isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/server").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/server").EVMTxParams & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            }) => Promise<string>;
+            signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/server").EVMTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        NEAR: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Near> & {
+            broadcastTransaction: (signedTransaction: import("@near-js/transactions").SignedTransaction) => Promise<any>;
+            callFunction: (params: import("@tcswap/toolboxes/near").NearFunctionCallParams) => Promise<string>;
+            createAction: (params: import("@tcswap/toolboxes/near").CreateActionParams) => Promise<import("@near-js/transactions").Action>;
+            createContract: <T_1 extends import("@near-js/accounts").Contract = import("@near-js/accounts").Contract>(contractInterface: import("@tcswap/toolboxes/near").NearContractInterface) => Promise<T_1>;
+            createContractFunctionCall: (params: import("@tcswap/toolboxes/near").ContractFunctionCallParams) => Promise<import("@near-js/transactions").Transaction>;
+            createSubAccount: (subAccountId: string, publicKey: string, initialBalance: string) => Promise<string>;
+            createTransaction: (params: import("@tcswap/toolboxes/near").NearCreateTransactionParams) => Promise<import("@near-js/transactions").Transaction>;
+            estimateGas: (params: import("@tcswap/toolboxes/near").NearGasEstimateParams, account?: import("@near-js/accounts").Account) => Promise<import("@tcswap/helpers").AssetValue>;
+            estimateTransactionFee: (params: import("@tcswap/toolboxes/near").NearTransferParams | import("@tcswap/toolboxes/near").NearGasEstimateParams) => Promise<import("@tcswap/helpers").AssetValue>;
+            executeBatchTransaction: (batch: import("@tcswap/toolboxes/near").BatchTransaction) => Promise<string>;
+            getAddress: () => Promise<string>;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getGasPrice: () => Promise<string>;
+            getPublicKey: () => Promise<string>;
+            getSignerFromPhrase: (params: import("@tcswap/toolboxes/near").GetSignerFromPhraseParams) => Promise<import("@tcswap/toolboxes/near").NearSigner>;
+            getSignerFromPrivateKey: typeof import("@tcswap/toolboxes/near").getNearSignerFromPrivateKey;
+            provider: import("@near-js/providers").JsonRpcProvider;
+            serializeTransaction: (transaction: import("@near-js/transactions").Transaction) => string;
+            signAndSendTransaction: (transaction: import("@near-js/transactions").Transaction) => Promise<any>;
+            signTransaction: (transaction: import("@near-js/transactions").Transaction) => Promise<import("@near-js/transactions").SignedTransaction>;
+            transfer: (params: import("@tcswap/toolboxes/near").NearTransferParams) => Promise<any>;
+            validateAddress: (address: string) => boolean;
+        };
+        NOBLE: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Noble> & {
+            createPrivateKeyFromPhrase: (phrase: string) => Promise<Uint8Array<ArrayBufferLike>>;
+            createTransaction: typeof import("@tcswap/server").cosmosCreateTransaction;
+            fetchFeeRateFromSwapKit: typeof import("@tcswap/server").fetchFeeRateFromSwapKit;
+            getAccount: (address: string) => Promise<import("@cosmjs/stargate/build").Account | null>;
+            getAddress: () => Promise<string | undefined>;
+            getBalance: (address: string, _potentialScamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getBalanceAsDenoms: (address: string) => Promise<{
+                denom: string;
+                amount: string;
+            }[]>;
+            getFees: () => Promise<{
+                average: import("@tcswap/helpers").USwapNumber;
+                fast: import("@tcswap/helpers").USwapNumber;
+                fastest: import("@tcswap/helpers").USwapNumber;
+            }>;
+            getPubKey: () => Promise<string>;
+            getSignerFromPhrase: ({ phrase, derivationPath }: {
+                phrase: string;
+                derivationPath: import("@tcswap/helpers").DerivationPathArray;
+            }) => Promise<import("@cosmjs/proto-signing/build").DirectSecp256k1HdWallet>;
+            getSignerFromPrivateKey: (privateKey: Uint8Array) => Promise<import("@cosmjs/proto-signing/build").DirectSecp256k1Wallet>;
+            signTransaction: ({ recipient, assetValue, memo, feeRate, feeOptionKey, }: import("@tcswap/helpers").GenericTransferParams) => Promise<string>;
+            transfer: ({ recipient, assetValue, memo, feeRate, feeOptionKey, dryRun, }: import("@tcswap/helpers").GenericTransferParams & {
+                dryRun?: boolean;
+            }) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+            verifySignature: ({ signature, message, address, }: {
+                signature: string;
+                message: string;
+                address: string;
+            }) => Promise<boolean>;
+        };
+        OP: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Optimism> & {
+            estimateGasPrices: Promise<{
+                average: {
+                    l1GasPrice?: bigint;
+                    gasPrice?: bigint;
+                    maxFeePerGas?: bigint;
+                    maxPriorityFeePerGas?: bigint;
+                };
+                fast: {
+                    l1GasPrice?: bigint;
+                    gasPrice?: bigint;
+                    maxFeePerGas?: bigint;
+                    maxPriorityFeePerGas?: bigint;
+                };
+                fastest: {
+                    l1GasPrice?: bigint;
+                    gasPrice?: bigint;
+                    maxFeePerGas?: bigint;
+                    maxPriorityFeePerGas?: bigint;
+                };
+            }>;
+            estimateL1Gas: (tx: import("ethers").TransactionRequest) => Promise<any>;
+            estimateL1GasCost: (tx: import("ethers").TransactionRequest) => Promise<any>;
+            estimateL2GasCost: (tx: import("ethers").TransactionRequest) => Promise<any>;
+            estimateTotalGasCost: (tx: import("ethers").TransactionRequest) => Promise<any>;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getL1GasPrice: () => Promise<bigint | undefined>;
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/server").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/server").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/server").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/server").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+            createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+            createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").CallParams) => Promise<import("ethers").ContractTransaction>;
+            createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/server").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/server").EVMTransferParams & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@tcswap/server").EVMTxParams;
+                data?: string;
+            }) => Promise<bigint>;
+            estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/server").EIP1559TxParams & {
+                feeOption: import("@tcswap/helpers").FeeOption;
+                chain: import("@tcswap/types").EVMChain;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string> | undefined;
+            getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
+            isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/server").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/server").EVMTxParams & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            }) => Promise<string>;
+            signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/server").EVMTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        DOT: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Polkadot> & {
+            api: import("@polkadot/api").ApiPromise;
+            broadcast: (tx: import("@polkadot/api/types").SubmittableExtrinsic<"promise">, callback?: import("@polkadot/types/types").Callback<import("@polkadot/types/types").ISubmittableResult>) => Promise<string | (() => void)>;
+            convertAddress: (address: string, newPrefix: number) => string;
+            createKeyring: (phrase: string) => Promise<import("@polkadot/keyring/types").KeyringPair>;
+            createTransaction: (params: import("@tcswap/helpers").GenericCreateTransactionParams) => import("@polkadot/api/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | undefined;
+            decodeAddress: (address: string, networkPrefix?: number) => Uint8Array<ArrayBufferLike>;
+            encodeAddress: (address: Uint8Array, encoding?: "ss58" | "hex", networkPrefix?: number) => string;
+            estimateTransactionFee: (params: import("@tcswap/server").SubstrateTransferParams) => Promise<import("@tcswap/helpers").AssetValue | undefined>;
+            gasAsset: import("@tcswap/helpers").AssetValue;
+            getAddress: (keyring?: import("@polkadot/types/types").IKeyringPair | import("@polkadot/types/types").Signer) => string | undefined;
+            getBalance: (address: string) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            network: import("@tcswap/server").SubstrateNetwork;
+            sign: (tx: import("@polkadot/api/types").SubmittableExtrinsic<"promise">) => Promise<import("@polkadot/api/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+            signAndBroadcast: ({ tx, callback, address, }: {
+                tx: import("@polkadot/api/types").SubmittableExtrinsic<"promise">;
+                callback?: import("@polkadot/types/types").Callback<import("@polkadot/types/types").ISubmittableResult>;
+                address?: string;
+            }) => string | Promise<string> | Promise<() => void>;
+            transfer: (params: import("@tcswap/server").SubstrateTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        POL: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Polygon> & {
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/server").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/server").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/server").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/server").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+            createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+            createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").CallParams) => Promise<import("ethers").ContractTransaction>;
+            createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/server").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/server").EVMTransferParams & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@tcswap/server").EVMTxParams;
+                data?: string;
+            }) => Promise<bigint>;
+            estimateGasPrices: () => Promise<{ [key_2 in import("@tcswap/helpers").FeeOption]: {
+                l1GasPrice?: bigint;
+                gasPrice?: bigint;
+                maxFeePerGas?: bigint;
+                maxPriorityFeePerGas?: bigint;
+            }; }>;
+            estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/server").EIP1559TxParams & {
+                feeOption: import("@tcswap/helpers").FeeOption;
+                chain: import("@tcswap/types").EVMChain;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string> | undefined;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
+            isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/server").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/server").EVMTxParams & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            }) => Promise<string>;
+            signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/server").EVMTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        XRD: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Radix> & {
+            getAddress: () => string;
+            getBalance: (address: string) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            networkApi: import("@radixdlt/babylon-gateway-api-sdk").GatewayApiClient;
+            signAndBroadcast: (params: any) => Promise<string>;
+            validateAddress: typeof import("@tcswap/server").radixValidateAddress;
+        };
+        XRP: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Ripple> & {
+            broadcastTransaction: (signedTxHex: string) => Promise<string>;
+            createSigner: (phrase: string) => import("@tcswap/helpers").ChainSigner<import("xrpl").Transaction, {
+                tx_blob: string;
+                hash: string;
+            }>;
+            createTransaction: ({ assetValue, recipient, memo, sender, }: {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                recipient: string;
+                sender?: string;
+                memo?: string;
+            }) => Promise<import("xrpl").Payment>;
+            disconnect: () => Promise<void>;
+            estimateTransactionFee: () => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string>;
+            getBalance: (address?: string) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            signer: import("@tcswap/helpers").ChainSigner<import("xrpl").Transaction, {
+                tx_blob: string;
+                hash: string;
+            }> | undefined;
+            signTransaction: (tx: import("xrpl").Transaction) => {
+                tx_blob: string;
+                hash: string;
+            } | Promise<{
+                tx_blob: string;
+                hash: string;
+            }>;
+            transfer: (params: import("@tcswap/helpers").GenericTransferParams) => Promise<string>;
+            validateAddress: typeof import("@tcswap/toolboxes/ripple").rippleValidateAddress;
+        };
+        SOL: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Solana> & {
+            broadcastTransaction: (transaction: import("@solana/web3.js/lib").Transaction | import("@solana/web3.js/lib").VersionedTransaction) => Promise<string>;
+            createKeysForPath: typeof import("@tcswap/server").createKeysForPath;
+            createTransaction: ({ recipient, assetValue, memo, isProgramDerivedAddress, sender }: import("@tcswap/server").SolanaCreateTransactionParams) => Promise<import("@solana/web3.js/lib").Transaction>;
+            createTransactionFromInstructions: ({ instructions, }: {
+                instructions: import("@solana/web3.js/lib").TransactionInstruction[];
+                isProgramDerivedAddress?: boolean;
+            }) => Promise<import("@solana/web3.js/lib").Transaction>;
+            estimateTransactionFee: ({ recipient, assetValue, memo, isProgramDerivedAddress, sender, }: Omit<import("@tcswap/helpers").GenericCreateTransactionParams, "feeRate"> & {
+                isProgramDerivedAddress?: boolean;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string;
+            getAddressFromPubKey: (publicKey: import("@solana/web3.js/lib").PublicKey) => string;
+            getAddressValidator: typeof import("@tcswap/server").getSolanaAddressValidator;
+            getBalance: (addressParam?: string) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getConnection: () => Promise<import("@solana/web3.js/lib").Connection>;
+            getPubkeyFromAddress: (address: string) => Promise<import("@solana/web3.js/lib").PublicKey>;
+            signTransaction: (transaction: import("@solana/web3.js/lib").Transaction | import("@solana/web3.js/lib").VersionedTransaction) => Promise<import("@solana/web3.js/lib").Transaction | import("@solana/web3.js/lib").VersionedTransaction>;
+            transfer: ({ recipient, assetValue, memo, isProgramDerivedAddress }: import("@tcswap/server").SolanaTransferParams) => Promise<string>;
+        };
+        SONIC: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Sonic> & {
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/server").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/server").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/server").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/server").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+            createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+            createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").CallParams) => Promise<import("ethers").ContractTransaction>;
+            createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/server").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/server").EVMTransferParams & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@tcswap/server").EVMTxParams;
+                data?: string;
+            }) => Promise<bigint>;
+            estimateGasPrices: () => Promise<{ [key_2 in import("@tcswap/helpers").FeeOption]: {
+                l1GasPrice?: bigint;
+                gasPrice?: bigint;
+                maxFeePerGas?: bigint;
+                maxPriorityFeePerGas?: bigint;
+            }; }>;
+            estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/server").EIP1559TxParams & {
+                feeOption: import("@tcswap/helpers").FeeOption;
+                chain: import("@tcswap/types").EVMChain;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string> | undefined;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
+            isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/server").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/server").EVMTxParams & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            }) => Promise<string>;
+            signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/server").EVMTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        SUI: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Sui> & {
+            createTransaction: ({ recipient, assetValue, gasBudget, sender }: import("@tcswap/toolboxes/sui").SuiCreateTransactionParams) => Promise<{
+                tx: import("@mysten/sui/transactions").Transaction;
+                txBytes: Uint8Array<ArrayBuffer>;
+            }>;
+            estimateTransactionFee: (params?: import("@tcswap/toolboxes/sui").SuiCreateTransactionParams) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string;
+            getBalance: (targetAddress?: string) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            signTransaction: (params: Uint8Array<ArrayBuffer> | import("@tcswap/toolboxes/sui").SuiCreateTransactionParams | Awaited<ReturnType<({ recipient, assetValue, gasBudget, sender }: import("@tcswap/toolboxes/sui").SuiCreateTransactionParams) => Promise<{
+                tx: import("@mysten/sui/transactions").Transaction;
+                txBytes: Uint8Array<ArrayBuffer>;
+            }>>>) => Promise<import("@mysten/sui/cryptography").SignatureWithBytes>;
+            transfer: ({ assetValue, gasBudget, recipient }: import("@tcswap/toolboxes/sui").SuiTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        THOR: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.THORChain> & {
+            broadcastMultisigTx: (tx: string, signers: import("@tcswap/server").MultiSigSigner[], membersPubKeys: string[], threshold: number, bodyBytes: Uint8Array) => Promise<string>;
+            buildAminoMsg: ({ sender, recipient, assetValue, memo, }: {
+                sender: string;
+                recipient?: string;
+                assetValue: import("@tcswap/helpers").AssetValue;
+                memo?: string;
+            }) => {
+                type: "thorchain/MsgDeposit" | "mayachain/MsgDeposit";
+                value: {
+                    coins: {
+                        amount: string;
+                        asset: string;
+                    }[];
+                    memo: string;
+                    signer: string;
+                };
+            } | {
+                type: "thorchain/MsgSend" | "mayachain/MsgSend";
+                value: {
+                    amount: {
+                        amount: string;
+                        denom: string;
+                    }[];
+                    from_address: string;
+                    to_address: string | undefined;
+                };
+            };
+            buildEncodedTxBody: typeof import("@tcswap/server").buildEncodedTxBody;
+            convertToSignable: (msg: {
+                type: "thorchain/MsgSend" | "mayachain/MsgSend";
+                value: {
+                    amount: {
+                        amount: string;
+                        denom: string;
+                    }[];
+                    from_address: string;
+                    to_address: string | undefined;
+                };
+            } | {
+                type: "thorchain/MsgDeposit" | "mayachain/MsgDeposit";
+                value: {
+                    coins: {
+                        amount: string;
+                        asset: string;
+                    }[];
+                    memo: string;
+                    signer: string;
+                };
+            }, chain: import("@tcswap/types").TCLikeChain) => Promise<import("@cosmjs/proto-signing/build").EncodeObject>;
+            createDefaultAminoTypes: () => Promise<import("@cosmjs/stargate/build").AminoTypes>;
+            createDefaultRegistry: typeof import("@tcswap/server").createDefaultRegistry;
+            createMultisig: (pubKeys: string[], threshold: number, noSortPubKeys?: boolean) => Promise<import("@cosmjs/amino/build").MultisigThresholdPubkey>;
+            createTransaction: (params: import("@tcswap/server").ThorchainCreateTransactionParams) => Promise<{
+                accountNumber: number;
+                chainId: import("@tcswap/types").ChainId.Maya | import("@tcswap/types").ChainId.THORChain;
+                fee: {
+                    amount: {
+                        amount: string;
+                        denom: string;
+                    }[];
+                    gas: string;
+                };
+                memo: string;
+                msgs: (import("@cosmjs/proto-signing/build").EncodeObject | {
+                    type: "thorchain/MsgSend" | "mayachain/MsgSend";
+                    value: {
+                        amount: {
+                            amount: string;
+                            denom: string;
+                        }[];
+                        from_address: string;
+                        to_address: string | undefined;
+                    };
+                })[];
+                sequence: number;
+            }> | Promise<{
+                accountNumber: number;
+                chainId: import("@tcswap/types").ChainId.Maya | import("@tcswap/types").ChainId.THORChain;
+                fee: {
+                    amount: {
+                        amount: string;
+                        denom: string;
+                    }[];
+                    gas: string;
+                };
+                memo: string;
+                msgs: (import("@cosmjs/proto-signing/build").EncodeObject | {
+                    type: "thorchain/MsgDeposit" | "mayachain/MsgDeposit";
+                    value: {
+                        coins: {
+                            amount: string;
+                            asset: string;
+                        }[];
+                        memo: string;
+                        signer: string;
+                    };
+                })[];
+                sequence: number;
+            }>;
+            deposit: ({ assetValue, memo, recipient, }: Omit<import("@tcswap/helpers").GenericTransferParams, "recipient"> & {
+                recipient?: string;
+            }) => Promise<string>;
+            getFees: () => Promise<{
+                average: import("@tcswap/helpers").USwapNumber;
+                fast: import("@tcswap/helpers").USwapNumber;
+                fastest: import("@tcswap/helpers").USwapNumber;
+            }>;
+            importSignature: (signature: string) => Uint8Array<ArrayBufferLike>;
+            parseAminoMessageForDirectSigning: typeof import("@tcswap/server").parseAminoMessageForDirectSigning;
+            pubkeyToAddress: (pubkey: import("@cosmjs/amino/build").Pubkey) => Promise<string>;
+            secp256k1HdWalletFromMnemonic: (mnemonic: string, index?: number) => Promise<import("@cosmjs/amino/build").Secp256k1HdWallet>;
+            signMultisigTx: ({ wallet, tx }: {
+                wallet: import("@cosmjs/amino/build").Secp256k1HdWallet;
+                tx: string | import("@tcswap/server").MultisigTx;
+            }) => Promise<{
+                bodyBytes: Uint8Array<ArrayBufferLike>;
+                signature: string;
+            }>;
+            signWithPrivateKey: ({ privateKey, message }: {
+                privateKey: Uint8Array;
+                message: string;
+            }) => Promise<string>;
+            transfer: ({ assetValue, memo, recipient, }: Omit<import("@tcswap/helpers").GenericTransferParams, "recipient"> & {
+                recipient?: string;
+            }) => Promise<string>;
+            createPrivateKeyFromPhrase: (phrase: string) => Promise<Uint8Array<ArrayBufferLike>>;
+            fetchFeeRateFromSwapKit: typeof import("@tcswap/server").fetchFeeRateFromSwapKit;
+            getAccount: (address: string) => Promise<import("@cosmjs/stargate/build").Account | null>;
+            getAddress: () => Promise<string | undefined>;
+            getBalance: (address: string, _potentialScamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getBalanceAsDenoms: (address: string) => Promise<{
+                denom: string;
+                amount: string;
+            }[]>;
+            getPubKey: () => Promise<string>;
+            getSignerFromPhrase: ({ phrase, derivationPath }: {
+                phrase: string;
+                derivationPath: import("@tcswap/helpers").DerivationPathArray;
+            }) => Promise<import("@cosmjs/proto-signing/build").DirectSecp256k1HdWallet>;
+            getSignerFromPrivateKey: (privateKey: Uint8Array) => Promise<import("@cosmjs/proto-signing/build").DirectSecp256k1Wallet>;
+            signTransaction: ({ recipient, assetValue, memo, feeRate, feeOptionKey, }: import("@tcswap/helpers").GenericTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+            verifySignature: ({ signature, message, address, }: {
+                signature: string;
+                message: string;
+                address: string;
+            }) => Promise<boolean>;
+        };
+        TON: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Ton> & {
+            createTransaction: ({ assetValue, recipient, memo }: import("@tcswap/toolboxes/ton").TONTransferParams) => Promise<import("@ton/ton/dist").Cell>;
+            estimateTransactionFee: () => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string;
+            getBalance: (address: string) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            sendTransaction: (transferCell: import("@ton/ton/dist").Cell) => Promise<string>;
+            transfer: ({ assetValue, recipient, memo }: import("@tcswap/toolboxes/ton").TONTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        TRON: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Tron> & {
+            tronWeb: import("tronweb").TronWeb;
+            getAddress: () => Promise<string>;
+            validateAddress: (address: string) => boolean;
+            getBalance: (address: string) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            transfer: (params: import("@tcswap/toolboxes/tron").TronTransferParams) => Promise<string>;
+            estimateTransactionFee: (params: import("@tcswap/toolboxes/tron").TronTransferParams & {
+                sender?: string;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            createTransaction: (params: import("@tcswap/toolboxes/tron").TronCreateTransactionParams) => Promise<import("@tcswap/toolboxes/tron").TronTransaction>;
+            signTransaction: (transaction: import("@tcswap/toolboxes/tron").TronTransaction) => Promise<import("@tcswap/toolboxes/tron").TronSignedTransaction>;
+            broadcastTransaction: (signedTransaction: import("@tcswap/toolboxes/tron").TronSignedTransaction) => Promise<string>;
+            approve: (params: import("@tcswap/toolboxes/tron").TronApproveParams) => Promise<string>;
+            isApproved: (params: import("@tcswap/toolboxes/tron").TronIsApprovedParams) => Promise<boolean>;
+            getApprovedAmount: (params: import("@tcswap/toolboxes/tron").TronApprovedParams) => Promise<bigint>;
+        };
+        UNI: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Unichain> & {
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/server").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/server").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/server").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/server").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+            createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+            createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").CallParams) => Promise<import("ethers").ContractTransaction>;
+            createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/server").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/server").EVMTransferParams & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@tcswap/server").EVMTxParams;
+                data?: string;
+            }) => Promise<bigint>;
+            estimateGasPrices: () => Promise<{ [key_2 in import("@tcswap/helpers").FeeOption]: {
+                l1GasPrice?: bigint;
+                gasPrice?: bigint;
+                maxFeePerGas?: bigint;
+                maxPriorityFeePerGas?: bigint;
+            }; }>;
+            estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/server").EIP1559TxParams & {
+                feeOption: import("@tcswap/helpers").FeeOption;
+                chain: import("@tcswap/types").EVMChain;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string> | undefined;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
+            isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/server").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/server").EVMTxParams & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            }) => Promise<string>;
+            signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/server").EVMTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        XLAYER: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.XLayer> & {
+            approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/server").ApproveParams) => Promise<string>;
+            approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/server").IsApprovedParams) => Promise<bigint>;
+            broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+            call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/server").CallParams) => Promise<T_1>;
+            createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/server").ApproveParams) => Promise<import("ethers").ContractTransaction>;
+            createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
+            createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").CallParams) => Promise<import("ethers").ContractTransaction>;
+            createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/server").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+            EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/server").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+            estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/server").EstimateCallParams) => Promise<bigint>;
+            estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/server").EVMTransferParams & {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                funcName?: string;
+                funcParams?: unknown[];
+                txOverrides?: import("@tcswap/server").EVMTxParams;
+                data?: string;
+            }) => Promise<bigint>;
+            estimateGasPrices: () => Promise<{ [key_2 in import("@tcswap/helpers").FeeOption]: {
+                l1GasPrice?: bigint;
+                gasPrice?: bigint;
+                maxFeePerGas?: bigint;
+                maxPriorityFeePerGas?: bigint;
+            }; }>;
+            estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/server").EIP1559TxParams & {
+                feeOption: import("@tcswap/helpers").FeeOption;
+                chain: import("@tcswap/types").EVMChain;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => string | Promise<string> | undefined;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
+            isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/server").IsApprovedParams) => Promise<boolean>;
+            sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/server").EVMTxParams & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+            }) => Promise<string>;
+            signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+            transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/server").EVMTransferParams) => Promise<string>;
+            validateAddress: (address: string) => boolean;
+        };
+        ZEC: import("@tcswap/helpers").ChainWallet<import("@tcswap/types").Chain.Zcash> & {
+            createKeysForPath: ({ phrase, derivationPath, }: {
+                phrase: string;
+                derivationPath?: string;
+            }) => import("ecpair").ECPairInterface;
+            createTransaction: (buildTxParams: import("@tcswap/server").UTXOBuildTxParams) => Promise<{
+                inputs: import("@tcswap/server").UTXOType[];
+                outputs: import("@tcswap/server").TargetOutput[];
+                psbt: import("@bitgo/utxo-lib/dist/src/bitgo").ZcashPsbt;
+            }>;
+            getPrivateKeyFromMnemonic: ({ phrase, derivationPath, }: {
+                phrase: string;
+                derivationPath: string;
+            }) => string;
+            transfer: ({ recipient, assetValue, feeOptionKey, ...rest }: import("@tcswap/server").UTXOTransferParams) => Promise<string>;
+            validateAddress: typeof import("@tcswap/server").validateZcashAddress;
+            accumulative: typeof import("@tcswap/server").accumulative;
+            broadcastTx: (txHash: string) => Promise<string>;
+            calculateTxSize: ({ inputs, outputs, feeRate }: import("@tcswap/server").UTXOCalculateTxSizeParams) => number;
+            estimateMaxSendableAmount: ({ from, memo, feeRate, feeOptionKey, recipients, }: {
+                from: string;
+                memo?: string;
+                feeRate?: number;
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+                recipients?: number | import("@tcswap/server").TargetOutput[];
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            estimateTransactionFee: (params: {
+                assetValue: import("@tcswap/helpers").AssetValue;
+                recipient: string;
+                sender: string;
+                memo?: string;
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+                feeRate?: number;
+                fetchTxHex?: boolean;
+            }) => Promise<import("@tcswap/helpers").AssetValue>;
+            getAddress: () => Promise<string | undefined>;
+            getAddressFromKeys: (keys: import("ecpair").ECPairInterface | import("@tcswap/server").BchECPair) => string;
+            getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
+            getFeeRates: () => Promise<{
+                average: number;
+                fast: number;
+                fastest: number;
+            }>;
+            getInputsOutputsFee: ({ assetValue, feeOptionKey, feeRate, memo, sender, recipient, }: Omit<import("@tcswap/server").UTXOBuildTxParams, "feeRate"> & {
+                feeOptionKey?: import("@tcswap/helpers").FeeOption;
+                feeRate?: number;
+            }) => Promise<{
+                fee: number;
+                inputs: (import("@tcswap/server").UTXOType | import("@tcswap/server").UTXOInputWithScriptType)[];
+                outputs: import("@tcswap/server").TargetOutput[];
+            } | {
+                fee: number;
+                inputs?: undefined;
+                outputs?: undefined;
+            }>;
+        };
+    };
+    getBalance: <T_1 extends import("@tcswap/types").Chain, R extends boolean>(chain: T_1, refresh?: R) => import("@tcswap/helpers").ConditionalAssetValueReturn<R>;
+    getWallet: <T_1 extends import("@tcswap/types").Chain>(walletOption: import("@tcswap/helpers").WalletOption, chain: T_1) => import("@tcswap/toolboxes").FullWallet[T_1];
+    getWalletByChain: <T_1 extends import("@tcswap/types").Chain>(chain: T_1) => import("@tcswap/toolboxes").FullWallet[T_1];
+    getWalletWithBalance: <T_1 extends import("@tcswap/types").Chain>(chain: T_1, scamFilter?: boolean) => Promise<import("@tcswap/toolboxes").FullWallet[T_1]>;
+    isAssetValueApproved: (assetValue: import("@tcswap/helpers").AssetValue, contractAddress: string) => Promise<boolean>;
+    signMessage: ({ chain, message }: {
+        chain: import("@tcswap/types").Chain;
+        message: string;
+    }) => Promise<string> | undefined;
+    swap: <T_1 extends "garden" | "near" | "solana" | "radix" | "thorchain" | "mayachain" | "evm" | "chainflip">({ route, pluginName, ...rest }: import("@tcswap/helpers").SwapParams<T_1, {
+        buyAsset: string;
+        expectedBuyAmount: string;
+        fees: {
+            amount: string;
+            asset: string;
+            chain: string;
+            protocol: import("@tcswap/helpers").ProviderName;
+            type: import("@tcswap/helpers").FeeTypeEnum;
+        }[];
+        providers: import("@tcswap/helpers").ProviderName[];
+        sellAmount: string;
+        sellAsset: string;
+        destinationAddress?: string | undefined;
+        estimatedTime?: {
+            total: number;
+            inbound?: number | undefined;
+            outbound?: number | undefined;
+            swap?: number | undefined;
+        } | undefined;
+        expectedBuyAmountMaxSlippage?: string | undefined;
+        expiration?: string | undefined;
+        inboundAddress?: string | undefined;
+        legs?: {
+            buyAmount: string;
+            buyAmountMaxSlippage: string;
+            buyAsset: string;
+            provider: import("@tcswap/helpers").ProviderName;
+            sellAmount: string;
+            sellAsset: string;
+            fees?: {
+                amount: string;
+                asset: string;
+                chain: string;
+                protocol: import("@tcswap/helpers").ProviderName;
+                type: import("@tcswap/helpers").FeeTypeEnum;
+            }[] | undefined;
+        }[] | undefined;
+        memo?: string | undefined;
+        meta?: {
+            assets?: {
+                asset: string;
+                image: string;
+                price: number;
+            }[] | undefined;
+            maxStreamingQuantity?: number | undefined;
+            streamingInterval?: number | undefined;
+            tags?: import("@tcswap/server").PriorityLabel[] | undefined;
+            affiliate?: string | undefined;
+            affiliateFee?: string | undefined;
+            approvalAddress?: string | undefined;
+            chainflip?: {
+                destinationAddress: string;
+                buyAsset: {
+                    asset: string;
+                    chain: string;
+                };
+                sellAsset: {
+                    asset: string;
+                    chain: string;
+                };
+                affiliateFees?: {
+                    brokerAddress: string;
+                    feeBps: number;
+                }[] | undefined;
+                brokerCommissionBps?: number | undefined;
+                channelMetadata?: {
+                    cfParameters?: string | undefined;
+                    gasBudget?: string | undefined;
+                    message?: string | undefined;
+                } | undefined;
+                dcaParameters?: {
+                    chunkInterval?: number | undefined;
+                    numberOfChunks?: number | undefined;
+                } | undefined;
+                maxBoostFeeBps?: number | undefined;
+                refundParameters?: {
+                    minPrice?: string | undefined;
+                    refundAddress?: string | undefined;
+                    retryDuration?: number | undefined;
+                } | undefined;
+            } | undefined;
+            garden?: {
+                destinationAddress: string;
+                buyAsset: string;
+                sellAmount: string;
+                sellAsset: string;
+                slippage: number;
+                sourceAddress: string;
+                affiliateFees?: {
+                    feeBps: number;
+                    nearId: string;
+                } | undefined;
+            } | undefined;
+            near?: {
+                destinationAddress: string;
+                buyAsset: string;
+                sellAmount: string;
+                sellAsset: string;
+                slippage: number;
+                sourceAddress: string;
+                affiliateFees?: {
+                    feeBps: number;
+                    nearId: string;
+                } | undefined;
+            } | undefined;
+            priceImpact?: number | undefined;
+            referrer?: string | undefined;
+            txType?: import("@tcswap/server").RouteQuoteTxType | undefined;
+        } | undefined;
+        refundAddress?: string | undefined;
+        sourceAddress?: string | undefined;
+        targetAddress?: string | undefined;
+        tx?: string | {
+            data: string;
+            from: string;
+            to: string;
+            value: string;
+        } | {
+            accountNumber: number;
+            chainId: import("@tcswap/types").ChainId;
+            fee: {
+                amount: {
+                    amount: string;
+                    denom: string;
+                }[];
+                gas: string;
+            };
+            memo: string;
+            msgs: {
+                typeUrl: string;
+                value: unknown;
+            }[];
+            sequence: number;
+        } | undefined;
+        txType?: import("@tcswap/server").RouteQuoteTxType | undefined;
+        warnings?: {
+            code: import("@tcswap/helpers").WarningCodeEnum;
+            display: string;
+            tooltip?: string | undefined;
+        }[] | undefined;
+    }>) => any;
+    transfer: ({ assetValue, ...params }: import("@tcswap/helpers").GenericTransferParams | import("@tcswap/server").EVMTransferParams) => Promise<string>;
+    verifyMessage: ({ address, chain, message, signature, }: {
+        chain: import("@tcswap/types").Chain;
+        signature: string;
+        message: string;
+        address: string;
+    }) => Promise<boolean>;
+};
+//# sourceMappingURL=index.d.ts.map