@tcswap/core 4.1.16

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (8) hide show
  1. package/dist/index.cjs +4 -0
  2. package/dist/index.cjs.map +10 -0
  3. package/dist/index.js +4 -0
  4. package/dist/index.js.map +10 -0
  5. package/dist/types/index.d.ts +2005 -0
  6. package/dist/types/index.d.ts.map +1 -0
  7. package/package.json +36 -0
  8. package/src/index.ts +409 -0
package/dist/types/index.d.ts ADDED
@@ -0,0 +1,2005 @@
1
+ /**
2
+ * Modifications © 2025 Horizontal Systems.
3
+ */
4
+ import { AssetValue, Chain, type ChainWallet, type ConditionalAssetValueReturn, type EVMChain, type FeeOption, type GenericTransferParams, ProviderName as PluginNameEnum, type SwapParams, type USwapConfigState, type WalletOption } from "@tcswap/helpers";
5
+ import type { QuoteResponseRoute } from "@tcswap/helpers/api";
6
+ import type { createPlugin } from "@tcswap/plugins";
7
+ import type { FullWallet } from "@tcswap/toolboxes";
8
+ import type { EVMCreateTransactionParams, EVMTransferParams } from "@tcswap/toolboxes/evm";
9
+ import type { createWallet } from "@tcswap/wallets";
10
+ export type USwapParams<P, W> = {
11
+ config?: USwapConfigState;
12
+ plugins?: P;
13
+ wallets?: W;
14
+ };
15
+ export declare function USwap<Plugins extends ReturnType<typeof createPlugin>, Wallets extends ReturnType<typeof createWallet>>({ config, plugins, wallets, getActiveWallet, }?: {
16
+ config?: USwapConfigState;
17
+ plugins?: Plugins;
18
+ wallets?: Wallets;
19
+ getActiveWallet?: () => WalletOption | undefined;
20
+ }): (keyof Plugins extends infer T extends keyof Plugins ? { [key in T]: ReturnType<Plugins[key]>; } : never) & { [key_1 in keyof Wallets]: ReturnType<Wallets[key_1]["connectWallet"]>; } & {
21
+ approveAssetValue: (assetValue: AssetValue, contractAddress: string | keyof Plugins) => Promise<string>;
22
+ disconnectAll: () => void;
23
+ disconnectChain: <T_1 extends Chain>(chain: T_1) => void;
24
+ estimateTransactionFee: <P extends keyof Plugins, T_1 extends "transfer" | "approve" | "swap">({ type, feeOptionKey, params, }: {
25
+ type: T_1;
26
+ params: {
27
+ transfer: EVMTransferParams | (GenericTransferParams & {
28
+ sender?: string;
29
+ });
30
+ approve: {
31
+ assetValue: AssetValue;
32
+ contractAddress: string;
33
+ feeOptionKey?: FeeOption;
34
+ };
35
+ swap: import("@tcswap/helpers").GenericSwapParams<{
36
+ buyAsset: string;
37
+ expectedBuyAmount: string;
38
+ fees: {
39
+ amount: string;
40
+ asset: string;
41
+ chain: string;
42
+ protocol: PluginNameEnum;
43
+ type: import("@tcswap/helpers").FeeTypeEnum;
44
+ }[];
45
+ providers: PluginNameEnum[];
46
+ sellAmount: string;
47
+ sellAsset: string;
48
+ destinationAddress?: string | undefined;
49
+ estimatedTime?: {
50
+ total: number;
51
+ inbound?: number | undefined;
52
+ outbound?: number | undefined;
53
+ swap?: number | undefined;
54
+ } | undefined;
55
+ expectedBuyAmountMaxSlippage?: string | undefined;
56
+ expiration?: string | undefined;
57
+ inboundAddress?: string | undefined;
58
+ legs?: {
59
+ buyAmount: string;
60
+ buyAmountMaxSlippage: string;
61
+ buyAsset: string;
62
+ provider: PluginNameEnum;
63
+ sellAmount: string;
64
+ sellAsset: string;
65
+ fees?: {
66
+ amount: string;
67
+ asset: string;
68
+ chain: string;
69
+ protocol: PluginNameEnum;
70
+ type: import("@tcswap/helpers").FeeTypeEnum;
71
+ }[] | undefined;
72
+ }[] | undefined;
73
+ memo?: string | undefined;
74
+ meta?: {
75
+ assets?: {
76
+ asset: string;
77
+ image: string;
78
+ price: number;
79
+ }[] | undefined;
80
+ maxStreamingQuantity?: number | undefined;
81
+ streamingInterval?: number | undefined;
82
+ tags?: import("@tcswap/helpers/api").PriorityLabel[] | undefined;
83
+ affiliate?: string | undefined;
84
+ affiliateFee?: string | undefined;
85
+ approvalAddress?: string | undefined;
86
+ chainflip?: {
87
+ destinationAddress: string;
88
+ buyAsset: {
89
+ asset: string;
90
+ chain: string;
91
+ };
92
+ sellAsset: {
93
+ asset: string;
94
+ chain: string;
95
+ };
96
+ affiliateFees?: {
97
+ brokerAddress: string;
98
+ feeBps: number;
99
+ }[] | undefined;
100
+ brokerCommissionBps?: number | undefined;
101
+ channelMetadata?: {
102
+ cfParameters?: string | undefined;
103
+ gasBudget?: string | undefined;
104
+ message?: string | undefined;
105
+ } | undefined;
106
+ dcaParameters?: {
107
+ chunkInterval?: number | undefined;
108
+ numberOfChunks?: number | undefined;
109
+ } | undefined;
110
+ maxBoostFeeBps?: number | undefined;
111
+ refundParameters?: {
112
+ minPrice?: string | undefined;
113
+ refundAddress?: string | undefined;
114
+ retryDuration?: number | undefined;
115
+ } | undefined;
116
+ } | undefined;
117
+ garden?: {
118
+ destinationAddress: string;
119
+ buyAsset: string;
120
+ sellAmount: string;
121
+ sellAsset: string;
122
+ slippage: number;
123
+ sourceAddress: string;
124
+ affiliateFees?: {
125
+ feeBps: number;
126
+ nearId: string;
127
+ } | undefined;
128
+ } | undefined;
129
+ near?: {
130
+ destinationAddress: string;
131
+ buyAsset: string;
132
+ sellAmount: string;
133
+ sellAsset: string;
134
+ slippage: number;
135
+ sourceAddress: string;
136
+ affiliateFees?: {
137
+ feeBps: number;
138
+ nearId: string;
139
+ } | undefined;
140
+ } | undefined;
141
+ priceImpact?: number | undefined;
142
+ referrer?: string | undefined;
143
+ txType?: import("@tcswap/helpers/api").RouteQuoteTxType | undefined;
144
+ } | undefined;
145
+ refundAddress?: string | undefined;
146
+ sourceAddress?: string | undefined;
147
+ targetAddress?: string | undefined;
148
+ tx?: string | {
149
+ data: string;
150
+ from: string;
151
+ to: string;
152
+ value: string;
153
+ } | {
154
+ accountNumber: number;
155
+ chainId: import("@tcswap/types").ChainId;
156
+ fee: {
157
+ amount: {
158
+ amount: string;
159
+ denom: string;
160
+ }[];
161
+ gas: string;
162
+ };
163
+ memo: string;
164
+ msgs: {
165
+ typeUrl: string;
166
+ value: unknown;
167
+ }[];
168
+ sequence: number;
169
+ } | undefined;
170
+ txType?: import("@tcswap/helpers/api").RouteQuoteTxType | undefined;
171
+ warnings?: {
172
+ code: import("@tcswap/helpers").WarningCodeEnum;
173
+ display: string;
174
+ tooltip?: string | undefined;
175
+ }[] | undefined;
176
+ }> & {
177
+ pluginName?: P | undefined;
178
+ } & {
179
+ assetValue: AssetValue;
180
+ };
181
+ }[T_1];
182
+ feeOptionKey: FeeOption;
183
+ }) => Promise<AssetValue | undefined>;
184
+ getAddress: <T_1 extends Chain>(chain: T_1) => string;
185
+ getAllWallets: () => {
186
+ ARB: ChainWallet<Chain.Arbitrum> & {
187
+ approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
188
+ approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
189
+ broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
190
+ call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T_1>;
191
+ createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
192
+ createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
193
+ createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
194
+ createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
195
+ createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
196
+ EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
197
+ estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
198
+ estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
199
+ assetValue: import("@tcswap/helpers").AssetValue;
200
+ funcName?: string;
201
+ funcParams?: unknown[];
202
+ txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
203
+ data?: string;
204
+ }) => Promise<bigint>;
205
+ estimateGasPrices: () => Promise<{ [key_2 in FeeOption]: {
206
+ l1GasPrice?: bigint;
207
+ gasPrice?: bigint;
208
+ maxFeePerGas?: bigint;
209
+ maxPriorityFeePerGas?: bigint;
210
+ }; }>;
211
+ estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
212
+ feeOption: FeeOption;
213
+ chain: EVMChain;
214
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
215
+ getAddress: () => string | Promise<string> | undefined;
216
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
217
+ getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
218
+ isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
219
+ sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
220
+ feeOptionKey?: FeeOption;
221
+ }) => Promise<string>;
222
+ signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
223
+ transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
224
+ validateAddress: (address: string) => boolean;
225
+ };
226
+ AURORA: ChainWallet<Chain.Aurora> & {
227
+ approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
228
+ approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
229
+ broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
230
+ call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T_1>;
231
+ createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
232
+ createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
233
+ createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
234
+ createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
235
+ createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
236
+ EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
237
+ estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
238
+ estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
239
+ assetValue: import("@tcswap/helpers").AssetValue;
240
+ funcName?: string;
241
+ funcParams?: unknown[];
242
+ txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
243
+ data?: string;
244
+ }) => Promise<bigint>;
245
+ estimateGasPrices: () => Promise<{ [key_2 in FeeOption]: {
246
+ l1GasPrice?: bigint;
247
+ gasPrice?: bigint;
248
+ maxFeePerGas?: bigint;
249
+ maxPriorityFeePerGas?: bigint;
250
+ }; }>;
251
+ estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
252
+ feeOption: FeeOption;
253
+ chain: EVMChain;
254
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
255
+ getAddress: () => string | Promise<string> | undefined;
256
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
257
+ getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
258
+ isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
259
+ sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
260
+ feeOptionKey?: FeeOption;
261
+ }) => Promise<string>;
262
+ signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
263
+ transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
264
+ validateAddress: (address: string) => boolean;
265
+ };
266
+ AVAX: ChainWallet<Chain.Avalanche> & {
267
+ approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
268
+ approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
269
+ broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
270
+ call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T_1>;
271
+ createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
272
+ createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
273
+ createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
274
+ createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
275
+ createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
276
+ EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
277
+ estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
278
+ estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
279
+ assetValue: import("@tcswap/helpers").AssetValue;
280
+ funcName?: string;
281
+ funcParams?: unknown[];
282
+ txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
283
+ data?: string;
284
+ }) => Promise<bigint>;
285
+ estimateGasPrices: () => Promise<{ [key_2 in FeeOption]: {
286
+ l1GasPrice?: bigint;
287
+ gasPrice?: bigint;
288
+ maxFeePerGas?: bigint;
289
+ maxPriorityFeePerGas?: bigint;
290
+ }; }>;
291
+ estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
292
+ feeOption: FeeOption;
293
+ chain: EVMChain;
294
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
295
+ getAddress: () => string | Promise<string> | undefined;
296
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
297
+ getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
298
+ isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
299
+ sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
300
+ feeOptionKey?: FeeOption;
301
+ }) => Promise<string>;
302
+ signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
303
+ transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
304
+ validateAddress: (address: string) => boolean;
305
+ };
306
+ BASE: ChainWallet<Chain.Base> & {
307
+ approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
308
+ approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
309
+ broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
310
+ call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T_1>;
311
+ createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
312
+ createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
313
+ createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
314
+ createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
315
+ createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
316
+ EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
317
+ estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
318
+ estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
319
+ assetValue: import("@tcswap/helpers").AssetValue;
320
+ funcName?: string;
321
+ funcParams?: unknown[];
322
+ txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
323
+ data?: string;
324
+ }) => Promise<bigint>;
325
+ estimateGasPrices: () => Promise<{ [key_2 in FeeOption]: {
326
+ l1GasPrice?: bigint;
327
+ gasPrice?: bigint;
328
+ maxFeePerGas?: bigint;
329
+ maxPriorityFeePerGas?: bigint;
330
+ }; }>;
331
+ estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
332
+ feeOption: FeeOption;
333
+ chain: EVMChain;
334
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
335
+ getAddress: () => string | Promise<string> | undefined;
336
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
337
+ getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
338
+ isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
339
+ sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
340
+ feeOptionKey?: FeeOption;
341
+ }) => Promise<string>;
342
+ signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
343
+ transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
344
+ validateAddress: (address: string) => boolean;
345
+ };
346
+ BERA: ChainWallet<Chain.Berachain> & {
347
+ approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
348
+ approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
349
+ broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
350
+ call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T_1>;
351
+ createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
352
+ createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
353
+ createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
354
+ createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
355
+ createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
356
+ EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
357
+ estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
358
+ estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
359
+ assetValue: import("@tcswap/helpers").AssetValue;
360
+ funcName?: string;
361
+ funcParams?: unknown[];
362
+ txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
363
+ data?: string;
364
+ }) => Promise<bigint>;
365
+ estimateGasPrices: () => Promise<{ [key_2 in FeeOption]: {
366
+ l1GasPrice?: bigint;
367
+ gasPrice?: bigint;
368
+ maxFeePerGas?: bigint;
369
+ maxPriorityFeePerGas?: bigint;
370
+ }; }>;
371
+ estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
372
+ feeOption: FeeOption;
373
+ chain: EVMChain;
374
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
375
+ getAddress: () => string | Promise<string> | undefined;
376
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
377
+ getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
378
+ isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
379
+ sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
380
+ feeOptionKey?: FeeOption;
381
+ }) => Promise<string>;
382
+ signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
383
+ transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
384
+ validateAddress: (address: string) => boolean;
385
+ };
386
+ BSC: ChainWallet<Chain.BinanceSmartChain> & {
387
+ approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
388
+ approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
389
+ broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
390
+ call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T_1>;
391
+ createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
392
+ createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
393
+ createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
394
+ createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
395
+ createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
396
+ EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
397
+ estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
398
+ estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
399
+ assetValue: import("@tcswap/helpers").AssetValue;
400
+ funcName?: string;
401
+ funcParams?: unknown[];
402
+ txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
403
+ data?: string;
404
+ }) => Promise<bigint>;
405
+ estimateGasPrices: () => Promise<{ [key_2 in FeeOption]: {
406
+ l1GasPrice?: bigint;
407
+ gasPrice?: bigint;
408
+ maxFeePerGas?: bigint;
409
+ maxPriorityFeePerGas?: bigint;
410
+ }; }>;
411
+ estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
412
+ feeOption: FeeOption;
413
+ chain: EVMChain;
414
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
415
+ getAddress: () => string | Promise<string> | undefined;
416
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
417
+ getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
418
+ isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
419
+ sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
420
+ feeOptionKey?: FeeOption;
421
+ }) => Promise<string>;
422
+ signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
423
+ transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
424
+ validateAddress: (address: string) => boolean;
425
+ };
426
+ BTC: ChainWallet<Chain.Bitcoin> & {
427
+ accumulative: typeof import("@tcswap/toolboxes/utxo").accumulative;
428
+ broadcastTx: (txHash: string) => Promise<string>;
429
+ calculateTxSize: ({ inputs, outputs, feeRate }: import("@tcswap/toolboxes/utxo").UTXOCalculateTxSizeParams) => number;
430
+ createKeysForPath: (params: {
431
+ wif?: string;
432
+ phrase?: string;
433
+ derivationPath?: string;
434
+ }) => import("ecpair").ECPairInterface;
435
+ createTransaction: ({ assetValue, recipient, memo, feeRate, sender, fetchTxHex, }: import("@tcswap/toolboxes/utxo").UTXOBuildTxParams) => Promise<{
436
+ psbt: import("bitcoinjs-lib").Psbt;
437
+ utxos: import("@tcswap/toolboxes/utxo").UTXOType[];
438
+ inputs: import("@tcswap/toolboxes/utxo").UTXOType[];
439
+ }>;
440
+ estimateMaxSendableAmount: ({ from, memo, feeRate, feeOptionKey, recipients, }: {
441
+ from: string;
442
+ memo?: string;
443
+ feeRate?: number;
444
+ feeOptionKey?: FeeOption;
445
+ recipients?: number | import("@tcswap/toolboxes/utxo").TargetOutput[];
446
+ }) => Promise<AssetValue>;
447
+ estimateTransactionFee: (params: {
448
+ assetValue: AssetValue;
449
+ recipient: string;
450
+ sender: string;
451
+ memo?: string;
452
+ feeOptionKey?: FeeOption;
453
+ feeRate?: number;
454
+ fetchTxHex?: boolean;
455
+ }) => Promise<AssetValue>;
456
+ getAddress: () => Promise<string | undefined>;
457
+ getAddressFromKeys: (keys: import("ecpair").ECPairInterface | import("@tcswap/toolboxes/utxo").BchECPair) => string;
458
+ getBalance: (address: string, scamFilter?: boolean) => Promise<AssetValue[]>;
459
+ getFeeRates: () => Promise<{
460
+ average: number;
461
+ fast: number;
462
+ fastest: number;
463
+ }>;
464
+ getInputsOutputsFee: ({ assetValue, feeOptionKey, feeRate, memo, sender, recipient, }: Omit<import("@tcswap/toolboxes/utxo").UTXOBuildTxParams, "feeRate"> & {
465
+ feeOptionKey?: FeeOption;
466
+ feeRate?: number;
467
+ }) => Promise<{
468
+ fee: number;
469
+ inputs: (import("@tcswap/toolboxes/utxo").UTXOType | import("@tcswap/toolboxes/utxo").UTXOInputWithScriptType)[];
470
+ outputs: import("@tcswap/toolboxes/utxo").TargetOutput[];
471
+ } | {
472
+ fee: number;
473
+ inputs?: undefined;
474
+ outputs?: undefined;
475
+ }>;
476
+ getPrivateKeyFromMnemonic: (params: {
477
+ phrase: string;
478
+ derivationPath: string;
479
+ }) => string;
480
+ transfer: ({ memo, recipient, feeOptionKey, feeRate, assetValue }: import("@tcswap/toolboxes/utxo").UTXOTransferParams) => Promise<string>;
481
+ validateAddress: (address: string) => boolean;
482
+ };
483
+ BCH: ChainWallet<Chain.BitcoinCash> & {
484
+ broadcastTx: (txHash: string) => Promise<string>;
485
+ buildTx: ({ assetValue, recipient, memo, feeRate, sender, setSigHashType, }: import("@tcswap/toolboxes/utxo").UTXOBuildTxParams & {
486
+ setSigHashType?: boolean;
487
+ }) => Promise<{
488
+ inputs: import("@tcswap/toolboxes/utxo").UTXOType[];
489
+ psbt: import("bitcoinjs-lib").Psbt;
490
+ utxos: {
491
+ address: string;
492
+ hash: string;
493
+ index: number;
494
+ txHex: string | undefined;
495
+ value: number;
496
+ witnessUtxo: {
497
+ script: Buffer<ArrayBuffer>;
498
+ value: number;
499
+ };
500
+ }[];
501
+ }>;
502
+ createTransaction: ({ assetValue, recipient, memo, feeRate, sender }: import("@tcswap/toolboxes/utxo").UTXOBuildTxParams) => Promise<{
503
+ builder: import("@tcswap/toolboxes/utxo").TransactionBuilderType;
504
+ utxos: (import("@tcswap/toolboxes/utxo").UTXOType | import("@tcswap/toolboxes/utxo").UTXOInputWithScriptType)[];
505
+ }>;
506
+ getAddress: () => Promise<string | undefined>;
507
+ getAddressFromKeys: (keys: {
508
+ getAddress: (index?: number) => string;
509
+ }) => string;
510
+ getBalance: (address: string, _scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
511
+ getFeeRates: () => Promise<{
512
+ average: number;
513
+ fast: number;
514
+ fastest: number;
515
+ }>;
516
+ stripPrefix: typeof import("@tcswap/toolboxes/utxo").stripPrefix;
517
+ stripToCashAddress: typeof import("@tcswap/toolboxes/utxo").stripToCashAddress;
518
+ transfer: ({ recipient, assetValue, feeOptionKey, ...rest }: import("@tcswap/toolboxes/utxo").UTXOTransferParams) => Promise<string>;
519
+ validateAddress: typeof import("@tcswap/toolboxes/utxo").bchValidateAddress;
520
+ accumulative: typeof import("@tcswap/toolboxes/utxo").accumulative;
521
+ calculateTxSize: ({ inputs, outputs, feeRate }: import("@tcswap/toolboxes/utxo").UTXOCalculateTxSizeParams) => number;
522
+ createKeysForPath: (params: {
523
+ wif?: string;
524
+ phrase?: string;
525
+ derivationPath?: string;
526
+ }) => import("@tcswap/toolboxes/utxo").BchECPair;
527
+ estimateMaxSendableAmount: ({ from, memo, feeRate, feeOptionKey, recipients, }: {
528
+ from: string;
529
+ memo?: string;
530
+ feeRate?: number;
531
+ feeOptionKey?: FeeOption;
532
+ recipients?: number | import("@tcswap/toolboxes/utxo").TargetOutput[];
533
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
534
+ estimateTransactionFee: (params: {
535
+ assetValue: import("@tcswap/helpers").AssetValue;
536
+ recipient: string;
537
+ sender: string;
538
+ memo?: string;
539
+ feeOptionKey?: FeeOption;
540
+ feeRate?: number;
541
+ fetchTxHex?: boolean;
542
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
543
+ getInputsOutputsFee: ({ assetValue, feeOptionKey, feeRate, memo, sender, recipient, }: Omit<import("@tcswap/toolboxes/utxo").UTXOBuildTxParams, "feeRate"> & {
544
+ feeOptionKey?: FeeOption;
545
+ feeRate?: number;
546
+ }) => Promise<{
547
+ fee: number;
548
+ inputs: (import("@tcswap/toolboxes/utxo").UTXOType | import("@tcswap/toolboxes/utxo").UTXOInputWithScriptType)[];
549
+ outputs: import("@tcswap/toolboxes/utxo").TargetOutput[];
550
+ } | {
551
+ fee: number;
552
+ inputs?: undefined;
553
+ outputs?: undefined;
554
+ }>;
555
+ getPrivateKeyFromMnemonic: (params: {
556
+ phrase: string;
557
+ derivationPath: string;
558
+ }) => string;
559
+ };
560
+ BOTANIX: ChainWallet<Chain.Botanix> & {
561
+ approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
562
+ approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
563
+ broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
564
+ call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T_1>;
565
+ createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
566
+ createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
567
+ createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
568
+ createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
569
+ createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
570
+ EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
571
+ estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
572
+ estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
573
+ assetValue: import("@tcswap/helpers").AssetValue;
574
+ funcName?: string;
575
+ funcParams?: unknown[];
576
+ txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
577
+ data?: string;
578
+ }) => Promise<bigint>;
579
+ estimateGasPrices: () => Promise<{ [key_2 in FeeOption]: {
580
+ l1GasPrice?: bigint;
581
+ gasPrice?: bigint;
582
+ maxFeePerGas?: bigint;
583
+ maxPriorityFeePerGas?: bigint;
584
+ }; }>;
585
+ estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
586
+ feeOption: FeeOption;
587
+ chain: EVMChain;
588
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
589
+ getAddress: () => string | Promise<string> | undefined;
590
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
591
+ getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
592
+ isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
593
+ sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
594
+ feeOptionKey?: FeeOption;
595
+ }) => Promise<string>;
596
+ signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
597
+ transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
598
+ validateAddress: (address: string) => boolean;
599
+ };
600
+ ADA: ChainWallet<Chain.Cardano> & {
601
+ createTransaction: ({ recipient, assetValue, memo, }: {
602
+ recipient: string;
603
+ assetValue: AssetValue;
604
+ memo?: string;
605
+ }) => Promise<{
606
+ tx: import("@meshsdk/core").Transaction;
607
+ unsignedTx: string;
608
+ }>;
609
+ estimateTransactionFee: () => Promise<AssetValue>;
610
+ getAddress: () => string;
611
+ getBalance: (addressParam?: string) => Promise<AssetValue[]>;
612
+ signTransaction: (txParams: string) => Promise<string>;
613
+ transfer: ({ recipient, assetValue, memo, }: {
614
+ recipient: string;
615
+ assetValue: AssetValue;
616
+ memo?: string;
617
+ }) => Promise<string>;
618
+ validateAddress: (address: string) => boolean;
619
+ };
620
+ FLIP: ChainWallet<Chain.Chainflip> & {
621
+ api: import("@polkadot/api").ApiPromise;
622
+ broadcast: (tx: import("@polkadot/api/types").SubmittableExtrinsic<"promise">, callback?: import("@polkadot/types/types").Callback<import("@polkadot/types/types").ISubmittableResult>) => Promise<string | (() => void)>;
623
+ convertAddress: (address: string, newPrefix: number) => string;
624
+ createKeyring: (phrase: string) => Promise<import("@polkadot/keyring/types").KeyringPair>;
625
+ createTransaction: (params: import("@tcswap/helpers").GenericCreateTransactionParams) => import("@polkadot/api/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | undefined;
626
+ decodeAddress: (address: string, networkPrefix?: number) => Uint8Array<ArrayBufferLike>;
627
+ encodeAddress: (address: Uint8Array, encoding?: "ss58" | "hex", networkPrefix?: number) => string;
628
+ estimateTransactionFee: (params: import("@tcswap/toolboxes/substrate").SubstrateTransferParams) => Promise<AssetValue | undefined>;
629
+ gasAsset: AssetValue;
630
+ getAddress: (keyring?: import("@polkadot/types/types").IKeyringPair | import("@polkadot/types/types").Signer) => string | undefined;
631
+ getBalance: (address: string) => Promise<AssetValue[]>;
632
+ network: import("@tcswap/toolboxes/substrate").SubstrateNetwork;
633
+ sign: (tx: import("@polkadot/api/types").SubmittableExtrinsic<"promise">) => Promise<import("@polkadot/api/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
634
+ signAndBroadcast: ({ tx, callback, address, }: {
635
+ tx: import("@polkadot/api/types").SubmittableExtrinsic<"promise">;
636
+ callback?: import("@polkadot/types/types").Callback<import("@polkadot/types/types").ISubmittableResult>;
637
+ address?: string;
638
+ }) => string | Promise<string> | Promise<() => void>;
639
+ transfer: (params: import("@tcswap/toolboxes/substrate").SubstrateTransferParams) => Promise<string>;
640
+ validateAddress: (address: string) => boolean;
641
+ };
642
+ CORE: ChainWallet<Chain.Core> & {
643
+ approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
644
+ approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
645
+ broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
646
+ call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T_1>;
647
+ createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
648
+ createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
649
+ createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
650
+ createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
651
+ createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
652
+ EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
653
+ estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
654
+ estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
655
+ assetValue: import("@tcswap/helpers").AssetValue;
656
+ funcName?: string;
657
+ funcParams?: unknown[];
658
+ txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
659
+ data?: string;
660
+ }) => Promise<bigint>;
661
+ estimateGasPrices: () => Promise<{ [key_2 in FeeOption]: {
662
+ l1GasPrice?: bigint;
663
+ gasPrice?: bigint;
664
+ maxFeePerGas?: bigint;
665
+ maxPriorityFeePerGas?: bigint;
666
+ }; }>;
667
+ estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
668
+ feeOption: FeeOption;
669
+ chain: EVMChain;
670
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
671
+ getAddress: () => string | Promise<string> | undefined;
672
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
673
+ getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
674
+ isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
675
+ sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
676
+ feeOptionKey?: FeeOption;
677
+ }) => Promise<string>;
678
+ signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
679
+ transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
680
+ validateAddress: (address: string) => boolean;
681
+ };
682
+ CORN: ChainWallet<Chain.Corn> & {
683
+ approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
684
+ approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
685
+ broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
686
+ call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T_1>;
687
+ createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
688
+ createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
689
+ createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
690
+ createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
691
+ createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
692
+ EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
693
+ estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
694
+ estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
695
+ assetValue: import("@tcswap/helpers").AssetValue;
696
+ funcName?: string;
697
+ funcParams?: unknown[];
698
+ txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
699
+ data?: string;
700
+ }) => Promise<bigint>;
701
+ estimateGasPrices: () => Promise<{ [key_2 in FeeOption]: {
702
+ l1GasPrice?: bigint;
703
+ gasPrice?: bigint;
704
+ maxFeePerGas?: bigint;
705
+ maxPriorityFeePerGas?: bigint;
706
+ }; }>;
707
+ estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
708
+ feeOption: FeeOption;
709
+ chain: EVMChain;
710
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
711
+ getAddress: () => string | Promise<string> | undefined;
712
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
713
+ getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
714
+ isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
715
+ sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
716
+ feeOptionKey?: FeeOption;
717
+ }) => Promise<string>;
718
+ signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
719
+ transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
720
+ validateAddress: (address: string) => boolean;
721
+ };
722
+ GAIA: ChainWallet<Chain.Cosmos> & {
723
+ createPrivateKeyFromPhrase: (phrase: string) => Promise<Uint8Array<ArrayBufferLike>>;
724
+ createTransaction: typeof import("@tcswap/toolboxes/cosmos").cosmosCreateTransaction;
725
+ fetchFeeRateFromSwapKit: typeof import("@tcswap/toolboxes/cosmos").fetchFeeRateFromSwapKit;
726
+ getAccount: (address: string) => Promise<import("@cosmjs/stargate").Account | null>;
727
+ getAddress: () => Promise<string | undefined>;
728
+ getBalance: (address: string, _potentialScamFilter?: boolean) => Promise<AssetValue[]>;
729
+ getBalanceAsDenoms: (address: string) => Promise<{
730
+ denom: string;
731
+ amount: string;
732
+ }[]>;
733
+ getFees: () => Promise<{
734
+ average: import("@tcswap/helpers").USwapNumber;
735
+ fast: import("@tcswap/helpers").USwapNumber;
736
+ fastest: import("@tcswap/helpers").USwapNumber;
737
+ }>;
738
+ getPubKey: () => Promise<string>;
739
+ getSignerFromPhrase: ({ phrase, derivationPath }: {
740
+ phrase: string;
741
+ derivationPath: import("@tcswap/helpers").DerivationPathArray;
742
+ }) => Promise<import("@cosmjs/proto-signing").DirectSecp256k1HdWallet>;
743
+ getSignerFromPrivateKey: (privateKey: Uint8Array) => Promise<import("@cosmjs/proto-signing").DirectSecp256k1Wallet>;
744
+ signTransaction: ({ recipient, assetValue, memo, feeRate, feeOptionKey, }: GenericTransferParams) => Promise<string>;
745
+ transfer: ({ recipient, assetValue, memo, feeRate, feeOptionKey, dryRun, }: GenericTransferParams & {
746
+ dryRun?: boolean;
747
+ }) => Promise<string>;
748
+ validateAddress: (address: string) => boolean;
749
+ verifySignature: ({ signature, message, address, }: {
750
+ signature: string;
751
+ message: string;
752
+ address: string;
753
+ }) => Promise<boolean>;
754
+ };
755
+ CRO: ChainWallet<Chain.Cronos> & {
756
+ approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
757
+ approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
758
+ broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
759
+ call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T_1>;
760
+ createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
761
+ createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
762
+ createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
763
+ createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
764
+ createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
765
+ EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
766
+ estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
767
+ estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
768
+ assetValue: import("@tcswap/helpers").AssetValue;
769
+ funcName?: string;
770
+ funcParams?: unknown[];
771
+ txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
772
+ data?: string;
773
+ }) => Promise<bigint>;
774
+ estimateGasPrices: () => Promise<{ [key_2 in FeeOption]: {
775
+ l1GasPrice?: bigint;
776
+ gasPrice?: bigint;
777
+ maxFeePerGas?: bigint;
778
+ maxPriorityFeePerGas?: bigint;
779
+ }; }>;
780
+ estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
781
+ feeOption: FeeOption;
782
+ chain: EVMChain;
783
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
784
+ getAddress: () => string | Promise<string> | undefined;
785
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
786
+ getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
787
+ isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
788
+ sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
789
+ feeOptionKey?: FeeOption;
790
+ }) => Promise<string>;
791
+ signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
792
+ transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
793
+ validateAddress: (address: string) => boolean;
794
+ };
795
+ DASH: ChainWallet<Chain.Dash> & {
796
+ accumulative: typeof import("@tcswap/toolboxes/utxo").accumulative;
797
+ broadcastTx: (txHash: string) => Promise<string>;
798
+ calculateTxSize: ({ inputs, outputs, feeRate }: import("@tcswap/toolboxes/utxo").UTXOCalculateTxSizeParams) => number;
799
+ createKeysForPath: (params: {
800
+ wif?: string;
801
+ phrase?: string;
802
+ derivationPath?: string;
803
+ }) => import("ecpair").ECPairInterface;
804
+ createTransaction: ({ assetValue, recipient, memo, feeRate, sender, fetchTxHex, }: import("@tcswap/toolboxes/utxo").UTXOBuildTxParams) => Promise<{
805
+ psbt: import("bitcoinjs-lib").Psbt;
806
+ utxos: import("@tcswap/toolboxes/utxo").UTXOType[];
807
+ inputs: import("@tcswap/toolboxes/utxo").UTXOType[];
808
+ }>;
809
+ estimateMaxSendableAmount: ({ from, memo, feeRate, feeOptionKey, recipients, }: {
810
+ from: string;
811
+ memo?: string;
812
+ feeRate?: number;
813
+ feeOptionKey?: FeeOption;
814
+ recipients?: number | import("@tcswap/toolboxes/utxo").TargetOutput[];
815
+ }) => Promise<AssetValue>;
816
+ estimateTransactionFee: (params: {
817
+ assetValue: AssetValue;
818
+ recipient: string;
819
+ sender: string;
820
+ memo?: string;
821
+ feeOptionKey?: FeeOption;
822
+ feeRate?: number;
823
+ fetchTxHex?: boolean;
824
+ }) => Promise<AssetValue>;
825
+ getAddress: () => Promise<string | undefined>;
826
+ getAddressFromKeys: (keys: import("ecpair").ECPairInterface | import("@tcswap/toolboxes/utxo").BchECPair) => string;
827
+ getBalance: (address: string, scamFilter?: boolean) => Promise<AssetValue[]>;
828
+ getFeeRates: () => Promise<{
829
+ average: number;
830
+ fast: number;
831
+ fastest: number;
832
+ }>;
833
+ getInputsOutputsFee: ({ assetValue, feeOptionKey, feeRate, memo, sender, recipient, }: Omit<import("@tcswap/toolboxes/utxo").UTXOBuildTxParams, "feeRate"> & {
834
+ feeOptionKey?: FeeOption;
835
+ feeRate?: number;
836
+ }) => Promise<{
837
+ fee: number;
838
+ inputs: (import("@tcswap/toolboxes/utxo").UTXOType | import("@tcswap/toolboxes/utxo").UTXOInputWithScriptType)[];
839
+ outputs: import("@tcswap/toolboxes/utxo").TargetOutput[];
840
+ } | {
841
+ fee: number;
842
+ inputs?: undefined;
843
+ outputs?: undefined;
844
+ }>;
845
+ getPrivateKeyFromMnemonic: (params: {
846
+ phrase: string;
847
+ derivationPath: string;
848
+ }) => string;
849
+ transfer: ({ memo, recipient, feeOptionKey, feeRate, assetValue }: import("@tcswap/toolboxes/utxo").UTXOTransferParams) => Promise<string>;
850
+ validateAddress: (address: string) => boolean;
851
+ };
852
+ DOGE: ChainWallet<Chain.Dogecoin> & {
853
+ accumulative: typeof import("@tcswap/toolboxes/utxo").accumulative;
854
+ broadcastTx: (txHash: string) => Promise<string>;
855
+ calculateTxSize: ({ inputs, outputs, feeRate }: import("@tcswap/toolboxes/utxo").UTXOCalculateTxSizeParams) => number;
856
+ createKeysForPath: (params: {
857
+ wif?: string;
858
+ phrase?: string;
859
+ derivationPath?: string;
860
+ }) => import("ecpair").ECPairInterface;
861
+ createTransaction: ({ assetValue, recipient, memo, feeRate, sender, fetchTxHex, }: import("@tcswap/toolboxes/utxo").UTXOBuildTxParams) => Promise<{
862
+ psbt: import("bitcoinjs-lib").Psbt;
863
+ utxos: import("@tcswap/toolboxes/utxo").UTXOType[];
864
+ inputs: import("@tcswap/toolboxes/utxo").UTXOType[];
865
+ }>;
866
+ estimateMaxSendableAmount: ({ from, memo, feeRate, feeOptionKey, recipients, }: {
867
+ from: string;
868
+ memo?: string;
869
+ feeRate?: number;
870
+ feeOptionKey?: FeeOption;
871
+ recipients?: number | import("@tcswap/toolboxes/utxo").TargetOutput[];
872
+ }) => Promise<AssetValue>;
873
+ estimateTransactionFee: (params: {
874
+ assetValue: AssetValue;
875
+ recipient: string;
876
+ sender: string;
877
+ memo?: string;
878
+ feeOptionKey?: FeeOption;
879
+ feeRate?: number;
880
+ fetchTxHex?: boolean;
881
+ }) => Promise<AssetValue>;
882
+ getAddress: () => Promise<string | undefined>;
883
+ getAddressFromKeys: (keys: import("ecpair").ECPairInterface | import("@tcswap/toolboxes/utxo").BchECPair) => string;
884
+ getBalance: (address: string, scamFilter?: boolean) => Promise<AssetValue[]>;
885
+ getFeeRates: () => Promise<{
886
+ average: number;
887
+ fast: number;
888
+ fastest: number;
889
+ }>;
890
+ getInputsOutputsFee: ({ assetValue, feeOptionKey, feeRate, memo, sender, recipient, }: Omit<import("@tcswap/toolboxes/utxo").UTXOBuildTxParams, "feeRate"> & {
891
+ feeOptionKey?: FeeOption;
892
+ feeRate?: number;
893
+ }) => Promise<{
894
+ fee: number;
895
+ inputs: (import("@tcswap/toolboxes/utxo").UTXOType | import("@tcswap/toolboxes/utxo").UTXOInputWithScriptType)[];
896
+ outputs: import("@tcswap/toolboxes/utxo").TargetOutput[];
897
+ } | {
898
+ fee: number;
899
+ inputs?: undefined;
900
+ outputs?: undefined;
901
+ }>;
902
+ getPrivateKeyFromMnemonic: (params: {
903
+ phrase: string;
904
+ derivationPath: string;
905
+ }) => string;
906
+ transfer: ({ memo, recipient, feeOptionKey, feeRate, assetValue }: import("@tcswap/toolboxes/utxo").UTXOTransferParams) => Promise<string>;
907
+ validateAddress: (address: string) => boolean;
908
+ };
909
+ ETH: ChainWallet<Chain.Ethereum> & {
910
+ multicall: (callTuples: {
911
+ address: string;
912
+ data: string;
913
+ }[], multicallAddress?: string, funcName?: string, feeOptionKey?: FeeOption) => Promise<string>;
914
+ approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
915
+ approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
916
+ broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
917
+ call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T_1>;
918
+ createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
919
+ createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
920
+ createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
921
+ createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
922
+ createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
923
+ EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
924
+ estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
925
+ estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
926
+ assetValue: import("@tcswap/helpers").AssetValue;
927
+ funcName?: string;
928
+ funcParams?: unknown[];
929
+ txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
930
+ data?: string;
931
+ }) => Promise<bigint>;
932
+ estimateGasPrices: () => Promise<{ [key_2 in FeeOption]: {
933
+ l1GasPrice?: bigint;
934
+ gasPrice?: bigint;
935
+ maxFeePerGas?: bigint;
936
+ maxPriorityFeePerGas?: bigint;
937
+ }; }>;
938
+ estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
939
+ feeOption: FeeOption;
940
+ chain: EVMChain;
941
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
942
+ getAddress: () => string | Promise<string> | undefined;
943
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
944
+ getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
945
+ isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
946
+ sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
947
+ feeOptionKey?: FeeOption;
948
+ }) => Promise<string>;
949
+ signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
950
+ transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
951
+ validateAddress: (address: string) => boolean;
952
+ };
953
+ GNO: ChainWallet<Chain.Gnosis> & {
954
+ approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
955
+ approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
956
+ broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
957
+ call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T_1>;
958
+ createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
959
+ createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
960
+ createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
961
+ createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
962
+ createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
963
+ EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
964
+ estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
965
+ estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
966
+ assetValue: import("@tcswap/helpers").AssetValue;
967
+ funcName?: string;
968
+ funcParams?: unknown[];
969
+ txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
970
+ data?: string;
971
+ }) => Promise<bigint>;
972
+ estimateGasPrices: () => Promise<{ [key_2 in FeeOption]: {
973
+ l1GasPrice?: bigint;
974
+ gasPrice?: bigint;
975
+ maxFeePerGas?: bigint;
976
+ maxPriorityFeePerGas?: bigint;
977
+ }; }>;
978
+ estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
979
+ feeOption: FeeOption;
980
+ chain: EVMChain;
981
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
982
+ getAddress: () => string | Promise<string> | undefined;
983
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
984
+ getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
985
+ isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
986
+ sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
987
+ feeOptionKey?: FeeOption;
988
+ }) => Promise<string>;
989
+ signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
990
+ transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
991
+ validateAddress: (address: string) => boolean;
992
+ };
993
+ HARBOR: ChainWallet<Chain.Harbor> & {
994
+ createPrivateKeyFromPhrase: (phrase: string) => Promise<Uint8Array<ArrayBufferLike>>;
995
+ createTransaction: typeof import("@tcswap/toolboxes/cosmos").cosmosCreateTransaction;
996
+ fetchFeeRateFromSwapKit: typeof import("@tcswap/toolboxes/cosmos").fetchFeeRateFromSwapKit;
997
+ getAccount: (address: string) => Promise<import("@cosmjs/stargate").Account | null>;
998
+ getAddress: () => Promise<string | undefined>;
999
+ getBalance: (address: string, _potentialScamFilter?: boolean) => Promise<AssetValue[]>;
1000
+ getBalanceAsDenoms: (address: string) => Promise<{
1001
+ denom: string;
1002
+ amount: string;
1003
+ }[]>;
1004
+ getFees: () => Promise<{
1005
+ average: import("@tcswap/helpers").USwapNumber;
1006
+ fast: import("@tcswap/helpers").USwapNumber;
1007
+ fastest: import("@tcswap/helpers").USwapNumber;
1008
+ }>;
1009
+ getPubKey: () => Promise<string>;
1010
+ getSignerFromPhrase: ({ phrase, derivationPath }: {
1011
+ phrase: string;
1012
+ derivationPath: import("@tcswap/helpers").DerivationPathArray;
1013
+ }) => Promise<import("@cosmjs/proto-signing").DirectSecp256k1HdWallet>;
1014
+ getSignerFromPrivateKey: (privateKey: Uint8Array) => Promise<import("@cosmjs/proto-signing").DirectSecp256k1Wallet>;
1015
+ signTransaction: ({ recipient, assetValue, memo, feeRate, feeOptionKey, }: GenericTransferParams) => Promise<string>;
1016
+ transfer: ({ recipient, assetValue, memo, feeRate, feeOptionKey, dryRun, }: GenericTransferParams & {
1017
+ dryRun?: boolean;
1018
+ }) => Promise<string>;
1019
+ validateAddress: (address: string) => boolean;
1020
+ verifySignature: ({ signature, message, address, }: {
1021
+ signature: string;
1022
+ message: string;
1023
+ address: string;
1024
+ }) => Promise<boolean>;
1025
+ };
1026
+ HYPEREVM: ChainWallet<Chain.Hyperevm> & {
1027
+ approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
1028
+ approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
1029
+ broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
1030
+ call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T_1>;
1031
+ createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
1032
+ createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
1033
+ createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
1034
+ createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
1035
+ createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
1036
+ EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
1037
+ estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
1038
+ estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
1039
+ assetValue: import("@tcswap/helpers").AssetValue;
1040
+ funcName?: string;
1041
+ funcParams?: unknown[];
1042
+ txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
1043
+ data?: string;
1044
+ }) => Promise<bigint>;
1045
+ estimateGasPrices: () => Promise<{ [key_2 in FeeOption]: {
1046
+ l1GasPrice?: bigint;
1047
+ gasPrice?: bigint;
1048
+ maxFeePerGas?: bigint;
1049
+ maxPriorityFeePerGas?: bigint;
1050
+ }; }>;
1051
+ estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
1052
+ feeOption: FeeOption;
1053
+ chain: EVMChain;
1054
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
1055
+ getAddress: () => string | Promise<string> | undefined;
1056
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
1057
+ getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
1058
+ isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
1059
+ sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
1060
+ feeOptionKey?: FeeOption;
1061
+ }) => Promise<string>;
1062
+ signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
1063
+ transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
1064
+ validateAddress: (address: string) => boolean;
1065
+ };
1066
+ KUJI: ChainWallet<Chain.Kujira> & {
1067
+ createPrivateKeyFromPhrase: (phrase: string) => Promise<Uint8Array<ArrayBufferLike>>;
1068
+ createTransaction: typeof import("@tcswap/toolboxes/cosmos").cosmosCreateTransaction;
1069
+ fetchFeeRateFromSwapKit: typeof import("@tcswap/toolboxes/cosmos").fetchFeeRateFromSwapKit;
1070
+ getAccount: (address: string) => Promise<import("@cosmjs/stargate").Account | null>;
1071
+ getAddress: () => Promise<string | undefined>;
1072
+ getBalance: (address: string, _potentialScamFilter?: boolean) => Promise<AssetValue[]>;
1073
+ getBalanceAsDenoms: (address: string) => Promise<{
1074
+ denom: string;
1075
+ amount: string;
1076
+ }[]>;
1077
+ getFees: () => Promise<{
1078
+ average: import("@tcswap/helpers").USwapNumber;
1079
+ fast: import("@tcswap/helpers").USwapNumber;
1080
+ fastest: import("@tcswap/helpers").USwapNumber;
1081
+ }>;
1082
+ getPubKey: () => Promise<string>;
1083
+ getSignerFromPhrase: ({ phrase, derivationPath }: {
1084
+ phrase: string;
1085
+ derivationPath: import("@tcswap/helpers").DerivationPathArray;
1086
+ }) => Promise<import("@cosmjs/proto-signing").DirectSecp256k1HdWallet>;
1087
+ getSignerFromPrivateKey: (privateKey: Uint8Array) => Promise<import("@cosmjs/proto-signing").DirectSecp256k1Wallet>;
1088
+ signTransaction: ({ recipient, assetValue, memo, feeRate, feeOptionKey, }: GenericTransferParams) => Promise<string>;
1089
+ transfer: ({ recipient, assetValue, memo, feeRate, feeOptionKey, dryRun, }: GenericTransferParams & {
1090
+ dryRun?: boolean;
1091
+ }) => Promise<string>;
1092
+ validateAddress: (address: string) => boolean;
1093
+ verifySignature: ({ signature, message, address, }: {
1094
+ signature: string;
1095
+ message: string;
1096
+ address: string;
1097
+ }) => Promise<boolean>;
1098
+ };
1099
+ LTC: ChainWallet<Chain.Litecoin> & {
1100
+ accumulative: typeof import("@tcswap/toolboxes/utxo").accumulative;
1101
+ broadcastTx: (txHash: string) => Promise<string>;
1102
+ calculateTxSize: ({ inputs, outputs, feeRate }: import("@tcswap/toolboxes/utxo").UTXOCalculateTxSizeParams) => number;
1103
+ createKeysForPath: (params: {
1104
+ wif?: string;
1105
+ phrase?: string;
1106
+ derivationPath?: string;
1107
+ }) => import("ecpair").ECPairInterface;
1108
+ createTransaction: ({ assetValue, recipient, memo, feeRate, sender, fetchTxHex, }: import("@tcswap/toolboxes/utxo").UTXOBuildTxParams) => Promise<{
1109
+ psbt: import("bitcoinjs-lib").Psbt;
1110
+ utxos: import("@tcswap/toolboxes/utxo").UTXOType[];
1111
+ inputs: import("@tcswap/toolboxes/utxo").UTXOType[];
1112
+ }>;
1113
+ estimateMaxSendableAmount: ({ from, memo, feeRate, feeOptionKey, recipients, }: {
1114
+ from: string;
1115
+ memo?: string;
1116
+ feeRate?: number;
1117
+ feeOptionKey?: FeeOption;
1118
+ recipients?: number | import("@tcswap/toolboxes/utxo").TargetOutput[];
1119
+ }) => Promise<AssetValue>;
1120
+ estimateTransactionFee: (params: {
1121
+ assetValue: AssetValue;
1122
+ recipient: string;
1123
+ sender: string;
1124
+ memo?: string;
1125
+ feeOptionKey?: FeeOption;
1126
+ feeRate?: number;
1127
+ fetchTxHex?: boolean;
1128
+ }) => Promise<AssetValue>;
1129
+ getAddress: () => Promise<string | undefined>;
1130
+ getAddressFromKeys: (keys: import("ecpair").ECPairInterface | import("@tcswap/toolboxes/utxo").BchECPair) => string;
1131
+ getBalance: (address: string, scamFilter?: boolean) => Promise<AssetValue[]>;
1132
+ getFeeRates: () => Promise<{
1133
+ average: number;
1134
+ fast: number;
1135
+ fastest: number;
1136
+ }>;
1137
+ getInputsOutputsFee: ({ assetValue, feeOptionKey, feeRate, memo, sender, recipient, }: Omit<import("@tcswap/toolboxes/utxo").UTXOBuildTxParams, "feeRate"> & {
1138
+ feeOptionKey?: FeeOption;
1139
+ feeRate?: number;
1140
+ }) => Promise<{
1141
+ fee: number;
1142
+ inputs: (import("@tcswap/toolboxes/utxo").UTXOType | import("@tcswap/toolboxes/utxo").UTXOInputWithScriptType)[];
1143
+ outputs: import("@tcswap/toolboxes/utxo").TargetOutput[];
1144
+ } | {
1145
+ fee: number;
1146
+ inputs?: undefined;
1147
+ outputs?: undefined;
1148
+ }>;
1149
+ getPrivateKeyFromMnemonic: (params: {
1150
+ phrase: string;
1151
+ derivationPath: string;
1152
+ }) => string;
1153
+ transfer: ({ memo, recipient, feeOptionKey, feeRate, assetValue }: import("@tcswap/toolboxes/utxo").UTXOTransferParams) => Promise<string>;
1154
+ validateAddress: (address: string) => boolean;
1155
+ };
1156
+ MAYA: ChainWallet<Chain.Maya> & {
1157
+ broadcastMultisigTx: (tx: string, signers: import("@tcswap/toolboxes/cosmos").MultiSigSigner[], membersPubKeys: string[], threshold: number, bodyBytes: Uint8Array) => Promise<string>;
1158
+ buildAminoMsg: ({ sender, recipient, assetValue, memo, }: {
1159
+ sender: string;
1160
+ recipient?: string;
1161
+ assetValue: import("@tcswap/helpers").AssetValue;
1162
+ memo?: string;
1163
+ }) => {
1164
+ type: "thorchain/MsgDeposit" | "mayachain/MsgDeposit";
1165
+ value: {
1166
+ coins: {
1167
+ amount: string;
1168
+ asset: string;
1169
+ }[];
1170
+ memo: string;
1171
+ signer: string;
1172
+ };
1173
+ } | {
1174
+ type: "thorchain/MsgSend" | "mayachain/MsgSend";
1175
+ value: {
1176
+ amount: {
1177
+ amount: string;
1178
+ denom: string;
1179
+ }[];
1180
+ from_address: string;
1181
+ to_address: string | undefined;
1182
+ };
1183
+ };
1184
+ buildEncodedTxBody: typeof import("@tcswap/toolboxes/cosmos").buildEncodedTxBody;
1185
+ convertToSignable: (msg: {
1186
+ type: "thorchain/MsgSend" | "mayachain/MsgSend";
1187
+ value: {
1188
+ amount: {
1189
+ amount: string;
1190
+ denom: string;
1191
+ }[];
1192
+ from_address: string;
1193
+ to_address: string | undefined;
1194
+ };
1195
+ } | {
1196
+ type: "thorchain/MsgDeposit" | "mayachain/MsgDeposit";
1197
+ value: {
1198
+ coins: {
1199
+ amount: string;
1200
+ asset: string;
1201
+ }[];
1202
+ memo: string;
1203
+ signer: string;
1204
+ };
1205
+ }, chain: import("@tcswap/types").TCLikeChain) => Promise<import("@cosmjs/proto-signing").EncodeObject>;
1206
+ createDefaultAminoTypes: () => Promise<import("@cosmjs/stargate").AminoTypes>;
1207
+ createDefaultRegistry: typeof import("@tcswap/toolboxes/cosmos").createDefaultRegistry;
1208
+ createMultisig: (pubKeys: string[], threshold: number, noSortPubKeys?: boolean) => Promise<import("@cosmjs/amino").MultisigThresholdPubkey>;
1209
+ createTransaction: (params: import("@tcswap/toolboxes/cosmos").ThorchainCreateTransactionParams) => Promise<{
1210
+ accountNumber: number;
1211
+ chainId: import("@tcswap/types").ChainId.Maya | import("@tcswap/types").ChainId.THORChain;
1212
+ fee: {
1213
+ amount: {
1214
+ amount: string;
1215
+ denom: string;
1216
+ }[];
1217
+ gas: string;
1218
+ };
1219
+ memo: string;
1220
+ msgs: (import("@cosmjs/proto-signing").EncodeObject | {
1221
+ type: "thorchain/MsgSend" | "mayachain/MsgSend";
1222
+ value: {
1223
+ amount: {
1224
+ amount: string;
1225
+ denom: string;
1226
+ }[];
1227
+ from_address: string;
1228
+ to_address: string | undefined;
1229
+ };
1230
+ })[];
1231
+ sequence: number;
1232
+ }> | Promise<{
1233
+ accountNumber: number;
1234
+ chainId: import("@tcswap/types").ChainId.Maya | import("@tcswap/types").ChainId.THORChain;
1235
+ fee: {
1236
+ amount: {
1237
+ amount: string;
1238
+ denom: string;
1239
+ }[];
1240
+ gas: string;
1241
+ };
1242
+ memo: string;
1243
+ msgs: (import("@cosmjs/proto-signing").EncodeObject | {
1244
+ type: "thorchain/MsgDeposit" | "mayachain/MsgDeposit";
1245
+ value: {
1246
+ coins: {
1247
+ amount: string;
1248
+ asset: string;
1249
+ }[];
1250
+ memo: string;
1251
+ signer: string;
1252
+ };
1253
+ })[];
1254
+ sequence: number;
1255
+ }>;
1256
+ deposit: ({ assetValue, memo, recipient, }: Omit<GenericTransferParams, "recipient"> & {
1257
+ recipient?: string;
1258
+ }) => Promise<string>;
1259
+ getFees: () => Promise<{
1260
+ average: import("@tcswap/helpers").USwapNumber;
1261
+ fast: import("@tcswap/helpers").USwapNumber;
1262
+ fastest: import("@tcswap/helpers").USwapNumber;
1263
+ }>;
1264
+ importSignature: (signature: string) => Uint8Array<ArrayBufferLike>;
1265
+ parseAminoMessageForDirectSigning: typeof import("@tcswap/toolboxes/cosmos").parseAminoMessageForDirectSigning;
1266
+ pubkeyToAddress: (pubkey: import("@cosmjs/amino").Pubkey) => Promise<string>;
1267
+ secp256k1HdWalletFromMnemonic: (mnemonic: string, index?: number) => Promise<import("@cosmjs/amino").Secp256k1HdWallet>;
1268
+ signMultisigTx: ({ wallet, tx }: {
1269
+ wallet: import("@cosmjs/amino").Secp256k1HdWallet;
1270
+ tx: string | import("@tcswap/toolboxes/cosmos").MultisigTx;
1271
+ }) => Promise<{
1272
+ bodyBytes: Uint8Array<ArrayBufferLike>;
1273
+ signature: string;
1274
+ }>;
1275
+ signWithPrivateKey: ({ privateKey, message }: {
1276
+ privateKey: Uint8Array;
1277
+ message: string;
1278
+ }) => Promise<string>;
1279
+ transfer: ({ assetValue, memo, recipient, }: Omit<GenericTransferParams, "recipient"> & {
1280
+ recipient?: string;
1281
+ }) => Promise<string>;
1282
+ createPrivateKeyFromPhrase: (phrase: string) => Promise<Uint8Array<ArrayBufferLike>>;
1283
+ fetchFeeRateFromSwapKit: typeof import("@tcswap/toolboxes/cosmos").fetchFeeRateFromSwapKit;
1284
+ getAccount: (address: string) => Promise<import("@cosmjs/stargate").Account | null>;
1285
+ getAddress: () => Promise<string | undefined>;
1286
+ getBalance: (address: string, _potentialScamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
1287
+ getBalanceAsDenoms: (address: string) => Promise<{
1288
+ denom: string;
1289
+ amount: string;
1290
+ }[]>;
1291
+ getPubKey: () => Promise<string>;
1292
+ getSignerFromPhrase: ({ phrase, derivationPath }: {
1293
+ phrase: string;
1294
+ derivationPath: import("@tcswap/helpers").DerivationPathArray;
1295
+ }) => Promise<import("@cosmjs/proto-signing").DirectSecp256k1HdWallet>;
1296
+ getSignerFromPrivateKey: (privateKey: Uint8Array) => Promise<import("@cosmjs/proto-signing").DirectSecp256k1Wallet>;
1297
+ signTransaction: ({ recipient, assetValue, memo, feeRate, feeOptionKey, }: GenericTransferParams) => Promise<string>;
1298
+ validateAddress: (address: string) => boolean;
1299
+ verifySignature: ({ signature, message, address, }: {
1300
+ signature: string;
1301
+ message: string;
1302
+ address: string;
1303
+ }) => Promise<boolean>;
1304
+ };
1305
+ MEGAETH: ChainWallet<Chain.MegaETH> & {
1306
+ approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
1307
+ approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
1308
+ broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
1309
+ call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T_1>;
1310
+ createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
1311
+ createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
1312
+ createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
1313
+ createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
1314
+ createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
1315
+ EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
1316
+ estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
1317
+ estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
1318
+ assetValue: import("@tcswap/helpers").AssetValue;
1319
+ funcName?: string;
1320
+ funcParams?: unknown[];
1321
+ txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
1322
+ data?: string;
1323
+ }) => Promise<bigint>;
1324
+ estimateGasPrices: () => Promise<{ [key_2 in FeeOption]: {
1325
+ l1GasPrice?: bigint;
1326
+ gasPrice?: bigint;
1327
+ maxFeePerGas?: bigint;
1328
+ maxPriorityFeePerGas?: bigint;
1329
+ }; }>;
1330
+ estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
1331
+ feeOption: FeeOption;
1332
+ chain: EVMChain;
1333
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
1334
+ getAddress: () => string | Promise<string> | undefined;
1335
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
1336
+ getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
1337
+ isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
1338
+ sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
1339
+ feeOptionKey?: FeeOption;
1340
+ }) => Promise<string>;
1341
+ signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
1342
+ transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
1343
+ validateAddress: (address: string) => boolean;
1344
+ };
1345
+ MONAD: ChainWallet<Chain.Monad> & {
1346
+ approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
1347
+ approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
1348
+ broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
1349
+ call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T_1>;
1350
+ createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
1351
+ createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
1352
+ createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
1353
+ createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
1354
+ createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
1355
+ EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
1356
+ estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
1357
+ estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
1358
+ assetValue: import("@tcswap/helpers").AssetValue;
1359
+ funcName?: string;
1360
+ funcParams?: unknown[];
1361
+ txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
1362
+ data?: string;
1363
+ }) => Promise<bigint>;
1364
+ estimateGasPrices: () => Promise<{ [key_2 in FeeOption]: {
1365
+ l1GasPrice?: bigint;
1366
+ gasPrice?: bigint;
1367
+ maxFeePerGas?: bigint;
1368
+ maxPriorityFeePerGas?: bigint;
1369
+ }; }>;
1370
+ estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
1371
+ feeOption: FeeOption;
1372
+ chain: EVMChain;
1373
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
1374
+ getAddress: () => string | Promise<string> | undefined;
1375
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
1376
+ getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
1377
+ isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
1378
+ sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
1379
+ feeOptionKey?: FeeOption;
1380
+ }) => Promise<string>;
1381
+ signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
1382
+ transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
1383
+ validateAddress: (address: string) => boolean;
1384
+ };
1385
+ NEAR: ChainWallet<Chain.Near> & {
1386
+ broadcastTransaction: (signedTransaction: import("@near-js/transactions").SignedTransaction) => Promise<any>;
1387
+ callFunction: (params: import("@tcswap/toolboxes/near").NearFunctionCallParams) => Promise<string>;
1388
+ createAction: (params: import("@tcswap/toolboxes/near").CreateActionParams) => Promise<import("@near-js/transactions").Action>;
1389
+ createContract: <T_1 extends import("@near-js/accounts").Contract = import("@near-js/accounts").Contract>(contractInterface: import("@tcswap/toolboxes/near").NearContractInterface) => Promise<T_1>;
1390
+ createContractFunctionCall: (params: import("@tcswap/toolboxes/near").ContractFunctionCallParams) => Promise<import("@near-js/transactions").Transaction>;
1391
+ createSubAccount: (subAccountId: string, publicKey: string, initialBalance: string) => Promise<string>;
1392
+ createTransaction: (params: import("@tcswap/toolboxes/near").NearCreateTransactionParams) => Promise<import("@near-js/transactions").Transaction>;
1393
+ estimateGas: (params: import("@tcswap/toolboxes/near").NearGasEstimateParams, account?: import("@near-js/accounts").Account) => Promise<AssetValue>;
1394
+ estimateTransactionFee: (params: import("@tcswap/toolboxes/near").NearTransferParams | import("@tcswap/toolboxes/near").NearGasEstimateParams) => Promise<AssetValue>;
1395
+ executeBatchTransaction: (batch: import("@tcswap/toolboxes/near").BatchTransaction) => Promise<string>;
1396
+ getAddress: () => Promise<string>;
1397
+ getBalance: (address: string, scamFilter?: boolean) => Promise<AssetValue[]>;
1398
+ getGasPrice: () => Promise<string>;
1399
+ getPublicKey: () => Promise<string>;
1400
+ getSignerFromPhrase: (params: import("@tcswap/toolboxes/near").GetSignerFromPhraseParams) => Promise<import("@tcswap/toolboxes/near").NearSigner>;
1401
+ getSignerFromPrivateKey: typeof import("@tcswap/toolboxes/near").getNearSignerFromPrivateKey;
1402
+ provider: import("@near-js/providers").JsonRpcProvider;
1403
+ serializeTransaction: (transaction: import("@near-js/transactions").Transaction) => string;
1404
+ signAndSendTransaction: (transaction: import("@near-js/transactions").Transaction) => Promise<any>;
1405
+ signTransaction: (transaction: import("@near-js/transactions").Transaction) => Promise<import("@near-js/transactions").SignedTransaction>;
1406
+ transfer: (params: import("@tcswap/toolboxes/near").NearTransferParams) => Promise<any>;
1407
+ validateAddress: (address: string) => boolean;
1408
+ };
1409
+ NOBLE: ChainWallet<Chain.Noble> & {
1410
+ createPrivateKeyFromPhrase: (phrase: string) => Promise<Uint8Array<ArrayBufferLike>>;
1411
+ createTransaction: typeof import("@tcswap/toolboxes/cosmos").cosmosCreateTransaction;
1412
+ fetchFeeRateFromSwapKit: typeof import("@tcswap/toolboxes/cosmos").fetchFeeRateFromSwapKit;
1413
+ getAccount: (address: string) => Promise<import("@cosmjs/stargate").Account | null>;
1414
+ getAddress: () => Promise<string | undefined>;
1415
+ getBalance: (address: string, _potentialScamFilter?: boolean) => Promise<AssetValue[]>;
1416
+ getBalanceAsDenoms: (address: string) => Promise<{
1417
+ denom: string;
1418
+ amount: string;
1419
+ }[]>;
1420
+ getFees: () => Promise<{
1421
+ average: import("@tcswap/helpers").USwapNumber;
1422
+ fast: import("@tcswap/helpers").USwapNumber;
1423
+ fastest: import("@tcswap/helpers").USwapNumber;
1424
+ }>;
1425
+ getPubKey: () => Promise<string>;
1426
+ getSignerFromPhrase: ({ phrase, derivationPath }: {
1427
+ phrase: string;
1428
+ derivationPath: import("@tcswap/helpers").DerivationPathArray;
1429
+ }) => Promise<import("@cosmjs/proto-signing").DirectSecp256k1HdWallet>;
1430
+ getSignerFromPrivateKey: (privateKey: Uint8Array) => Promise<import("@cosmjs/proto-signing").DirectSecp256k1Wallet>;
1431
+ signTransaction: ({ recipient, assetValue, memo, feeRate, feeOptionKey, }: GenericTransferParams) => Promise<string>;
1432
+ transfer: ({ recipient, assetValue, memo, feeRate, feeOptionKey, dryRun, }: GenericTransferParams & {
1433
+ dryRun?: boolean;
1434
+ }) => Promise<string>;
1435
+ validateAddress: (address: string) => boolean;
1436
+ verifySignature: ({ signature, message, address, }: {
1437
+ signature: string;
1438
+ message: string;
1439
+ address: string;
1440
+ }) => Promise<boolean>;
1441
+ };
1442
+ OP: ChainWallet<Chain.Optimism> & {
1443
+ estimateGasPrices: Promise<{
1444
+ average: {
1445
+ l1GasPrice?: bigint;
1446
+ gasPrice?: bigint;
1447
+ maxFeePerGas?: bigint;
1448
+ maxPriorityFeePerGas?: bigint;
1449
+ };
1450
+ fast: {
1451
+ l1GasPrice?: bigint;
1452
+ gasPrice?: bigint;
1453
+ maxFeePerGas?: bigint;
1454
+ maxPriorityFeePerGas?: bigint;
1455
+ };
1456
+ fastest: {
1457
+ l1GasPrice?: bigint;
1458
+ gasPrice?: bigint;
1459
+ maxFeePerGas?: bigint;
1460
+ maxPriorityFeePerGas?: bigint;
1461
+ };
1462
+ }>;
1463
+ estimateL1Gas: (tx: import("ethers").TransactionRequest) => Promise<any>;
1464
+ estimateL1GasCost: (tx: import("ethers").TransactionRequest) => Promise<any>;
1465
+ estimateL2GasCost: (tx: import("ethers").TransactionRequest) => Promise<any>;
1466
+ estimateTotalGasCost: (tx: import("ethers").TransactionRequest) => Promise<any>;
1467
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
1468
+ getL1GasPrice: () => Promise<bigint | undefined>;
1469
+ approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
1470
+ approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
1471
+ broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
1472
+ call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T_1>;
1473
+ createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
1474
+ createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
1475
+ createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
1476
+ createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
1477
+ createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
1478
+ EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
1479
+ estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
1480
+ estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
1481
+ assetValue: import("@tcswap/helpers").AssetValue;
1482
+ funcName?: string;
1483
+ funcParams?: unknown[];
1484
+ txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
1485
+ data?: string;
1486
+ }) => Promise<bigint>;
1487
+ estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
1488
+ feeOption: FeeOption;
1489
+ chain: import("@tcswap/types").EVMChain;
1490
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
1491
+ getAddress: () => string | Promise<string> | undefined;
1492
+ getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
1493
+ isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
1494
+ sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
1495
+ feeOptionKey?: FeeOption;
1496
+ }) => Promise<string>;
1497
+ signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
1498
+ transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
1499
+ validateAddress: (address: string) => boolean;
1500
+ };
1501
+ DOT: ChainWallet<Chain.Polkadot> & {
1502
+ api: import("@polkadot/api").ApiPromise;
1503
+ broadcast: (tx: import("@polkadot/api/types").SubmittableExtrinsic<"promise">, callback?: import("@polkadot/types/types").Callback<import("@polkadot/types/types").ISubmittableResult>) => Promise<string | (() => void)>;
1504
+ convertAddress: (address: string, newPrefix: number) => string;
1505
+ createKeyring: (phrase: string) => Promise<import("@polkadot/keyring/types").KeyringPair>;
1506
+ createTransaction: (params: import("@tcswap/helpers").GenericCreateTransactionParams) => import("@polkadot/api/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | undefined;
1507
+ decodeAddress: (address: string, networkPrefix?: number) => Uint8Array<ArrayBufferLike>;
1508
+ encodeAddress: (address: Uint8Array, encoding?: "ss58" | "hex", networkPrefix?: number) => string;
1509
+ estimateTransactionFee: (params: import("@tcswap/toolboxes/substrate").SubstrateTransferParams) => Promise<AssetValue | undefined>;
1510
+ gasAsset: AssetValue;
1511
+ getAddress: (keyring?: import("@polkadot/types/types").IKeyringPair | import("@polkadot/types/types").Signer) => string | undefined;
1512
+ getBalance: (address: string) => Promise<AssetValue[]>;
1513
+ network: import("@tcswap/toolboxes/substrate").SubstrateNetwork;
1514
+ sign: (tx: import("@polkadot/api/types").SubmittableExtrinsic<"promise">) => Promise<import("@polkadot/api/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
1515
+ signAndBroadcast: ({ tx, callback, address, }: {
1516
+ tx: import("@polkadot/api/types").SubmittableExtrinsic<"promise">;
1517
+ callback?: import("@polkadot/types/types").Callback<import("@polkadot/types/types").ISubmittableResult>;
1518
+ address?: string;
1519
+ }) => string | Promise<string> | Promise<() => void>;
1520
+ transfer: (params: import("@tcswap/toolboxes/substrate").SubstrateTransferParams) => Promise<string>;
1521
+ validateAddress: (address: string) => boolean;
1522
+ };
1523
+ POL: ChainWallet<Chain.Polygon> & {
1524
+ approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
1525
+ approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
1526
+ broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
1527
+ call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T_1>;
1528
+ createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
1529
+ createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
1530
+ createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
1531
+ createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
1532
+ createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
1533
+ EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
1534
+ estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
1535
+ estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
1536
+ assetValue: import("@tcswap/helpers").AssetValue;
1537
+ funcName?: string;
1538
+ funcParams?: unknown[];
1539
+ txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
1540
+ data?: string;
1541
+ }) => Promise<bigint>;
1542
+ estimateGasPrices: () => Promise<{ [key_2 in FeeOption]: {
1543
+ l1GasPrice?: bigint;
1544
+ gasPrice?: bigint;
1545
+ maxFeePerGas?: bigint;
1546
+ maxPriorityFeePerGas?: bigint;
1547
+ }; }>;
1548
+ estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
1549
+ feeOption: FeeOption;
1550
+ chain: EVMChain;
1551
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
1552
+ getAddress: () => string | Promise<string> | undefined;
1553
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
1554
+ getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
1555
+ isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
1556
+ sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
1557
+ feeOptionKey?: FeeOption;
1558
+ }) => Promise<string>;
1559
+ signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
1560
+ transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
1561
+ validateAddress: (address: string) => boolean;
1562
+ };
1563
+ XRD: ChainWallet<Chain.Radix> & {
1564
+ getAddress: () => string;
1565
+ getBalance: (address: string) => Promise<AssetValue[]>;
1566
+ networkApi: import("@radixdlt/babylon-gateway-api-sdk").GatewayApiClient;
1567
+ signAndBroadcast: (params: any) => Promise<string>;
1568
+ validateAddress: typeof import("@tcswap/toolboxes/radix").radixValidateAddress;
1569
+ };
1570
+ XRP: ChainWallet<Chain.Ripple> & {
1571
+ broadcastTransaction: (signedTxHex: string) => Promise<string>;
1572
+ createSigner: (phrase: string) => import("@tcswap/helpers").ChainSigner<import("xrpl").Transaction, {
1573
+ tx_blob: string;
1574
+ hash: string;
1575
+ }>;
1576
+ createTransaction: ({ assetValue, recipient, memo, sender, }: {
1577
+ assetValue: AssetValue;
1578
+ recipient: string;
1579
+ sender?: string;
1580
+ memo?: string;
1581
+ }) => Promise<import("xrpl").Payment>;
1582
+ disconnect: () => Promise<void>;
1583
+ estimateTransactionFee: () => Promise<AssetValue>;
1584
+ getAddress: () => string | Promise<string>;
1585
+ getBalance: (address?: string) => Promise<AssetValue[]>;
1586
+ signer: import("@tcswap/helpers").ChainSigner<import("xrpl").Transaction, {
1587
+ tx_blob: string;
1588
+ hash: string;
1589
+ }> | undefined;
1590
+ signTransaction: (tx: import("xrpl").Transaction) => {
1591
+ tx_blob: string;
1592
+ hash: string;
1593
+ } | Promise<{
1594
+ tx_blob: string;
1595
+ hash: string;
1596
+ }>;
1597
+ transfer: (params: GenericTransferParams) => Promise<string>;
1598
+ validateAddress: typeof import("@tcswap/toolboxes/ripple").rippleValidateAddress;
1599
+ };
1600
+ SOL: ChainWallet<Chain.Solana> & {
1601
+ broadcastTransaction: (transaction: import("@solana/web3.js/lib").Transaction | import("@solana/web3.js/lib").VersionedTransaction) => Promise<string>;
1602
+ createKeysForPath: typeof import("@tcswap/toolboxes/solana").createKeysForPath;
1603
+ createTransaction: ({ recipient, assetValue, memo, isProgramDerivedAddress, sender }: import("@tcswap/toolboxes/solana").SolanaCreateTransactionParams) => Promise<import("@solana/web3.js/lib").Transaction>;
1604
+ createTransactionFromInstructions: ({ instructions, }: {
1605
+ instructions: import("@solana/web3.js/lib").TransactionInstruction[];
1606
+ isProgramDerivedAddress?: boolean;
1607
+ }) => Promise<import("@solana/web3.js/lib").Transaction>;
1608
+ estimateTransactionFee: ({ recipient, assetValue, memo, isProgramDerivedAddress, sender, }: Omit<import("@tcswap/helpers").GenericCreateTransactionParams, "feeRate"> & {
1609
+ isProgramDerivedAddress?: boolean;
1610
+ }) => Promise<AssetValue>;
1611
+ getAddress: () => string;
1612
+ getAddressFromPubKey: (publicKey: import("@solana/web3.js/lib").PublicKey) => string;
1613
+ getAddressValidator: typeof import("@tcswap/toolboxes/solana").getSolanaAddressValidator;
1614
+ getBalance: (addressParam?: string) => Promise<AssetValue[]>;
1615
+ getConnection: () => Promise<import("@solana/web3.js/lib").Connection>;
1616
+ getPubkeyFromAddress: (address: string) => Promise<import("@solana/web3.js/lib").PublicKey>;
1617
+ 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>;
1618
+ transfer: ({ recipient, assetValue, memo, isProgramDerivedAddress }: import("@tcswap/toolboxes/solana").SolanaTransferParams) => Promise<string>;
1619
+ };
1620
+ SONIC: ChainWallet<Chain.Sonic> & {
1621
+ approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
1622
+ approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
1623
+ broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
1624
+ call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T_1>;
1625
+ createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
1626
+ createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
1627
+ createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
1628
+ createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
1629
+ createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
1630
+ EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
1631
+ estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
1632
+ estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
1633
+ assetValue: import("@tcswap/helpers").AssetValue;
1634
+ funcName?: string;
1635
+ funcParams?: unknown[];
1636
+ txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
1637
+ data?: string;
1638
+ }) => Promise<bigint>;
1639
+ estimateGasPrices: () => Promise<{ [key_2 in FeeOption]: {
1640
+ l1GasPrice?: bigint;
1641
+ gasPrice?: bigint;
1642
+ maxFeePerGas?: bigint;
1643
+ maxPriorityFeePerGas?: bigint;
1644
+ }; }>;
1645
+ estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
1646
+ feeOption: FeeOption;
1647
+ chain: EVMChain;
1648
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
1649
+ getAddress: () => string | Promise<string> | undefined;
1650
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
1651
+ getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
1652
+ isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
1653
+ sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
1654
+ feeOptionKey?: FeeOption;
1655
+ }) => Promise<string>;
1656
+ signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
1657
+ transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
1658
+ validateAddress: (address: string) => boolean;
1659
+ };
1660
+ SUI: ChainWallet<Chain.Sui> & {
1661
+ createTransaction: ({ recipient, assetValue, gasBudget, sender }: import("@tcswap/toolboxes/sui").SuiCreateTransactionParams) => Promise<{
1662
+ tx: import("@mysten/sui/transactions").Transaction;
1663
+ txBytes: Uint8Array<ArrayBuffer>;
1664
+ }>;
1665
+ estimateTransactionFee: (params?: import("@tcswap/toolboxes/sui").SuiCreateTransactionParams) => Promise<AssetValue>;
1666
+ getAddress: () => string;
1667
+ getBalance: (targetAddress?: string) => Promise<AssetValue[]>;
1668
+ signTransaction: (params: Uint8Array<ArrayBuffer> | import("@tcswap/toolboxes/sui").SuiCreateTransactionParams | Awaited<ReturnType<({ recipient, assetValue, gasBudget, sender }: import("@tcswap/toolboxes/sui").SuiCreateTransactionParams) => Promise<{
1669
+ tx: import("@mysten/sui/transactions").Transaction;
1670
+ txBytes: Uint8Array<ArrayBuffer>;
1671
+ }>>>) => Promise<import("@mysten/sui/cryptography").SignatureWithBytes>;
1672
+ transfer: ({ assetValue, gasBudget, recipient }: import("@tcswap/toolboxes/sui").SuiTransferParams) => Promise<string>;
1673
+ validateAddress: (address: string) => boolean;
1674
+ };
1675
+ THOR: ChainWallet<Chain.THORChain> & {
1676
+ broadcastMultisigTx: (tx: string, signers: import("@tcswap/toolboxes/cosmos").MultiSigSigner[], membersPubKeys: string[], threshold: number, bodyBytes: Uint8Array) => Promise<string>;
1677
+ buildAminoMsg: ({ sender, recipient, assetValue, memo, }: {
1678
+ sender: string;
1679
+ recipient?: string;
1680
+ assetValue: import("@tcswap/helpers").AssetValue;
1681
+ memo?: string;
1682
+ }) => {
1683
+ type: "thorchain/MsgDeposit" | "mayachain/MsgDeposit";
1684
+ value: {
1685
+ coins: {
1686
+ amount: string;
1687
+ asset: string;
1688
+ }[];
1689
+ memo: string;
1690
+ signer: string;
1691
+ };
1692
+ } | {
1693
+ type: "thorchain/MsgSend" | "mayachain/MsgSend";
1694
+ value: {
1695
+ amount: {
1696
+ amount: string;
1697
+ denom: string;
1698
+ }[];
1699
+ from_address: string;
1700
+ to_address: string | undefined;
1701
+ };
1702
+ };
1703
+ buildEncodedTxBody: typeof import("@tcswap/toolboxes/cosmos").buildEncodedTxBody;
1704
+ convertToSignable: (msg: {
1705
+ type: "thorchain/MsgSend" | "mayachain/MsgSend";
1706
+ value: {
1707
+ amount: {
1708
+ amount: string;
1709
+ denom: string;
1710
+ }[];
1711
+ from_address: string;
1712
+ to_address: string | undefined;
1713
+ };
1714
+ } | {
1715
+ type: "thorchain/MsgDeposit" | "mayachain/MsgDeposit";
1716
+ value: {
1717
+ coins: {
1718
+ amount: string;
1719
+ asset: string;
1720
+ }[];
1721
+ memo: string;
1722
+ signer: string;
1723
+ };
1724
+ }, chain: import("@tcswap/types").TCLikeChain) => Promise<import("@cosmjs/proto-signing").EncodeObject>;
1725
+ createDefaultAminoTypes: () => Promise<import("@cosmjs/stargate").AminoTypes>;
1726
+ createDefaultRegistry: typeof import("@tcswap/toolboxes/cosmos").createDefaultRegistry;
1727
+ createMultisig: (pubKeys: string[], threshold: number, noSortPubKeys?: boolean) => Promise<import("@cosmjs/amino").MultisigThresholdPubkey>;
1728
+ createTransaction: (params: import("@tcswap/toolboxes/cosmos").ThorchainCreateTransactionParams) => Promise<{
1729
+ accountNumber: number;
1730
+ chainId: import("@tcswap/types").ChainId.Maya | import("@tcswap/types").ChainId.THORChain;
1731
+ fee: {
1732
+ amount: {
1733
+ amount: string;
1734
+ denom: string;
1735
+ }[];
1736
+ gas: string;
1737
+ };
1738
+ memo: string;
1739
+ msgs: (import("@cosmjs/proto-signing").EncodeObject | {
1740
+ type: "thorchain/MsgSend" | "mayachain/MsgSend";
1741
+ value: {
1742
+ amount: {
1743
+ amount: string;
1744
+ denom: string;
1745
+ }[];
1746
+ from_address: string;
1747
+ to_address: string | undefined;
1748
+ };
1749
+ })[];
1750
+ sequence: number;
1751
+ }> | Promise<{
1752
+ accountNumber: number;
1753
+ chainId: import("@tcswap/types").ChainId.Maya | import("@tcswap/types").ChainId.THORChain;
1754
+ fee: {
1755
+ amount: {
1756
+ amount: string;
1757
+ denom: string;
1758
+ }[];
1759
+ gas: string;
1760
+ };
1761
+ memo: string;
1762
+ msgs: (import("@cosmjs/proto-signing").EncodeObject | {
1763
+ type: "thorchain/MsgDeposit" | "mayachain/MsgDeposit";
1764
+ value: {
1765
+ coins: {
1766
+ amount: string;
1767
+ asset: string;
1768
+ }[];
1769
+ memo: string;
1770
+ signer: string;
1771
+ };
1772
+ })[];
1773
+ sequence: number;
1774
+ }>;
1775
+ deposit: ({ assetValue, memo, recipient, }: Omit<GenericTransferParams, "recipient"> & {
1776
+ recipient?: string;
1777
+ }) => Promise<string>;
1778
+ getFees: () => Promise<{
1779
+ average: import("@tcswap/helpers").USwapNumber;
1780
+ fast: import("@tcswap/helpers").USwapNumber;
1781
+ fastest: import("@tcswap/helpers").USwapNumber;
1782
+ }>;
1783
+ importSignature: (signature: string) => Uint8Array<ArrayBufferLike>;
1784
+ parseAminoMessageForDirectSigning: typeof import("@tcswap/toolboxes/cosmos").parseAminoMessageForDirectSigning;
1785
+ pubkeyToAddress: (pubkey: import("@cosmjs/amino").Pubkey) => Promise<string>;
1786
+ secp256k1HdWalletFromMnemonic: (mnemonic: string, index?: number) => Promise<import("@cosmjs/amino").Secp256k1HdWallet>;
1787
+ signMultisigTx: ({ wallet, tx }: {
1788
+ wallet: import("@cosmjs/amino").Secp256k1HdWallet;
1789
+ tx: string | import("@tcswap/toolboxes/cosmos").MultisigTx;
1790
+ }) => Promise<{
1791
+ bodyBytes: Uint8Array<ArrayBufferLike>;
1792
+ signature: string;
1793
+ }>;
1794
+ signWithPrivateKey: ({ privateKey, message }: {
1795
+ privateKey: Uint8Array;
1796
+ message: string;
1797
+ }) => Promise<string>;
1798
+ transfer: ({ assetValue, memo, recipient, }: Omit<GenericTransferParams, "recipient"> & {
1799
+ recipient?: string;
1800
+ }) => Promise<string>;
1801
+ createPrivateKeyFromPhrase: (phrase: string) => Promise<Uint8Array<ArrayBufferLike>>;
1802
+ fetchFeeRateFromSwapKit: typeof import("@tcswap/toolboxes/cosmos").fetchFeeRateFromSwapKit;
1803
+ getAccount: (address: string) => Promise<import("@cosmjs/stargate").Account | null>;
1804
+ getAddress: () => Promise<string | undefined>;
1805
+ getBalance: (address: string, _potentialScamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
1806
+ getBalanceAsDenoms: (address: string) => Promise<{
1807
+ denom: string;
1808
+ amount: string;
1809
+ }[]>;
1810
+ getPubKey: () => Promise<string>;
1811
+ getSignerFromPhrase: ({ phrase, derivationPath }: {
1812
+ phrase: string;
1813
+ derivationPath: import("@tcswap/helpers").DerivationPathArray;
1814
+ }) => Promise<import("@cosmjs/proto-signing").DirectSecp256k1HdWallet>;
1815
+ getSignerFromPrivateKey: (privateKey: Uint8Array) => Promise<import("@cosmjs/proto-signing").DirectSecp256k1Wallet>;
1816
+ signTransaction: ({ recipient, assetValue, memo, feeRate, feeOptionKey, }: GenericTransferParams) => Promise<string>;
1817
+ validateAddress: (address: string) => boolean;
1818
+ verifySignature: ({ signature, message, address, }: {
1819
+ signature: string;
1820
+ message: string;
1821
+ address: string;
1822
+ }) => Promise<boolean>;
1823
+ };
1824
+ TON: ChainWallet<Chain.Ton> & {
1825
+ createTransaction: ({ assetValue, recipient, memo }: import("@tcswap/toolboxes/ton").TONTransferParams) => Promise<import("@ton/ton/dist").Cell>;
1826
+ estimateTransactionFee: () => Promise<AssetValue>;
1827
+ getAddress: () => string;
1828
+ getBalance: (address: string) => Promise<AssetValue[]>;
1829
+ sendTransaction: (transferCell: import("@ton/ton/dist").Cell) => Promise<string>;
1830
+ transfer: ({ assetValue, recipient, memo }: import("@tcswap/toolboxes/ton").TONTransferParams) => Promise<string>;
1831
+ validateAddress: (address: string) => boolean;
1832
+ };
1833
+ TRON: ChainWallet<Chain.Tron> & {
1834
+ tronWeb: import("tronweb").TronWeb;
1835
+ getAddress: () => Promise<string>;
1836
+ validateAddress: (address: string) => boolean;
1837
+ getBalance: (address: string) => Promise<AssetValue[]>;
1838
+ transfer: (params: import("@tcswap/toolboxes/tron").TronTransferParams) => Promise<string>;
1839
+ estimateTransactionFee: (params: import("@tcswap/toolboxes/tron").TronTransferParams & {
1840
+ sender?: string;
1841
+ }) => Promise<AssetValue>;
1842
+ createTransaction: (params: import("@tcswap/toolboxes/tron").TronCreateTransactionParams) => Promise<import("@tcswap/toolboxes/tron").TronTransaction>;
1843
+ signTransaction: (transaction: import("@tcswap/toolboxes/tron").TronTransaction) => Promise<import("@tcswap/toolboxes/tron").TronSignedTransaction>;
1844
+ broadcastTransaction: (signedTransaction: import("@tcswap/toolboxes/tron").TronSignedTransaction) => Promise<string>;
1845
+ approve: (params: import("@tcswap/toolboxes/tron").TronApproveParams) => Promise<string>;
1846
+ isApproved: (params: import("@tcswap/toolboxes/tron").TronIsApprovedParams) => Promise<boolean>;
1847
+ getApprovedAmount: (params: import("@tcswap/toolboxes/tron").TronApprovedParams) => Promise<bigint>;
1848
+ };
1849
+ UNI: ChainWallet<Chain.Unichain> & {
1850
+ approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
1851
+ approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
1852
+ broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
1853
+ call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T_1>;
1854
+ createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
1855
+ createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
1856
+ createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
1857
+ createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
1858
+ createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
1859
+ EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
1860
+ estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
1861
+ estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
1862
+ assetValue: import("@tcswap/helpers").AssetValue;
1863
+ funcName?: string;
1864
+ funcParams?: unknown[];
1865
+ txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
1866
+ data?: string;
1867
+ }) => Promise<bigint>;
1868
+ estimateGasPrices: () => Promise<{ [key_2 in FeeOption]: {
1869
+ l1GasPrice?: bigint;
1870
+ gasPrice?: bigint;
1871
+ maxFeePerGas?: bigint;
1872
+ maxPriorityFeePerGas?: bigint;
1873
+ }; }>;
1874
+ estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
1875
+ feeOption: FeeOption;
1876
+ chain: EVMChain;
1877
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
1878
+ getAddress: () => string | Promise<string> | undefined;
1879
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
1880
+ getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
1881
+ isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
1882
+ sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
1883
+ feeOptionKey?: FeeOption;
1884
+ }) => Promise<string>;
1885
+ signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
1886
+ transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
1887
+ validateAddress: (address: string) => boolean;
1888
+ };
1889
+ XLAYER: ChainWallet<Chain.XLayer> & {
1890
+ approve: ({ assetAddress, spenderAddress, feeOptionKey, amount, gasLimitFallback, from: fromParam, nonce, }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<string>;
1891
+ approvedAmount: ({ assetAddress, spenderAddress, from }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<bigint>;
1892
+ broadcastTransaction: ((signedTx: string) => Promise<import("ethers").TransactionResponse>) | ((signedTx: string) => Promise<import("ethers").TransactionResponse>);
1893
+ call: <T_1>({ callProvider, contractAddress, abi, funcName, funcParams, txOverrides, feeOption, }: import("@tcswap/toolboxes/evm").CallParams) => Promise<T_1>;
1894
+ createApprovalTx: ({ assetAddress, spenderAddress, amount, from: fromParam }: import("@tcswap/toolboxes/evm").ApproveParams) => Promise<import("ethers").ContractTransaction>;
1895
+ createContract: (address: string, abi: readonly (import("ethers").JsonFragment | import("ethers").Fragment)[]) => import("ethers").Contract;
1896
+ createContractTxObject: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").CallParams) => Promise<import("ethers").ContractTransaction>;
1897
+ createTransaction: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
1898
+ createTransferTx: ({ assetValue, memo, recipient, data, sender: fromOverride, maxFeePerGas, maxPriorityFeePerGas, gasPrice, ...tx }: import("@tcswap/toolboxes/evm").EVMCreateTransactionParams) => Promise<import("ethers").ContractTransaction>;
1899
+ EIP1193SendTransaction: ({ value, ...params }: import("@tcswap/toolboxes/evm").EVMTxParams | import("ethers").ContractTransaction) => Promise<string>;
1900
+ estimateCall: ({ contractAddress, abi, funcName, funcParams, txOverrides }: import("@tcswap/toolboxes/evm").EstimateCallParams) => Promise<bigint>;
1901
+ estimateGasLimit: ({ assetValue, recipient, memo, data, sender, funcName, funcParams, txOverrides, }: import("@tcswap/toolboxes/evm").EVMTransferParams & {
1902
+ assetValue: import("@tcswap/helpers").AssetValue;
1903
+ funcName?: string;
1904
+ funcParams?: unknown[];
1905
+ txOverrides?: import("@tcswap/toolboxes/evm").EVMTxParams;
1906
+ data?: string;
1907
+ }) => Promise<bigint>;
1908
+ estimateGasPrices: () => Promise<{ [key_2 in FeeOption]: {
1909
+ l1GasPrice?: bigint;
1910
+ gasPrice?: bigint;
1911
+ maxFeePerGas?: bigint;
1912
+ maxPriorityFeePerGas?: bigint;
1913
+ }; }>;
1914
+ estimateTransactionFee: ({ feeOption, chain, ...txObject }: import("@tcswap/toolboxes/evm").EIP1559TxParams & {
1915
+ feeOption: FeeOption;
1916
+ chain: EVMChain;
1917
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
1918
+ getAddress: () => string | Promise<string> | undefined;
1919
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
1920
+ getNetworkParams: () => import("@tcswap/helpers").NetworkParams | undefined;
1921
+ isApproved: ({ assetAddress, spenderAddress, from, amount }: import("@tcswap/toolboxes/evm").IsApprovedParams) => Promise<boolean>;
1922
+ sendTransaction: ({ feeOptionKey, ...tx }: import("@tcswap/toolboxes/evm").EVMTxParams & {
1923
+ feeOptionKey?: FeeOption;
1924
+ }) => Promise<string>;
1925
+ signMessage: ((message: string | Uint8Array) => Promise<string>) | undefined;
1926
+ transfer: ({ assetValue, memo, recipient, feeOptionKey, sender, ...tx }: import("@tcswap/toolboxes/evm").EVMTransferParams) => Promise<string>;
1927
+ validateAddress: (address: string) => boolean;
1928
+ };
1929
+ ZEC: ChainWallet<Chain.Zcash> & {
1930
+ createKeysForPath: ({ phrase, derivationPath, }: {
1931
+ phrase: string;
1932
+ derivationPath?: string;
1933
+ }) => import("ecpair").ECPairInterface;
1934
+ createTransaction: (buildTxParams: import("@tcswap/toolboxes/utxo").UTXOBuildTxParams) => Promise<{
1935
+ inputs: import("@tcswap/toolboxes/utxo").UTXOType[];
1936
+ outputs: import("@tcswap/toolboxes/utxo").TargetOutput[];
1937
+ psbt: import("@bitgo/utxo-lib/dist/src/bitgo").ZcashPsbt;
1938
+ }>;
1939
+ getPrivateKeyFromMnemonic: ({ phrase, derivationPath, }: {
1940
+ phrase: string;
1941
+ derivationPath: string;
1942
+ }) => string;
1943
+ transfer: ({ recipient, assetValue, feeOptionKey, ...rest }: import("@tcswap/toolboxes/utxo").UTXOTransferParams) => Promise<string>;
1944
+ validateAddress: typeof import("@tcswap/toolboxes/utxo").validateZcashAddress;
1945
+ accumulative: typeof import("@tcswap/toolboxes/utxo").accumulative;
1946
+ broadcastTx: (txHash: string) => Promise<string>;
1947
+ calculateTxSize: ({ inputs, outputs, feeRate }: import("@tcswap/toolboxes/utxo").UTXOCalculateTxSizeParams) => number;
1948
+ estimateMaxSendableAmount: ({ from, memo, feeRate, feeOptionKey, recipients, }: {
1949
+ from: string;
1950
+ memo?: string;
1951
+ feeRate?: number;
1952
+ feeOptionKey?: FeeOption;
1953
+ recipients?: number | import("@tcswap/toolboxes/utxo").TargetOutput[];
1954
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
1955
+ estimateTransactionFee: (params: {
1956
+ assetValue: import("@tcswap/helpers").AssetValue;
1957
+ recipient: string;
1958
+ sender: string;
1959
+ memo?: string;
1960
+ feeOptionKey?: FeeOption;
1961
+ feeRate?: number;
1962
+ fetchTxHex?: boolean;
1963
+ }) => Promise<import("@tcswap/helpers").AssetValue>;
1964
+ getAddress: () => Promise<string | undefined>;
1965
+ getAddressFromKeys: (keys: import("ecpair").ECPairInterface | import("@tcswap/toolboxes/utxo").BchECPair) => string;
1966
+ getBalance: (address: string, scamFilter?: boolean) => Promise<import("@tcswap/helpers").AssetValue[]>;
1967
+ getFeeRates: () => Promise<{
1968
+ average: number;
1969
+ fast: number;
1970
+ fastest: number;
1971
+ }>;
1972
+ getInputsOutputsFee: ({ assetValue, feeOptionKey, feeRate, memo, sender, recipient, }: Omit<import("@tcswap/toolboxes/utxo").UTXOBuildTxParams, "feeRate"> & {
1973
+ feeOptionKey?: FeeOption;
1974
+ feeRate?: number;
1975
+ }) => Promise<{
1976
+ fee: number;
1977
+ inputs: (import("@tcswap/toolboxes/utxo").UTXOType | import("@tcswap/toolboxes/utxo").UTXOInputWithScriptType)[];
1978
+ outputs: import("@tcswap/toolboxes/utxo").TargetOutput[];
1979
+ } | {
1980
+ fee: number;
1981
+ inputs?: undefined;
1982
+ outputs?: undefined;
1983
+ }>;
1984
+ };
1985
+ };
1986
+ getBalance: <T_1 extends Chain, R extends boolean>(chain: T_1, refresh?: R) => ConditionalAssetValueReturn<R>;
1987
+ getWallet: <T_1 extends Chain>(walletOption: WalletOption, chain: T_1) => FullWallet[T_1];
1988
+ getWalletByChain: <T_1 extends Chain>(chain: T_1) => FullWallet[T_1];
1989
+ getWalletWithBalance: <T_1 extends Chain>(chain: T_1, scamFilter?: boolean) => Promise<FullWallet[T_1]>;
1990
+ isAssetValueApproved: (assetValue: AssetValue, contractAddress: string | keyof Plugins) => Promise<boolean>;
1991
+ signMessage: ({ chain, message }: {
1992
+ chain: Chain;
1993
+ message: string;
1994
+ }) => Promise<string> | undefined;
1995
+ swap: <T_1 extends keyof Plugins>({ route, pluginName, ...rest }: SwapParams<T_1, QuoteResponseRoute>) => any;
1996
+ transfer: ({ assetValue, ...params }: GenericTransferParams | EVMTransferParams) => Promise<string>;
1997
+ verifyMessage: ({ address, chain, message, signature, }: {
1998
+ chain: Chain;
1999
+ signature: string;
2000
+ message: string;
2001
+ address: string;
2002
+ }) => Promise<boolean>;
2003
+ };
2004
+ export * from "@tcswap/helpers";
2005
+ //# sourceMappingURL=index.d.ts.map