@tcswap/wallet-extensions 4.1.16

package/dist/types/bitget/helpers.d.ts

@@ -0,0 +1,1607 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+import { Chain, type EVMChain } from "@tcswap/helpers";
+import type { TronTransaction } from "@tcswap/toolboxes/tron";
+import { Psbt } from "bitcoinjs-lib";
+import type { Eip1193Provider } from "ethers";
+export declare function getWalletMethods(chain: Chain): Promise<{
+    address: string;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    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/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    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/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    accumulative: typeof import("@tcswap/toolboxes/utxo").accumulative;
+    broadcastTx: (txHash: string) => Promise<string>;
+    calculateTxSize: ({ inputs, outputs, feeRate }: import("@tcswap/toolboxes/utxo").UTXOCalculateTxSizeParams) => number;
+    createKeysForPath: (params: {
+        wif?: string;
+        phrase?: string;
+        derivationPath?: string;
+    }) => import("ecpair").ECPairInterface;
+    createTransaction: ({ assetValue, recipient, memo, feeRate, sender, fetchTxHex, }: import("@tcswap/toolboxes/utxo").UTXOBuildTxParams) => Promise<{
+        psbt: Psbt;
+        utxos: import("@tcswap/toolboxes/utxo").UTXOType[];
+        inputs: import("@tcswap/toolboxes/utxo").UTXOType[];
+    }>;
+    estimateMaxSendableAmount: ({ from, memo, feeRate, feeOptionKey, recipients, }: {
+        from: string;
+        memo?: string;
+        feeRate?: number;
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+        recipients?: number | import("@tcswap/toolboxes/utxo").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/toolboxes/utxo").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/toolboxes/utxo").UTXOBuildTxParams, "feeRate"> & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+        feeRate?: number;
+    }) => Promise<{
+        fee: number;
+        inputs: (import("@tcswap/toolboxes/utxo").UTXOType | import("@tcswap/toolboxes/utxo").UTXOInputWithScriptType)[];
+        outputs: import("@tcswap/toolboxes/utxo").TargetOutput[];
+    } | {
+        fee: number;
+        inputs?: undefined;
+        outputs?: undefined;
+    }>;
+    getPrivateKeyFromMnemonic: (params: {
+        phrase: string;
+        derivationPath: string;
+    }) => string;
+    transfer: ({ memo, recipient, feeOptionKey, feeRate, assetValue }: import("@tcswap/toolboxes/utxo").UTXOTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    address: string;
+    createPrivateKeyFromPhrase: (phrase: string) => Promise<Uint8Array<ArrayBufferLike>>;
+    createTransaction: typeof import("@tcswap/toolboxes/cosmos").cosmosCreateTransaction;
+    fetchFeeRateFromSwapKit: typeof import("@tcswap/toolboxes/cosmos").fetchFeeRateFromSwapKit;
+    getAccount: (address: string) => Promise<import("@cosmjs/stargate").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").DirectSecp256k1HdWallet>;
+    getSignerFromPrivateKey: (privateKey: Uint8Array) => Promise<import("@cosmjs/proto-signing").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>;
+} | {
+    address: string;
+    broadcastTransaction: (transaction: import("@solana/web3.js/lib").Transaction | import("@solana/web3.js/lib").VersionedTransaction) => Promise<string>;
+    createKeysForPath: typeof import("@tcswap/toolboxes/solana").createKeysForPath;
+    createTransaction: ({ recipient, assetValue, memo, isProgramDerivedAddress, sender }: import("@tcswap/toolboxes/solana").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/toolboxes/solana").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/toolboxes/solana").SolanaTransferParams) => Promise<string>;
+} | {
+    address: string;
+    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<TronTransaction>;
+    signTransaction: (transaction: 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>;
+}>;
+export declare const getWeb3WalletMethods: ({ chain, walletProvider, }: {
+    walletProvider?: Eip1193Provider;
+    chain: EVMChain;
+}) => Promise<{
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    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/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    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/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+} | {
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
+    broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
+    call: <T>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").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/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
+        assetValue: import("@tcswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in import("@tcswap/helpers").FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
+        feeOption: import("@tcswap/helpers").FeeOption;
+        chain: 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/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
+        feeOptionKey?: import("@tcswap/helpers").FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+}>;
+//# sourceMappingURL=helpers.d.ts.map