@gitmyabi/logic 0.0.0-stage → 1.0.0
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.
- package/README.md +107 -2
- package/contracts/Logic.d.ts +2256 -0
- package/contracts/Logic.js +1992 -0
- package/contracts/Logic.ts +2890 -0
- package/contracts/OwnedProxy.d.ts +168 -0
- package/contracts/OwnedProxy.js +185 -0
- package/contracts/OwnedProxy.ts +237 -0
- package/contracts/index.d.ts +4 -0
- package/contracts/index.js +10 -0
- package/contracts/index.ts +5 -0
- package/index.d.ts +1 -0
- package/index.js +19 -0
- package/package.json +40 -3
|
@@ -0,0 +1,2890 @@
|
|
|
1
|
+
import type { Abi, Address, PublicClient, WalletClient, GetContractReturnType } from 'viem';
|
|
2
|
+
import { getContract } from 'viem';
|
|
3
|
+
|
|
4
|
+
|
|
5
|
+
/**
|
|
6
|
+
* Logic.V4SwapData struct type
|
|
7
|
+
*/
|
|
8
|
+
export type Logic_V4SwapData = {
|
|
9
|
+
key: PoolKey;
|
|
10
|
+
params: SwapParams;
|
|
11
|
+
};
|
|
12
|
+
|
|
13
|
+
/**
|
|
14
|
+
* PoolKey struct type
|
|
15
|
+
*/
|
|
16
|
+
export type PoolKey = {
|
|
17
|
+
currency0: `0x${string}`;
|
|
18
|
+
currency1: `0x${string}`;
|
|
19
|
+
fee: bigint;
|
|
20
|
+
tickSpacing: bigint;
|
|
21
|
+
hooks: `0x${string}`;
|
|
22
|
+
};
|
|
23
|
+
|
|
24
|
+
/**
|
|
25
|
+
* SwapParams struct type
|
|
26
|
+
*/
|
|
27
|
+
export type SwapParams = {
|
|
28
|
+
zeroForOne: boolean;
|
|
29
|
+
amountSpecified: bigint;
|
|
30
|
+
sqrtPriceLimitX96: bigint;
|
|
31
|
+
};
|
|
32
|
+
/**
|
|
33
|
+
* Logic ABI
|
|
34
|
+
*
|
|
35
|
+
* This ABI is typed using viem's type system for full type safety.
|
|
36
|
+
*/
|
|
37
|
+
export const LogicAbi = [
|
|
38
|
+
{
|
|
39
|
+
"inputs": [
|
|
40
|
+
{
|
|
41
|
+
"internalType": "address",
|
|
42
|
+
"name": "proxyOwner",
|
|
43
|
+
"type": "address"
|
|
44
|
+
},
|
|
45
|
+
{
|
|
46
|
+
"internalType": "address",
|
|
47
|
+
"name": "proxyContract",
|
|
48
|
+
"type": "address"
|
|
49
|
+
}
|
|
50
|
+
],
|
|
51
|
+
"stateMutability": "nonpayable",
|
|
52
|
+
"type": "constructor"
|
|
53
|
+
},
|
|
54
|
+
{
|
|
55
|
+
"inputs": [],
|
|
56
|
+
"name": "WHITELIST_MANAGER",
|
|
57
|
+
"outputs": [
|
|
58
|
+
{
|
|
59
|
+
"internalType": "address",
|
|
60
|
+
"name": "",
|
|
61
|
+
"type": "address"
|
|
62
|
+
}
|
|
63
|
+
],
|
|
64
|
+
"stateMutability": "view",
|
|
65
|
+
"type": "function"
|
|
66
|
+
},
|
|
67
|
+
{
|
|
68
|
+
"inputs": [
|
|
69
|
+
{
|
|
70
|
+
"internalType": "address",
|
|
71
|
+
"name": "deployer",
|
|
72
|
+
"type": "address"
|
|
73
|
+
},
|
|
74
|
+
{
|
|
75
|
+
"internalType": "address[]",
|
|
76
|
+
"name": "pools",
|
|
77
|
+
"type": "address[]"
|
|
78
|
+
}
|
|
79
|
+
],
|
|
80
|
+
"name": "addWhitelistedAlgebraCustomPoolAddressesHum_1T0MDH",
|
|
81
|
+
"outputs": [],
|
|
82
|
+
"stateMutability": "nonpayable",
|
|
83
|
+
"type": "function"
|
|
84
|
+
},
|
|
85
|
+
{
|
|
86
|
+
"inputs": [
|
|
87
|
+
{
|
|
88
|
+
"internalType": "address[]",
|
|
89
|
+
"name": "bots",
|
|
90
|
+
"type": "address[]"
|
|
91
|
+
}
|
|
92
|
+
],
|
|
93
|
+
"name": "addWhitelistedBotAddressesHum",
|
|
94
|
+
"outputs": [],
|
|
95
|
+
"stateMutability": "nonpayable",
|
|
96
|
+
"type": "function"
|
|
97
|
+
},
|
|
98
|
+
{
|
|
99
|
+
"inputs": [
|
|
100
|
+
{
|
|
101
|
+
"internalType": "address[]",
|
|
102
|
+
"name": "pairs",
|
|
103
|
+
"type": "address[]"
|
|
104
|
+
}
|
|
105
|
+
],
|
|
106
|
+
"name": "addWhitelistedPairAddressesHum",
|
|
107
|
+
"outputs": [],
|
|
108
|
+
"stateMutability": "nonpayable",
|
|
109
|
+
"type": "function"
|
|
110
|
+
},
|
|
111
|
+
{
|
|
112
|
+
"inputs": [
|
|
113
|
+
{
|
|
114
|
+
"internalType": "address[]",
|
|
115
|
+
"name": "accounts",
|
|
116
|
+
"type": "address[]"
|
|
117
|
+
}
|
|
118
|
+
],
|
|
119
|
+
"name": "addWhitelistedTokenAddressesHum",
|
|
120
|
+
"outputs": [],
|
|
121
|
+
"stateMutability": "nonpayable",
|
|
122
|
+
"type": "function"
|
|
123
|
+
},
|
|
124
|
+
{
|
|
125
|
+
"inputs": [
|
|
126
|
+
{
|
|
127
|
+
"internalType": "address[]",
|
|
128
|
+
"name": "accounts",
|
|
129
|
+
"type": "address[]"
|
|
130
|
+
}
|
|
131
|
+
],
|
|
132
|
+
"name": "addWhitelistedTransferAddressesHum",
|
|
133
|
+
"outputs": [],
|
|
134
|
+
"stateMutability": "nonpayable",
|
|
135
|
+
"type": "function"
|
|
136
|
+
},
|
|
137
|
+
{
|
|
138
|
+
"inputs": [
|
|
139
|
+
{
|
|
140
|
+
"internalType": "address[]",
|
|
141
|
+
"name": "factories",
|
|
142
|
+
"type": "address[]"
|
|
143
|
+
}
|
|
144
|
+
],
|
|
145
|
+
"name": "addWhitelistedUniswapV3FactoryHum",
|
|
146
|
+
"outputs": [],
|
|
147
|
+
"stateMutability": "nonpayable",
|
|
148
|
+
"type": "function"
|
|
149
|
+
},
|
|
150
|
+
{
|
|
151
|
+
"inputs": [
|
|
152
|
+
{
|
|
153
|
+
"internalType": "address[]",
|
|
154
|
+
"name": "pools",
|
|
155
|
+
"type": "address[]"
|
|
156
|
+
}
|
|
157
|
+
],
|
|
158
|
+
"name": "addWhitelistedUniswapV3PoolAddressesHum",
|
|
159
|
+
"outputs": [],
|
|
160
|
+
"stateMutability": "nonpayable",
|
|
161
|
+
"type": "function"
|
|
162
|
+
},
|
|
163
|
+
{
|
|
164
|
+
"inputs": [
|
|
165
|
+
{
|
|
166
|
+
"internalType": "address[]",
|
|
167
|
+
"name": "accounts",
|
|
168
|
+
"type": "address[]"
|
|
169
|
+
}
|
|
170
|
+
],
|
|
171
|
+
"name": "addWhitelistedUniswapV3PositionManagerHum",
|
|
172
|
+
"outputs": [],
|
|
173
|
+
"stateMutability": "nonpayable",
|
|
174
|
+
"type": "function"
|
|
175
|
+
},
|
|
176
|
+
{
|
|
177
|
+
"inputs": [
|
|
178
|
+
{
|
|
179
|
+
"internalType": "address[]",
|
|
180
|
+
"name": "hooks",
|
|
181
|
+
"type": "address[]"
|
|
182
|
+
}
|
|
183
|
+
],
|
|
184
|
+
"name": "addWhitelistedUniswapV4HooksHum",
|
|
185
|
+
"outputs": [],
|
|
186
|
+
"stateMutability": "nonpayable",
|
|
187
|
+
"type": "function"
|
|
188
|
+
},
|
|
189
|
+
{
|
|
190
|
+
"inputs": [
|
|
191
|
+
{
|
|
192
|
+
"internalType": "address",
|
|
193
|
+
"name": "poolManager",
|
|
194
|
+
"type": "address"
|
|
195
|
+
},
|
|
196
|
+
{
|
|
197
|
+
"internalType": "bytes[]",
|
|
198
|
+
"name": "keys",
|
|
199
|
+
"type": "bytes[]"
|
|
200
|
+
}
|
|
201
|
+
],
|
|
202
|
+
"name": "addWhitelistedUniswapV4PoolsHum",
|
|
203
|
+
"outputs": [],
|
|
204
|
+
"stateMutability": "nonpayable",
|
|
205
|
+
"type": "function"
|
|
206
|
+
},
|
|
207
|
+
{
|
|
208
|
+
"inputs": [
|
|
209
|
+
{
|
|
210
|
+
"internalType": "int256",
|
|
211
|
+
"name": "amount0Delta",
|
|
212
|
+
"type": "int256"
|
|
213
|
+
},
|
|
214
|
+
{
|
|
215
|
+
"internalType": "int256",
|
|
216
|
+
"name": "amount1Delta",
|
|
217
|
+
"type": "int256"
|
|
218
|
+
},
|
|
219
|
+
{
|
|
220
|
+
"internalType": "bytes",
|
|
221
|
+
"name": "data",
|
|
222
|
+
"type": "bytes"
|
|
223
|
+
}
|
|
224
|
+
],
|
|
225
|
+
"name": "algebraSwapCallback",
|
|
226
|
+
"outputs": [],
|
|
227
|
+
"stateMutability": "nonpayable",
|
|
228
|
+
"type": "function"
|
|
229
|
+
},
|
|
230
|
+
{
|
|
231
|
+
"inputs": [
|
|
232
|
+
{
|
|
233
|
+
"internalType": "address",
|
|
234
|
+
"name": "",
|
|
235
|
+
"type": "address"
|
|
236
|
+
}
|
|
237
|
+
],
|
|
238
|
+
"name": "isWhitelistedBotAddress",
|
|
239
|
+
"outputs": [
|
|
240
|
+
{
|
|
241
|
+
"internalType": "bool",
|
|
242
|
+
"name": "",
|
|
243
|
+
"type": "bool"
|
|
244
|
+
}
|
|
245
|
+
],
|
|
246
|
+
"stateMutability": "view",
|
|
247
|
+
"type": "function"
|
|
248
|
+
},
|
|
249
|
+
{
|
|
250
|
+
"inputs": [
|
|
251
|
+
{
|
|
252
|
+
"internalType": "address",
|
|
253
|
+
"name": "",
|
|
254
|
+
"type": "address"
|
|
255
|
+
}
|
|
256
|
+
],
|
|
257
|
+
"name": "isWhitelistedPairAddress",
|
|
258
|
+
"outputs": [
|
|
259
|
+
{
|
|
260
|
+
"internalType": "bool",
|
|
261
|
+
"name": "",
|
|
262
|
+
"type": "bool"
|
|
263
|
+
}
|
|
264
|
+
],
|
|
265
|
+
"stateMutability": "view",
|
|
266
|
+
"type": "function"
|
|
267
|
+
},
|
|
268
|
+
{
|
|
269
|
+
"inputs": [
|
|
270
|
+
{
|
|
271
|
+
"internalType": "bytes32",
|
|
272
|
+
"name": "",
|
|
273
|
+
"type": "bytes32"
|
|
274
|
+
}
|
|
275
|
+
],
|
|
276
|
+
"name": "isWhitelistedPoolHash",
|
|
277
|
+
"outputs": [
|
|
278
|
+
{
|
|
279
|
+
"internalType": "bool",
|
|
280
|
+
"name": "",
|
|
281
|
+
"type": "bool"
|
|
282
|
+
}
|
|
283
|
+
],
|
|
284
|
+
"stateMutability": "view",
|
|
285
|
+
"type": "function"
|
|
286
|
+
},
|
|
287
|
+
{
|
|
288
|
+
"inputs": [
|
|
289
|
+
{
|
|
290
|
+
"internalType": "address",
|
|
291
|
+
"name": "",
|
|
292
|
+
"type": "address"
|
|
293
|
+
}
|
|
294
|
+
],
|
|
295
|
+
"name": "isWhitelistedPoolHook",
|
|
296
|
+
"outputs": [
|
|
297
|
+
{
|
|
298
|
+
"internalType": "bool",
|
|
299
|
+
"name": "",
|
|
300
|
+
"type": "bool"
|
|
301
|
+
}
|
|
302
|
+
],
|
|
303
|
+
"stateMutability": "view",
|
|
304
|
+
"type": "function"
|
|
305
|
+
},
|
|
306
|
+
{
|
|
307
|
+
"inputs": [
|
|
308
|
+
{
|
|
309
|
+
"internalType": "address",
|
|
310
|
+
"name": "",
|
|
311
|
+
"type": "address"
|
|
312
|
+
}
|
|
313
|
+
],
|
|
314
|
+
"name": "isWhitelistedRouterAddress",
|
|
315
|
+
"outputs": [
|
|
316
|
+
{
|
|
317
|
+
"internalType": "bool",
|
|
318
|
+
"name": "",
|
|
319
|
+
"type": "bool"
|
|
320
|
+
}
|
|
321
|
+
],
|
|
322
|
+
"stateMutability": "view",
|
|
323
|
+
"type": "function"
|
|
324
|
+
},
|
|
325
|
+
{
|
|
326
|
+
"inputs": [
|
|
327
|
+
{
|
|
328
|
+
"internalType": "address",
|
|
329
|
+
"name": "",
|
|
330
|
+
"type": "address"
|
|
331
|
+
}
|
|
332
|
+
],
|
|
333
|
+
"name": "isWhitelistedSlot11Address_3HRmBk",
|
|
334
|
+
"outputs": [
|
|
335
|
+
{
|
|
336
|
+
"internalType": "bool",
|
|
337
|
+
"name": "",
|
|
338
|
+
"type": "bool"
|
|
339
|
+
}
|
|
340
|
+
],
|
|
341
|
+
"stateMutability": "view",
|
|
342
|
+
"type": "function"
|
|
343
|
+
},
|
|
344
|
+
{
|
|
345
|
+
"inputs": [
|
|
346
|
+
{
|
|
347
|
+
"internalType": "address",
|
|
348
|
+
"name": "",
|
|
349
|
+
"type": "address"
|
|
350
|
+
}
|
|
351
|
+
],
|
|
352
|
+
"name": "isWhitelistedSlot3Address_7xvhmR",
|
|
353
|
+
"outputs": [
|
|
354
|
+
{
|
|
355
|
+
"internalType": "bool",
|
|
356
|
+
"name": "",
|
|
357
|
+
"type": "bool"
|
|
358
|
+
}
|
|
359
|
+
],
|
|
360
|
+
"stateMutability": "view",
|
|
361
|
+
"type": "function"
|
|
362
|
+
},
|
|
363
|
+
{
|
|
364
|
+
"inputs": [
|
|
365
|
+
{
|
|
366
|
+
"internalType": "address",
|
|
367
|
+
"name": "",
|
|
368
|
+
"type": "address"
|
|
369
|
+
}
|
|
370
|
+
],
|
|
371
|
+
"name": "isWhitelistedTokenAddress",
|
|
372
|
+
"outputs": [
|
|
373
|
+
{
|
|
374
|
+
"internalType": "bool",
|
|
375
|
+
"name": "",
|
|
376
|
+
"type": "bool"
|
|
377
|
+
}
|
|
378
|
+
],
|
|
379
|
+
"stateMutability": "view",
|
|
380
|
+
"type": "function"
|
|
381
|
+
},
|
|
382
|
+
{
|
|
383
|
+
"inputs": [
|
|
384
|
+
{
|
|
385
|
+
"internalType": "address",
|
|
386
|
+
"name": "",
|
|
387
|
+
"type": "address"
|
|
388
|
+
}
|
|
389
|
+
],
|
|
390
|
+
"name": "isWhitelistedTransferAddress",
|
|
391
|
+
"outputs": [
|
|
392
|
+
{
|
|
393
|
+
"internalType": "bool",
|
|
394
|
+
"name": "",
|
|
395
|
+
"type": "bool"
|
|
396
|
+
}
|
|
397
|
+
],
|
|
398
|
+
"stateMutability": "view",
|
|
399
|
+
"type": "function"
|
|
400
|
+
},
|
|
401
|
+
{
|
|
402
|
+
"inputs": [
|
|
403
|
+
{
|
|
404
|
+
"internalType": "address",
|
|
405
|
+
"name": "",
|
|
406
|
+
"type": "address"
|
|
407
|
+
}
|
|
408
|
+
],
|
|
409
|
+
"name": "isWhitelistedUniswapV3FactoryAddress",
|
|
410
|
+
"outputs": [
|
|
411
|
+
{
|
|
412
|
+
"internalType": "bool",
|
|
413
|
+
"name": "",
|
|
414
|
+
"type": "bool"
|
|
415
|
+
}
|
|
416
|
+
],
|
|
417
|
+
"stateMutability": "view",
|
|
418
|
+
"type": "function"
|
|
419
|
+
},
|
|
420
|
+
{
|
|
421
|
+
"inputs": [
|
|
422
|
+
{
|
|
423
|
+
"internalType": "address",
|
|
424
|
+
"name": "",
|
|
425
|
+
"type": "address"
|
|
426
|
+
}
|
|
427
|
+
],
|
|
428
|
+
"name": "isWhitelistedUniswapV3PoolAddress",
|
|
429
|
+
"outputs": [
|
|
430
|
+
{
|
|
431
|
+
"internalType": "bool",
|
|
432
|
+
"name": "",
|
|
433
|
+
"type": "bool"
|
|
434
|
+
}
|
|
435
|
+
],
|
|
436
|
+
"stateMutability": "view",
|
|
437
|
+
"type": "function"
|
|
438
|
+
},
|
|
439
|
+
{
|
|
440
|
+
"inputs": [
|
|
441
|
+
{
|
|
442
|
+
"internalType": "address",
|
|
443
|
+
"name": "",
|
|
444
|
+
"type": "address"
|
|
445
|
+
}
|
|
446
|
+
],
|
|
447
|
+
"name": "isWhitelistedUniswapV3PositionManagerAddress",
|
|
448
|
+
"outputs": [
|
|
449
|
+
{
|
|
450
|
+
"internalType": "bool",
|
|
451
|
+
"name": "",
|
|
452
|
+
"type": "bool"
|
|
453
|
+
}
|
|
454
|
+
],
|
|
455
|
+
"stateMutability": "view",
|
|
456
|
+
"type": "function"
|
|
457
|
+
},
|
|
458
|
+
{
|
|
459
|
+
"inputs": [
|
|
460
|
+
{
|
|
461
|
+
"internalType": "address[]",
|
|
462
|
+
"name": "tokens",
|
|
463
|
+
"type": "address[]"
|
|
464
|
+
},
|
|
465
|
+
{
|
|
466
|
+
"internalType": "address",
|
|
467
|
+
"name": "newProxy",
|
|
468
|
+
"type": "address"
|
|
469
|
+
},
|
|
470
|
+
{
|
|
471
|
+
"internalType": "address",
|
|
472
|
+
"name": "newProxyOwner",
|
|
473
|
+
"type": "address"
|
|
474
|
+
}
|
|
475
|
+
],
|
|
476
|
+
"name": "migrateTokensProxyOwnerHum",
|
|
477
|
+
"outputs": [],
|
|
478
|
+
"stateMutability": "nonpayable",
|
|
479
|
+
"type": "function"
|
|
480
|
+
},
|
|
481
|
+
{
|
|
482
|
+
"inputs": [
|
|
483
|
+
{
|
|
484
|
+
"internalType": "int256",
|
|
485
|
+
"name": "amount0Delta",
|
|
486
|
+
"type": "int256"
|
|
487
|
+
},
|
|
488
|
+
{
|
|
489
|
+
"internalType": "int256",
|
|
490
|
+
"name": "amount1Delta",
|
|
491
|
+
"type": "int256"
|
|
492
|
+
},
|
|
493
|
+
{
|
|
494
|
+
"internalType": "bytes",
|
|
495
|
+
"name": "data",
|
|
496
|
+
"type": "bytes"
|
|
497
|
+
}
|
|
498
|
+
],
|
|
499
|
+
"name": "pancakeV3SwapCallback",
|
|
500
|
+
"outputs": [],
|
|
501
|
+
"stateMutability": "nonpayable",
|
|
502
|
+
"type": "function"
|
|
503
|
+
},
|
|
504
|
+
{
|
|
505
|
+
"inputs": [
|
|
506
|
+
{
|
|
507
|
+
"internalType": "int256",
|
|
508
|
+
"name": "amount0Delta",
|
|
509
|
+
"type": "int256"
|
|
510
|
+
},
|
|
511
|
+
{
|
|
512
|
+
"internalType": "int256",
|
|
513
|
+
"name": "amount1Delta",
|
|
514
|
+
"type": "int256"
|
|
515
|
+
},
|
|
516
|
+
{
|
|
517
|
+
"internalType": "bytes",
|
|
518
|
+
"name": "data",
|
|
519
|
+
"type": "bytes"
|
|
520
|
+
}
|
|
521
|
+
],
|
|
522
|
+
"name": "ramsesV2SwapCallback",
|
|
523
|
+
"outputs": [],
|
|
524
|
+
"stateMutability": "nonpayable",
|
|
525
|
+
"type": "function"
|
|
526
|
+
},
|
|
527
|
+
{
|
|
528
|
+
"inputs": [
|
|
529
|
+
{
|
|
530
|
+
"internalType": "address[]",
|
|
531
|
+
"name": "bots",
|
|
532
|
+
"type": "address[]"
|
|
533
|
+
}
|
|
534
|
+
],
|
|
535
|
+
"name": "removeWhitelistedBotAddressesHum",
|
|
536
|
+
"outputs": [],
|
|
537
|
+
"stateMutability": "nonpayable",
|
|
538
|
+
"type": "function"
|
|
539
|
+
},
|
|
540
|
+
{
|
|
541
|
+
"inputs": [
|
|
542
|
+
{
|
|
543
|
+
"internalType": "address[]",
|
|
544
|
+
"name": "pairs",
|
|
545
|
+
"type": "address[]"
|
|
546
|
+
}
|
|
547
|
+
],
|
|
548
|
+
"name": "removeWhitelistedPairAddressesHum",
|
|
549
|
+
"outputs": [],
|
|
550
|
+
"stateMutability": "nonpayable",
|
|
551
|
+
"type": "function"
|
|
552
|
+
},
|
|
553
|
+
{
|
|
554
|
+
"inputs": [
|
|
555
|
+
{
|
|
556
|
+
"internalType": "address[]",
|
|
557
|
+
"name": "accounts",
|
|
558
|
+
"type": "address[]"
|
|
559
|
+
}
|
|
560
|
+
],
|
|
561
|
+
"name": "removeWhitelistedTokenAddressesHum",
|
|
562
|
+
"outputs": [],
|
|
563
|
+
"stateMutability": "nonpayable",
|
|
564
|
+
"type": "function"
|
|
565
|
+
},
|
|
566
|
+
{
|
|
567
|
+
"inputs": [
|
|
568
|
+
{
|
|
569
|
+
"internalType": "address[]",
|
|
570
|
+
"name": "accounts",
|
|
571
|
+
"type": "address[]"
|
|
572
|
+
}
|
|
573
|
+
],
|
|
574
|
+
"name": "removeWhitelistedTransferAddressesHum",
|
|
575
|
+
"outputs": [],
|
|
576
|
+
"stateMutability": "nonpayable",
|
|
577
|
+
"type": "function"
|
|
578
|
+
},
|
|
579
|
+
{
|
|
580
|
+
"inputs": [
|
|
581
|
+
{
|
|
582
|
+
"internalType": "address[]",
|
|
583
|
+
"name": "factories",
|
|
584
|
+
"type": "address[]"
|
|
585
|
+
}
|
|
586
|
+
],
|
|
587
|
+
"name": "removeWhitelistedUniswapV3FactoryHum",
|
|
588
|
+
"outputs": [],
|
|
589
|
+
"stateMutability": "nonpayable",
|
|
590
|
+
"type": "function"
|
|
591
|
+
},
|
|
592
|
+
{
|
|
593
|
+
"inputs": [
|
|
594
|
+
{
|
|
595
|
+
"internalType": "address[]",
|
|
596
|
+
"name": "pools",
|
|
597
|
+
"type": "address[]"
|
|
598
|
+
}
|
|
599
|
+
],
|
|
600
|
+
"name": "removeWhitelistedUniswapV3PoolAddressesHum",
|
|
601
|
+
"outputs": [],
|
|
602
|
+
"stateMutability": "nonpayable",
|
|
603
|
+
"type": "function"
|
|
604
|
+
},
|
|
605
|
+
{
|
|
606
|
+
"inputs": [
|
|
607
|
+
{
|
|
608
|
+
"internalType": "address[]",
|
|
609
|
+
"name": "accounts",
|
|
610
|
+
"type": "address[]"
|
|
611
|
+
}
|
|
612
|
+
],
|
|
613
|
+
"name": "removeWhitelistedUniswapV3PositionManagerHum",
|
|
614
|
+
"outputs": [],
|
|
615
|
+
"stateMutability": "nonpayable",
|
|
616
|
+
"type": "function"
|
|
617
|
+
},
|
|
618
|
+
{
|
|
619
|
+
"inputs": [
|
|
620
|
+
{
|
|
621
|
+
"internalType": "address[]",
|
|
622
|
+
"name": "hooks",
|
|
623
|
+
"type": "address[]"
|
|
624
|
+
}
|
|
625
|
+
],
|
|
626
|
+
"name": "removeWhitelistedUniswapV4HooksHum",
|
|
627
|
+
"outputs": [],
|
|
628
|
+
"stateMutability": "nonpayable",
|
|
629
|
+
"type": "function"
|
|
630
|
+
},
|
|
631
|
+
{
|
|
632
|
+
"inputs": [
|
|
633
|
+
{
|
|
634
|
+
"internalType": "address",
|
|
635
|
+
"name": "poolManager",
|
|
636
|
+
"type": "address"
|
|
637
|
+
},
|
|
638
|
+
{
|
|
639
|
+
"internalType": "bytes[]",
|
|
640
|
+
"name": "keys",
|
|
641
|
+
"type": "bytes[]"
|
|
642
|
+
}
|
|
643
|
+
],
|
|
644
|
+
"name": "removeWhitelistedUniswapV4PoolsHum",
|
|
645
|
+
"outputs": [],
|
|
646
|
+
"stateMutability": "nonpayable",
|
|
647
|
+
"type": "function"
|
|
648
|
+
},
|
|
649
|
+
{
|
|
650
|
+
"inputs": [
|
|
651
|
+
{
|
|
652
|
+
"internalType": "address",
|
|
653
|
+
"name": "",
|
|
654
|
+
"type": "address"
|
|
655
|
+
}
|
|
656
|
+
],
|
|
657
|
+
"name": "slot9ValueOf_A7ULVH",
|
|
658
|
+
"outputs": [
|
|
659
|
+
{
|
|
660
|
+
"internalType": "uint256",
|
|
661
|
+
"name": "",
|
|
662
|
+
"type": "uint256"
|
|
663
|
+
}
|
|
664
|
+
],
|
|
665
|
+
"stateMutability": "view",
|
|
666
|
+
"type": "function"
|
|
667
|
+
},
|
|
668
|
+
{
|
|
669
|
+
"inputs": [
|
|
670
|
+
{
|
|
671
|
+
"internalType": "int256",
|
|
672
|
+
"name": "amount0Delta",
|
|
673
|
+
"type": "int256"
|
|
674
|
+
},
|
|
675
|
+
{
|
|
676
|
+
"internalType": "int256",
|
|
677
|
+
"name": "amount1Delta",
|
|
678
|
+
"type": "int256"
|
|
679
|
+
},
|
|
680
|
+
{
|
|
681
|
+
"internalType": "bytes",
|
|
682
|
+
"name": "data",
|
|
683
|
+
"type": "bytes"
|
|
684
|
+
}
|
|
685
|
+
],
|
|
686
|
+
"name": "squadV3SwapCallback",
|
|
687
|
+
"outputs": [],
|
|
688
|
+
"stateMutability": "nonpayable",
|
|
689
|
+
"type": "function"
|
|
690
|
+
},
|
|
691
|
+
{
|
|
692
|
+
"inputs": [
|
|
693
|
+
{
|
|
694
|
+
"internalType": "uint256",
|
|
695
|
+
"name": "amountIn",
|
|
696
|
+
"type": "uint256"
|
|
697
|
+
},
|
|
698
|
+
{
|
|
699
|
+
"internalType": "address",
|
|
700
|
+
"name": "tokenIn",
|
|
701
|
+
"type": "address"
|
|
702
|
+
},
|
|
703
|
+
{
|
|
704
|
+
"internalType": "uint256",
|
|
705
|
+
"name": "amountOutMin",
|
|
706
|
+
"type": "uint256"
|
|
707
|
+
},
|
|
708
|
+
{
|
|
709
|
+
"internalType": "bool",
|
|
710
|
+
"name": "zeroForOne",
|
|
711
|
+
"type": "bool"
|
|
712
|
+
},
|
|
713
|
+
{
|
|
714
|
+
"internalType": "address",
|
|
715
|
+
"name": "pool",
|
|
716
|
+
"type": "address"
|
|
717
|
+
},
|
|
718
|
+
{
|
|
719
|
+
"internalType": "uint256",
|
|
720
|
+
"name": "deadline",
|
|
721
|
+
"type": "uint256"
|
|
722
|
+
}
|
|
723
|
+
],
|
|
724
|
+
"name": "swapExactTokensForTokensUniswapV3Hum",
|
|
725
|
+
"outputs": [],
|
|
726
|
+
"stateMutability": "nonpayable",
|
|
727
|
+
"type": "function"
|
|
728
|
+
},
|
|
729
|
+
{
|
|
730
|
+
"inputs": [
|
|
731
|
+
{
|
|
732
|
+
"components": [
|
|
733
|
+
{
|
|
734
|
+
"components": [
|
|
735
|
+
{
|
|
736
|
+
"internalType": "address",
|
|
737
|
+
"name": "currency0",
|
|
738
|
+
"type": "address"
|
|
739
|
+
},
|
|
740
|
+
{
|
|
741
|
+
"internalType": "address",
|
|
742
|
+
"name": "currency1",
|
|
743
|
+
"type": "address"
|
|
744
|
+
},
|
|
745
|
+
{
|
|
746
|
+
"internalType": "uint24",
|
|
747
|
+
"name": "fee",
|
|
748
|
+
"type": "uint24"
|
|
749
|
+
},
|
|
750
|
+
{
|
|
751
|
+
"internalType": "int24",
|
|
752
|
+
"name": "tickSpacing",
|
|
753
|
+
"type": "int24"
|
|
754
|
+
},
|
|
755
|
+
{
|
|
756
|
+
"internalType": "address",
|
|
757
|
+
"name": "hooks",
|
|
758
|
+
"type": "address"
|
|
759
|
+
}
|
|
760
|
+
],
|
|
761
|
+
"internalType": "struct PoolKey",
|
|
762
|
+
"name": "key",
|
|
763
|
+
"type": "tuple"
|
|
764
|
+
},
|
|
765
|
+
{
|
|
766
|
+
"components": [
|
|
767
|
+
{
|
|
768
|
+
"internalType": "bool",
|
|
769
|
+
"name": "zeroForOne",
|
|
770
|
+
"type": "bool"
|
|
771
|
+
},
|
|
772
|
+
{
|
|
773
|
+
"internalType": "int256",
|
|
774
|
+
"name": "amountSpecified",
|
|
775
|
+
"type": "int256"
|
|
776
|
+
},
|
|
777
|
+
{
|
|
778
|
+
"internalType": "uint160",
|
|
779
|
+
"name": "sqrtPriceLimitX96",
|
|
780
|
+
"type": "uint160"
|
|
781
|
+
}
|
|
782
|
+
],
|
|
783
|
+
"internalType": "struct SwapParams",
|
|
784
|
+
"name": "params",
|
|
785
|
+
"type": "tuple"
|
|
786
|
+
}
|
|
787
|
+
],
|
|
788
|
+
"internalType": "struct Logic.V4SwapData",
|
|
789
|
+
"name": "data",
|
|
790
|
+
"type": "tuple"
|
|
791
|
+
},
|
|
792
|
+
{
|
|
793
|
+
"internalType": "address",
|
|
794
|
+
"name": "poolManager",
|
|
795
|
+
"type": "address"
|
|
796
|
+
},
|
|
797
|
+
{
|
|
798
|
+
"internalType": "uint256",
|
|
799
|
+
"name": "amountOutMin",
|
|
800
|
+
"type": "uint256"
|
|
801
|
+
},
|
|
802
|
+
{
|
|
803
|
+
"internalType": "uint256",
|
|
804
|
+
"name": "deadline",
|
|
805
|
+
"type": "uint256"
|
|
806
|
+
}
|
|
807
|
+
],
|
|
808
|
+
"name": "swapExactTokensForTokensUniswapV4Hum",
|
|
809
|
+
"outputs": [],
|
|
810
|
+
"stateMutability": "nonpayable",
|
|
811
|
+
"type": "function"
|
|
812
|
+
},
|
|
813
|
+
{
|
|
814
|
+
"inputs": [
|
|
815
|
+
{
|
|
816
|
+
"internalType": "uint128",
|
|
817
|
+
"name": "amount",
|
|
818
|
+
"type": "uint128"
|
|
819
|
+
},
|
|
820
|
+
{
|
|
821
|
+
"internalType": "int24",
|
|
822
|
+
"name": "boundaryPoint",
|
|
823
|
+
"type": "int24"
|
|
824
|
+
},
|
|
825
|
+
{
|
|
826
|
+
"internalType": "address",
|
|
827
|
+
"name": "tokenIn",
|
|
828
|
+
"type": "address"
|
|
829
|
+
},
|
|
830
|
+
{
|
|
831
|
+
"internalType": "bool",
|
|
832
|
+
"name": "x2y",
|
|
833
|
+
"type": "bool"
|
|
834
|
+
},
|
|
835
|
+
{
|
|
836
|
+
"internalType": "address",
|
|
837
|
+
"name": "pool",
|
|
838
|
+
"type": "address"
|
|
839
|
+
},
|
|
840
|
+
{
|
|
841
|
+
"internalType": "uint256",
|
|
842
|
+
"name": "deadline",
|
|
843
|
+
"type": "uint256"
|
|
844
|
+
}
|
|
845
|
+
],
|
|
846
|
+
"name": "swapToBoundaryIziSwapHum_4KPMRG",
|
|
847
|
+
"outputs": [],
|
|
848
|
+
"stateMutability": "nonpayable",
|
|
849
|
+
"type": "function"
|
|
850
|
+
},
|
|
851
|
+
{
|
|
852
|
+
"inputs": [
|
|
853
|
+
{
|
|
854
|
+
"internalType": "uint256",
|
|
855
|
+
"name": "amountIn",
|
|
856
|
+
"type": "uint256"
|
|
857
|
+
},
|
|
858
|
+
{
|
|
859
|
+
"internalType": "uint256",
|
|
860
|
+
"name": "sqrtPriceLimitX96",
|
|
861
|
+
"type": "uint256"
|
|
862
|
+
},
|
|
863
|
+
{
|
|
864
|
+
"internalType": "address",
|
|
865
|
+
"name": "tokenIn",
|
|
866
|
+
"type": "address"
|
|
867
|
+
},
|
|
868
|
+
{
|
|
869
|
+
"internalType": "bool",
|
|
870
|
+
"name": "zeroForOne",
|
|
871
|
+
"type": "bool"
|
|
872
|
+
},
|
|
873
|
+
{
|
|
874
|
+
"internalType": "uint256",
|
|
875
|
+
"name": "fee",
|
|
876
|
+
"type": "uint256"
|
|
877
|
+
},
|
|
878
|
+
{
|
|
879
|
+
"internalType": "address",
|
|
880
|
+
"name": "pair",
|
|
881
|
+
"type": "address"
|
|
882
|
+
},
|
|
883
|
+
{
|
|
884
|
+
"internalType": "uint256",
|
|
885
|
+
"name": "deadline",
|
|
886
|
+
"type": "uint256"
|
|
887
|
+
}
|
|
888
|
+
],
|
|
889
|
+
"name": "swapTokensForTokensLimitOrderUniswapV2Hum",
|
|
890
|
+
"outputs": [],
|
|
891
|
+
"stateMutability": "nonpayable",
|
|
892
|
+
"type": "function"
|
|
893
|
+
},
|
|
894
|
+
{
|
|
895
|
+
"inputs": [
|
|
896
|
+
{
|
|
897
|
+
"internalType": "uint256",
|
|
898
|
+
"name": "amountIn",
|
|
899
|
+
"type": "uint256"
|
|
900
|
+
},
|
|
901
|
+
{
|
|
902
|
+
"internalType": "uint256",
|
|
903
|
+
"name": "sqrtPriceLimitX96",
|
|
904
|
+
"type": "uint256"
|
|
905
|
+
},
|
|
906
|
+
{
|
|
907
|
+
"internalType": "address",
|
|
908
|
+
"name": "tokenIn",
|
|
909
|
+
"type": "address"
|
|
910
|
+
},
|
|
911
|
+
{
|
|
912
|
+
"internalType": "bool",
|
|
913
|
+
"name": "zeroForOne",
|
|
914
|
+
"type": "bool"
|
|
915
|
+
},
|
|
916
|
+
{
|
|
917
|
+
"internalType": "address",
|
|
918
|
+
"name": "pool",
|
|
919
|
+
"type": "address"
|
|
920
|
+
},
|
|
921
|
+
{
|
|
922
|
+
"internalType": "uint256",
|
|
923
|
+
"name": "deadline",
|
|
924
|
+
"type": "uint256"
|
|
925
|
+
}
|
|
926
|
+
],
|
|
927
|
+
"name": "swapTokensForTokensLimitOrderUniswapV3Hum",
|
|
928
|
+
"outputs": [],
|
|
929
|
+
"stateMutability": "nonpayable",
|
|
930
|
+
"type": "function"
|
|
931
|
+
},
|
|
932
|
+
{
|
|
933
|
+
"inputs": [
|
|
934
|
+
{
|
|
935
|
+
"components": [
|
|
936
|
+
{
|
|
937
|
+
"components": [
|
|
938
|
+
{
|
|
939
|
+
"internalType": "address",
|
|
940
|
+
"name": "currency0",
|
|
941
|
+
"type": "address"
|
|
942
|
+
},
|
|
943
|
+
{
|
|
944
|
+
"internalType": "address",
|
|
945
|
+
"name": "currency1",
|
|
946
|
+
"type": "address"
|
|
947
|
+
},
|
|
948
|
+
{
|
|
949
|
+
"internalType": "uint24",
|
|
950
|
+
"name": "fee",
|
|
951
|
+
"type": "uint24"
|
|
952
|
+
},
|
|
953
|
+
{
|
|
954
|
+
"internalType": "int24",
|
|
955
|
+
"name": "tickSpacing",
|
|
956
|
+
"type": "int24"
|
|
957
|
+
},
|
|
958
|
+
{
|
|
959
|
+
"internalType": "address",
|
|
960
|
+
"name": "hooks",
|
|
961
|
+
"type": "address"
|
|
962
|
+
}
|
|
963
|
+
],
|
|
964
|
+
"internalType": "struct PoolKey",
|
|
965
|
+
"name": "key",
|
|
966
|
+
"type": "tuple"
|
|
967
|
+
},
|
|
968
|
+
{
|
|
969
|
+
"components": [
|
|
970
|
+
{
|
|
971
|
+
"internalType": "bool",
|
|
972
|
+
"name": "zeroForOne",
|
|
973
|
+
"type": "bool"
|
|
974
|
+
},
|
|
975
|
+
{
|
|
976
|
+
"internalType": "int256",
|
|
977
|
+
"name": "amountSpecified",
|
|
978
|
+
"type": "int256"
|
|
979
|
+
},
|
|
980
|
+
{
|
|
981
|
+
"internalType": "uint160",
|
|
982
|
+
"name": "sqrtPriceLimitX96",
|
|
983
|
+
"type": "uint160"
|
|
984
|
+
}
|
|
985
|
+
],
|
|
986
|
+
"internalType": "struct SwapParams",
|
|
987
|
+
"name": "params",
|
|
988
|
+
"type": "tuple"
|
|
989
|
+
}
|
|
990
|
+
],
|
|
991
|
+
"internalType": "struct Logic.V4SwapData",
|
|
992
|
+
"name": "data",
|
|
993
|
+
"type": "tuple"
|
|
994
|
+
},
|
|
995
|
+
{
|
|
996
|
+
"internalType": "address",
|
|
997
|
+
"name": "poolManager",
|
|
998
|
+
"type": "address"
|
|
999
|
+
},
|
|
1000
|
+
{
|
|
1001
|
+
"internalType": "uint256",
|
|
1002
|
+
"name": "deadline",
|
|
1003
|
+
"type": "uint256"
|
|
1004
|
+
}
|
|
1005
|
+
],
|
|
1006
|
+
"name": "swapTokensForTokensLimitOrderUniswapV4Hum",
|
|
1007
|
+
"outputs": [],
|
|
1008
|
+
"stateMutability": "nonpayable",
|
|
1009
|
+
"type": "function"
|
|
1010
|
+
},
|
|
1011
|
+
{
|
|
1012
|
+
"inputs": [
|
|
1013
|
+
{
|
|
1014
|
+
"internalType": "uint256",
|
|
1015
|
+
"name": "x",
|
|
1016
|
+
"type": "uint256"
|
|
1017
|
+
},
|
|
1018
|
+
{
|
|
1019
|
+
"internalType": "uint256",
|
|
1020
|
+
"name": "y",
|
|
1021
|
+
"type": "uint256"
|
|
1022
|
+
},
|
|
1023
|
+
{
|
|
1024
|
+
"internalType": "bytes",
|
|
1025
|
+
"name": "data",
|
|
1026
|
+
"type": "bytes"
|
|
1027
|
+
}
|
|
1028
|
+
],
|
|
1029
|
+
"name": "swapX2YCallback",
|
|
1030
|
+
"outputs": [],
|
|
1031
|
+
"stateMutability": "nonpayable",
|
|
1032
|
+
"type": "function"
|
|
1033
|
+
},
|
|
1034
|
+
{
|
|
1035
|
+
"inputs": [
|
|
1036
|
+
{
|
|
1037
|
+
"internalType": "uint256",
|
|
1038
|
+
"name": "x",
|
|
1039
|
+
"type": "uint256"
|
|
1040
|
+
},
|
|
1041
|
+
{
|
|
1042
|
+
"internalType": "uint256",
|
|
1043
|
+
"name": "y",
|
|
1044
|
+
"type": "uint256"
|
|
1045
|
+
},
|
|
1046
|
+
{
|
|
1047
|
+
"internalType": "bytes",
|
|
1048
|
+
"name": "data",
|
|
1049
|
+
"type": "bytes"
|
|
1050
|
+
}
|
|
1051
|
+
],
|
|
1052
|
+
"name": "swapY2XCallback",
|
|
1053
|
+
"outputs": [],
|
|
1054
|
+
"stateMutability": "nonpayable",
|
|
1055
|
+
"type": "function"
|
|
1056
|
+
},
|
|
1057
|
+
{
|
|
1058
|
+
"inputs": [
|
|
1059
|
+
{
|
|
1060
|
+
"internalType": "address",
|
|
1061
|
+
"name": "to",
|
|
1062
|
+
"type": "address"
|
|
1063
|
+
},
|
|
1064
|
+
{
|
|
1065
|
+
"internalType": "uint256",
|
|
1066
|
+
"name": "amount",
|
|
1067
|
+
"type": "uint256"
|
|
1068
|
+
}
|
|
1069
|
+
],
|
|
1070
|
+
"name": "transferChainCoinProxyOwnerHum",
|
|
1071
|
+
"outputs": [],
|
|
1072
|
+
"stateMutability": "nonpayable",
|
|
1073
|
+
"type": "function"
|
|
1074
|
+
},
|
|
1075
|
+
{
|
|
1076
|
+
"inputs": [
|
|
1077
|
+
{
|
|
1078
|
+
"internalType": "address",
|
|
1079
|
+
"name": "token",
|
|
1080
|
+
"type": "address"
|
|
1081
|
+
},
|
|
1082
|
+
{
|
|
1083
|
+
"internalType": "address",
|
|
1084
|
+
"name": "to",
|
|
1085
|
+
"type": "address"
|
|
1086
|
+
},
|
|
1087
|
+
{
|
|
1088
|
+
"internalType": "uint256",
|
|
1089
|
+
"name": "amount",
|
|
1090
|
+
"type": "uint256"
|
|
1091
|
+
}
|
|
1092
|
+
],
|
|
1093
|
+
"name": "transferTokenProxyOwnerHum",
|
|
1094
|
+
"outputs": [],
|
|
1095
|
+
"stateMutability": "nonpayable",
|
|
1096
|
+
"type": "function"
|
|
1097
|
+
},
|
|
1098
|
+
{
|
|
1099
|
+
"inputs": [
|
|
1100
|
+
{
|
|
1101
|
+
"internalType": "int256",
|
|
1102
|
+
"name": "amount0Delta",
|
|
1103
|
+
"type": "int256"
|
|
1104
|
+
},
|
|
1105
|
+
{
|
|
1106
|
+
"internalType": "int256",
|
|
1107
|
+
"name": "amount1Delta",
|
|
1108
|
+
"type": "int256"
|
|
1109
|
+
},
|
|
1110
|
+
{
|
|
1111
|
+
"internalType": "bytes",
|
|
1112
|
+
"name": "data",
|
|
1113
|
+
"type": "bytes"
|
|
1114
|
+
}
|
|
1115
|
+
],
|
|
1116
|
+
"name": "uniswapV3SwapCallback",
|
|
1117
|
+
"outputs": [],
|
|
1118
|
+
"stateMutability": "nonpayable",
|
|
1119
|
+
"type": "function"
|
|
1120
|
+
},
|
|
1121
|
+
{
|
|
1122
|
+
"inputs": [
|
|
1123
|
+
{
|
|
1124
|
+
"internalType": "bytes",
|
|
1125
|
+
"name": "data",
|
|
1126
|
+
"type": "bytes"
|
|
1127
|
+
}
|
|
1128
|
+
],
|
|
1129
|
+
"name": "unlockCallback",
|
|
1130
|
+
"outputs": [
|
|
1131
|
+
{
|
|
1132
|
+
"internalType": "bytes",
|
|
1133
|
+
"name": "",
|
|
1134
|
+
"type": "bytes"
|
|
1135
|
+
}
|
|
1136
|
+
],
|
|
1137
|
+
"stateMutability": "nonpayable",
|
|
1138
|
+
"type": "function"
|
|
1139
|
+
},
|
|
1140
|
+
{
|
|
1141
|
+
"inputs": [],
|
|
1142
|
+
"name": "validateProxyHum",
|
|
1143
|
+
"outputs": [],
|
|
1144
|
+
"stateMutability": "view",
|
|
1145
|
+
"type": "function"
|
|
1146
|
+
}
|
|
1147
|
+
] as const satisfies Abi;
|
|
1148
|
+
|
|
1149
|
+
/**
|
|
1150
|
+
* Type-safe ABI for Logic
|
|
1151
|
+
*/
|
|
1152
|
+
export type LogicAbi = typeof LogicAbi;
|
|
1153
|
+
|
|
1154
|
+
/**
|
|
1155
|
+
* Contract instance type for Logic
|
|
1156
|
+
*/
|
|
1157
|
+
// Use any for contract type to avoid complex viem type issues
|
|
1158
|
+
// The runtime behavior is type-safe through viem's ABI typing
|
|
1159
|
+
export type LogicContract = any;
|
|
1160
|
+
|
|
1161
|
+
/**
|
|
1162
|
+
* Logic Contract Class
|
|
1163
|
+
*
|
|
1164
|
+
* Provides a class-based API similar to TypeChain for interacting with the contract.
|
|
1165
|
+
*
|
|
1166
|
+
* @example
|
|
1167
|
+
* ```typescript
|
|
1168
|
+
* import { createPublicClient, createWalletClient, http } from 'viem';
|
|
1169
|
+
* import { mainnet } from 'viem/chains';
|
|
1170
|
+
* import { Logic } from 'Logic';
|
|
1171
|
+
*
|
|
1172
|
+
* const publicClient = createPublicClient({ chain: mainnet, transport: http() });
|
|
1173
|
+
* const walletClient = createWalletClient({ chain: mainnet, transport: http() });
|
|
1174
|
+
*
|
|
1175
|
+
* const contract = new Logic('0x...', { publicClient, walletClient });
|
|
1176
|
+
*
|
|
1177
|
+
* // Read functions
|
|
1178
|
+
* const result = await contract.balanceOf('0x...');
|
|
1179
|
+
*
|
|
1180
|
+
* // Write functions
|
|
1181
|
+
* const hash = await contract.transfer('0x...', 1000n);
|
|
1182
|
+
*
|
|
1183
|
+
* // Simulate transactions (dry-run)
|
|
1184
|
+
* const simulation = await contract.simulate.transfer('0x...', 1000n);
|
|
1185
|
+
* console.log('Gas estimate:', simulation.request.gas);
|
|
1186
|
+
*
|
|
1187
|
+
* // Watch events
|
|
1188
|
+
* const unwatch = contract.watch.Transfer((event) => {
|
|
1189
|
+
* console.log('Transfer event:', event);
|
|
1190
|
+
* });
|
|
1191
|
+
* ```
|
|
1192
|
+
*/
|
|
1193
|
+
export class Logic {
|
|
1194
|
+
private contract: LogicContract;
|
|
1195
|
+
private contractAddress: Address;
|
|
1196
|
+
private publicClient: PublicClient;
|
|
1197
|
+
|
|
1198
|
+
constructor(
|
|
1199
|
+
address: Address,
|
|
1200
|
+
clients: {
|
|
1201
|
+
publicClient: PublicClient;
|
|
1202
|
+
walletClient?: WalletClient;
|
|
1203
|
+
}
|
|
1204
|
+
) {
|
|
1205
|
+
this.contractAddress = address;
|
|
1206
|
+
this.publicClient = clients.publicClient;
|
|
1207
|
+
this.contract = getContract({
|
|
1208
|
+
address,
|
|
1209
|
+
abi: LogicAbi,
|
|
1210
|
+
client: {
|
|
1211
|
+
public: clients.publicClient,
|
|
1212
|
+
wallet: clients.walletClient,
|
|
1213
|
+
},
|
|
1214
|
+
});
|
|
1215
|
+
}
|
|
1216
|
+
|
|
1217
|
+
/**
|
|
1218
|
+
* Get the contract address
|
|
1219
|
+
*/
|
|
1220
|
+
get address(): Address {
|
|
1221
|
+
return this.contractAddress;
|
|
1222
|
+
}
|
|
1223
|
+
|
|
1224
|
+
/**
|
|
1225
|
+
* Get the underlying viem contract instance.
|
|
1226
|
+
*/
|
|
1227
|
+
getContract(): LogicContract {
|
|
1228
|
+
return this.contract;
|
|
1229
|
+
}
|
|
1230
|
+
|
|
1231
|
+
/**
|
|
1232
|
+
* WHITELIST_MANAGER
|
|
1233
|
+
* view
|
|
1234
|
+
*/
|
|
1235
|
+
async WHITELIST_MANAGER(): Promise<`0x${string}`> {
|
|
1236
|
+
return this.contract.read.WHITELIST_MANAGER() as Promise<`0x${string}`>;
|
|
1237
|
+
}
|
|
1238
|
+
|
|
1239
|
+
/**
|
|
1240
|
+
* isWhitelistedBotAddress
|
|
1241
|
+
* view
|
|
1242
|
+
*/
|
|
1243
|
+
async isWhitelistedBotAddress(arg0: `0x${string}`): Promise<boolean> {
|
|
1244
|
+
return this.contract.read.isWhitelistedBotAddress([arg0] as const) as Promise<boolean>;
|
|
1245
|
+
}
|
|
1246
|
+
|
|
1247
|
+
/**
|
|
1248
|
+
* isWhitelistedPairAddress
|
|
1249
|
+
* view
|
|
1250
|
+
*/
|
|
1251
|
+
async isWhitelistedPairAddress(arg0: `0x${string}`): Promise<boolean> {
|
|
1252
|
+
return this.contract.read.isWhitelistedPairAddress([arg0] as const) as Promise<boolean>;
|
|
1253
|
+
}
|
|
1254
|
+
|
|
1255
|
+
/**
|
|
1256
|
+
* isWhitelistedPoolHash
|
|
1257
|
+
* view
|
|
1258
|
+
*/
|
|
1259
|
+
async isWhitelistedPoolHash(arg0: `0x${string}`): Promise<boolean> {
|
|
1260
|
+
return this.contract.read.isWhitelistedPoolHash([arg0] as const) as Promise<boolean>;
|
|
1261
|
+
}
|
|
1262
|
+
|
|
1263
|
+
/**
|
|
1264
|
+
* isWhitelistedPoolHook
|
|
1265
|
+
* view
|
|
1266
|
+
*/
|
|
1267
|
+
async isWhitelistedPoolHook(arg0: `0x${string}`): Promise<boolean> {
|
|
1268
|
+
return this.contract.read.isWhitelistedPoolHook([arg0] as const) as Promise<boolean>;
|
|
1269
|
+
}
|
|
1270
|
+
|
|
1271
|
+
/**
|
|
1272
|
+
* isWhitelistedRouterAddress
|
|
1273
|
+
* view
|
|
1274
|
+
*/
|
|
1275
|
+
async isWhitelistedRouterAddress(arg0: `0x${string}`): Promise<boolean> {
|
|
1276
|
+
return this.contract.read.isWhitelistedRouterAddress([arg0] as const) as Promise<boolean>;
|
|
1277
|
+
}
|
|
1278
|
+
|
|
1279
|
+
/**
|
|
1280
|
+
* isWhitelistedSlot11Address_3HRmBk
|
|
1281
|
+
* view
|
|
1282
|
+
*/
|
|
1283
|
+
async isWhitelistedSlot11Address_3HRmBk(arg0: `0x${string}`): Promise<boolean> {
|
|
1284
|
+
return this.contract.read.isWhitelistedSlot11Address_3HRmBk([arg0] as const) as Promise<boolean>;
|
|
1285
|
+
}
|
|
1286
|
+
|
|
1287
|
+
/**
|
|
1288
|
+
* isWhitelistedSlot3Address_7xvhmR
|
|
1289
|
+
* view
|
|
1290
|
+
*/
|
|
1291
|
+
async isWhitelistedSlot3Address_7xvhmR(arg0: `0x${string}`): Promise<boolean> {
|
|
1292
|
+
return this.contract.read.isWhitelistedSlot3Address_7xvhmR([arg0] as const) as Promise<boolean>;
|
|
1293
|
+
}
|
|
1294
|
+
|
|
1295
|
+
/**
|
|
1296
|
+
* isWhitelistedTokenAddress
|
|
1297
|
+
* view
|
|
1298
|
+
*/
|
|
1299
|
+
async isWhitelistedTokenAddress(arg0: `0x${string}`): Promise<boolean> {
|
|
1300
|
+
return this.contract.read.isWhitelistedTokenAddress([arg0] as const) as Promise<boolean>;
|
|
1301
|
+
}
|
|
1302
|
+
|
|
1303
|
+
/**
|
|
1304
|
+
* isWhitelistedTransferAddress
|
|
1305
|
+
* view
|
|
1306
|
+
*/
|
|
1307
|
+
async isWhitelistedTransferAddress(arg0: `0x${string}`): Promise<boolean> {
|
|
1308
|
+
return this.contract.read.isWhitelistedTransferAddress([arg0] as const) as Promise<boolean>;
|
|
1309
|
+
}
|
|
1310
|
+
|
|
1311
|
+
/**
|
|
1312
|
+
* isWhitelistedUniswapV3FactoryAddress
|
|
1313
|
+
* view
|
|
1314
|
+
*/
|
|
1315
|
+
async isWhitelistedUniswapV3FactoryAddress(arg0: `0x${string}`): Promise<boolean> {
|
|
1316
|
+
return this.contract.read.isWhitelistedUniswapV3FactoryAddress([arg0] as const) as Promise<boolean>;
|
|
1317
|
+
}
|
|
1318
|
+
|
|
1319
|
+
/**
|
|
1320
|
+
* isWhitelistedUniswapV3PoolAddress
|
|
1321
|
+
* view
|
|
1322
|
+
*/
|
|
1323
|
+
async isWhitelistedUniswapV3PoolAddress(arg0: `0x${string}`): Promise<boolean> {
|
|
1324
|
+
return this.contract.read.isWhitelistedUniswapV3PoolAddress([arg0] as const) as Promise<boolean>;
|
|
1325
|
+
}
|
|
1326
|
+
|
|
1327
|
+
/**
|
|
1328
|
+
* isWhitelistedUniswapV3PositionManagerAddress
|
|
1329
|
+
* view
|
|
1330
|
+
*/
|
|
1331
|
+
async isWhitelistedUniswapV3PositionManagerAddress(arg0: `0x${string}`): Promise<boolean> {
|
|
1332
|
+
return this.contract.read.isWhitelistedUniswapV3PositionManagerAddress([arg0] as const) as Promise<boolean>;
|
|
1333
|
+
}
|
|
1334
|
+
|
|
1335
|
+
/**
|
|
1336
|
+
* slot9ValueOf_A7ULVH
|
|
1337
|
+
* view
|
|
1338
|
+
*/
|
|
1339
|
+
async slot9ValueOf_A7ULVH(arg0: `0x${string}`): Promise<bigint> {
|
|
1340
|
+
return this.contract.read.slot9ValueOf_A7ULVH([arg0] as const) as Promise<bigint>;
|
|
1341
|
+
}
|
|
1342
|
+
|
|
1343
|
+
/**
|
|
1344
|
+
* validateProxyHum
|
|
1345
|
+
* view
|
|
1346
|
+
*/
|
|
1347
|
+
async validateProxyHum(): Promise<void> {
|
|
1348
|
+
return this.contract.read.validateProxyHum() as Promise<void>;
|
|
1349
|
+
}
|
|
1350
|
+
|
|
1351
|
+
/**
|
|
1352
|
+
* addWhitelistedAlgebraCustomPoolAddressesHum_1T0MDH
|
|
1353
|
+
* nonpayable
|
|
1354
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1355
|
+
*/
|
|
1356
|
+
async addWhitelistedAlgebraCustomPoolAddressesHum_1T0MDH(deployer: `0x${string}`, pools: `0x${string}`[], options?: {
|
|
1357
|
+
accessList?: import('viem').AccessList;
|
|
1358
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1359
|
+
chain?: import('viem').Chain | null;
|
|
1360
|
+
dataSuffix?: `0x${string}`;
|
|
1361
|
+
gas?: bigint;
|
|
1362
|
+
gasPrice?: bigint;
|
|
1363
|
+
maxFeePerGas?: bigint;
|
|
1364
|
+
maxPriorityFeePerGas?: bigint;
|
|
1365
|
+
nonce?: number;
|
|
1366
|
+
value?: bigint;
|
|
1367
|
+
}): Promise<`0x${string}`> {
|
|
1368
|
+
if (!this.contract.write) {
|
|
1369
|
+
throw new Error('Wallet client is required for write operations');
|
|
1370
|
+
}
|
|
1371
|
+
return this.contract.write.addWhitelistedAlgebraCustomPoolAddressesHum_1T0MDH([deployer, pools] as const, options) as Promise<`0x${string}`>;
|
|
1372
|
+
}
|
|
1373
|
+
|
|
1374
|
+
/**
|
|
1375
|
+
* addWhitelistedBotAddressesHum
|
|
1376
|
+
* nonpayable
|
|
1377
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1378
|
+
*/
|
|
1379
|
+
async addWhitelistedBotAddressesHum(bots: `0x${string}`[], options?: {
|
|
1380
|
+
accessList?: import('viem').AccessList;
|
|
1381
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1382
|
+
chain?: import('viem').Chain | null;
|
|
1383
|
+
dataSuffix?: `0x${string}`;
|
|
1384
|
+
gas?: bigint;
|
|
1385
|
+
gasPrice?: bigint;
|
|
1386
|
+
maxFeePerGas?: bigint;
|
|
1387
|
+
maxPriorityFeePerGas?: bigint;
|
|
1388
|
+
nonce?: number;
|
|
1389
|
+
value?: bigint;
|
|
1390
|
+
}): Promise<`0x${string}`> {
|
|
1391
|
+
if (!this.contract.write) {
|
|
1392
|
+
throw new Error('Wallet client is required for write operations');
|
|
1393
|
+
}
|
|
1394
|
+
return this.contract.write.addWhitelistedBotAddressesHum([bots] as const, options) as Promise<`0x${string}`>;
|
|
1395
|
+
}
|
|
1396
|
+
|
|
1397
|
+
/**
|
|
1398
|
+
* addWhitelistedPairAddressesHum
|
|
1399
|
+
* nonpayable
|
|
1400
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1401
|
+
*/
|
|
1402
|
+
async addWhitelistedPairAddressesHum(pairs: `0x${string}`[], options?: {
|
|
1403
|
+
accessList?: import('viem').AccessList;
|
|
1404
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1405
|
+
chain?: import('viem').Chain | null;
|
|
1406
|
+
dataSuffix?: `0x${string}`;
|
|
1407
|
+
gas?: bigint;
|
|
1408
|
+
gasPrice?: bigint;
|
|
1409
|
+
maxFeePerGas?: bigint;
|
|
1410
|
+
maxPriorityFeePerGas?: bigint;
|
|
1411
|
+
nonce?: number;
|
|
1412
|
+
value?: bigint;
|
|
1413
|
+
}): Promise<`0x${string}`> {
|
|
1414
|
+
if (!this.contract.write) {
|
|
1415
|
+
throw new Error('Wallet client is required for write operations');
|
|
1416
|
+
}
|
|
1417
|
+
return this.contract.write.addWhitelistedPairAddressesHum([pairs] as const, options) as Promise<`0x${string}`>;
|
|
1418
|
+
}
|
|
1419
|
+
|
|
1420
|
+
/**
|
|
1421
|
+
* addWhitelistedTokenAddressesHum
|
|
1422
|
+
* nonpayable
|
|
1423
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1424
|
+
*/
|
|
1425
|
+
async addWhitelistedTokenAddressesHum(accounts: `0x${string}`[], options?: {
|
|
1426
|
+
accessList?: import('viem').AccessList;
|
|
1427
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1428
|
+
chain?: import('viem').Chain | null;
|
|
1429
|
+
dataSuffix?: `0x${string}`;
|
|
1430
|
+
gas?: bigint;
|
|
1431
|
+
gasPrice?: bigint;
|
|
1432
|
+
maxFeePerGas?: bigint;
|
|
1433
|
+
maxPriorityFeePerGas?: bigint;
|
|
1434
|
+
nonce?: number;
|
|
1435
|
+
value?: bigint;
|
|
1436
|
+
}): Promise<`0x${string}`> {
|
|
1437
|
+
if (!this.contract.write) {
|
|
1438
|
+
throw new Error('Wallet client is required for write operations');
|
|
1439
|
+
}
|
|
1440
|
+
return this.contract.write.addWhitelistedTokenAddressesHum([accounts] as const, options) as Promise<`0x${string}`>;
|
|
1441
|
+
}
|
|
1442
|
+
|
|
1443
|
+
/**
|
|
1444
|
+
* addWhitelistedTransferAddressesHum
|
|
1445
|
+
* nonpayable
|
|
1446
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1447
|
+
*/
|
|
1448
|
+
async addWhitelistedTransferAddressesHum(accounts: `0x${string}`[], options?: {
|
|
1449
|
+
accessList?: import('viem').AccessList;
|
|
1450
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1451
|
+
chain?: import('viem').Chain | null;
|
|
1452
|
+
dataSuffix?: `0x${string}`;
|
|
1453
|
+
gas?: bigint;
|
|
1454
|
+
gasPrice?: bigint;
|
|
1455
|
+
maxFeePerGas?: bigint;
|
|
1456
|
+
maxPriorityFeePerGas?: bigint;
|
|
1457
|
+
nonce?: number;
|
|
1458
|
+
value?: bigint;
|
|
1459
|
+
}): Promise<`0x${string}`> {
|
|
1460
|
+
if (!this.contract.write) {
|
|
1461
|
+
throw new Error('Wallet client is required for write operations');
|
|
1462
|
+
}
|
|
1463
|
+
return this.contract.write.addWhitelistedTransferAddressesHum([accounts] as const, options) as Promise<`0x${string}`>;
|
|
1464
|
+
}
|
|
1465
|
+
|
|
1466
|
+
/**
|
|
1467
|
+
* addWhitelistedUniswapV3FactoryHum
|
|
1468
|
+
* nonpayable
|
|
1469
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1470
|
+
*/
|
|
1471
|
+
async addWhitelistedUniswapV3FactoryHum(factories: `0x${string}`[], options?: {
|
|
1472
|
+
accessList?: import('viem').AccessList;
|
|
1473
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1474
|
+
chain?: import('viem').Chain | null;
|
|
1475
|
+
dataSuffix?: `0x${string}`;
|
|
1476
|
+
gas?: bigint;
|
|
1477
|
+
gasPrice?: bigint;
|
|
1478
|
+
maxFeePerGas?: bigint;
|
|
1479
|
+
maxPriorityFeePerGas?: bigint;
|
|
1480
|
+
nonce?: number;
|
|
1481
|
+
value?: bigint;
|
|
1482
|
+
}): Promise<`0x${string}`> {
|
|
1483
|
+
if (!this.contract.write) {
|
|
1484
|
+
throw new Error('Wallet client is required for write operations');
|
|
1485
|
+
}
|
|
1486
|
+
return this.contract.write.addWhitelistedUniswapV3FactoryHum([factories] as const, options) as Promise<`0x${string}`>;
|
|
1487
|
+
}
|
|
1488
|
+
|
|
1489
|
+
/**
|
|
1490
|
+
* addWhitelistedUniswapV3PoolAddressesHum
|
|
1491
|
+
* nonpayable
|
|
1492
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1493
|
+
*/
|
|
1494
|
+
async addWhitelistedUniswapV3PoolAddressesHum(pools: `0x${string}`[], options?: {
|
|
1495
|
+
accessList?: import('viem').AccessList;
|
|
1496
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1497
|
+
chain?: import('viem').Chain | null;
|
|
1498
|
+
dataSuffix?: `0x${string}`;
|
|
1499
|
+
gas?: bigint;
|
|
1500
|
+
gasPrice?: bigint;
|
|
1501
|
+
maxFeePerGas?: bigint;
|
|
1502
|
+
maxPriorityFeePerGas?: bigint;
|
|
1503
|
+
nonce?: number;
|
|
1504
|
+
value?: bigint;
|
|
1505
|
+
}): Promise<`0x${string}`> {
|
|
1506
|
+
if (!this.contract.write) {
|
|
1507
|
+
throw new Error('Wallet client is required for write operations');
|
|
1508
|
+
}
|
|
1509
|
+
return this.contract.write.addWhitelistedUniswapV3PoolAddressesHum([pools] as const, options) as Promise<`0x${string}`>;
|
|
1510
|
+
}
|
|
1511
|
+
|
|
1512
|
+
/**
|
|
1513
|
+
* addWhitelistedUniswapV3PositionManagerHum
|
|
1514
|
+
* nonpayable
|
|
1515
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1516
|
+
*/
|
|
1517
|
+
async addWhitelistedUniswapV3PositionManagerHum(accounts: `0x${string}`[], options?: {
|
|
1518
|
+
accessList?: import('viem').AccessList;
|
|
1519
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1520
|
+
chain?: import('viem').Chain | null;
|
|
1521
|
+
dataSuffix?: `0x${string}`;
|
|
1522
|
+
gas?: bigint;
|
|
1523
|
+
gasPrice?: bigint;
|
|
1524
|
+
maxFeePerGas?: bigint;
|
|
1525
|
+
maxPriorityFeePerGas?: bigint;
|
|
1526
|
+
nonce?: number;
|
|
1527
|
+
value?: bigint;
|
|
1528
|
+
}): Promise<`0x${string}`> {
|
|
1529
|
+
if (!this.contract.write) {
|
|
1530
|
+
throw new Error('Wallet client is required for write operations');
|
|
1531
|
+
}
|
|
1532
|
+
return this.contract.write.addWhitelistedUniswapV3PositionManagerHum([accounts] as const, options) as Promise<`0x${string}`>;
|
|
1533
|
+
}
|
|
1534
|
+
|
|
1535
|
+
/**
|
|
1536
|
+
* addWhitelistedUniswapV4HooksHum
|
|
1537
|
+
* nonpayable
|
|
1538
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1539
|
+
*/
|
|
1540
|
+
async addWhitelistedUniswapV4HooksHum(hooks: `0x${string}`[], options?: {
|
|
1541
|
+
accessList?: import('viem').AccessList;
|
|
1542
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1543
|
+
chain?: import('viem').Chain | null;
|
|
1544
|
+
dataSuffix?: `0x${string}`;
|
|
1545
|
+
gas?: bigint;
|
|
1546
|
+
gasPrice?: bigint;
|
|
1547
|
+
maxFeePerGas?: bigint;
|
|
1548
|
+
maxPriorityFeePerGas?: bigint;
|
|
1549
|
+
nonce?: number;
|
|
1550
|
+
value?: bigint;
|
|
1551
|
+
}): Promise<`0x${string}`> {
|
|
1552
|
+
if (!this.contract.write) {
|
|
1553
|
+
throw new Error('Wallet client is required for write operations');
|
|
1554
|
+
}
|
|
1555
|
+
return this.contract.write.addWhitelistedUniswapV4HooksHum([hooks] as const, options) as Promise<`0x${string}`>;
|
|
1556
|
+
}
|
|
1557
|
+
|
|
1558
|
+
/**
|
|
1559
|
+
* addWhitelistedUniswapV4PoolsHum
|
|
1560
|
+
* nonpayable
|
|
1561
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1562
|
+
*/
|
|
1563
|
+
async addWhitelistedUniswapV4PoolsHum(poolManager: `0x${string}`, keys: `0x${string}`[], options?: {
|
|
1564
|
+
accessList?: import('viem').AccessList;
|
|
1565
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1566
|
+
chain?: import('viem').Chain | null;
|
|
1567
|
+
dataSuffix?: `0x${string}`;
|
|
1568
|
+
gas?: bigint;
|
|
1569
|
+
gasPrice?: bigint;
|
|
1570
|
+
maxFeePerGas?: bigint;
|
|
1571
|
+
maxPriorityFeePerGas?: bigint;
|
|
1572
|
+
nonce?: number;
|
|
1573
|
+
value?: bigint;
|
|
1574
|
+
}): Promise<`0x${string}`> {
|
|
1575
|
+
if (!this.contract.write) {
|
|
1576
|
+
throw new Error('Wallet client is required for write operations');
|
|
1577
|
+
}
|
|
1578
|
+
return this.contract.write.addWhitelistedUniswapV4PoolsHum([poolManager, keys] as const, options) as Promise<`0x${string}`>;
|
|
1579
|
+
}
|
|
1580
|
+
|
|
1581
|
+
/**
|
|
1582
|
+
* algebraSwapCallback
|
|
1583
|
+
* nonpayable
|
|
1584
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1585
|
+
*/
|
|
1586
|
+
async algebraSwapCallback(amount0Delta: bigint, amount1Delta: bigint, data: `0x${string}`, options?: {
|
|
1587
|
+
accessList?: import('viem').AccessList;
|
|
1588
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1589
|
+
chain?: import('viem').Chain | null;
|
|
1590
|
+
dataSuffix?: `0x${string}`;
|
|
1591
|
+
gas?: bigint;
|
|
1592
|
+
gasPrice?: bigint;
|
|
1593
|
+
maxFeePerGas?: bigint;
|
|
1594
|
+
maxPriorityFeePerGas?: bigint;
|
|
1595
|
+
nonce?: number;
|
|
1596
|
+
value?: bigint;
|
|
1597
|
+
}): Promise<`0x${string}`> {
|
|
1598
|
+
if (!this.contract.write) {
|
|
1599
|
+
throw new Error('Wallet client is required for write operations');
|
|
1600
|
+
}
|
|
1601
|
+
return this.contract.write.algebraSwapCallback([amount0Delta, amount1Delta, data] as const, options) as Promise<`0x${string}`>;
|
|
1602
|
+
}
|
|
1603
|
+
|
|
1604
|
+
/**
|
|
1605
|
+
* migrateTokensProxyOwnerHum
|
|
1606
|
+
* nonpayable
|
|
1607
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1608
|
+
*/
|
|
1609
|
+
async migrateTokensProxyOwnerHum(tokens: `0x${string}`[], newProxy: `0x${string}`, newProxyOwner: `0x${string}`, options?: {
|
|
1610
|
+
accessList?: import('viem').AccessList;
|
|
1611
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1612
|
+
chain?: import('viem').Chain | null;
|
|
1613
|
+
dataSuffix?: `0x${string}`;
|
|
1614
|
+
gas?: bigint;
|
|
1615
|
+
gasPrice?: bigint;
|
|
1616
|
+
maxFeePerGas?: bigint;
|
|
1617
|
+
maxPriorityFeePerGas?: bigint;
|
|
1618
|
+
nonce?: number;
|
|
1619
|
+
value?: bigint;
|
|
1620
|
+
}): Promise<`0x${string}`> {
|
|
1621
|
+
if (!this.contract.write) {
|
|
1622
|
+
throw new Error('Wallet client is required for write operations');
|
|
1623
|
+
}
|
|
1624
|
+
return this.contract.write.migrateTokensProxyOwnerHum([tokens, newProxy, newProxyOwner] as const, options) as Promise<`0x${string}`>;
|
|
1625
|
+
}
|
|
1626
|
+
|
|
1627
|
+
/**
|
|
1628
|
+
* pancakeV3SwapCallback
|
|
1629
|
+
* nonpayable
|
|
1630
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1631
|
+
*/
|
|
1632
|
+
async pancakeV3SwapCallback(amount0Delta: bigint, amount1Delta: bigint, data: `0x${string}`, options?: {
|
|
1633
|
+
accessList?: import('viem').AccessList;
|
|
1634
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1635
|
+
chain?: import('viem').Chain | null;
|
|
1636
|
+
dataSuffix?: `0x${string}`;
|
|
1637
|
+
gas?: bigint;
|
|
1638
|
+
gasPrice?: bigint;
|
|
1639
|
+
maxFeePerGas?: bigint;
|
|
1640
|
+
maxPriorityFeePerGas?: bigint;
|
|
1641
|
+
nonce?: number;
|
|
1642
|
+
value?: bigint;
|
|
1643
|
+
}): Promise<`0x${string}`> {
|
|
1644
|
+
if (!this.contract.write) {
|
|
1645
|
+
throw new Error('Wallet client is required for write operations');
|
|
1646
|
+
}
|
|
1647
|
+
return this.contract.write.pancakeV3SwapCallback([amount0Delta, amount1Delta, data] as const, options) as Promise<`0x${string}`>;
|
|
1648
|
+
}
|
|
1649
|
+
|
|
1650
|
+
/**
|
|
1651
|
+
* ramsesV2SwapCallback
|
|
1652
|
+
* nonpayable
|
|
1653
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1654
|
+
*/
|
|
1655
|
+
async ramsesV2SwapCallback(amount0Delta: bigint, amount1Delta: bigint, data: `0x${string}`, options?: {
|
|
1656
|
+
accessList?: import('viem').AccessList;
|
|
1657
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1658
|
+
chain?: import('viem').Chain | null;
|
|
1659
|
+
dataSuffix?: `0x${string}`;
|
|
1660
|
+
gas?: bigint;
|
|
1661
|
+
gasPrice?: bigint;
|
|
1662
|
+
maxFeePerGas?: bigint;
|
|
1663
|
+
maxPriorityFeePerGas?: bigint;
|
|
1664
|
+
nonce?: number;
|
|
1665
|
+
value?: bigint;
|
|
1666
|
+
}): Promise<`0x${string}`> {
|
|
1667
|
+
if (!this.contract.write) {
|
|
1668
|
+
throw new Error('Wallet client is required for write operations');
|
|
1669
|
+
}
|
|
1670
|
+
return this.contract.write.ramsesV2SwapCallback([amount0Delta, amount1Delta, data] as const, options) as Promise<`0x${string}`>;
|
|
1671
|
+
}
|
|
1672
|
+
|
|
1673
|
+
/**
|
|
1674
|
+
* removeWhitelistedBotAddressesHum
|
|
1675
|
+
* nonpayable
|
|
1676
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1677
|
+
*/
|
|
1678
|
+
async removeWhitelistedBotAddressesHum(bots: `0x${string}`[], options?: {
|
|
1679
|
+
accessList?: import('viem').AccessList;
|
|
1680
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1681
|
+
chain?: import('viem').Chain | null;
|
|
1682
|
+
dataSuffix?: `0x${string}`;
|
|
1683
|
+
gas?: bigint;
|
|
1684
|
+
gasPrice?: bigint;
|
|
1685
|
+
maxFeePerGas?: bigint;
|
|
1686
|
+
maxPriorityFeePerGas?: bigint;
|
|
1687
|
+
nonce?: number;
|
|
1688
|
+
value?: bigint;
|
|
1689
|
+
}): Promise<`0x${string}`> {
|
|
1690
|
+
if (!this.contract.write) {
|
|
1691
|
+
throw new Error('Wallet client is required for write operations');
|
|
1692
|
+
}
|
|
1693
|
+
return this.contract.write.removeWhitelistedBotAddressesHum([bots] as const, options) as Promise<`0x${string}`>;
|
|
1694
|
+
}
|
|
1695
|
+
|
|
1696
|
+
/**
|
|
1697
|
+
* removeWhitelistedPairAddressesHum
|
|
1698
|
+
* nonpayable
|
|
1699
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1700
|
+
*/
|
|
1701
|
+
async removeWhitelistedPairAddressesHum(pairs: `0x${string}`[], options?: {
|
|
1702
|
+
accessList?: import('viem').AccessList;
|
|
1703
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1704
|
+
chain?: import('viem').Chain | null;
|
|
1705
|
+
dataSuffix?: `0x${string}`;
|
|
1706
|
+
gas?: bigint;
|
|
1707
|
+
gasPrice?: bigint;
|
|
1708
|
+
maxFeePerGas?: bigint;
|
|
1709
|
+
maxPriorityFeePerGas?: bigint;
|
|
1710
|
+
nonce?: number;
|
|
1711
|
+
value?: bigint;
|
|
1712
|
+
}): Promise<`0x${string}`> {
|
|
1713
|
+
if (!this.contract.write) {
|
|
1714
|
+
throw new Error('Wallet client is required for write operations');
|
|
1715
|
+
}
|
|
1716
|
+
return this.contract.write.removeWhitelistedPairAddressesHum([pairs] as const, options) as Promise<`0x${string}`>;
|
|
1717
|
+
}
|
|
1718
|
+
|
|
1719
|
+
/**
|
|
1720
|
+
* removeWhitelistedTokenAddressesHum
|
|
1721
|
+
* nonpayable
|
|
1722
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1723
|
+
*/
|
|
1724
|
+
async removeWhitelistedTokenAddressesHum(accounts: `0x${string}`[], options?: {
|
|
1725
|
+
accessList?: import('viem').AccessList;
|
|
1726
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1727
|
+
chain?: import('viem').Chain | null;
|
|
1728
|
+
dataSuffix?: `0x${string}`;
|
|
1729
|
+
gas?: bigint;
|
|
1730
|
+
gasPrice?: bigint;
|
|
1731
|
+
maxFeePerGas?: bigint;
|
|
1732
|
+
maxPriorityFeePerGas?: bigint;
|
|
1733
|
+
nonce?: number;
|
|
1734
|
+
value?: bigint;
|
|
1735
|
+
}): Promise<`0x${string}`> {
|
|
1736
|
+
if (!this.contract.write) {
|
|
1737
|
+
throw new Error('Wallet client is required for write operations');
|
|
1738
|
+
}
|
|
1739
|
+
return this.contract.write.removeWhitelistedTokenAddressesHum([accounts] as const, options) as Promise<`0x${string}`>;
|
|
1740
|
+
}
|
|
1741
|
+
|
|
1742
|
+
/**
|
|
1743
|
+
* removeWhitelistedTransferAddressesHum
|
|
1744
|
+
* nonpayable
|
|
1745
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1746
|
+
*/
|
|
1747
|
+
async removeWhitelistedTransferAddressesHum(accounts: `0x${string}`[], options?: {
|
|
1748
|
+
accessList?: import('viem').AccessList;
|
|
1749
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1750
|
+
chain?: import('viem').Chain | null;
|
|
1751
|
+
dataSuffix?: `0x${string}`;
|
|
1752
|
+
gas?: bigint;
|
|
1753
|
+
gasPrice?: bigint;
|
|
1754
|
+
maxFeePerGas?: bigint;
|
|
1755
|
+
maxPriorityFeePerGas?: bigint;
|
|
1756
|
+
nonce?: number;
|
|
1757
|
+
value?: bigint;
|
|
1758
|
+
}): Promise<`0x${string}`> {
|
|
1759
|
+
if (!this.contract.write) {
|
|
1760
|
+
throw new Error('Wallet client is required for write operations');
|
|
1761
|
+
}
|
|
1762
|
+
return this.contract.write.removeWhitelistedTransferAddressesHum([accounts] as const, options) as Promise<`0x${string}`>;
|
|
1763
|
+
}
|
|
1764
|
+
|
|
1765
|
+
/**
|
|
1766
|
+
* removeWhitelistedUniswapV3FactoryHum
|
|
1767
|
+
* nonpayable
|
|
1768
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1769
|
+
*/
|
|
1770
|
+
async removeWhitelistedUniswapV3FactoryHum(factories: `0x${string}`[], options?: {
|
|
1771
|
+
accessList?: import('viem').AccessList;
|
|
1772
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1773
|
+
chain?: import('viem').Chain | null;
|
|
1774
|
+
dataSuffix?: `0x${string}`;
|
|
1775
|
+
gas?: bigint;
|
|
1776
|
+
gasPrice?: bigint;
|
|
1777
|
+
maxFeePerGas?: bigint;
|
|
1778
|
+
maxPriorityFeePerGas?: bigint;
|
|
1779
|
+
nonce?: number;
|
|
1780
|
+
value?: bigint;
|
|
1781
|
+
}): Promise<`0x${string}`> {
|
|
1782
|
+
if (!this.contract.write) {
|
|
1783
|
+
throw new Error('Wallet client is required for write operations');
|
|
1784
|
+
}
|
|
1785
|
+
return this.contract.write.removeWhitelistedUniswapV3FactoryHum([factories] as const, options) as Promise<`0x${string}`>;
|
|
1786
|
+
}
|
|
1787
|
+
|
|
1788
|
+
/**
|
|
1789
|
+
* removeWhitelistedUniswapV3PoolAddressesHum
|
|
1790
|
+
* nonpayable
|
|
1791
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1792
|
+
*/
|
|
1793
|
+
async removeWhitelistedUniswapV3PoolAddressesHum(pools: `0x${string}`[], options?: {
|
|
1794
|
+
accessList?: import('viem').AccessList;
|
|
1795
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1796
|
+
chain?: import('viem').Chain | null;
|
|
1797
|
+
dataSuffix?: `0x${string}`;
|
|
1798
|
+
gas?: bigint;
|
|
1799
|
+
gasPrice?: bigint;
|
|
1800
|
+
maxFeePerGas?: bigint;
|
|
1801
|
+
maxPriorityFeePerGas?: bigint;
|
|
1802
|
+
nonce?: number;
|
|
1803
|
+
value?: bigint;
|
|
1804
|
+
}): Promise<`0x${string}`> {
|
|
1805
|
+
if (!this.contract.write) {
|
|
1806
|
+
throw new Error('Wallet client is required for write operations');
|
|
1807
|
+
}
|
|
1808
|
+
return this.contract.write.removeWhitelistedUniswapV3PoolAddressesHum([pools] as const, options) as Promise<`0x${string}`>;
|
|
1809
|
+
}
|
|
1810
|
+
|
|
1811
|
+
/**
|
|
1812
|
+
* removeWhitelistedUniswapV3PositionManagerHum
|
|
1813
|
+
* nonpayable
|
|
1814
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1815
|
+
*/
|
|
1816
|
+
async removeWhitelistedUniswapV3PositionManagerHum(accounts: `0x${string}`[], options?: {
|
|
1817
|
+
accessList?: import('viem').AccessList;
|
|
1818
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1819
|
+
chain?: import('viem').Chain | null;
|
|
1820
|
+
dataSuffix?: `0x${string}`;
|
|
1821
|
+
gas?: bigint;
|
|
1822
|
+
gasPrice?: bigint;
|
|
1823
|
+
maxFeePerGas?: bigint;
|
|
1824
|
+
maxPriorityFeePerGas?: bigint;
|
|
1825
|
+
nonce?: number;
|
|
1826
|
+
value?: bigint;
|
|
1827
|
+
}): Promise<`0x${string}`> {
|
|
1828
|
+
if (!this.contract.write) {
|
|
1829
|
+
throw new Error('Wallet client is required for write operations');
|
|
1830
|
+
}
|
|
1831
|
+
return this.contract.write.removeWhitelistedUniswapV3PositionManagerHum([accounts] as const, options) as Promise<`0x${string}`>;
|
|
1832
|
+
}
|
|
1833
|
+
|
|
1834
|
+
/**
|
|
1835
|
+
* removeWhitelistedUniswapV4HooksHum
|
|
1836
|
+
* nonpayable
|
|
1837
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1838
|
+
*/
|
|
1839
|
+
async removeWhitelistedUniswapV4HooksHum(hooks: `0x${string}`[], options?: {
|
|
1840
|
+
accessList?: import('viem').AccessList;
|
|
1841
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1842
|
+
chain?: import('viem').Chain | null;
|
|
1843
|
+
dataSuffix?: `0x${string}`;
|
|
1844
|
+
gas?: bigint;
|
|
1845
|
+
gasPrice?: bigint;
|
|
1846
|
+
maxFeePerGas?: bigint;
|
|
1847
|
+
maxPriorityFeePerGas?: bigint;
|
|
1848
|
+
nonce?: number;
|
|
1849
|
+
value?: bigint;
|
|
1850
|
+
}): Promise<`0x${string}`> {
|
|
1851
|
+
if (!this.contract.write) {
|
|
1852
|
+
throw new Error('Wallet client is required for write operations');
|
|
1853
|
+
}
|
|
1854
|
+
return this.contract.write.removeWhitelistedUniswapV4HooksHum([hooks] as const, options) as Promise<`0x${string}`>;
|
|
1855
|
+
}
|
|
1856
|
+
|
|
1857
|
+
/**
|
|
1858
|
+
* removeWhitelistedUniswapV4PoolsHum
|
|
1859
|
+
* nonpayable
|
|
1860
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1861
|
+
*/
|
|
1862
|
+
async removeWhitelistedUniswapV4PoolsHum(poolManager: `0x${string}`, keys: `0x${string}`[], options?: {
|
|
1863
|
+
accessList?: import('viem').AccessList;
|
|
1864
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1865
|
+
chain?: import('viem').Chain | null;
|
|
1866
|
+
dataSuffix?: `0x${string}`;
|
|
1867
|
+
gas?: bigint;
|
|
1868
|
+
gasPrice?: bigint;
|
|
1869
|
+
maxFeePerGas?: bigint;
|
|
1870
|
+
maxPriorityFeePerGas?: bigint;
|
|
1871
|
+
nonce?: number;
|
|
1872
|
+
value?: bigint;
|
|
1873
|
+
}): Promise<`0x${string}`> {
|
|
1874
|
+
if (!this.contract.write) {
|
|
1875
|
+
throw new Error('Wallet client is required for write operations');
|
|
1876
|
+
}
|
|
1877
|
+
return this.contract.write.removeWhitelistedUniswapV4PoolsHum([poolManager, keys] as const, options) as Promise<`0x${string}`>;
|
|
1878
|
+
}
|
|
1879
|
+
|
|
1880
|
+
/**
|
|
1881
|
+
* squadV3SwapCallback
|
|
1882
|
+
* nonpayable
|
|
1883
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1884
|
+
*/
|
|
1885
|
+
async squadV3SwapCallback(amount0Delta: bigint, amount1Delta: bigint, data: `0x${string}`, options?: {
|
|
1886
|
+
accessList?: import('viem').AccessList;
|
|
1887
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1888
|
+
chain?: import('viem').Chain | null;
|
|
1889
|
+
dataSuffix?: `0x${string}`;
|
|
1890
|
+
gas?: bigint;
|
|
1891
|
+
gasPrice?: bigint;
|
|
1892
|
+
maxFeePerGas?: bigint;
|
|
1893
|
+
maxPriorityFeePerGas?: bigint;
|
|
1894
|
+
nonce?: number;
|
|
1895
|
+
value?: bigint;
|
|
1896
|
+
}): Promise<`0x${string}`> {
|
|
1897
|
+
if (!this.contract.write) {
|
|
1898
|
+
throw new Error('Wallet client is required for write operations');
|
|
1899
|
+
}
|
|
1900
|
+
return this.contract.write.squadV3SwapCallback([amount0Delta, amount1Delta, data] as const, options) as Promise<`0x${string}`>;
|
|
1901
|
+
}
|
|
1902
|
+
|
|
1903
|
+
/**
|
|
1904
|
+
* swapExactTokensForTokensUniswapV3Hum
|
|
1905
|
+
* nonpayable
|
|
1906
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1907
|
+
*/
|
|
1908
|
+
async swapExactTokensForTokensUniswapV3Hum(amountIn: bigint, tokenIn: `0x${string}`, amountOutMin: bigint, zeroForOne: boolean, pool: `0x${string}`, deadline: bigint, options?: {
|
|
1909
|
+
accessList?: import('viem').AccessList;
|
|
1910
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1911
|
+
chain?: import('viem').Chain | null;
|
|
1912
|
+
dataSuffix?: `0x${string}`;
|
|
1913
|
+
gas?: bigint;
|
|
1914
|
+
gasPrice?: bigint;
|
|
1915
|
+
maxFeePerGas?: bigint;
|
|
1916
|
+
maxPriorityFeePerGas?: bigint;
|
|
1917
|
+
nonce?: number;
|
|
1918
|
+
value?: bigint;
|
|
1919
|
+
}): Promise<`0x${string}`> {
|
|
1920
|
+
if (!this.contract.write) {
|
|
1921
|
+
throw new Error('Wallet client is required for write operations');
|
|
1922
|
+
}
|
|
1923
|
+
return this.contract.write.swapExactTokensForTokensUniswapV3Hum([amountIn, tokenIn, amountOutMin, zeroForOne, pool, deadline] as const, options) as Promise<`0x${string}`>;
|
|
1924
|
+
}
|
|
1925
|
+
|
|
1926
|
+
/**
|
|
1927
|
+
* swapExactTokensForTokensUniswapV4Hum
|
|
1928
|
+
* nonpayable
|
|
1929
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1930
|
+
*/
|
|
1931
|
+
async swapExactTokensForTokensUniswapV4Hum(data: Logic_V4SwapData, poolManager: `0x${string}`, amountOutMin: bigint, deadline: bigint, options?: {
|
|
1932
|
+
accessList?: import('viem').AccessList;
|
|
1933
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1934
|
+
chain?: import('viem').Chain | null;
|
|
1935
|
+
dataSuffix?: `0x${string}`;
|
|
1936
|
+
gas?: bigint;
|
|
1937
|
+
gasPrice?: bigint;
|
|
1938
|
+
maxFeePerGas?: bigint;
|
|
1939
|
+
maxPriorityFeePerGas?: bigint;
|
|
1940
|
+
nonce?: number;
|
|
1941
|
+
value?: bigint;
|
|
1942
|
+
}): Promise<`0x${string}`> {
|
|
1943
|
+
if (!this.contract.write) {
|
|
1944
|
+
throw new Error('Wallet client is required for write operations');
|
|
1945
|
+
}
|
|
1946
|
+
return this.contract.write.swapExactTokensForTokensUniswapV4Hum([data, poolManager, amountOutMin, deadline] as const, options) as Promise<`0x${string}`>;
|
|
1947
|
+
}
|
|
1948
|
+
|
|
1949
|
+
/**
|
|
1950
|
+
* swapToBoundaryIziSwapHum_4KPMRG
|
|
1951
|
+
* nonpayable
|
|
1952
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1953
|
+
*/
|
|
1954
|
+
async swapToBoundaryIziSwapHum_4KPMRG(amount: bigint, boundaryPoint: bigint, tokenIn: `0x${string}`, x2y: boolean, pool: `0x${string}`, deadline: bigint, options?: {
|
|
1955
|
+
accessList?: import('viem').AccessList;
|
|
1956
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1957
|
+
chain?: import('viem').Chain | null;
|
|
1958
|
+
dataSuffix?: `0x${string}`;
|
|
1959
|
+
gas?: bigint;
|
|
1960
|
+
gasPrice?: bigint;
|
|
1961
|
+
maxFeePerGas?: bigint;
|
|
1962
|
+
maxPriorityFeePerGas?: bigint;
|
|
1963
|
+
nonce?: number;
|
|
1964
|
+
value?: bigint;
|
|
1965
|
+
}): Promise<`0x${string}`> {
|
|
1966
|
+
if (!this.contract.write) {
|
|
1967
|
+
throw new Error('Wallet client is required for write operations');
|
|
1968
|
+
}
|
|
1969
|
+
return this.contract.write.swapToBoundaryIziSwapHum_4KPMRG([amount, boundaryPoint, tokenIn, x2y, pool, deadline] as const, options) as Promise<`0x${string}`>;
|
|
1970
|
+
}
|
|
1971
|
+
|
|
1972
|
+
/**
|
|
1973
|
+
* swapTokensForTokensLimitOrderUniswapV2Hum
|
|
1974
|
+
* nonpayable
|
|
1975
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1976
|
+
*/
|
|
1977
|
+
async swapTokensForTokensLimitOrderUniswapV2Hum(amountIn: bigint, sqrtPriceLimitX96: bigint, tokenIn: `0x${string}`, zeroForOne: boolean, fee: bigint, pair: `0x${string}`, deadline: bigint, options?: {
|
|
1978
|
+
accessList?: import('viem').AccessList;
|
|
1979
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1980
|
+
chain?: import('viem').Chain | null;
|
|
1981
|
+
dataSuffix?: `0x${string}`;
|
|
1982
|
+
gas?: bigint;
|
|
1983
|
+
gasPrice?: bigint;
|
|
1984
|
+
maxFeePerGas?: bigint;
|
|
1985
|
+
maxPriorityFeePerGas?: bigint;
|
|
1986
|
+
nonce?: number;
|
|
1987
|
+
value?: bigint;
|
|
1988
|
+
}): Promise<`0x${string}`> {
|
|
1989
|
+
if (!this.contract.write) {
|
|
1990
|
+
throw new Error('Wallet client is required for write operations');
|
|
1991
|
+
}
|
|
1992
|
+
return this.contract.write.swapTokensForTokensLimitOrderUniswapV2Hum([amountIn, sqrtPriceLimitX96, tokenIn, zeroForOne, fee, pair, deadline] as const, options) as Promise<`0x${string}`>;
|
|
1993
|
+
}
|
|
1994
|
+
|
|
1995
|
+
/**
|
|
1996
|
+
* swapTokensForTokensLimitOrderUniswapV3Hum
|
|
1997
|
+
* nonpayable
|
|
1998
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1999
|
+
*/
|
|
2000
|
+
async swapTokensForTokensLimitOrderUniswapV3Hum(amountIn: bigint, sqrtPriceLimitX96: bigint, tokenIn: `0x${string}`, zeroForOne: boolean, pool: `0x${string}`, deadline: bigint, options?: {
|
|
2001
|
+
accessList?: import('viem').AccessList;
|
|
2002
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2003
|
+
chain?: import('viem').Chain | null;
|
|
2004
|
+
dataSuffix?: `0x${string}`;
|
|
2005
|
+
gas?: bigint;
|
|
2006
|
+
gasPrice?: bigint;
|
|
2007
|
+
maxFeePerGas?: bigint;
|
|
2008
|
+
maxPriorityFeePerGas?: bigint;
|
|
2009
|
+
nonce?: number;
|
|
2010
|
+
value?: bigint;
|
|
2011
|
+
}): Promise<`0x${string}`> {
|
|
2012
|
+
if (!this.contract.write) {
|
|
2013
|
+
throw new Error('Wallet client is required for write operations');
|
|
2014
|
+
}
|
|
2015
|
+
return this.contract.write.swapTokensForTokensLimitOrderUniswapV3Hum([amountIn, sqrtPriceLimitX96, tokenIn, zeroForOne, pool, deadline] as const, options) as Promise<`0x${string}`>;
|
|
2016
|
+
}
|
|
2017
|
+
|
|
2018
|
+
/**
|
|
2019
|
+
* swapTokensForTokensLimitOrderUniswapV4Hum
|
|
2020
|
+
* nonpayable
|
|
2021
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2022
|
+
*/
|
|
2023
|
+
async swapTokensForTokensLimitOrderUniswapV4Hum(data: Logic_V4SwapData, poolManager: `0x${string}`, deadline: bigint, options?: {
|
|
2024
|
+
accessList?: import('viem').AccessList;
|
|
2025
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2026
|
+
chain?: import('viem').Chain | null;
|
|
2027
|
+
dataSuffix?: `0x${string}`;
|
|
2028
|
+
gas?: bigint;
|
|
2029
|
+
gasPrice?: bigint;
|
|
2030
|
+
maxFeePerGas?: bigint;
|
|
2031
|
+
maxPriorityFeePerGas?: bigint;
|
|
2032
|
+
nonce?: number;
|
|
2033
|
+
value?: bigint;
|
|
2034
|
+
}): Promise<`0x${string}`> {
|
|
2035
|
+
if (!this.contract.write) {
|
|
2036
|
+
throw new Error('Wallet client is required for write operations');
|
|
2037
|
+
}
|
|
2038
|
+
return this.contract.write.swapTokensForTokensLimitOrderUniswapV4Hum([data, poolManager, deadline] as const, options) as Promise<`0x${string}`>;
|
|
2039
|
+
}
|
|
2040
|
+
|
|
2041
|
+
/**
|
|
2042
|
+
* swapX2YCallback
|
|
2043
|
+
* nonpayable
|
|
2044
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2045
|
+
*/
|
|
2046
|
+
async swapX2YCallback(x: bigint, y: bigint, data: `0x${string}`, options?: {
|
|
2047
|
+
accessList?: import('viem').AccessList;
|
|
2048
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2049
|
+
chain?: import('viem').Chain | null;
|
|
2050
|
+
dataSuffix?: `0x${string}`;
|
|
2051
|
+
gas?: bigint;
|
|
2052
|
+
gasPrice?: bigint;
|
|
2053
|
+
maxFeePerGas?: bigint;
|
|
2054
|
+
maxPriorityFeePerGas?: bigint;
|
|
2055
|
+
nonce?: number;
|
|
2056
|
+
value?: bigint;
|
|
2057
|
+
}): Promise<`0x${string}`> {
|
|
2058
|
+
if (!this.contract.write) {
|
|
2059
|
+
throw new Error('Wallet client is required for write operations');
|
|
2060
|
+
}
|
|
2061
|
+
return this.contract.write.swapX2YCallback([x, y, data] as const, options) as Promise<`0x${string}`>;
|
|
2062
|
+
}
|
|
2063
|
+
|
|
2064
|
+
/**
|
|
2065
|
+
* swapY2XCallback
|
|
2066
|
+
* nonpayable
|
|
2067
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2068
|
+
*/
|
|
2069
|
+
async swapY2XCallback(x: bigint, y: bigint, data: `0x${string}`, options?: {
|
|
2070
|
+
accessList?: import('viem').AccessList;
|
|
2071
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2072
|
+
chain?: import('viem').Chain | null;
|
|
2073
|
+
dataSuffix?: `0x${string}`;
|
|
2074
|
+
gas?: bigint;
|
|
2075
|
+
gasPrice?: bigint;
|
|
2076
|
+
maxFeePerGas?: bigint;
|
|
2077
|
+
maxPriorityFeePerGas?: bigint;
|
|
2078
|
+
nonce?: number;
|
|
2079
|
+
value?: bigint;
|
|
2080
|
+
}): Promise<`0x${string}`> {
|
|
2081
|
+
if (!this.contract.write) {
|
|
2082
|
+
throw new Error('Wallet client is required for write operations');
|
|
2083
|
+
}
|
|
2084
|
+
return this.contract.write.swapY2XCallback([x, y, data] as const, options) as Promise<`0x${string}`>;
|
|
2085
|
+
}
|
|
2086
|
+
|
|
2087
|
+
/**
|
|
2088
|
+
* transferChainCoinProxyOwnerHum
|
|
2089
|
+
* nonpayable
|
|
2090
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2091
|
+
*/
|
|
2092
|
+
async transferChainCoinProxyOwnerHum(to: `0x${string}`, amount: bigint, options?: {
|
|
2093
|
+
accessList?: import('viem').AccessList;
|
|
2094
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2095
|
+
chain?: import('viem').Chain | null;
|
|
2096
|
+
dataSuffix?: `0x${string}`;
|
|
2097
|
+
gas?: bigint;
|
|
2098
|
+
gasPrice?: bigint;
|
|
2099
|
+
maxFeePerGas?: bigint;
|
|
2100
|
+
maxPriorityFeePerGas?: bigint;
|
|
2101
|
+
nonce?: number;
|
|
2102
|
+
value?: bigint;
|
|
2103
|
+
}): Promise<`0x${string}`> {
|
|
2104
|
+
if (!this.contract.write) {
|
|
2105
|
+
throw new Error('Wallet client is required for write operations');
|
|
2106
|
+
}
|
|
2107
|
+
return this.contract.write.transferChainCoinProxyOwnerHum([to, amount] as const, options) as Promise<`0x${string}`>;
|
|
2108
|
+
}
|
|
2109
|
+
|
|
2110
|
+
/**
|
|
2111
|
+
* transferTokenProxyOwnerHum
|
|
2112
|
+
* nonpayable
|
|
2113
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2114
|
+
*/
|
|
2115
|
+
async transferTokenProxyOwnerHum(token: `0x${string}`, to: `0x${string}`, amount: bigint, options?: {
|
|
2116
|
+
accessList?: import('viem').AccessList;
|
|
2117
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2118
|
+
chain?: import('viem').Chain | null;
|
|
2119
|
+
dataSuffix?: `0x${string}`;
|
|
2120
|
+
gas?: bigint;
|
|
2121
|
+
gasPrice?: bigint;
|
|
2122
|
+
maxFeePerGas?: bigint;
|
|
2123
|
+
maxPriorityFeePerGas?: bigint;
|
|
2124
|
+
nonce?: number;
|
|
2125
|
+
value?: bigint;
|
|
2126
|
+
}): Promise<`0x${string}`> {
|
|
2127
|
+
if (!this.contract.write) {
|
|
2128
|
+
throw new Error('Wallet client is required for write operations');
|
|
2129
|
+
}
|
|
2130
|
+
return this.contract.write.transferTokenProxyOwnerHum([token, to, amount] as const, options) as Promise<`0x${string}`>;
|
|
2131
|
+
}
|
|
2132
|
+
|
|
2133
|
+
/**
|
|
2134
|
+
* uniswapV3SwapCallback
|
|
2135
|
+
* nonpayable
|
|
2136
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2137
|
+
*/
|
|
2138
|
+
async uniswapV3SwapCallback(amount0Delta: bigint, amount1Delta: bigint, data: `0x${string}`, options?: {
|
|
2139
|
+
accessList?: import('viem').AccessList;
|
|
2140
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2141
|
+
chain?: import('viem').Chain | null;
|
|
2142
|
+
dataSuffix?: `0x${string}`;
|
|
2143
|
+
gas?: bigint;
|
|
2144
|
+
gasPrice?: bigint;
|
|
2145
|
+
maxFeePerGas?: bigint;
|
|
2146
|
+
maxPriorityFeePerGas?: bigint;
|
|
2147
|
+
nonce?: number;
|
|
2148
|
+
value?: bigint;
|
|
2149
|
+
}): Promise<`0x${string}`> {
|
|
2150
|
+
if (!this.contract.write) {
|
|
2151
|
+
throw new Error('Wallet client is required for write operations');
|
|
2152
|
+
}
|
|
2153
|
+
return this.contract.write.uniswapV3SwapCallback([amount0Delta, amount1Delta, data] as const, options) as Promise<`0x${string}`>;
|
|
2154
|
+
}
|
|
2155
|
+
|
|
2156
|
+
/**
|
|
2157
|
+
* unlockCallback
|
|
2158
|
+
* nonpayable
|
|
2159
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2160
|
+
*/
|
|
2161
|
+
async unlockCallback(data: `0x${string}`, options?: {
|
|
2162
|
+
accessList?: import('viem').AccessList;
|
|
2163
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2164
|
+
chain?: import('viem').Chain | null;
|
|
2165
|
+
dataSuffix?: `0x${string}`;
|
|
2166
|
+
gas?: bigint;
|
|
2167
|
+
gasPrice?: bigint;
|
|
2168
|
+
maxFeePerGas?: bigint;
|
|
2169
|
+
maxPriorityFeePerGas?: bigint;
|
|
2170
|
+
nonce?: number;
|
|
2171
|
+
value?: bigint;
|
|
2172
|
+
}): Promise<`0x${string}`> {
|
|
2173
|
+
if (!this.contract.write) {
|
|
2174
|
+
throw new Error('Wallet client is required for write operations');
|
|
2175
|
+
}
|
|
2176
|
+
return this.contract.write.unlockCallback([data] as const, options) as Promise<`0x${string}`>;
|
|
2177
|
+
}
|
|
2178
|
+
|
|
2179
|
+
|
|
2180
|
+
|
|
2181
|
+
/**
|
|
2182
|
+
* Simulate contract write operations (dry-run without sending transaction)
|
|
2183
|
+
*
|
|
2184
|
+
* @example
|
|
2185
|
+
* const result = await contract.simulate.transfer('0x...', 1000n);
|
|
2186
|
+
* console.log('Gas estimate:', result.request.gas);
|
|
2187
|
+
* console.log('Would succeed:', result.result);
|
|
2188
|
+
*/
|
|
2189
|
+
get simulate() {
|
|
2190
|
+
const contract = this.contract;
|
|
2191
|
+
if (!contract.simulate) {
|
|
2192
|
+
throw new Error('Public client is required for simulation');
|
|
2193
|
+
}
|
|
2194
|
+
return {
|
|
2195
|
+
/**
|
|
2196
|
+
* Simulate addWhitelistedAlgebraCustomPoolAddressesHum_1T0MDH
|
|
2197
|
+
* Returns gas estimate and result without sending transaction
|
|
2198
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2199
|
+
*/
|
|
2200
|
+
async addWhitelistedAlgebraCustomPoolAddressesHum_1T0MDH(deployer: `0x${string}`, pools: `0x${string}`[], options?: {
|
|
2201
|
+
accessList?: import('viem').AccessList;
|
|
2202
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2203
|
+
chain?: import('viem').Chain | null;
|
|
2204
|
+
dataSuffix?: `0x${string}`;
|
|
2205
|
+
gas?: bigint;
|
|
2206
|
+
gasPrice?: bigint;
|
|
2207
|
+
maxFeePerGas?: bigint;
|
|
2208
|
+
maxPriorityFeePerGas?: bigint;
|
|
2209
|
+
nonce?: number;
|
|
2210
|
+
value?: bigint;
|
|
2211
|
+
}): Promise<void> {
|
|
2212
|
+
return contract.simulate.addWhitelistedAlgebraCustomPoolAddressesHum_1T0MDH([deployer, pools] as const, options) as Promise<void>;
|
|
2213
|
+
},
|
|
2214
|
+
/**
|
|
2215
|
+
* Simulate addWhitelistedBotAddressesHum
|
|
2216
|
+
* Returns gas estimate and result without sending transaction
|
|
2217
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2218
|
+
*/
|
|
2219
|
+
async addWhitelistedBotAddressesHum(bots: `0x${string}`[], options?: {
|
|
2220
|
+
accessList?: import('viem').AccessList;
|
|
2221
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2222
|
+
chain?: import('viem').Chain | null;
|
|
2223
|
+
dataSuffix?: `0x${string}`;
|
|
2224
|
+
gas?: bigint;
|
|
2225
|
+
gasPrice?: bigint;
|
|
2226
|
+
maxFeePerGas?: bigint;
|
|
2227
|
+
maxPriorityFeePerGas?: bigint;
|
|
2228
|
+
nonce?: number;
|
|
2229
|
+
value?: bigint;
|
|
2230
|
+
}): Promise<void> {
|
|
2231
|
+
return contract.simulate.addWhitelistedBotAddressesHum([bots] as const, options) as Promise<void>;
|
|
2232
|
+
},
|
|
2233
|
+
/**
|
|
2234
|
+
* Simulate addWhitelistedPairAddressesHum
|
|
2235
|
+
* Returns gas estimate and result without sending transaction
|
|
2236
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2237
|
+
*/
|
|
2238
|
+
async addWhitelistedPairAddressesHum(pairs: `0x${string}`[], options?: {
|
|
2239
|
+
accessList?: import('viem').AccessList;
|
|
2240
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2241
|
+
chain?: import('viem').Chain | null;
|
|
2242
|
+
dataSuffix?: `0x${string}`;
|
|
2243
|
+
gas?: bigint;
|
|
2244
|
+
gasPrice?: bigint;
|
|
2245
|
+
maxFeePerGas?: bigint;
|
|
2246
|
+
maxPriorityFeePerGas?: bigint;
|
|
2247
|
+
nonce?: number;
|
|
2248
|
+
value?: bigint;
|
|
2249
|
+
}): Promise<void> {
|
|
2250
|
+
return contract.simulate.addWhitelistedPairAddressesHum([pairs] as const, options) as Promise<void>;
|
|
2251
|
+
},
|
|
2252
|
+
/**
|
|
2253
|
+
* Simulate addWhitelistedTokenAddressesHum
|
|
2254
|
+
* Returns gas estimate and result without sending transaction
|
|
2255
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2256
|
+
*/
|
|
2257
|
+
async addWhitelistedTokenAddressesHum(accounts: `0x${string}`[], options?: {
|
|
2258
|
+
accessList?: import('viem').AccessList;
|
|
2259
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2260
|
+
chain?: import('viem').Chain | null;
|
|
2261
|
+
dataSuffix?: `0x${string}`;
|
|
2262
|
+
gas?: bigint;
|
|
2263
|
+
gasPrice?: bigint;
|
|
2264
|
+
maxFeePerGas?: bigint;
|
|
2265
|
+
maxPriorityFeePerGas?: bigint;
|
|
2266
|
+
nonce?: number;
|
|
2267
|
+
value?: bigint;
|
|
2268
|
+
}): Promise<void> {
|
|
2269
|
+
return contract.simulate.addWhitelistedTokenAddressesHum([accounts] as const, options) as Promise<void>;
|
|
2270
|
+
},
|
|
2271
|
+
/**
|
|
2272
|
+
* Simulate addWhitelistedTransferAddressesHum
|
|
2273
|
+
* Returns gas estimate and result without sending transaction
|
|
2274
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2275
|
+
*/
|
|
2276
|
+
async addWhitelistedTransferAddressesHum(accounts: `0x${string}`[], options?: {
|
|
2277
|
+
accessList?: import('viem').AccessList;
|
|
2278
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2279
|
+
chain?: import('viem').Chain | null;
|
|
2280
|
+
dataSuffix?: `0x${string}`;
|
|
2281
|
+
gas?: bigint;
|
|
2282
|
+
gasPrice?: bigint;
|
|
2283
|
+
maxFeePerGas?: bigint;
|
|
2284
|
+
maxPriorityFeePerGas?: bigint;
|
|
2285
|
+
nonce?: number;
|
|
2286
|
+
value?: bigint;
|
|
2287
|
+
}): Promise<void> {
|
|
2288
|
+
return contract.simulate.addWhitelistedTransferAddressesHum([accounts] as const, options) as Promise<void>;
|
|
2289
|
+
},
|
|
2290
|
+
/**
|
|
2291
|
+
* Simulate addWhitelistedUniswapV3FactoryHum
|
|
2292
|
+
* Returns gas estimate and result without sending transaction
|
|
2293
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2294
|
+
*/
|
|
2295
|
+
async addWhitelistedUniswapV3FactoryHum(factories: `0x${string}`[], options?: {
|
|
2296
|
+
accessList?: import('viem').AccessList;
|
|
2297
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2298
|
+
chain?: import('viem').Chain | null;
|
|
2299
|
+
dataSuffix?: `0x${string}`;
|
|
2300
|
+
gas?: bigint;
|
|
2301
|
+
gasPrice?: bigint;
|
|
2302
|
+
maxFeePerGas?: bigint;
|
|
2303
|
+
maxPriorityFeePerGas?: bigint;
|
|
2304
|
+
nonce?: number;
|
|
2305
|
+
value?: bigint;
|
|
2306
|
+
}): Promise<void> {
|
|
2307
|
+
return contract.simulate.addWhitelistedUniswapV3FactoryHum([factories] as const, options) as Promise<void>;
|
|
2308
|
+
},
|
|
2309
|
+
/**
|
|
2310
|
+
* Simulate addWhitelistedUniswapV3PoolAddressesHum
|
|
2311
|
+
* Returns gas estimate and result without sending transaction
|
|
2312
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2313
|
+
*/
|
|
2314
|
+
async addWhitelistedUniswapV3PoolAddressesHum(pools: `0x${string}`[], options?: {
|
|
2315
|
+
accessList?: import('viem').AccessList;
|
|
2316
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2317
|
+
chain?: import('viem').Chain | null;
|
|
2318
|
+
dataSuffix?: `0x${string}`;
|
|
2319
|
+
gas?: bigint;
|
|
2320
|
+
gasPrice?: bigint;
|
|
2321
|
+
maxFeePerGas?: bigint;
|
|
2322
|
+
maxPriorityFeePerGas?: bigint;
|
|
2323
|
+
nonce?: number;
|
|
2324
|
+
value?: bigint;
|
|
2325
|
+
}): Promise<void> {
|
|
2326
|
+
return contract.simulate.addWhitelistedUniswapV3PoolAddressesHum([pools] as const, options) as Promise<void>;
|
|
2327
|
+
},
|
|
2328
|
+
/**
|
|
2329
|
+
* Simulate addWhitelistedUniswapV3PositionManagerHum
|
|
2330
|
+
* Returns gas estimate and result without sending transaction
|
|
2331
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2332
|
+
*/
|
|
2333
|
+
async addWhitelistedUniswapV3PositionManagerHum(accounts: `0x${string}`[], options?: {
|
|
2334
|
+
accessList?: import('viem').AccessList;
|
|
2335
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2336
|
+
chain?: import('viem').Chain | null;
|
|
2337
|
+
dataSuffix?: `0x${string}`;
|
|
2338
|
+
gas?: bigint;
|
|
2339
|
+
gasPrice?: bigint;
|
|
2340
|
+
maxFeePerGas?: bigint;
|
|
2341
|
+
maxPriorityFeePerGas?: bigint;
|
|
2342
|
+
nonce?: number;
|
|
2343
|
+
value?: bigint;
|
|
2344
|
+
}): Promise<void> {
|
|
2345
|
+
return contract.simulate.addWhitelistedUniswapV3PositionManagerHum([accounts] as const, options) as Promise<void>;
|
|
2346
|
+
},
|
|
2347
|
+
/**
|
|
2348
|
+
* Simulate addWhitelistedUniswapV4HooksHum
|
|
2349
|
+
* Returns gas estimate and result without sending transaction
|
|
2350
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2351
|
+
*/
|
|
2352
|
+
async addWhitelistedUniswapV4HooksHum(hooks: `0x${string}`[], options?: {
|
|
2353
|
+
accessList?: import('viem').AccessList;
|
|
2354
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2355
|
+
chain?: import('viem').Chain | null;
|
|
2356
|
+
dataSuffix?: `0x${string}`;
|
|
2357
|
+
gas?: bigint;
|
|
2358
|
+
gasPrice?: bigint;
|
|
2359
|
+
maxFeePerGas?: bigint;
|
|
2360
|
+
maxPriorityFeePerGas?: bigint;
|
|
2361
|
+
nonce?: number;
|
|
2362
|
+
value?: bigint;
|
|
2363
|
+
}): Promise<void> {
|
|
2364
|
+
return contract.simulate.addWhitelistedUniswapV4HooksHum([hooks] as const, options) as Promise<void>;
|
|
2365
|
+
},
|
|
2366
|
+
/**
|
|
2367
|
+
* Simulate addWhitelistedUniswapV4PoolsHum
|
|
2368
|
+
* Returns gas estimate and result without sending transaction
|
|
2369
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2370
|
+
*/
|
|
2371
|
+
async addWhitelistedUniswapV4PoolsHum(poolManager: `0x${string}`, keys: `0x${string}`[], options?: {
|
|
2372
|
+
accessList?: import('viem').AccessList;
|
|
2373
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2374
|
+
chain?: import('viem').Chain | null;
|
|
2375
|
+
dataSuffix?: `0x${string}`;
|
|
2376
|
+
gas?: bigint;
|
|
2377
|
+
gasPrice?: bigint;
|
|
2378
|
+
maxFeePerGas?: bigint;
|
|
2379
|
+
maxPriorityFeePerGas?: bigint;
|
|
2380
|
+
nonce?: number;
|
|
2381
|
+
value?: bigint;
|
|
2382
|
+
}): Promise<void> {
|
|
2383
|
+
return contract.simulate.addWhitelistedUniswapV4PoolsHum([poolManager, keys] as const, options) as Promise<void>;
|
|
2384
|
+
},
|
|
2385
|
+
/**
|
|
2386
|
+
* Simulate algebraSwapCallback
|
|
2387
|
+
* Returns gas estimate and result without sending transaction
|
|
2388
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2389
|
+
*/
|
|
2390
|
+
async algebraSwapCallback(amount0Delta: bigint, amount1Delta: bigint, data: `0x${string}`, options?: {
|
|
2391
|
+
accessList?: import('viem').AccessList;
|
|
2392
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2393
|
+
chain?: import('viem').Chain | null;
|
|
2394
|
+
dataSuffix?: `0x${string}`;
|
|
2395
|
+
gas?: bigint;
|
|
2396
|
+
gasPrice?: bigint;
|
|
2397
|
+
maxFeePerGas?: bigint;
|
|
2398
|
+
maxPriorityFeePerGas?: bigint;
|
|
2399
|
+
nonce?: number;
|
|
2400
|
+
value?: bigint;
|
|
2401
|
+
}): Promise<void> {
|
|
2402
|
+
return contract.simulate.algebraSwapCallback([amount0Delta, amount1Delta, data] as const, options) as Promise<void>;
|
|
2403
|
+
},
|
|
2404
|
+
/**
|
|
2405
|
+
* Simulate migrateTokensProxyOwnerHum
|
|
2406
|
+
* Returns gas estimate and result without sending transaction
|
|
2407
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2408
|
+
*/
|
|
2409
|
+
async migrateTokensProxyOwnerHum(tokens: `0x${string}`[], newProxy: `0x${string}`, newProxyOwner: `0x${string}`, options?: {
|
|
2410
|
+
accessList?: import('viem').AccessList;
|
|
2411
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2412
|
+
chain?: import('viem').Chain | null;
|
|
2413
|
+
dataSuffix?: `0x${string}`;
|
|
2414
|
+
gas?: bigint;
|
|
2415
|
+
gasPrice?: bigint;
|
|
2416
|
+
maxFeePerGas?: bigint;
|
|
2417
|
+
maxPriorityFeePerGas?: bigint;
|
|
2418
|
+
nonce?: number;
|
|
2419
|
+
value?: bigint;
|
|
2420
|
+
}): Promise<void> {
|
|
2421
|
+
return contract.simulate.migrateTokensProxyOwnerHum([tokens, newProxy, newProxyOwner] as const, options) as Promise<void>;
|
|
2422
|
+
},
|
|
2423
|
+
/**
|
|
2424
|
+
* Simulate pancakeV3SwapCallback
|
|
2425
|
+
* Returns gas estimate and result without sending transaction
|
|
2426
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2427
|
+
*/
|
|
2428
|
+
async pancakeV3SwapCallback(amount0Delta: bigint, amount1Delta: bigint, data: `0x${string}`, options?: {
|
|
2429
|
+
accessList?: import('viem').AccessList;
|
|
2430
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2431
|
+
chain?: import('viem').Chain | null;
|
|
2432
|
+
dataSuffix?: `0x${string}`;
|
|
2433
|
+
gas?: bigint;
|
|
2434
|
+
gasPrice?: bigint;
|
|
2435
|
+
maxFeePerGas?: bigint;
|
|
2436
|
+
maxPriorityFeePerGas?: bigint;
|
|
2437
|
+
nonce?: number;
|
|
2438
|
+
value?: bigint;
|
|
2439
|
+
}): Promise<void> {
|
|
2440
|
+
return contract.simulate.pancakeV3SwapCallback([amount0Delta, amount1Delta, data] as const, options) as Promise<void>;
|
|
2441
|
+
},
|
|
2442
|
+
/**
|
|
2443
|
+
* Simulate ramsesV2SwapCallback
|
|
2444
|
+
* Returns gas estimate and result without sending transaction
|
|
2445
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2446
|
+
*/
|
|
2447
|
+
async ramsesV2SwapCallback(amount0Delta: bigint, amount1Delta: bigint, data: `0x${string}`, options?: {
|
|
2448
|
+
accessList?: import('viem').AccessList;
|
|
2449
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2450
|
+
chain?: import('viem').Chain | null;
|
|
2451
|
+
dataSuffix?: `0x${string}`;
|
|
2452
|
+
gas?: bigint;
|
|
2453
|
+
gasPrice?: bigint;
|
|
2454
|
+
maxFeePerGas?: bigint;
|
|
2455
|
+
maxPriorityFeePerGas?: bigint;
|
|
2456
|
+
nonce?: number;
|
|
2457
|
+
value?: bigint;
|
|
2458
|
+
}): Promise<void> {
|
|
2459
|
+
return contract.simulate.ramsesV2SwapCallback([amount0Delta, amount1Delta, data] as const, options) as Promise<void>;
|
|
2460
|
+
},
|
|
2461
|
+
/**
|
|
2462
|
+
* Simulate removeWhitelistedBotAddressesHum
|
|
2463
|
+
* Returns gas estimate and result without sending transaction
|
|
2464
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2465
|
+
*/
|
|
2466
|
+
async removeWhitelistedBotAddressesHum(bots: `0x${string}`[], options?: {
|
|
2467
|
+
accessList?: import('viem').AccessList;
|
|
2468
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2469
|
+
chain?: import('viem').Chain | null;
|
|
2470
|
+
dataSuffix?: `0x${string}`;
|
|
2471
|
+
gas?: bigint;
|
|
2472
|
+
gasPrice?: bigint;
|
|
2473
|
+
maxFeePerGas?: bigint;
|
|
2474
|
+
maxPriorityFeePerGas?: bigint;
|
|
2475
|
+
nonce?: number;
|
|
2476
|
+
value?: bigint;
|
|
2477
|
+
}): Promise<void> {
|
|
2478
|
+
return contract.simulate.removeWhitelistedBotAddressesHum([bots] as const, options) as Promise<void>;
|
|
2479
|
+
},
|
|
2480
|
+
/**
|
|
2481
|
+
* Simulate removeWhitelistedPairAddressesHum
|
|
2482
|
+
* Returns gas estimate and result without sending transaction
|
|
2483
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2484
|
+
*/
|
|
2485
|
+
async removeWhitelistedPairAddressesHum(pairs: `0x${string}`[], options?: {
|
|
2486
|
+
accessList?: import('viem').AccessList;
|
|
2487
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2488
|
+
chain?: import('viem').Chain | null;
|
|
2489
|
+
dataSuffix?: `0x${string}`;
|
|
2490
|
+
gas?: bigint;
|
|
2491
|
+
gasPrice?: bigint;
|
|
2492
|
+
maxFeePerGas?: bigint;
|
|
2493
|
+
maxPriorityFeePerGas?: bigint;
|
|
2494
|
+
nonce?: number;
|
|
2495
|
+
value?: bigint;
|
|
2496
|
+
}): Promise<void> {
|
|
2497
|
+
return contract.simulate.removeWhitelistedPairAddressesHum([pairs] as const, options) as Promise<void>;
|
|
2498
|
+
},
|
|
2499
|
+
/**
|
|
2500
|
+
* Simulate removeWhitelistedTokenAddressesHum
|
|
2501
|
+
* Returns gas estimate and result without sending transaction
|
|
2502
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2503
|
+
*/
|
|
2504
|
+
async removeWhitelistedTokenAddressesHum(accounts: `0x${string}`[], options?: {
|
|
2505
|
+
accessList?: import('viem').AccessList;
|
|
2506
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2507
|
+
chain?: import('viem').Chain | null;
|
|
2508
|
+
dataSuffix?: `0x${string}`;
|
|
2509
|
+
gas?: bigint;
|
|
2510
|
+
gasPrice?: bigint;
|
|
2511
|
+
maxFeePerGas?: bigint;
|
|
2512
|
+
maxPriorityFeePerGas?: bigint;
|
|
2513
|
+
nonce?: number;
|
|
2514
|
+
value?: bigint;
|
|
2515
|
+
}): Promise<void> {
|
|
2516
|
+
return contract.simulate.removeWhitelistedTokenAddressesHum([accounts] as const, options) as Promise<void>;
|
|
2517
|
+
},
|
|
2518
|
+
/**
|
|
2519
|
+
* Simulate removeWhitelistedTransferAddressesHum
|
|
2520
|
+
* Returns gas estimate and result without sending transaction
|
|
2521
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2522
|
+
*/
|
|
2523
|
+
async removeWhitelistedTransferAddressesHum(accounts: `0x${string}`[], options?: {
|
|
2524
|
+
accessList?: import('viem').AccessList;
|
|
2525
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2526
|
+
chain?: import('viem').Chain | null;
|
|
2527
|
+
dataSuffix?: `0x${string}`;
|
|
2528
|
+
gas?: bigint;
|
|
2529
|
+
gasPrice?: bigint;
|
|
2530
|
+
maxFeePerGas?: bigint;
|
|
2531
|
+
maxPriorityFeePerGas?: bigint;
|
|
2532
|
+
nonce?: number;
|
|
2533
|
+
value?: bigint;
|
|
2534
|
+
}): Promise<void> {
|
|
2535
|
+
return contract.simulate.removeWhitelistedTransferAddressesHum([accounts] as const, options) as Promise<void>;
|
|
2536
|
+
},
|
|
2537
|
+
/**
|
|
2538
|
+
* Simulate removeWhitelistedUniswapV3FactoryHum
|
|
2539
|
+
* Returns gas estimate and result without sending transaction
|
|
2540
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2541
|
+
*/
|
|
2542
|
+
async removeWhitelistedUniswapV3FactoryHum(factories: `0x${string}`[], options?: {
|
|
2543
|
+
accessList?: import('viem').AccessList;
|
|
2544
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2545
|
+
chain?: import('viem').Chain | null;
|
|
2546
|
+
dataSuffix?: `0x${string}`;
|
|
2547
|
+
gas?: bigint;
|
|
2548
|
+
gasPrice?: bigint;
|
|
2549
|
+
maxFeePerGas?: bigint;
|
|
2550
|
+
maxPriorityFeePerGas?: bigint;
|
|
2551
|
+
nonce?: number;
|
|
2552
|
+
value?: bigint;
|
|
2553
|
+
}): Promise<void> {
|
|
2554
|
+
return contract.simulate.removeWhitelistedUniswapV3FactoryHum([factories] as const, options) as Promise<void>;
|
|
2555
|
+
},
|
|
2556
|
+
/**
|
|
2557
|
+
* Simulate removeWhitelistedUniswapV3PoolAddressesHum
|
|
2558
|
+
* Returns gas estimate and result without sending transaction
|
|
2559
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2560
|
+
*/
|
|
2561
|
+
async removeWhitelistedUniswapV3PoolAddressesHum(pools: `0x${string}`[], options?: {
|
|
2562
|
+
accessList?: import('viem').AccessList;
|
|
2563
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2564
|
+
chain?: import('viem').Chain | null;
|
|
2565
|
+
dataSuffix?: `0x${string}`;
|
|
2566
|
+
gas?: bigint;
|
|
2567
|
+
gasPrice?: bigint;
|
|
2568
|
+
maxFeePerGas?: bigint;
|
|
2569
|
+
maxPriorityFeePerGas?: bigint;
|
|
2570
|
+
nonce?: number;
|
|
2571
|
+
value?: bigint;
|
|
2572
|
+
}): Promise<void> {
|
|
2573
|
+
return contract.simulate.removeWhitelistedUniswapV3PoolAddressesHum([pools] as const, options) as Promise<void>;
|
|
2574
|
+
},
|
|
2575
|
+
/**
|
|
2576
|
+
* Simulate removeWhitelistedUniswapV3PositionManagerHum
|
|
2577
|
+
* Returns gas estimate and result without sending transaction
|
|
2578
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2579
|
+
*/
|
|
2580
|
+
async removeWhitelistedUniswapV3PositionManagerHum(accounts: `0x${string}`[], options?: {
|
|
2581
|
+
accessList?: import('viem').AccessList;
|
|
2582
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2583
|
+
chain?: import('viem').Chain | null;
|
|
2584
|
+
dataSuffix?: `0x${string}`;
|
|
2585
|
+
gas?: bigint;
|
|
2586
|
+
gasPrice?: bigint;
|
|
2587
|
+
maxFeePerGas?: bigint;
|
|
2588
|
+
maxPriorityFeePerGas?: bigint;
|
|
2589
|
+
nonce?: number;
|
|
2590
|
+
value?: bigint;
|
|
2591
|
+
}): Promise<void> {
|
|
2592
|
+
return contract.simulate.removeWhitelistedUniswapV3PositionManagerHum([accounts] as const, options) as Promise<void>;
|
|
2593
|
+
},
|
|
2594
|
+
/**
|
|
2595
|
+
* Simulate removeWhitelistedUniswapV4HooksHum
|
|
2596
|
+
* Returns gas estimate and result without sending transaction
|
|
2597
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2598
|
+
*/
|
|
2599
|
+
async removeWhitelistedUniswapV4HooksHum(hooks: `0x${string}`[], options?: {
|
|
2600
|
+
accessList?: import('viem').AccessList;
|
|
2601
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2602
|
+
chain?: import('viem').Chain | null;
|
|
2603
|
+
dataSuffix?: `0x${string}`;
|
|
2604
|
+
gas?: bigint;
|
|
2605
|
+
gasPrice?: bigint;
|
|
2606
|
+
maxFeePerGas?: bigint;
|
|
2607
|
+
maxPriorityFeePerGas?: bigint;
|
|
2608
|
+
nonce?: number;
|
|
2609
|
+
value?: bigint;
|
|
2610
|
+
}): Promise<void> {
|
|
2611
|
+
return contract.simulate.removeWhitelistedUniswapV4HooksHum([hooks] as const, options) as Promise<void>;
|
|
2612
|
+
},
|
|
2613
|
+
/**
|
|
2614
|
+
* Simulate removeWhitelistedUniswapV4PoolsHum
|
|
2615
|
+
* Returns gas estimate and result without sending transaction
|
|
2616
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2617
|
+
*/
|
|
2618
|
+
async removeWhitelistedUniswapV4PoolsHum(poolManager: `0x${string}`, keys: `0x${string}`[], options?: {
|
|
2619
|
+
accessList?: import('viem').AccessList;
|
|
2620
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2621
|
+
chain?: import('viem').Chain | null;
|
|
2622
|
+
dataSuffix?: `0x${string}`;
|
|
2623
|
+
gas?: bigint;
|
|
2624
|
+
gasPrice?: bigint;
|
|
2625
|
+
maxFeePerGas?: bigint;
|
|
2626
|
+
maxPriorityFeePerGas?: bigint;
|
|
2627
|
+
nonce?: number;
|
|
2628
|
+
value?: bigint;
|
|
2629
|
+
}): Promise<void> {
|
|
2630
|
+
return contract.simulate.removeWhitelistedUniswapV4PoolsHum([poolManager, keys] as const, options) as Promise<void>;
|
|
2631
|
+
},
|
|
2632
|
+
/**
|
|
2633
|
+
* Simulate squadV3SwapCallback
|
|
2634
|
+
* Returns gas estimate and result without sending transaction
|
|
2635
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2636
|
+
*/
|
|
2637
|
+
async squadV3SwapCallback(amount0Delta: bigint, amount1Delta: bigint, data: `0x${string}`, options?: {
|
|
2638
|
+
accessList?: import('viem').AccessList;
|
|
2639
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2640
|
+
chain?: import('viem').Chain | null;
|
|
2641
|
+
dataSuffix?: `0x${string}`;
|
|
2642
|
+
gas?: bigint;
|
|
2643
|
+
gasPrice?: bigint;
|
|
2644
|
+
maxFeePerGas?: bigint;
|
|
2645
|
+
maxPriorityFeePerGas?: bigint;
|
|
2646
|
+
nonce?: number;
|
|
2647
|
+
value?: bigint;
|
|
2648
|
+
}): Promise<void> {
|
|
2649
|
+
return contract.simulate.squadV3SwapCallback([amount0Delta, amount1Delta, data] as const, options) as Promise<void>;
|
|
2650
|
+
},
|
|
2651
|
+
/**
|
|
2652
|
+
* Simulate swapExactTokensForTokensUniswapV3Hum
|
|
2653
|
+
* Returns gas estimate and result without sending transaction
|
|
2654
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2655
|
+
*/
|
|
2656
|
+
async swapExactTokensForTokensUniswapV3Hum(amountIn: bigint, tokenIn: `0x${string}`, amountOutMin: bigint, zeroForOne: boolean, pool: `0x${string}`, deadline: bigint, options?: {
|
|
2657
|
+
accessList?: import('viem').AccessList;
|
|
2658
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2659
|
+
chain?: import('viem').Chain | null;
|
|
2660
|
+
dataSuffix?: `0x${string}`;
|
|
2661
|
+
gas?: bigint;
|
|
2662
|
+
gasPrice?: bigint;
|
|
2663
|
+
maxFeePerGas?: bigint;
|
|
2664
|
+
maxPriorityFeePerGas?: bigint;
|
|
2665
|
+
nonce?: number;
|
|
2666
|
+
value?: bigint;
|
|
2667
|
+
}): Promise<void> {
|
|
2668
|
+
return contract.simulate.swapExactTokensForTokensUniswapV3Hum([amountIn, tokenIn, amountOutMin, zeroForOne, pool, deadline] as const, options) as Promise<void>;
|
|
2669
|
+
},
|
|
2670
|
+
/**
|
|
2671
|
+
* Simulate swapExactTokensForTokensUniswapV4Hum
|
|
2672
|
+
* Returns gas estimate and result without sending transaction
|
|
2673
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2674
|
+
*/
|
|
2675
|
+
async swapExactTokensForTokensUniswapV4Hum(data: Logic_V4SwapData, poolManager: `0x${string}`, amountOutMin: bigint, deadline: bigint, options?: {
|
|
2676
|
+
accessList?: import('viem').AccessList;
|
|
2677
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2678
|
+
chain?: import('viem').Chain | null;
|
|
2679
|
+
dataSuffix?: `0x${string}`;
|
|
2680
|
+
gas?: bigint;
|
|
2681
|
+
gasPrice?: bigint;
|
|
2682
|
+
maxFeePerGas?: bigint;
|
|
2683
|
+
maxPriorityFeePerGas?: bigint;
|
|
2684
|
+
nonce?: number;
|
|
2685
|
+
value?: bigint;
|
|
2686
|
+
}): Promise<void> {
|
|
2687
|
+
return contract.simulate.swapExactTokensForTokensUniswapV4Hum([data, poolManager, amountOutMin, deadline] as const, options) as Promise<void>;
|
|
2688
|
+
},
|
|
2689
|
+
/**
|
|
2690
|
+
* Simulate swapToBoundaryIziSwapHum_4KPMRG
|
|
2691
|
+
* Returns gas estimate and result without sending transaction
|
|
2692
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2693
|
+
*/
|
|
2694
|
+
async swapToBoundaryIziSwapHum_4KPMRG(amount: bigint, boundaryPoint: bigint, tokenIn: `0x${string}`, x2y: boolean, pool: `0x${string}`, deadline: bigint, options?: {
|
|
2695
|
+
accessList?: import('viem').AccessList;
|
|
2696
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2697
|
+
chain?: import('viem').Chain | null;
|
|
2698
|
+
dataSuffix?: `0x${string}`;
|
|
2699
|
+
gas?: bigint;
|
|
2700
|
+
gasPrice?: bigint;
|
|
2701
|
+
maxFeePerGas?: bigint;
|
|
2702
|
+
maxPriorityFeePerGas?: bigint;
|
|
2703
|
+
nonce?: number;
|
|
2704
|
+
value?: bigint;
|
|
2705
|
+
}): Promise<void> {
|
|
2706
|
+
return contract.simulate.swapToBoundaryIziSwapHum_4KPMRG([amount, boundaryPoint, tokenIn, x2y, pool, deadline] as const, options) as Promise<void>;
|
|
2707
|
+
},
|
|
2708
|
+
/**
|
|
2709
|
+
* Simulate swapTokensForTokensLimitOrderUniswapV2Hum
|
|
2710
|
+
* Returns gas estimate and result without sending transaction
|
|
2711
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2712
|
+
*/
|
|
2713
|
+
async swapTokensForTokensLimitOrderUniswapV2Hum(amountIn: bigint, sqrtPriceLimitX96: bigint, tokenIn: `0x${string}`, zeroForOne: boolean, fee: bigint, pair: `0x${string}`, deadline: bigint, options?: {
|
|
2714
|
+
accessList?: import('viem').AccessList;
|
|
2715
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2716
|
+
chain?: import('viem').Chain | null;
|
|
2717
|
+
dataSuffix?: `0x${string}`;
|
|
2718
|
+
gas?: bigint;
|
|
2719
|
+
gasPrice?: bigint;
|
|
2720
|
+
maxFeePerGas?: bigint;
|
|
2721
|
+
maxPriorityFeePerGas?: bigint;
|
|
2722
|
+
nonce?: number;
|
|
2723
|
+
value?: bigint;
|
|
2724
|
+
}): Promise<void> {
|
|
2725
|
+
return contract.simulate.swapTokensForTokensLimitOrderUniswapV2Hum([amountIn, sqrtPriceLimitX96, tokenIn, zeroForOne, fee, pair, deadline] as const, options) as Promise<void>;
|
|
2726
|
+
},
|
|
2727
|
+
/**
|
|
2728
|
+
* Simulate swapTokensForTokensLimitOrderUniswapV3Hum
|
|
2729
|
+
* Returns gas estimate and result without sending transaction
|
|
2730
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2731
|
+
*/
|
|
2732
|
+
async swapTokensForTokensLimitOrderUniswapV3Hum(amountIn: bigint, sqrtPriceLimitX96: bigint, tokenIn: `0x${string}`, zeroForOne: boolean, pool: `0x${string}`, deadline: bigint, options?: {
|
|
2733
|
+
accessList?: import('viem').AccessList;
|
|
2734
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2735
|
+
chain?: import('viem').Chain | null;
|
|
2736
|
+
dataSuffix?: `0x${string}`;
|
|
2737
|
+
gas?: bigint;
|
|
2738
|
+
gasPrice?: bigint;
|
|
2739
|
+
maxFeePerGas?: bigint;
|
|
2740
|
+
maxPriorityFeePerGas?: bigint;
|
|
2741
|
+
nonce?: number;
|
|
2742
|
+
value?: bigint;
|
|
2743
|
+
}): Promise<void> {
|
|
2744
|
+
return contract.simulate.swapTokensForTokensLimitOrderUniswapV3Hum([amountIn, sqrtPriceLimitX96, tokenIn, zeroForOne, pool, deadline] as const, options) as Promise<void>;
|
|
2745
|
+
},
|
|
2746
|
+
/**
|
|
2747
|
+
* Simulate swapTokensForTokensLimitOrderUniswapV4Hum
|
|
2748
|
+
* Returns gas estimate and result without sending transaction
|
|
2749
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2750
|
+
*/
|
|
2751
|
+
async swapTokensForTokensLimitOrderUniswapV4Hum(data: Logic_V4SwapData, poolManager: `0x${string}`, deadline: bigint, options?: {
|
|
2752
|
+
accessList?: import('viem').AccessList;
|
|
2753
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2754
|
+
chain?: import('viem').Chain | null;
|
|
2755
|
+
dataSuffix?: `0x${string}`;
|
|
2756
|
+
gas?: bigint;
|
|
2757
|
+
gasPrice?: bigint;
|
|
2758
|
+
maxFeePerGas?: bigint;
|
|
2759
|
+
maxPriorityFeePerGas?: bigint;
|
|
2760
|
+
nonce?: number;
|
|
2761
|
+
value?: bigint;
|
|
2762
|
+
}): Promise<void> {
|
|
2763
|
+
return contract.simulate.swapTokensForTokensLimitOrderUniswapV4Hum([data, poolManager, deadline] as const, options) as Promise<void>;
|
|
2764
|
+
},
|
|
2765
|
+
/**
|
|
2766
|
+
* Simulate swapX2YCallback
|
|
2767
|
+
* Returns gas estimate and result without sending transaction
|
|
2768
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2769
|
+
*/
|
|
2770
|
+
async swapX2YCallback(x: bigint, y: bigint, data: `0x${string}`, options?: {
|
|
2771
|
+
accessList?: import('viem').AccessList;
|
|
2772
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2773
|
+
chain?: import('viem').Chain | null;
|
|
2774
|
+
dataSuffix?: `0x${string}`;
|
|
2775
|
+
gas?: bigint;
|
|
2776
|
+
gasPrice?: bigint;
|
|
2777
|
+
maxFeePerGas?: bigint;
|
|
2778
|
+
maxPriorityFeePerGas?: bigint;
|
|
2779
|
+
nonce?: number;
|
|
2780
|
+
value?: bigint;
|
|
2781
|
+
}): Promise<void> {
|
|
2782
|
+
return contract.simulate.swapX2YCallback([x, y, data] as const, options) as Promise<void>;
|
|
2783
|
+
},
|
|
2784
|
+
/**
|
|
2785
|
+
* Simulate swapY2XCallback
|
|
2786
|
+
* Returns gas estimate and result without sending transaction
|
|
2787
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2788
|
+
*/
|
|
2789
|
+
async swapY2XCallback(x: bigint, y: bigint, data: `0x${string}`, options?: {
|
|
2790
|
+
accessList?: import('viem').AccessList;
|
|
2791
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2792
|
+
chain?: import('viem').Chain | null;
|
|
2793
|
+
dataSuffix?: `0x${string}`;
|
|
2794
|
+
gas?: bigint;
|
|
2795
|
+
gasPrice?: bigint;
|
|
2796
|
+
maxFeePerGas?: bigint;
|
|
2797
|
+
maxPriorityFeePerGas?: bigint;
|
|
2798
|
+
nonce?: number;
|
|
2799
|
+
value?: bigint;
|
|
2800
|
+
}): Promise<void> {
|
|
2801
|
+
return contract.simulate.swapY2XCallback([x, y, data] as const, options) as Promise<void>;
|
|
2802
|
+
},
|
|
2803
|
+
/**
|
|
2804
|
+
* Simulate transferChainCoinProxyOwnerHum
|
|
2805
|
+
* Returns gas estimate and result without sending transaction
|
|
2806
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2807
|
+
*/
|
|
2808
|
+
async transferChainCoinProxyOwnerHum(to: `0x${string}`, amount: bigint, options?: {
|
|
2809
|
+
accessList?: import('viem').AccessList;
|
|
2810
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2811
|
+
chain?: import('viem').Chain | null;
|
|
2812
|
+
dataSuffix?: `0x${string}`;
|
|
2813
|
+
gas?: bigint;
|
|
2814
|
+
gasPrice?: bigint;
|
|
2815
|
+
maxFeePerGas?: bigint;
|
|
2816
|
+
maxPriorityFeePerGas?: bigint;
|
|
2817
|
+
nonce?: number;
|
|
2818
|
+
value?: bigint;
|
|
2819
|
+
}): Promise<void> {
|
|
2820
|
+
return contract.simulate.transferChainCoinProxyOwnerHum([to, amount] as const, options) as Promise<void>;
|
|
2821
|
+
},
|
|
2822
|
+
/**
|
|
2823
|
+
* Simulate transferTokenProxyOwnerHum
|
|
2824
|
+
* Returns gas estimate and result without sending transaction
|
|
2825
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2826
|
+
*/
|
|
2827
|
+
async transferTokenProxyOwnerHum(token: `0x${string}`, to: `0x${string}`, amount: bigint, options?: {
|
|
2828
|
+
accessList?: import('viem').AccessList;
|
|
2829
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2830
|
+
chain?: import('viem').Chain | null;
|
|
2831
|
+
dataSuffix?: `0x${string}`;
|
|
2832
|
+
gas?: bigint;
|
|
2833
|
+
gasPrice?: bigint;
|
|
2834
|
+
maxFeePerGas?: bigint;
|
|
2835
|
+
maxPriorityFeePerGas?: bigint;
|
|
2836
|
+
nonce?: number;
|
|
2837
|
+
value?: bigint;
|
|
2838
|
+
}): Promise<void> {
|
|
2839
|
+
return contract.simulate.transferTokenProxyOwnerHum([token, to, amount] as const, options) as Promise<void>;
|
|
2840
|
+
},
|
|
2841
|
+
/**
|
|
2842
|
+
* Simulate uniswapV3SwapCallback
|
|
2843
|
+
* Returns gas estimate and result without sending transaction
|
|
2844
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2845
|
+
*/
|
|
2846
|
+
async uniswapV3SwapCallback(amount0Delta: bigint, amount1Delta: bigint, data: `0x${string}`, options?: {
|
|
2847
|
+
accessList?: import('viem').AccessList;
|
|
2848
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2849
|
+
chain?: import('viem').Chain | null;
|
|
2850
|
+
dataSuffix?: `0x${string}`;
|
|
2851
|
+
gas?: bigint;
|
|
2852
|
+
gasPrice?: bigint;
|
|
2853
|
+
maxFeePerGas?: bigint;
|
|
2854
|
+
maxPriorityFeePerGas?: bigint;
|
|
2855
|
+
nonce?: number;
|
|
2856
|
+
value?: bigint;
|
|
2857
|
+
}): Promise<void> {
|
|
2858
|
+
return contract.simulate.uniswapV3SwapCallback([amount0Delta, amount1Delta, data] as const, options) as Promise<void>;
|
|
2859
|
+
},
|
|
2860
|
+
/**
|
|
2861
|
+
* Simulate unlockCallback
|
|
2862
|
+
* Returns gas estimate and result without sending transaction
|
|
2863
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2864
|
+
*/
|
|
2865
|
+
async unlockCallback(data: `0x${string}`, options?: {
|
|
2866
|
+
accessList?: import('viem').AccessList;
|
|
2867
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2868
|
+
chain?: import('viem').Chain | null;
|
|
2869
|
+
dataSuffix?: `0x${string}`;
|
|
2870
|
+
gas?: bigint;
|
|
2871
|
+
gasPrice?: bigint;
|
|
2872
|
+
maxFeePerGas?: bigint;
|
|
2873
|
+
maxPriorityFeePerGas?: bigint;
|
|
2874
|
+
nonce?: number;
|
|
2875
|
+
value?: bigint;
|
|
2876
|
+
}): Promise<`0x${string}`> {
|
|
2877
|
+
return contract.simulate.unlockCallback([data] as const, options) as Promise<`0x${string}`>;
|
|
2878
|
+
}
|
|
2879
|
+
};
|
|
2880
|
+
}
|
|
2881
|
+
|
|
2882
|
+
/**
|
|
2883
|
+
* Watch contract events
|
|
2884
|
+
*
|
|
2885
|
+
* Note: This contract has no events, so watch returns an empty object.
|
|
2886
|
+
*/
|
|
2887
|
+
get watch() {
|
|
2888
|
+
return {};
|
|
2889
|
+
}
|
|
2890
|
+
}
|