@uswap/toolboxes 4.3.6

package/dist/types/evm/toolbox/evm.d.ts

@@ -0,0 +1,767 @@
+import { type EVMChain, FeeOption } from "@uswap/helpers";
+import type { EVMToolboxParams } from "../types";
+export declare function ETHToolbox({ provider, ...signer }: EVMToolboxParams): Promise<{
+    multicall: (callTuples: {
+        address: string;
+        data: string;
+    }[], multicallAddress?: string, funcName?: string, feeOptionKey?: FeeOption) => Promise<string>;
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@uswap/helpers").AssetValue[]>;
+    getNetworkParams: () => undefined;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("..").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("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("..").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("..").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("..").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("..").EVMTransferParams & {
+        assetValue: import("@uswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("..").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("..").EIP1559TxParams & {
+        feeOption: FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@uswap/helpers").AssetValue>;
+    getAddress: () => string | Promise<string> | undefined;
+    isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("..").EVMTxParams & {
+        feeOptionKey?: FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+}>;
+export declare const ARBToolbox: ({ provider: providerParam, ...toolboxSignerParams }: EVMToolboxParams) => Promise<{
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@uswap/helpers").AssetValue[]>;
+    getNetworkParams: () => import("@uswap/helpers").NetworkParams;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("..").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("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("..").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("..").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("..").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("..").EVMTransferParams & {
+        assetValue: import("@uswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("..").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("..").EIP1559TxParams & {
+        feeOption: FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@uswap/helpers").AssetValue>;
+    getAddress: () => string | Promise<string> | undefined;
+    isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("..").EVMTxParams & {
+        feeOptionKey?: FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+}>;
+export declare const AURORAToolbox: ({ provider: providerParam, ...toolboxSignerParams }: EVMToolboxParams) => Promise<{
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@uswap/helpers").AssetValue[]>;
+    getNetworkParams: () => import("@uswap/helpers").NetworkParams;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("..").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("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("..").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("..").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("..").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("..").EVMTransferParams & {
+        assetValue: import("@uswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("..").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("..").EIP1559TxParams & {
+        feeOption: FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@uswap/helpers").AssetValue>;
+    getAddress: () => string | Promise<string> | undefined;
+    isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("..").EVMTxParams & {
+        feeOptionKey?: FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+}>;
+export declare const AVAXToolbox: ({ provider: providerParam, ...toolboxSignerParams }: EVMToolboxParams) => Promise<{
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@uswap/helpers").AssetValue[]>;
+    getNetworkParams: () => import("@uswap/helpers").NetworkParams;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("..").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("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("..").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("..").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("..").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("..").EVMTransferParams & {
+        assetValue: import("@uswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("..").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("..").EIP1559TxParams & {
+        feeOption: FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@uswap/helpers").AssetValue>;
+    getAddress: () => string | Promise<string> | undefined;
+    isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("..").EVMTxParams & {
+        feeOptionKey?: FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+}>;
+export declare const BASEToolbox: ({ provider: providerParam, ...toolboxSignerParams }: EVMToolboxParams) => Promise<{
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@uswap/helpers").AssetValue[]>;
+    getNetworkParams: () => import("@uswap/helpers").NetworkParams;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("..").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("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("..").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("..").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("..").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("..").EVMTransferParams & {
+        assetValue: import("@uswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("..").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("..").EIP1559TxParams & {
+        feeOption: FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@uswap/helpers").AssetValue>;
+    getAddress: () => string | Promise<string> | undefined;
+    isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("..").EVMTxParams & {
+        feeOptionKey?: FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+}>;
+export declare const BERAToolbox: ({ provider: providerParam, ...toolboxSignerParams }: EVMToolboxParams) => Promise<{
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@uswap/helpers").AssetValue[]>;
+    getNetworkParams: () => import("@uswap/helpers").NetworkParams;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("..").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("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("..").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("..").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("..").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("..").EVMTransferParams & {
+        assetValue: import("@uswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("..").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("..").EIP1559TxParams & {
+        feeOption: FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@uswap/helpers").AssetValue>;
+    getAddress: () => string | Promise<string> | undefined;
+    isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("..").EVMTxParams & {
+        feeOptionKey?: FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+}>;
+export declare const BSCToolbox: ({ provider: providerParam, ...toolboxSignerParams }: EVMToolboxParams) => Promise<{
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@uswap/helpers").AssetValue[]>;
+    getNetworkParams: () => import("@uswap/helpers").NetworkParams;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("..").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("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("..").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("..").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("..").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("..").EVMTransferParams & {
+        assetValue: import("@uswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("..").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("..").EIP1559TxParams & {
+        feeOption: FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@uswap/helpers").AssetValue>;
+    getAddress: () => string | Promise<string> | undefined;
+    isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("..").EVMTxParams & {
+        feeOptionKey?: FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+}>;
+export declare const BotanixToolbox: ({ provider: providerParam, ...toolboxSignerParams }: EVMToolboxParams) => Promise<{
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@uswap/helpers").AssetValue[]>;
+    getNetworkParams: () => import("@uswap/helpers").NetworkParams;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("..").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("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("..").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("..").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("..").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("..").EVMTransferParams & {
+        assetValue: import("@uswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("..").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("..").EIP1559TxParams & {
+        feeOption: FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@uswap/helpers").AssetValue>;
+    getAddress: () => string | Promise<string> | undefined;
+    isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("..").EVMTxParams & {
+        feeOptionKey?: FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+}>;
+export declare const COREToolbox: ({ provider: providerParam, ...toolboxSignerParams }: EVMToolboxParams) => Promise<{
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@uswap/helpers").AssetValue[]>;
+    getNetworkParams: () => import("@uswap/helpers").NetworkParams;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("..").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("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("..").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("..").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("..").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("..").EVMTransferParams & {
+        assetValue: import("@uswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("..").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("..").EIP1559TxParams & {
+        feeOption: FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@uswap/helpers").AssetValue>;
+    getAddress: () => string | Promise<string> | undefined;
+    isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("..").EVMTxParams & {
+        feeOptionKey?: FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+}>;
+export declare const CORNToolbox: ({ provider: providerParam, ...toolboxSignerParams }: EVMToolboxParams) => Promise<{
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@uswap/helpers").AssetValue[]>;
+    getNetworkParams: () => import("@uswap/helpers").NetworkParams;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("..").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("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("..").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("..").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("..").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("..").EVMTransferParams & {
+        assetValue: import("@uswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("..").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("..").EIP1559TxParams & {
+        feeOption: FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@uswap/helpers").AssetValue>;
+    getAddress: () => string | Promise<string> | undefined;
+    isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("..").EVMTxParams & {
+        feeOptionKey?: FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+}>;
+export declare const CROToolbox: ({ provider: providerParam, ...toolboxSignerParams }: EVMToolboxParams) => Promise<{
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@uswap/helpers").AssetValue[]>;
+    getNetworkParams: () => import("@uswap/helpers").NetworkParams;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("..").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("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("..").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("..").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("..").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("..").EVMTransferParams & {
+        assetValue: import("@uswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("..").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("..").EIP1559TxParams & {
+        feeOption: FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@uswap/helpers").AssetValue>;
+    getAddress: () => string | Promise<string> | undefined;
+    isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("..").EVMTxParams & {
+        feeOptionKey?: FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+}>;
+export declare const GNOToolbox: ({ provider: providerParam, ...toolboxSignerParams }: EVMToolboxParams) => Promise<{
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@uswap/helpers").AssetValue[]>;
+    getNetworkParams: () => import("@uswap/helpers").NetworkParams;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("..").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("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("..").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("..").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("..").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("..").EVMTransferParams & {
+        assetValue: import("@uswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("..").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("..").EIP1559TxParams & {
+        feeOption: FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@uswap/helpers").AssetValue>;
+    getAddress: () => string | Promise<string> | undefined;
+    isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("..").EVMTxParams & {
+        feeOptionKey?: FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+}>;
+export declare const HYPEREVMToolbox: ({ provider: providerParam, ...toolboxSignerParams }: EVMToolboxParams) => Promise<{
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@uswap/helpers").AssetValue[]>;
+    getNetworkParams: () => import("@uswap/helpers").NetworkParams;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("..").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("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("..").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("..").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("..").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("..").EVMTransferParams & {
+        assetValue: import("@uswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("..").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("..").EIP1559TxParams & {
+        feeOption: FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@uswap/helpers").AssetValue>;
+    getAddress: () => string | Promise<string> | undefined;
+    isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("..").EVMTxParams & {
+        feeOptionKey?: FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+}>;
+export declare const MATICToolbox: ({ provider: providerParam, ...toolboxSignerParams }: EVMToolboxParams) => Promise<{
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@uswap/helpers").AssetValue[]>;
+    getNetworkParams: () => import("@uswap/helpers").NetworkParams;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("..").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("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("..").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("..").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("..").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("..").EVMTransferParams & {
+        assetValue: import("@uswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("..").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("..").EIP1559TxParams & {
+        feeOption: FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@uswap/helpers").AssetValue>;
+    getAddress: () => string | Promise<string> | undefined;
+    isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("..").EVMTxParams & {
+        feeOptionKey?: FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+}>;
+export declare const SONICToolbox: ({ provider: providerParam, ...toolboxSignerParams }: EVMToolboxParams) => Promise<{
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@uswap/helpers").AssetValue[]>;
+    getNetworkParams: () => import("@uswap/helpers").NetworkParams;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("..").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("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("..").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("..").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("..").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("..").EVMTransferParams & {
+        assetValue: import("@uswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("..").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("..").EIP1559TxParams & {
+        feeOption: FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@uswap/helpers").AssetValue>;
+    getAddress: () => string | Promise<string> | undefined;
+    isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("..").EVMTxParams & {
+        feeOptionKey?: FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+}>;
+export declare const UNIToolbox: ({ provider: providerParam, ...toolboxSignerParams }: EVMToolboxParams) => Promise<{
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@uswap/helpers").AssetValue[]>;
+    getNetworkParams: () => import("@uswap/helpers").NetworkParams;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("..").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("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("..").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("..").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("..").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("..").EVMTransferParams & {
+        assetValue: import("@uswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("..").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("..").EIP1559TxParams & {
+        feeOption: FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@uswap/helpers").AssetValue>;
+    getAddress: () => string | Promise<string> | undefined;
+    isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("..").EVMTxParams & {
+        feeOptionKey?: FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+}>;
+export declare const XLayerToolbox: ({ provider: providerParam, ...toolboxSignerParams }: EVMToolboxParams) => Promise<{
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@uswap/helpers").AssetValue[]>;
+    getNetworkParams: () => import("@uswap/helpers").NetworkParams;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("..").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("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("..").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("..").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("..").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("..").EVMTransferParams & {
+        assetValue: import("@uswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("..").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("..").EIP1559TxParams & {
+        feeOption: FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@uswap/helpers").AssetValue>;
+    getAddress: () => string | Promise<string> | undefined;
+    isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("..").EVMTxParams & {
+        feeOptionKey?: FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+}>;
+export declare const MONADToolbox: ({ provider: providerParam, ...toolboxSignerParams }: EVMToolboxParams) => Promise<{
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@uswap/helpers").AssetValue[]>;
+    getNetworkParams: () => import("@uswap/helpers").NetworkParams;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("..").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("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("..").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("..").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("..").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("..").EVMTransferParams & {
+        assetValue: import("@uswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("..").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("..").EIP1559TxParams & {
+        feeOption: FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@uswap/helpers").AssetValue>;
+    getAddress: () => string | Promise<string> | undefined;
+    isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("..").EVMTxParams & {
+        feeOptionKey?: FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+}>;
+export declare const MEGAETHToolbox: ({ provider: providerParam, ...toolboxSignerParams }: EVMToolboxParams) => Promise<{
+    getBalance: (address: string, scamFilter?: boolean) => Promise<import("@uswap/helpers").AssetValue[]>;
+    getNetworkParams: () => import("@uswap/helpers").NetworkParams | undefined;
+    approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("..").ApproveParams) => Promise<string>;
+    approvedAmount: ({ assetAddress, spenderAddress, from }: import("..").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("..").CallParams) => Promise<T>;
+    createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("..").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("..").CallParams) => Promise<import("ethers").ContractTransaction>;
+    createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("..").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
+    EIP1193SendTransaction: ({ value, ...params }: import("..").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
+    estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("..").EstimateCallParams) => Promise<bigint>;
+    estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("..").EVMTransferParams & {
+        assetValue: import("@uswap/helpers").AssetValue;
+        funcName?: string;
+        funcParams?: unknown[];
+        txOverrides?: import("..").EVMTxParams;
+        data?: string;
+    }) => Promise<bigint>;
+    estimateGasPrices: () => Promise<{ [key in FeeOption]: {
+        l1GasPrice?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+    }; }>;
+    estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("..").EIP1559TxParams & {
+        feeOption: FeeOption;
+        chain: EVMChain;
+    }) => Promise<import("@uswap/helpers").AssetValue>;
+    getAddress: () => string | Promise<string> | undefined;
+    isApproved: ({ assetAddress, spenderAddress, from, amount }: import("..").IsApprovedParams) => Promise<boolean>;
+    sendTransaction: ({ feeOptionKey, ...tx }: import("..").EVMTxParams & {
+        feeOptionKey?: FeeOption;
+    }) => Promise<string>;
+    signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
+    transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("..").EVMTransferParams) => Promise<string>;
+    validateAddress: (address: string) => boolean;
+}>;
+//# sourceMappingURL=evm.d.ts.map