@gitmyabi/presale 1.0.1
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 +108 -0
- package/contracts/PresaleV2_json.d.ts +2755 -0
- package/contracts/PresaleV2_json.js +2734 -0
- package/contracts/PresaleV2_json.ts +3611 -0
- package/contracts/TransparentUpgradeableProxy_json.d.ts +401 -0
- package/contracts/TransparentUpgradeableProxy_json.js +398 -0
- package/contracts/TransparentUpgradeableProxy_json.ts +542 -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 +43 -0
|
@@ -0,0 +1,3611 @@
|
|
|
1
|
+
import type { Abi, Address, PublicClient, WalletClient, GetContractReturnType } from 'viem';
|
|
2
|
+
import { getContract } from 'viem';
|
|
3
|
+
|
|
4
|
+
/**
|
|
5
|
+
* PresaleV2_json ABI
|
|
6
|
+
*
|
|
7
|
+
* This ABI is typed using viem's type system for full type safety.
|
|
8
|
+
*/
|
|
9
|
+
export const PresaleV2_jsonAbi = [
|
|
10
|
+
{
|
|
11
|
+
"inputs": [],
|
|
12
|
+
"stateMutability": "nonpayable",
|
|
13
|
+
"type": "constructor"
|
|
14
|
+
},
|
|
15
|
+
{
|
|
16
|
+
"anonymous": false,
|
|
17
|
+
"inputs": [
|
|
18
|
+
{
|
|
19
|
+
"indexed": false,
|
|
20
|
+
"internalType": "uint256",
|
|
21
|
+
"name": "prevValue",
|
|
22
|
+
"type": "uint256"
|
|
23
|
+
},
|
|
24
|
+
{
|
|
25
|
+
"indexed": false,
|
|
26
|
+
"internalType": "uint256",
|
|
27
|
+
"name": "newValue",
|
|
28
|
+
"type": "uint256"
|
|
29
|
+
},
|
|
30
|
+
{
|
|
31
|
+
"indexed": false,
|
|
32
|
+
"internalType": "uint256",
|
|
33
|
+
"name": "timestamp",
|
|
34
|
+
"type": "uint256"
|
|
35
|
+
}
|
|
36
|
+
],
|
|
37
|
+
"name": "ClaimStartUpdated",
|
|
38
|
+
"type": "event"
|
|
39
|
+
},
|
|
40
|
+
{
|
|
41
|
+
"anonymous": false,
|
|
42
|
+
"inputs": [
|
|
43
|
+
{
|
|
44
|
+
"indexed": false,
|
|
45
|
+
"internalType": "uint8",
|
|
46
|
+
"name": "version",
|
|
47
|
+
"type": "uint8"
|
|
48
|
+
}
|
|
49
|
+
],
|
|
50
|
+
"name": "Initialized",
|
|
51
|
+
"type": "event"
|
|
52
|
+
},
|
|
53
|
+
{
|
|
54
|
+
"anonymous": false,
|
|
55
|
+
"inputs": [
|
|
56
|
+
{
|
|
57
|
+
"indexed": false,
|
|
58
|
+
"internalType": "uint256",
|
|
59
|
+
"name": "prevValue",
|
|
60
|
+
"type": "uint256"
|
|
61
|
+
},
|
|
62
|
+
{
|
|
63
|
+
"indexed": false,
|
|
64
|
+
"internalType": "uint256",
|
|
65
|
+
"name": "newValue",
|
|
66
|
+
"type": "uint256"
|
|
67
|
+
},
|
|
68
|
+
{
|
|
69
|
+
"indexed": false,
|
|
70
|
+
"internalType": "uint256",
|
|
71
|
+
"name": "timestamp",
|
|
72
|
+
"type": "uint256"
|
|
73
|
+
}
|
|
74
|
+
],
|
|
75
|
+
"name": "MaxTokensUpdated",
|
|
76
|
+
"type": "event"
|
|
77
|
+
},
|
|
78
|
+
{
|
|
79
|
+
"anonymous": false,
|
|
80
|
+
"inputs": [
|
|
81
|
+
{
|
|
82
|
+
"indexed": true,
|
|
83
|
+
"internalType": "address",
|
|
84
|
+
"name": "previousOwner",
|
|
85
|
+
"type": "address"
|
|
86
|
+
},
|
|
87
|
+
{
|
|
88
|
+
"indexed": true,
|
|
89
|
+
"internalType": "address",
|
|
90
|
+
"name": "newOwner",
|
|
91
|
+
"type": "address"
|
|
92
|
+
}
|
|
93
|
+
],
|
|
94
|
+
"name": "OwnershipTransferred",
|
|
95
|
+
"type": "event"
|
|
96
|
+
},
|
|
97
|
+
{
|
|
98
|
+
"anonymous": false,
|
|
99
|
+
"inputs": [
|
|
100
|
+
{
|
|
101
|
+
"indexed": false,
|
|
102
|
+
"internalType": "address",
|
|
103
|
+
"name": "account",
|
|
104
|
+
"type": "address"
|
|
105
|
+
}
|
|
106
|
+
],
|
|
107
|
+
"name": "Paused",
|
|
108
|
+
"type": "event"
|
|
109
|
+
},
|
|
110
|
+
{
|
|
111
|
+
"anonymous": false,
|
|
112
|
+
"inputs": [
|
|
113
|
+
{
|
|
114
|
+
"indexed": false,
|
|
115
|
+
"internalType": "uint256",
|
|
116
|
+
"name": "_start",
|
|
117
|
+
"type": "uint256"
|
|
118
|
+
},
|
|
119
|
+
{
|
|
120
|
+
"indexed": false,
|
|
121
|
+
"internalType": "uint256",
|
|
122
|
+
"name": "_end",
|
|
123
|
+
"type": "uint256"
|
|
124
|
+
},
|
|
125
|
+
{
|
|
126
|
+
"indexed": false,
|
|
127
|
+
"internalType": "uint256",
|
|
128
|
+
"name": "timestamp",
|
|
129
|
+
"type": "uint256"
|
|
130
|
+
}
|
|
131
|
+
],
|
|
132
|
+
"name": "SaleTimeSet",
|
|
133
|
+
"type": "event"
|
|
134
|
+
},
|
|
135
|
+
{
|
|
136
|
+
"anonymous": false,
|
|
137
|
+
"inputs": [
|
|
138
|
+
{
|
|
139
|
+
"indexed": true,
|
|
140
|
+
"internalType": "bytes32",
|
|
141
|
+
"name": "key",
|
|
142
|
+
"type": "bytes32"
|
|
143
|
+
},
|
|
144
|
+
{
|
|
145
|
+
"indexed": false,
|
|
146
|
+
"internalType": "uint256",
|
|
147
|
+
"name": "prevValue",
|
|
148
|
+
"type": "uint256"
|
|
149
|
+
},
|
|
150
|
+
{
|
|
151
|
+
"indexed": false,
|
|
152
|
+
"internalType": "uint256",
|
|
153
|
+
"name": "newValue",
|
|
154
|
+
"type": "uint256"
|
|
155
|
+
},
|
|
156
|
+
{
|
|
157
|
+
"indexed": false,
|
|
158
|
+
"internalType": "uint256",
|
|
159
|
+
"name": "timestamp",
|
|
160
|
+
"type": "uint256"
|
|
161
|
+
}
|
|
162
|
+
],
|
|
163
|
+
"name": "SaleTimeUpdated",
|
|
164
|
+
"type": "event"
|
|
165
|
+
},
|
|
166
|
+
{
|
|
167
|
+
"anonymous": false,
|
|
168
|
+
"inputs": [
|
|
169
|
+
{
|
|
170
|
+
"indexed": true,
|
|
171
|
+
"internalType": "address",
|
|
172
|
+
"name": "token",
|
|
173
|
+
"type": "address"
|
|
174
|
+
},
|
|
175
|
+
{
|
|
176
|
+
"indexed": false,
|
|
177
|
+
"internalType": "uint256",
|
|
178
|
+
"name": "noOfTokens",
|
|
179
|
+
"type": "uint256"
|
|
180
|
+
},
|
|
181
|
+
{
|
|
182
|
+
"indexed": false,
|
|
183
|
+
"internalType": "uint256",
|
|
184
|
+
"name": "timestamp",
|
|
185
|
+
"type": "uint256"
|
|
186
|
+
}
|
|
187
|
+
],
|
|
188
|
+
"name": "TokensAdded",
|
|
189
|
+
"type": "event"
|
|
190
|
+
},
|
|
191
|
+
{
|
|
192
|
+
"anonymous": false,
|
|
193
|
+
"inputs": [
|
|
194
|
+
{
|
|
195
|
+
"indexed": true,
|
|
196
|
+
"internalType": "address",
|
|
197
|
+
"name": "user",
|
|
198
|
+
"type": "address"
|
|
199
|
+
},
|
|
200
|
+
{
|
|
201
|
+
"indexed": true,
|
|
202
|
+
"internalType": "uint256",
|
|
203
|
+
"name": "tokensBought",
|
|
204
|
+
"type": "uint256"
|
|
205
|
+
},
|
|
206
|
+
{
|
|
207
|
+
"indexed": true,
|
|
208
|
+
"internalType": "address",
|
|
209
|
+
"name": "purchaseToken",
|
|
210
|
+
"type": "address"
|
|
211
|
+
},
|
|
212
|
+
{
|
|
213
|
+
"indexed": false,
|
|
214
|
+
"internalType": "uint256",
|
|
215
|
+
"name": "amountPaid",
|
|
216
|
+
"type": "uint256"
|
|
217
|
+
},
|
|
218
|
+
{
|
|
219
|
+
"indexed": false,
|
|
220
|
+
"internalType": "uint256",
|
|
221
|
+
"name": "usdEq",
|
|
222
|
+
"type": "uint256"
|
|
223
|
+
},
|
|
224
|
+
{
|
|
225
|
+
"indexed": false,
|
|
226
|
+
"internalType": "uint256",
|
|
227
|
+
"name": "timestamp",
|
|
228
|
+
"type": "uint256"
|
|
229
|
+
}
|
|
230
|
+
],
|
|
231
|
+
"name": "TokensBought",
|
|
232
|
+
"type": "event"
|
|
233
|
+
},
|
|
234
|
+
{
|
|
235
|
+
"anonymous": false,
|
|
236
|
+
"inputs": [
|
|
237
|
+
{
|
|
238
|
+
"indexed": true,
|
|
239
|
+
"internalType": "address",
|
|
240
|
+
"name": "user",
|
|
241
|
+
"type": "address"
|
|
242
|
+
},
|
|
243
|
+
{
|
|
244
|
+
"indexed": true,
|
|
245
|
+
"internalType": "uint256",
|
|
246
|
+
"name": "tokensBought",
|
|
247
|
+
"type": "uint256"
|
|
248
|
+
},
|
|
249
|
+
{
|
|
250
|
+
"indexed": true,
|
|
251
|
+
"internalType": "address",
|
|
252
|
+
"name": "purchaseToken",
|
|
253
|
+
"type": "address"
|
|
254
|
+
},
|
|
255
|
+
{
|
|
256
|
+
"indexed": false,
|
|
257
|
+
"internalType": "uint256",
|
|
258
|
+
"name": "amountPaid",
|
|
259
|
+
"type": "uint256"
|
|
260
|
+
},
|
|
261
|
+
{
|
|
262
|
+
"indexed": false,
|
|
263
|
+
"internalType": "uint256",
|
|
264
|
+
"name": "usdEq",
|
|
265
|
+
"type": "uint256"
|
|
266
|
+
},
|
|
267
|
+
{
|
|
268
|
+
"indexed": false,
|
|
269
|
+
"internalType": "uint256",
|
|
270
|
+
"name": "timestamp",
|
|
271
|
+
"type": "uint256"
|
|
272
|
+
}
|
|
273
|
+
],
|
|
274
|
+
"name": "TokensBoughtAndStaked",
|
|
275
|
+
"type": "event"
|
|
276
|
+
},
|
|
277
|
+
{
|
|
278
|
+
"anonymous": false,
|
|
279
|
+
"inputs": [
|
|
280
|
+
{
|
|
281
|
+
"indexed": true,
|
|
282
|
+
"internalType": "address",
|
|
283
|
+
"name": "user",
|
|
284
|
+
"type": "address"
|
|
285
|
+
},
|
|
286
|
+
{
|
|
287
|
+
"indexed": false,
|
|
288
|
+
"internalType": "uint256",
|
|
289
|
+
"name": "amount",
|
|
290
|
+
"type": "uint256"
|
|
291
|
+
},
|
|
292
|
+
{
|
|
293
|
+
"indexed": false,
|
|
294
|
+
"internalType": "uint256",
|
|
295
|
+
"name": "timestamp",
|
|
296
|
+
"type": "uint256"
|
|
297
|
+
}
|
|
298
|
+
],
|
|
299
|
+
"name": "TokensClaimed",
|
|
300
|
+
"type": "event"
|
|
301
|
+
},
|
|
302
|
+
{
|
|
303
|
+
"anonymous": false,
|
|
304
|
+
"inputs": [
|
|
305
|
+
{
|
|
306
|
+
"indexed": true,
|
|
307
|
+
"internalType": "address",
|
|
308
|
+
"name": "user",
|
|
309
|
+
"type": "address"
|
|
310
|
+
},
|
|
311
|
+
{
|
|
312
|
+
"indexed": false,
|
|
313
|
+
"internalType": "uint256",
|
|
314
|
+
"name": "amount",
|
|
315
|
+
"type": "uint256"
|
|
316
|
+
},
|
|
317
|
+
{
|
|
318
|
+
"indexed": false,
|
|
319
|
+
"internalType": "uint256",
|
|
320
|
+
"name": "timestamp",
|
|
321
|
+
"type": "uint256"
|
|
322
|
+
}
|
|
323
|
+
],
|
|
324
|
+
"name": "TokensClaimedAndStaked",
|
|
325
|
+
"type": "event"
|
|
326
|
+
},
|
|
327
|
+
{
|
|
328
|
+
"anonymous": false,
|
|
329
|
+
"inputs": [
|
|
330
|
+
{
|
|
331
|
+
"indexed": false,
|
|
332
|
+
"internalType": "address",
|
|
333
|
+
"name": "account",
|
|
334
|
+
"type": "address"
|
|
335
|
+
}
|
|
336
|
+
],
|
|
337
|
+
"name": "Unpaused",
|
|
338
|
+
"type": "event"
|
|
339
|
+
},
|
|
340
|
+
{
|
|
341
|
+
"inputs": [],
|
|
342
|
+
"name": "USDCInterface",
|
|
343
|
+
"outputs": [
|
|
344
|
+
{
|
|
345
|
+
"internalType": "contract IERC20Upgradeable",
|
|
346
|
+
"name": "",
|
|
347
|
+
"type": "address"
|
|
348
|
+
}
|
|
349
|
+
],
|
|
350
|
+
"stateMutability": "view",
|
|
351
|
+
"type": "function"
|
|
352
|
+
},
|
|
353
|
+
{
|
|
354
|
+
"inputs": [],
|
|
355
|
+
"name": "USDTInterface",
|
|
356
|
+
"outputs": [
|
|
357
|
+
{
|
|
358
|
+
"internalType": "contract IERC20Upgradeable",
|
|
359
|
+
"name": "",
|
|
360
|
+
"type": "address"
|
|
361
|
+
}
|
|
362
|
+
],
|
|
363
|
+
"stateMutability": "view",
|
|
364
|
+
"type": "function"
|
|
365
|
+
},
|
|
366
|
+
{
|
|
367
|
+
"inputs": [],
|
|
368
|
+
"name": "admin",
|
|
369
|
+
"outputs": [
|
|
370
|
+
{
|
|
371
|
+
"internalType": "address",
|
|
372
|
+
"name": "",
|
|
373
|
+
"type": "address"
|
|
374
|
+
}
|
|
375
|
+
],
|
|
376
|
+
"stateMutability": "view",
|
|
377
|
+
"type": "function"
|
|
378
|
+
},
|
|
379
|
+
{
|
|
380
|
+
"inputs": [],
|
|
381
|
+
"name": "aggregatorInterface",
|
|
382
|
+
"outputs": [
|
|
383
|
+
{
|
|
384
|
+
"internalType": "contract Aggregator",
|
|
385
|
+
"name": "",
|
|
386
|
+
"type": "address"
|
|
387
|
+
}
|
|
388
|
+
],
|
|
389
|
+
"stateMutability": "view",
|
|
390
|
+
"type": "function"
|
|
391
|
+
},
|
|
392
|
+
{
|
|
393
|
+
"inputs": [],
|
|
394
|
+
"name": "baseDecimals",
|
|
395
|
+
"outputs": [
|
|
396
|
+
{
|
|
397
|
+
"internalType": "uint256",
|
|
398
|
+
"name": "",
|
|
399
|
+
"type": "uint256"
|
|
400
|
+
}
|
|
401
|
+
],
|
|
402
|
+
"stateMutability": "view",
|
|
403
|
+
"type": "function"
|
|
404
|
+
},
|
|
405
|
+
{
|
|
406
|
+
"inputs": [
|
|
407
|
+
{
|
|
408
|
+
"internalType": "address[]",
|
|
409
|
+
"name": "_usersToBlacklist",
|
|
410
|
+
"type": "address[]"
|
|
411
|
+
}
|
|
412
|
+
],
|
|
413
|
+
"name": "blacklistUsers",
|
|
414
|
+
"outputs": [],
|
|
415
|
+
"stateMutability": "nonpayable",
|
|
416
|
+
"type": "function"
|
|
417
|
+
},
|
|
418
|
+
{
|
|
419
|
+
"inputs": [
|
|
420
|
+
{
|
|
421
|
+
"internalType": "address",
|
|
422
|
+
"name": "_user",
|
|
423
|
+
"type": "address"
|
|
424
|
+
},
|
|
425
|
+
{
|
|
426
|
+
"internalType": "uint256",
|
|
427
|
+
"name": "_amount",
|
|
428
|
+
"type": "uint256"
|
|
429
|
+
},
|
|
430
|
+
{
|
|
431
|
+
"internalType": "bool",
|
|
432
|
+
"name": "stake",
|
|
433
|
+
"type": "bool"
|
|
434
|
+
}
|
|
435
|
+
],
|
|
436
|
+
"name": "buyWithETHWert",
|
|
437
|
+
"outputs": [
|
|
438
|
+
{
|
|
439
|
+
"internalType": "bool",
|
|
440
|
+
"name": "",
|
|
441
|
+
"type": "bool"
|
|
442
|
+
}
|
|
443
|
+
],
|
|
444
|
+
"stateMutability": "payable",
|
|
445
|
+
"type": "function"
|
|
446
|
+
},
|
|
447
|
+
{
|
|
448
|
+
"inputs": [
|
|
449
|
+
{
|
|
450
|
+
"internalType": "uint256",
|
|
451
|
+
"name": "amount",
|
|
452
|
+
"type": "uint256"
|
|
453
|
+
},
|
|
454
|
+
{
|
|
455
|
+
"internalType": "bool",
|
|
456
|
+
"name": "stake",
|
|
457
|
+
"type": "bool"
|
|
458
|
+
}
|
|
459
|
+
],
|
|
460
|
+
"name": "buyWithEth",
|
|
461
|
+
"outputs": [
|
|
462
|
+
{
|
|
463
|
+
"internalType": "bool",
|
|
464
|
+
"name": "",
|
|
465
|
+
"type": "bool"
|
|
466
|
+
}
|
|
467
|
+
],
|
|
468
|
+
"stateMutability": "payable",
|
|
469
|
+
"type": "function"
|
|
470
|
+
},
|
|
471
|
+
{
|
|
472
|
+
"inputs": [
|
|
473
|
+
{
|
|
474
|
+
"internalType": "uint256",
|
|
475
|
+
"name": "amount",
|
|
476
|
+
"type": "uint256"
|
|
477
|
+
},
|
|
478
|
+
{
|
|
479
|
+
"internalType": "bool",
|
|
480
|
+
"name": "stake",
|
|
481
|
+
"type": "bool"
|
|
482
|
+
}
|
|
483
|
+
],
|
|
484
|
+
"name": "buyWithUSDC",
|
|
485
|
+
"outputs": [
|
|
486
|
+
{
|
|
487
|
+
"internalType": "bool",
|
|
488
|
+
"name": "",
|
|
489
|
+
"type": "bool"
|
|
490
|
+
}
|
|
491
|
+
],
|
|
492
|
+
"stateMutability": "nonpayable",
|
|
493
|
+
"type": "function"
|
|
494
|
+
},
|
|
495
|
+
{
|
|
496
|
+
"inputs": [
|
|
497
|
+
{
|
|
498
|
+
"internalType": "uint256",
|
|
499
|
+
"name": "amount",
|
|
500
|
+
"type": "uint256"
|
|
501
|
+
},
|
|
502
|
+
{
|
|
503
|
+
"internalType": "bool",
|
|
504
|
+
"name": "stake",
|
|
505
|
+
"type": "bool"
|
|
506
|
+
}
|
|
507
|
+
],
|
|
508
|
+
"name": "buyWithUSDT",
|
|
509
|
+
"outputs": [
|
|
510
|
+
{
|
|
511
|
+
"internalType": "bool",
|
|
512
|
+
"name": "",
|
|
513
|
+
"type": "bool"
|
|
514
|
+
}
|
|
515
|
+
],
|
|
516
|
+
"stateMutability": "nonpayable",
|
|
517
|
+
"type": "function"
|
|
518
|
+
},
|
|
519
|
+
{
|
|
520
|
+
"inputs": [
|
|
521
|
+
{
|
|
522
|
+
"internalType": "uint256",
|
|
523
|
+
"name": "_amount",
|
|
524
|
+
"type": "uint256"
|
|
525
|
+
}
|
|
526
|
+
],
|
|
527
|
+
"name": "calculatePrice",
|
|
528
|
+
"outputs": [
|
|
529
|
+
{
|
|
530
|
+
"internalType": "uint256",
|
|
531
|
+
"name": "",
|
|
532
|
+
"type": "uint256"
|
|
533
|
+
}
|
|
534
|
+
],
|
|
535
|
+
"stateMutability": "view",
|
|
536
|
+
"type": "function"
|
|
537
|
+
},
|
|
538
|
+
{
|
|
539
|
+
"inputs": [
|
|
540
|
+
{
|
|
541
|
+
"internalType": "uint256",
|
|
542
|
+
"name": "_claimStart",
|
|
543
|
+
"type": "uint256"
|
|
544
|
+
}
|
|
545
|
+
],
|
|
546
|
+
"name": "changeClaimStart",
|
|
547
|
+
"outputs": [
|
|
548
|
+
{
|
|
549
|
+
"internalType": "bool",
|
|
550
|
+
"name": "",
|
|
551
|
+
"type": "bool"
|
|
552
|
+
}
|
|
553
|
+
],
|
|
554
|
+
"stateMutability": "nonpayable",
|
|
555
|
+
"type": "function"
|
|
556
|
+
},
|
|
557
|
+
{
|
|
558
|
+
"inputs": [
|
|
559
|
+
{
|
|
560
|
+
"internalType": "uint256",
|
|
561
|
+
"name": "_maxTokensToBuy",
|
|
562
|
+
"type": "uint256"
|
|
563
|
+
}
|
|
564
|
+
],
|
|
565
|
+
"name": "changeMaxTokensToBuy",
|
|
566
|
+
"outputs": [],
|
|
567
|
+
"stateMutability": "nonpayable",
|
|
568
|
+
"type": "function"
|
|
569
|
+
},
|
|
570
|
+
{
|
|
571
|
+
"inputs": [
|
|
572
|
+
{
|
|
573
|
+
"internalType": "address",
|
|
574
|
+
"name": "_newPaymentWallet",
|
|
575
|
+
"type": "address"
|
|
576
|
+
}
|
|
577
|
+
],
|
|
578
|
+
"name": "changePaymentWallet",
|
|
579
|
+
"outputs": [],
|
|
580
|
+
"stateMutability": "nonpayable",
|
|
581
|
+
"type": "function"
|
|
582
|
+
},
|
|
583
|
+
{
|
|
584
|
+
"inputs": [
|
|
585
|
+
{
|
|
586
|
+
"internalType": "uint256[][3]",
|
|
587
|
+
"name": "_rounds",
|
|
588
|
+
"type": "uint256[][3]"
|
|
589
|
+
}
|
|
590
|
+
],
|
|
591
|
+
"name": "changeRoundsData",
|
|
592
|
+
"outputs": [],
|
|
593
|
+
"stateMutability": "nonpayable",
|
|
594
|
+
"type": "function"
|
|
595
|
+
},
|
|
596
|
+
{
|
|
597
|
+
"inputs": [
|
|
598
|
+
{
|
|
599
|
+
"internalType": "uint256",
|
|
600
|
+
"name": "_startTime",
|
|
601
|
+
"type": "uint256"
|
|
602
|
+
},
|
|
603
|
+
{
|
|
604
|
+
"internalType": "uint256",
|
|
605
|
+
"name": "_endTime",
|
|
606
|
+
"type": "uint256"
|
|
607
|
+
}
|
|
608
|
+
],
|
|
609
|
+
"name": "changeSaleTimes",
|
|
610
|
+
"outputs": [],
|
|
611
|
+
"stateMutability": "nonpayable",
|
|
612
|
+
"type": "function"
|
|
613
|
+
},
|
|
614
|
+
{
|
|
615
|
+
"inputs": [],
|
|
616
|
+
"name": "checkPoint",
|
|
617
|
+
"outputs": [
|
|
618
|
+
{
|
|
619
|
+
"internalType": "uint256",
|
|
620
|
+
"name": "",
|
|
621
|
+
"type": "uint256"
|
|
622
|
+
}
|
|
623
|
+
],
|
|
624
|
+
"stateMutability": "view",
|
|
625
|
+
"type": "function"
|
|
626
|
+
},
|
|
627
|
+
{
|
|
628
|
+
"inputs": [],
|
|
629
|
+
"name": "claim",
|
|
630
|
+
"outputs": [
|
|
631
|
+
{
|
|
632
|
+
"internalType": "bool",
|
|
633
|
+
"name": "",
|
|
634
|
+
"type": "bool"
|
|
635
|
+
}
|
|
636
|
+
],
|
|
637
|
+
"stateMutability": "nonpayable",
|
|
638
|
+
"type": "function"
|
|
639
|
+
},
|
|
640
|
+
{
|
|
641
|
+
"inputs": [],
|
|
642
|
+
"name": "claimAndStake",
|
|
643
|
+
"outputs": [
|
|
644
|
+
{
|
|
645
|
+
"internalType": "bool",
|
|
646
|
+
"name": "",
|
|
647
|
+
"type": "bool"
|
|
648
|
+
}
|
|
649
|
+
],
|
|
650
|
+
"stateMutability": "nonpayable",
|
|
651
|
+
"type": "function"
|
|
652
|
+
},
|
|
653
|
+
{
|
|
654
|
+
"inputs": [],
|
|
655
|
+
"name": "claimStart",
|
|
656
|
+
"outputs": [
|
|
657
|
+
{
|
|
658
|
+
"internalType": "uint256",
|
|
659
|
+
"name": "",
|
|
660
|
+
"type": "uint256"
|
|
661
|
+
}
|
|
662
|
+
],
|
|
663
|
+
"stateMutability": "view",
|
|
664
|
+
"type": "function"
|
|
665
|
+
},
|
|
666
|
+
{
|
|
667
|
+
"inputs": [],
|
|
668
|
+
"name": "currentStep",
|
|
669
|
+
"outputs": [
|
|
670
|
+
{
|
|
671
|
+
"internalType": "uint256",
|
|
672
|
+
"name": "",
|
|
673
|
+
"type": "uint256"
|
|
674
|
+
}
|
|
675
|
+
],
|
|
676
|
+
"stateMutability": "view",
|
|
677
|
+
"type": "function"
|
|
678
|
+
},
|
|
679
|
+
{
|
|
680
|
+
"inputs": [],
|
|
681
|
+
"name": "dynamicTimeFlag",
|
|
682
|
+
"outputs": [
|
|
683
|
+
{
|
|
684
|
+
"internalType": "bool",
|
|
685
|
+
"name": "",
|
|
686
|
+
"type": "bool"
|
|
687
|
+
}
|
|
688
|
+
],
|
|
689
|
+
"stateMutability": "view",
|
|
690
|
+
"type": "function"
|
|
691
|
+
},
|
|
692
|
+
{
|
|
693
|
+
"inputs": [],
|
|
694
|
+
"name": "endTime",
|
|
695
|
+
"outputs": [
|
|
696
|
+
{
|
|
697
|
+
"internalType": "uint256",
|
|
698
|
+
"name": "",
|
|
699
|
+
"type": "uint256"
|
|
700
|
+
}
|
|
701
|
+
],
|
|
702
|
+
"stateMutability": "view",
|
|
703
|
+
"type": "function"
|
|
704
|
+
},
|
|
705
|
+
{
|
|
706
|
+
"inputs": [
|
|
707
|
+
{
|
|
708
|
+
"internalType": "uint256",
|
|
709
|
+
"name": "amount",
|
|
710
|
+
"type": "uint256"
|
|
711
|
+
}
|
|
712
|
+
],
|
|
713
|
+
"name": "ethBuyHelper",
|
|
714
|
+
"outputs": [
|
|
715
|
+
{
|
|
716
|
+
"internalType": "uint256",
|
|
717
|
+
"name": "ethAmount",
|
|
718
|
+
"type": "uint256"
|
|
719
|
+
}
|
|
720
|
+
],
|
|
721
|
+
"stateMutability": "view",
|
|
722
|
+
"type": "function"
|
|
723
|
+
},
|
|
724
|
+
{
|
|
725
|
+
"inputs": [],
|
|
726
|
+
"name": "getLatestPrice",
|
|
727
|
+
"outputs": [
|
|
728
|
+
{
|
|
729
|
+
"internalType": "uint256",
|
|
730
|
+
"name": "",
|
|
731
|
+
"type": "uint256"
|
|
732
|
+
}
|
|
733
|
+
],
|
|
734
|
+
"stateMutability": "view",
|
|
735
|
+
"type": "function"
|
|
736
|
+
},
|
|
737
|
+
{
|
|
738
|
+
"inputs": [
|
|
739
|
+
{
|
|
740
|
+
"internalType": "address",
|
|
741
|
+
"name": "",
|
|
742
|
+
"type": "address"
|
|
743
|
+
}
|
|
744
|
+
],
|
|
745
|
+
"name": "hasClaimed",
|
|
746
|
+
"outputs": [
|
|
747
|
+
{
|
|
748
|
+
"internalType": "bool",
|
|
749
|
+
"name": "",
|
|
750
|
+
"type": "bool"
|
|
751
|
+
}
|
|
752
|
+
],
|
|
753
|
+
"stateMutability": "view",
|
|
754
|
+
"type": "function"
|
|
755
|
+
},
|
|
756
|
+
{
|
|
757
|
+
"inputs": [],
|
|
758
|
+
"name": "incrementCurrentStep",
|
|
759
|
+
"outputs": [],
|
|
760
|
+
"stateMutability": "nonpayable",
|
|
761
|
+
"type": "function"
|
|
762
|
+
},
|
|
763
|
+
{
|
|
764
|
+
"inputs": [
|
|
765
|
+
{
|
|
766
|
+
"internalType": "address",
|
|
767
|
+
"name": "",
|
|
768
|
+
"type": "address"
|
|
769
|
+
}
|
|
770
|
+
],
|
|
771
|
+
"name": "isBlacklisted",
|
|
772
|
+
"outputs": [
|
|
773
|
+
{
|
|
774
|
+
"internalType": "bool",
|
|
775
|
+
"name": "",
|
|
776
|
+
"type": "bool"
|
|
777
|
+
}
|
|
778
|
+
],
|
|
779
|
+
"stateMutability": "view",
|
|
780
|
+
"type": "function"
|
|
781
|
+
},
|
|
782
|
+
{
|
|
783
|
+
"inputs": [
|
|
784
|
+
{
|
|
785
|
+
"internalType": "address",
|
|
786
|
+
"name": "",
|
|
787
|
+
"type": "address"
|
|
788
|
+
}
|
|
789
|
+
],
|
|
790
|
+
"name": "isWhitelisted",
|
|
791
|
+
"outputs": [
|
|
792
|
+
{
|
|
793
|
+
"internalType": "bool",
|
|
794
|
+
"name": "",
|
|
795
|
+
"type": "bool"
|
|
796
|
+
}
|
|
797
|
+
],
|
|
798
|
+
"stateMutability": "view",
|
|
799
|
+
"type": "function"
|
|
800
|
+
},
|
|
801
|
+
{
|
|
802
|
+
"inputs": [],
|
|
803
|
+
"name": "maxTokensToBuy",
|
|
804
|
+
"outputs": [
|
|
805
|
+
{
|
|
806
|
+
"internalType": "uint256",
|
|
807
|
+
"name": "",
|
|
808
|
+
"type": "uint256"
|
|
809
|
+
}
|
|
810
|
+
],
|
|
811
|
+
"stateMutability": "view",
|
|
812
|
+
"type": "function"
|
|
813
|
+
},
|
|
814
|
+
{
|
|
815
|
+
"inputs": [],
|
|
816
|
+
"name": "owner",
|
|
817
|
+
"outputs": [
|
|
818
|
+
{
|
|
819
|
+
"internalType": "address",
|
|
820
|
+
"name": "",
|
|
821
|
+
"type": "address"
|
|
822
|
+
}
|
|
823
|
+
],
|
|
824
|
+
"stateMutability": "view",
|
|
825
|
+
"type": "function"
|
|
826
|
+
},
|
|
827
|
+
{
|
|
828
|
+
"inputs": [],
|
|
829
|
+
"name": "pause",
|
|
830
|
+
"outputs": [],
|
|
831
|
+
"stateMutability": "nonpayable",
|
|
832
|
+
"type": "function"
|
|
833
|
+
},
|
|
834
|
+
{
|
|
835
|
+
"inputs": [],
|
|
836
|
+
"name": "paused",
|
|
837
|
+
"outputs": [
|
|
838
|
+
{
|
|
839
|
+
"internalType": "bool",
|
|
840
|
+
"name": "",
|
|
841
|
+
"type": "bool"
|
|
842
|
+
}
|
|
843
|
+
],
|
|
844
|
+
"stateMutability": "view",
|
|
845
|
+
"type": "function"
|
|
846
|
+
},
|
|
847
|
+
{
|
|
848
|
+
"inputs": [],
|
|
849
|
+
"name": "paymentWallet",
|
|
850
|
+
"outputs": [
|
|
851
|
+
{
|
|
852
|
+
"internalType": "address",
|
|
853
|
+
"name": "",
|
|
854
|
+
"type": "address"
|
|
855
|
+
}
|
|
856
|
+
],
|
|
857
|
+
"stateMutability": "view",
|
|
858
|
+
"type": "function"
|
|
859
|
+
},
|
|
860
|
+
{
|
|
861
|
+
"inputs": [
|
|
862
|
+
{
|
|
863
|
+
"internalType": "uint256",
|
|
864
|
+
"name": "",
|
|
865
|
+
"type": "uint256"
|
|
866
|
+
}
|
|
867
|
+
],
|
|
868
|
+
"name": "percentages",
|
|
869
|
+
"outputs": [
|
|
870
|
+
{
|
|
871
|
+
"internalType": "uint256",
|
|
872
|
+
"name": "",
|
|
873
|
+
"type": "uint256"
|
|
874
|
+
}
|
|
875
|
+
],
|
|
876
|
+
"stateMutability": "view",
|
|
877
|
+
"type": "function"
|
|
878
|
+
},
|
|
879
|
+
{
|
|
880
|
+
"inputs": [
|
|
881
|
+
{
|
|
882
|
+
"internalType": "uint256",
|
|
883
|
+
"name": "",
|
|
884
|
+
"type": "uint256"
|
|
885
|
+
}
|
|
886
|
+
],
|
|
887
|
+
"name": "prevCheckpoints",
|
|
888
|
+
"outputs": [
|
|
889
|
+
{
|
|
890
|
+
"internalType": "uint256",
|
|
891
|
+
"name": "",
|
|
892
|
+
"type": "uint256"
|
|
893
|
+
}
|
|
894
|
+
],
|
|
895
|
+
"stateMutability": "view",
|
|
896
|
+
"type": "function"
|
|
897
|
+
},
|
|
898
|
+
{
|
|
899
|
+
"inputs": [
|
|
900
|
+
{
|
|
901
|
+
"internalType": "uint256",
|
|
902
|
+
"name": "",
|
|
903
|
+
"type": "uint256"
|
|
904
|
+
}
|
|
905
|
+
],
|
|
906
|
+
"name": "remainingTokensTracker",
|
|
907
|
+
"outputs": [
|
|
908
|
+
{
|
|
909
|
+
"internalType": "uint256",
|
|
910
|
+
"name": "",
|
|
911
|
+
"type": "uint256"
|
|
912
|
+
}
|
|
913
|
+
],
|
|
914
|
+
"stateMutability": "view",
|
|
915
|
+
"type": "function"
|
|
916
|
+
},
|
|
917
|
+
{
|
|
918
|
+
"inputs": [
|
|
919
|
+
{
|
|
920
|
+
"internalType": "address[]",
|
|
921
|
+
"name": "_userToRemoveFromBlacklist",
|
|
922
|
+
"type": "address[]"
|
|
923
|
+
}
|
|
924
|
+
],
|
|
925
|
+
"name": "removeFromBlacklist",
|
|
926
|
+
"outputs": [],
|
|
927
|
+
"stateMutability": "nonpayable",
|
|
928
|
+
"type": "function"
|
|
929
|
+
},
|
|
930
|
+
{
|
|
931
|
+
"inputs": [
|
|
932
|
+
{
|
|
933
|
+
"internalType": "address[]",
|
|
934
|
+
"name": "_userToRemoveFromWhitelist",
|
|
935
|
+
"type": "address[]"
|
|
936
|
+
}
|
|
937
|
+
],
|
|
938
|
+
"name": "removeFromWhitelist",
|
|
939
|
+
"outputs": [],
|
|
940
|
+
"stateMutability": "nonpayable",
|
|
941
|
+
"type": "function"
|
|
942
|
+
},
|
|
943
|
+
{
|
|
944
|
+
"inputs": [
|
|
945
|
+
{
|
|
946
|
+
"internalType": "address[]",
|
|
947
|
+
"name": "_addressesToRemoveFromWhitelist",
|
|
948
|
+
"type": "address[]"
|
|
949
|
+
}
|
|
950
|
+
],
|
|
951
|
+
"name": "removeFromWhitelistForWERT",
|
|
952
|
+
"outputs": [],
|
|
953
|
+
"stateMutability": "nonpayable",
|
|
954
|
+
"type": "function"
|
|
955
|
+
},
|
|
956
|
+
{
|
|
957
|
+
"inputs": [],
|
|
958
|
+
"name": "renounceOwnership",
|
|
959
|
+
"outputs": [],
|
|
960
|
+
"stateMutability": "nonpayable",
|
|
961
|
+
"type": "function"
|
|
962
|
+
},
|
|
963
|
+
{
|
|
964
|
+
"inputs": [
|
|
965
|
+
{
|
|
966
|
+
"internalType": "uint256",
|
|
967
|
+
"name": "_no",
|
|
968
|
+
"type": "uint256"
|
|
969
|
+
}
|
|
970
|
+
],
|
|
971
|
+
"name": "roundDetails",
|
|
972
|
+
"outputs": [
|
|
973
|
+
{
|
|
974
|
+
"internalType": "uint256[]",
|
|
975
|
+
"name": "",
|
|
976
|
+
"type": "uint256[]"
|
|
977
|
+
}
|
|
978
|
+
],
|
|
979
|
+
"stateMutability": "view",
|
|
980
|
+
"type": "function"
|
|
981
|
+
},
|
|
982
|
+
{
|
|
983
|
+
"inputs": [
|
|
984
|
+
{
|
|
985
|
+
"internalType": "uint256",
|
|
986
|
+
"name": "",
|
|
987
|
+
"type": "uint256"
|
|
988
|
+
},
|
|
989
|
+
{
|
|
990
|
+
"internalType": "uint256",
|
|
991
|
+
"name": "",
|
|
992
|
+
"type": "uint256"
|
|
993
|
+
}
|
|
994
|
+
],
|
|
995
|
+
"name": "rounds",
|
|
996
|
+
"outputs": [
|
|
997
|
+
{
|
|
998
|
+
"internalType": "uint256",
|
|
999
|
+
"name": "",
|
|
1000
|
+
"type": "uint256"
|
|
1001
|
+
}
|
|
1002
|
+
],
|
|
1003
|
+
"stateMutability": "view",
|
|
1004
|
+
"type": "function"
|
|
1005
|
+
},
|
|
1006
|
+
{
|
|
1007
|
+
"inputs": [],
|
|
1008
|
+
"name": "saleToken",
|
|
1009
|
+
"outputs": [
|
|
1010
|
+
{
|
|
1011
|
+
"internalType": "address",
|
|
1012
|
+
"name": "",
|
|
1013
|
+
"type": "address"
|
|
1014
|
+
}
|
|
1015
|
+
],
|
|
1016
|
+
"stateMutability": "view",
|
|
1017
|
+
"type": "function"
|
|
1018
|
+
},
|
|
1019
|
+
{
|
|
1020
|
+
"inputs": [
|
|
1021
|
+
{
|
|
1022
|
+
"internalType": "address",
|
|
1023
|
+
"name": "_admin",
|
|
1024
|
+
"type": "address"
|
|
1025
|
+
}
|
|
1026
|
+
],
|
|
1027
|
+
"name": "setAdmin",
|
|
1028
|
+
"outputs": [],
|
|
1029
|
+
"stateMutability": "nonpayable",
|
|
1030
|
+
"type": "function"
|
|
1031
|
+
},
|
|
1032
|
+
{
|
|
1033
|
+
"inputs": [
|
|
1034
|
+
{
|
|
1035
|
+
"internalType": "bool",
|
|
1036
|
+
"name": "_status",
|
|
1037
|
+
"type": "bool"
|
|
1038
|
+
}
|
|
1039
|
+
],
|
|
1040
|
+
"name": "setClaimWhitelistStatus",
|
|
1041
|
+
"outputs": [],
|
|
1042
|
+
"stateMutability": "nonpayable",
|
|
1043
|
+
"type": "function"
|
|
1044
|
+
},
|
|
1045
|
+
{
|
|
1046
|
+
"inputs": [
|
|
1047
|
+
{
|
|
1048
|
+
"internalType": "uint256",
|
|
1049
|
+
"name": "_step",
|
|
1050
|
+
"type": "uint256"
|
|
1051
|
+
},
|
|
1052
|
+
{
|
|
1053
|
+
"internalType": "uint256",
|
|
1054
|
+
"name": "_checkpoint",
|
|
1055
|
+
"type": "uint256"
|
|
1056
|
+
}
|
|
1057
|
+
],
|
|
1058
|
+
"name": "setCurrentStep",
|
|
1059
|
+
"outputs": [],
|
|
1060
|
+
"stateMutability": "nonpayable",
|
|
1061
|
+
"type": "function"
|
|
1062
|
+
},
|
|
1063
|
+
{
|
|
1064
|
+
"inputs": [
|
|
1065
|
+
{
|
|
1066
|
+
"internalType": "bool",
|
|
1067
|
+
"name": "_dynamicTimeFlag",
|
|
1068
|
+
"type": "bool"
|
|
1069
|
+
}
|
|
1070
|
+
],
|
|
1071
|
+
"name": "setDynamicTimeFlag",
|
|
1072
|
+
"outputs": [],
|
|
1073
|
+
"stateMutability": "nonpayable",
|
|
1074
|
+
"type": "function"
|
|
1075
|
+
},
|
|
1076
|
+
{
|
|
1077
|
+
"inputs": [
|
|
1078
|
+
{
|
|
1079
|
+
"internalType": "uint256[]",
|
|
1080
|
+
"name": "_unsoldTokens",
|
|
1081
|
+
"type": "uint256[]"
|
|
1082
|
+
}
|
|
1083
|
+
],
|
|
1084
|
+
"name": "setRemainingTokensArray",
|
|
1085
|
+
"outputs": [],
|
|
1086
|
+
"stateMutability": "nonpayable",
|
|
1087
|
+
"type": "function"
|
|
1088
|
+
},
|
|
1089
|
+
{
|
|
1090
|
+
"inputs": [
|
|
1091
|
+
{
|
|
1092
|
+
"internalType": "address[]",
|
|
1093
|
+
"name": "_wallets",
|
|
1094
|
+
"type": "address[]"
|
|
1095
|
+
},
|
|
1096
|
+
{
|
|
1097
|
+
"internalType": "uint256[]",
|
|
1098
|
+
"name": "_percentages",
|
|
1099
|
+
"type": "uint256[]"
|
|
1100
|
+
}
|
|
1101
|
+
],
|
|
1102
|
+
"name": "setSplits",
|
|
1103
|
+
"outputs": [],
|
|
1104
|
+
"stateMutability": "nonpayable",
|
|
1105
|
+
"type": "function"
|
|
1106
|
+
},
|
|
1107
|
+
{
|
|
1108
|
+
"inputs": [
|
|
1109
|
+
{
|
|
1110
|
+
"internalType": "bool",
|
|
1111
|
+
"name": "_status",
|
|
1112
|
+
"type": "bool"
|
|
1113
|
+
}
|
|
1114
|
+
],
|
|
1115
|
+
"name": "setStakeingWhitelistStatus",
|
|
1116
|
+
"outputs": [],
|
|
1117
|
+
"stateMutability": "nonpayable",
|
|
1118
|
+
"type": "function"
|
|
1119
|
+
},
|
|
1120
|
+
{
|
|
1121
|
+
"inputs": [
|
|
1122
|
+
{
|
|
1123
|
+
"internalType": "address",
|
|
1124
|
+
"name": "_stakingManagerAddress",
|
|
1125
|
+
"type": "address"
|
|
1126
|
+
}
|
|
1127
|
+
],
|
|
1128
|
+
"name": "setStakingManager",
|
|
1129
|
+
"outputs": [],
|
|
1130
|
+
"stateMutability": "nonpayable",
|
|
1131
|
+
"type": "function"
|
|
1132
|
+
},
|
|
1133
|
+
{
|
|
1134
|
+
"inputs": [
|
|
1135
|
+
{
|
|
1136
|
+
"internalType": "uint256",
|
|
1137
|
+
"name": "_timeConstant",
|
|
1138
|
+
"type": "uint256"
|
|
1139
|
+
}
|
|
1140
|
+
],
|
|
1141
|
+
"name": "setTimeConstant",
|
|
1142
|
+
"outputs": [],
|
|
1143
|
+
"stateMutability": "nonpayable",
|
|
1144
|
+
"type": "function"
|
|
1145
|
+
},
|
|
1146
|
+
{
|
|
1147
|
+
"inputs": [
|
|
1148
|
+
{
|
|
1149
|
+
"internalType": "address",
|
|
1150
|
+
"name": "_usdc",
|
|
1151
|
+
"type": "address"
|
|
1152
|
+
}
|
|
1153
|
+
],
|
|
1154
|
+
"name": "setUSDCInterface",
|
|
1155
|
+
"outputs": [],
|
|
1156
|
+
"stateMutability": "nonpayable",
|
|
1157
|
+
"type": "function"
|
|
1158
|
+
},
|
|
1159
|
+
{
|
|
1160
|
+
"inputs": [],
|
|
1161
|
+
"name": "stakeingWhitelistStatus",
|
|
1162
|
+
"outputs": [
|
|
1163
|
+
{
|
|
1164
|
+
"internalType": "bool",
|
|
1165
|
+
"name": "",
|
|
1166
|
+
"type": "bool"
|
|
1167
|
+
}
|
|
1168
|
+
],
|
|
1169
|
+
"stateMutability": "view",
|
|
1170
|
+
"type": "function"
|
|
1171
|
+
},
|
|
1172
|
+
{
|
|
1173
|
+
"inputs": [],
|
|
1174
|
+
"name": "stakingManagerInterface",
|
|
1175
|
+
"outputs": [
|
|
1176
|
+
{
|
|
1177
|
+
"internalType": "contract StakingManager",
|
|
1178
|
+
"name": "",
|
|
1179
|
+
"type": "address"
|
|
1180
|
+
}
|
|
1181
|
+
],
|
|
1182
|
+
"stateMutability": "view",
|
|
1183
|
+
"type": "function"
|
|
1184
|
+
},
|
|
1185
|
+
{
|
|
1186
|
+
"inputs": [
|
|
1187
|
+
{
|
|
1188
|
+
"internalType": "uint256",
|
|
1189
|
+
"name": "_claimStart",
|
|
1190
|
+
"type": "uint256"
|
|
1191
|
+
},
|
|
1192
|
+
{
|
|
1193
|
+
"internalType": "uint256",
|
|
1194
|
+
"name": "noOfTokens",
|
|
1195
|
+
"type": "uint256"
|
|
1196
|
+
},
|
|
1197
|
+
{
|
|
1198
|
+
"internalType": "address",
|
|
1199
|
+
"name": "_saleToken",
|
|
1200
|
+
"type": "address"
|
|
1201
|
+
},
|
|
1202
|
+
{
|
|
1203
|
+
"internalType": "address",
|
|
1204
|
+
"name": "_stakingManagerAddress",
|
|
1205
|
+
"type": "address"
|
|
1206
|
+
}
|
|
1207
|
+
],
|
|
1208
|
+
"name": "startClaim",
|
|
1209
|
+
"outputs": [
|
|
1210
|
+
{
|
|
1211
|
+
"internalType": "bool",
|
|
1212
|
+
"name": "",
|
|
1213
|
+
"type": "bool"
|
|
1214
|
+
}
|
|
1215
|
+
],
|
|
1216
|
+
"stateMutability": "nonpayable",
|
|
1217
|
+
"type": "function"
|
|
1218
|
+
},
|
|
1219
|
+
{
|
|
1220
|
+
"inputs": [],
|
|
1221
|
+
"name": "startTime",
|
|
1222
|
+
"outputs": [
|
|
1223
|
+
{
|
|
1224
|
+
"internalType": "uint256",
|
|
1225
|
+
"name": "",
|
|
1226
|
+
"type": "uint256"
|
|
1227
|
+
}
|
|
1228
|
+
],
|
|
1229
|
+
"stateMutability": "view",
|
|
1230
|
+
"type": "function"
|
|
1231
|
+
},
|
|
1232
|
+
{
|
|
1233
|
+
"inputs": [],
|
|
1234
|
+
"name": "timeConstant",
|
|
1235
|
+
"outputs": [
|
|
1236
|
+
{
|
|
1237
|
+
"internalType": "uint256",
|
|
1238
|
+
"name": "",
|
|
1239
|
+
"type": "uint256"
|
|
1240
|
+
}
|
|
1241
|
+
],
|
|
1242
|
+
"stateMutability": "view",
|
|
1243
|
+
"type": "function"
|
|
1244
|
+
},
|
|
1245
|
+
{
|
|
1246
|
+
"inputs": [
|
|
1247
|
+
{
|
|
1248
|
+
"internalType": "uint256",
|
|
1249
|
+
"name": "amount",
|
|
1250
|
+
"type": "uint256"
|
|
1251
|
+
}
|
|
1252
|
+
],
|
|
1253
|
+
"name": "tokenTransfer",
|
|
1254
|
+
"outputs": [],
|
|
1255
|
+
"stateMutability": "nonpayable",
|
|
1256
|
+
"type": "function"
|
|
1257
|
+
},
|
|
1258
|
+
{
|
|
1259
|
+
"inputs": [],
|
|
1260
|
+
"name": "totalBoughtAndStaked",
|
|
1261
|
+
"outputs": [
|
|
1262
|
+
{
|
|
1263
|
+
"internalType": "uint256",
|
|
1264
|
+
"name": "",
|
|
1265
|
+
"type": "uint256"
|
|
1266
|
+
}
|
|
1267
|
+
],
|
|
1268
|
+
"stateMutability": "view",
|
|
1269
|
+
"type": "function"
|
|
1270
|
+
},
|
|
1271
|
+
{
|
|
1272
|
+
"inputs": [],
|
|
1273
|
+
"name": "totalTokensSold",
|
|
1274
|
+
"outputs": [
|
|
1275
|
+
{
|
|
1276
|
+
"internalType": "uint256",
|
|
1277
|
+
"name": "",
|
|
1278
|
+
"type": "uint256"
|
|
1279
|
+
}
|
|
1280
|
+
],
|
|
1281
|
+
"stateMutability": "view",
|
|
1282
|
+
"type": "function"
|
|
1283
|
+
},
|
|
1284
|
+
{
|
|
1285
|
+
"inputs": [],
|
|
1286
|
+
"name": "trackRemainingTokens",
|
|
1287
|
+
"outputs": [
|
|
1288
|
+
{
|
|
1289
|
+
"internalType": "uint256[]",
|
|
1290
|
+
"name": "",
|
|
1291
|
+
"type": "uint256[]"
|
|
1292
|
+
}
|
|
1293
|
+
],
|
|
1294
|
+
"stateMutability": "view",
|
|
1295
|
+
"type": "function"
|
|
1296
|
+
},
|
|
1297
|
+
{
|
|
1298
|
+
"inputs": [
|
|
1299
|
+
{
|
|
1300
|
+
"internalType": "address",
|
|
1301
|
+
"name": "newOwner",
|
|
1302
|
+
"type": "address"
|
|
1303
|
+
}
|
|
1304
|
+
],
|
|
1305
|
+
"name": "transferOwnership",
|
|
1306
|
+
"outputs": [],
|
|
1307
|
+
"stateMutability": "nonpayable",
|
|
1308
|
+
"type": "function"
|
|
1309
|
+
},
|
|
1310
|
+
{
|
|
1311
|
+
"inputs": [],
|
|
1312
|
+
"name": "unpause",
|
|
1313
|
+
"outputs": [],
|
|
1314
|
+
"stateMutability": "nonpayable",
|
|
1315
|
+
"type": "function"
|
|
1316
|
+
},
|
|
1317
|
+
{
|
|
1318
|
+
"inputs": [
|
|
1319
|
+
{
|
|
1320
|
+
"internalType": "address[]",
|
|
1321
|
+
"name": "_users",
|
|
1322
|
+
"type": "address[]"
|
|
1323
|
+
},
|
|
1324
|
+
{
|
|
1325
|
+
"internalType": "uint256[]",
|
|
1326
|
+
"name": "_userDeposits",
|
|
1327
|
+
"type": "uint256[]"
|
|
1328
|
+
}
|
|
1329
|
+
],
|
|
1330
|
+
"name": "updateFromBSC",
|
|
1331
|
+
"outputs": [],
|
|
1332
|
+
"stateMutability": "nonpayable",
|
|
1333
|
+
"type": "function"
|
|
1334
|
+
},
|
|
1335
|
+
{
|
|
1336
|
+
"inputs": [],
|
|
1337
|
+
"name": "usdRaised",
|
|
1338
|
+
"outputs": [
|
|
1339
|
+
{
|
|
1340
|
+
"internalType": "uint256",
|
|
1341
|
+
"name": "",
|
|
1342
|
+
"type": "uint256"
|
|
1343
|
+
}
|
|
1344
|
+
],
|
|
1345
|
+
"stateMutability": "view",
|
|
1346
|
+
"type": "function"
|
|
1347
|
+
},
|
|
1348
|
+
{
|
|
1349
|
+
"inputs": [
|
|
1350
|
+
{
|
|
1351
|
+
"internalType": "uint256",
|
|
1352
|
+
"name": "amount",
|
|
1353
|
+
"type": "uint256"
|
|
1354
|
+
}
|
|
1355
|
+
],
|
|
1356
|
+
"name": "usdtBuyHelper",
|
|
1357
|
+
"outputs": [
|
|
1358
|
+
{
|
|
1359
|
+
"internalType": "uint256",
|
|
1360
|
+
"name": "usdPrice",
|
|
1361
|
+
"type": "uint256"
|
|
1362
|
+
}
|
|
1363
|
+
],
|
|
1364
|
+
"stateMutability": "view",
|
|
1365
|
+
"type": "function"
|
|
1366
|
+
},
|
|
1367
|
+
{
|
|
1368
|
+
"inputs": [
|
|
1369
|
+
{
|
|
1370
|
+
"internalType": "address",
|
|
1371
|
+
"name": "",
|
|
1372
|
+
"type": "address"
|
|
1373
|
+
}
|
|
1374
|
+
],
|
|
1375
|
+
"name": "userDeposits",
|
|
1376
|
+
"outputs": [
|
|
1377
|
+
{
|
|
1378
|
+
"internalType": "uint256",
|
|
1379
|
+
"name": "",
|
|
1380
|
+
"type": "uint256"
|
|
1381
|
+
}
|
|
1382
|
+
],
|
|
1383
|
+
"stateMutability": "view",
|
|
1384
|
+
"type": "function"
|
|
1385
|
+
},
|
|
1386
|
+
{
|
|
1387
|
+
"inputs": [
|
|
1388
|
+
{
|
|
1389
|
+
"internalType": "uint256",
|
|
1390
|
+
"name": "",
|
|
1391
|
+
"type": "uint256"
|
|
1392
|
+
}
|
|
1393
|
+
],
|
|
1394
|
+
"name": "wallets",
|
|
1395
|
+
"outputs": [
|
|
1396
|
+
{
|
|
1397
|
+
"internalType": "address",
|
|
1398
|
+
"name": "",
|
|
1399
|
+
"type": "address"
|
|
1400
|
+
}
|
|
1401
|
+
],
|
|
1402
|
+
"stateMutability": "view",
|
|
1403
|
+
"type": "function"
|
|
1404
|
+
},
|
|
1405
|
+
{
|
|
1406
|
+
"inputs": [
|
|
1407
|
+
{
|
|
1408
|
+
"internalType": "address",
|
|
1409
|
+
"name": "",
|
|
1410
|
+
"type": "address"
|
|
1411
|
+
}
|
|
1412
|
+
],
|
|
1413
|
+
"name": "wertWhitelisted",
|
|
1414
|
+
"outputs": [
|
|
1415
|
+
{
|
|
1416
|
+
"internalType": "bool",
|
|
1417
|
+
"name": "",
|
|
1418
|
+
"type": "bool"
|
|
1419
|
+
}
|
|
1420
|
+
],
|
|
1421
|
+
"stateMutability": "view",
|
|
1422
|
+
"type": "function"
|
|
1423
|
+
},
|
|
1424
|
+
{
|
|
1425
|
+
"inputs": [],
|
|
1426
|
+
"name": "whitelistClaimOnly",
|
|
1427
|
+
"outputs": [
|
|
1428
|
+
{
|
|
1429
|
+
"internalType": "bool",
|
|
1430
|
+
"name": "",
|
|
1431
|
+
"type": "bool"
|
|
1432
|
+
}
|
|
1433
|
+
],
|
|
1434
|
+
"stateMutability": "view",
|
|
1435
|
+
"type": "function"
|
|
1436
|
+
},
|
|
1437
|
+
{
|
|
1438
|
+
"inputs": [
|
|
1439
|
+
{
|
|
1440
|
+
"internalType": "address[]",
|
|
1441
|
+
"name": "_usersToWhitelist",
|
|
1442
|
+
"type": "address[]"
|
|
1443
|
+
}
|
|
1444
|
+
],
|
|
1445
|
+
"name": "whitelistUsers",
|
|
1446
|
+
"outputs": [],
|
|
1447
|
+
"stateMutability": "nonpayable",
|
|
1448
|
+
"type": "function"
|
|
1449
|
+
},
|
|
1450
|
+
{
|
|
1451
|
+
"inputs": [
|
|
1452
|
+
{
|
|
1453
|
+
"internalType": "address[]",
|
|
1454
|
+
"name": "_addressesToWhitelist",
|
|
1455
|
+
"type": "address[]"
|
|
1456
|
+
}
|
|
1457
|
+
],
|
|
1458
|
+
"name": "whitelistUsersForWERT",
|
|
1459
|
+
"outputs": [],
|
|
1460
|
+
"stateMutability": "nonpayable",
|
|
1461
|
+
"type": "function"
|
|
1462
|
+
}
|
|
1463
|
+
] as const satisfies Abi;
|
|
1464
|
+
|
|
1465
|
+
/**
|
|
1466
|
+
* Type-safe ABI for PresaleV2_json
|
|
1467
|
+
*/
|
|
1468
|
+
export type PresaleV2_jsonAbi = typeof PresaleV2_jsonAbi;
|
|
1469
|
+
|
|
1470
|
+
/**
|
|
1471
|
+
* Contract instance type for PresaleV2_json
|
|
1472
|
+
*/
|
|
1473
|
+
// Use any for contract type to avoid complex viem type issues
|
|
1474
|
+
// The runtime behavior is type-safe through viem's ABI typing
|
|
1475
|
+
export type PresaleV2_jsonContract = any;
|
|
1476
|
+
|
|
1477
|
+
/**
|
|
1478
|
+
* PresaleV2_json Contract Class
|
|
1479
|
+
*
|
|
1480
|
+
* Provides a class-based API similar to TypeChain for interacting with the contract.
|
|
1481
|
+
*
|
|
1482
|
+
* @example
|
|
1483
|
+
* ```typescript
|
|
1484
|
+
* import { createPublicClient, createWalletClient, http } from 'viem';
|
|
1485
|
+
* import { mainnet } from 'viem/chains';
|
|
1486
|
+
* import { PresaleV2_json } from 'PresaleV2_json';
|
|
1487
|
+
*
|
|
1488
|
+
* const publicClient = createPublicClient({ chain: mainnet, transport: http() });
|
|
1489
|
+
* const walletClient = createWalletClient({ chain: mainnet, transport: http() });
|
|
1490
|
+
*
|
|
1491
|
+
* const contract = new PresaleV2_json('0x...', { publicClient, walletClient });
|
|
1492
|
+
*
|
|
1493
|
+
* // Read functions
|
|
1494
|
+
* const result = await contract.balanceOf('0x...');
|
|
1495
|
+
*
|
|
1496
|
+
* // Write functions
|
|
1497
|
+
* const hash = await contract.transfer('0x...', 1000n);
|
|
1498
|
+
*
|
|
1499
|
+
* // Simulate transactions (dry-run)
|
|
1500
|
+
* const simulation = await contract.simulate.transfer('0x...', 1000n);
|
|
1501
|
+
* console.log('Gas estimate:', simulation.request.gas);
|
|
1502
|
+
*
|
|
1503
|
+
* // Watch events
|
|
1504
|
+
* const unwatch = contract.watch.Transfer((event) => {
|
|
1505
|
+
* console.log('Transfer event:', event);
|
|
1506
|
+
* });
|
|
1507
|
+
* ```
|
|
1508
|
+
*/
|
|
1509
|
+
export class PresaleV2_json {
|
|
1510
|
+
private contract: PresaleV2_jsonContract;
|
|
1511
|
+
private contractAddress: Address;
|
|
1512
|
+
private publicClient: PublicClient;
|
|
1513
|
+
|
|
1514
|
+
constructor(
|
|
1515
|
+
address: Address,
|
|
1516
|
+
clients: {
|
|
1517
|
+
publicClient: PublicClient;
|
|
1518
|
+
walletClient?: WalletClient;
|
|
1519
|
+
}
|
|
1520
|
+
) {
|
|
1521
|
+
this.contractAddress = address;
|
|
1522
|
+
this.publicClient = clients.publicClient;
|
|
1523
|
+
this.contract = getContract({
|
|
1524
|
+
address,
|
|
1525
|
+
abi: PresaleV2_jsonAbi,
|
|
1526
|
+
client: {
|
|
1527
|
+
public: clients.publicClient,
|
|
1528
|
+
wallet: clients.walletClient,
|
|
1529
|
+
},
|
|
1530
|
+
});
|
|
1531
|
+
}
|
|
1532
|
+
|
|
1533
|
+
/**
|
|
1534
|
+
* Get the contract address
|
|
1535
|
+
*/
|
|
1536
|
+
get address(): Address {
|
|
1537
|
+
return this.contractAddress;
|
|
1538
|
+
}
|
|
1539
|
+
|
|
1540
|
+
/**
|
|
1541
|
+
* Get the underlying viem contract instance
|
|
1542
|
+
*/
|
|
1543
|
+
getContract(): PresaleV2_jsonContract {
|
|
1544
|
+
return this.contract;
|
|
1545
|
+
}
|
|
1546
|
+
|
|
1547
|
+
/**
|
|
1548
|
+
* USDCInterface
|
|
1549
|
+
* view
|
|
1550
|
+
*/
|
|
1551
|
+
async USDCInterface(): Promise<`0x${string}`> {
|
|
1552
|
+
return this.contract.read.USDCInterface() as Promise<`0x${string}`>;
|
|
1553
|
+
}
|
|
1554
|
+
|
|
1555
|
+
/**
|
|
1556
|
+
* USDTInterface
|
|
1557
|
+
* view
|
|
1558
|
+
*/
|
|
1559
|
+
async USDTInterface(): Promise<`0x${string}`> {
|
|
1560
|
+
return this.contract.read.USDTInterface() as Promise<`0x${string}`>;
|
|
1561
|
+
}
|
|
1562
|
+
|
|
1563
|
+
/**
|
|
1564
|
+
* admin
|
|
1565
|
+
* view
|
|
1566
|
+
*/
|
|
1567
|
+
async admin(): Promise<`0x${string}`> {
|
|
1568
|
+
return this.contract.read.admin() as Promise<`0x${string}`>;
|
|
1569
|
+
}
|
|
1570
|
+
|
|
1571
|
+
/**
|
|
1572
|
+
* aggregatorInterface
|
|
1573
|
+
* view
|
|
1574
|
+
*/
|
|
1575
|
+
async aggregatorInterface(): Promise<`0x${string}`> {
|
|
1576
|
+
return this.contract.read.aggregatorInterface() as Promise<`0x${string}`>;
|
|
1577
|
+
}
|
|
1578
|
+
|
|
1579
|
+
/**
|
|
1580
|
+
* baseDecimals
|
|
1581
|
+
* view
|
|
1582
|
+
*/
|
|
1583
|
+
async baseDecimals(): Promise<bigint> {
|
|
1584
|
+
return this.contract.read.baseDecimals() as Promise<bigint>;
|
|
1585
|
+
}
|
|
1586
|
+
|
|
1587
|
+
/**
|
|
1588
|
+
* calculatePrice
|
|
1589
|
+
* view
|
|
1590
|
+
*/
|
|
1591
|
+
async calculatePrice(_amount: bigint): Promise<bigint> {
|
|
1592
|
+
return this.contract.read.calculatePrice([_amount] as const) as Promise<bigint>;
|
|
1593
|
+
}
|
|
1594
|
+
|
|
1595
|
+
/**
|
|
1596
|
+
* checkPoint
|
|
1597
|
+
* view
|
|
1598
|
+
*/
|
|
1599
|
+
async checkPoint(): Promise<bigint> {
|
|
1600
|
+
return this.contract.read.checkPoint() as Promise<bigint>;
|
|
1601
|
+
}
|
|
1602
|
+
|
|
1603
|
+
/**
|
|
1604
|
+
* claimStart
|
|
1605
|
+
* view
|
|
1606
|
+
*/
|
|
1607
|
+
async claimStart(): Promise<bigint> {
|
|
1608
|
+
return this.contract.read.claimStart() as Promise<bigint>;
|
|
1609
|
+
}
|
|
1610
|
+
|
|
1611
|
+
/**
|
|
1612
|
+
* currentStep
|
|
1613
|
+
* view
|
|
1614
|
+
*/
|
|
1615
|
+
async currentStep(): Promise<bigint> {
|
|
1616
|
+
return this.contract.read.currentStep() as Promise<bigint>;
|
|
1617
|
+
}
|
|
1618
|
+
|
|
1619
|
+
/**
|
|
1620
|
+
* dynamicTimeFlag
|
|
1621
|
+
* view
|
|
1622
|
+
*/
|
|
1623
|
+
async dynamicTimeFlag(): Promise<boolean> {
|
|
1624
|
+
return this.contract.read.dynamicTimeFlag() as Promise<boolean>;
|
|
1625
|
+
}
|
|
1626
|
+
|
|
1627
|
+
/**
|
|
1628
|
+
* endTime
|
|
1629
|
+
* view
|
|
1630
|
+
*/
|
|
1631
|
+
async endTime(): Promise<bigint> {
|
|
1632
|
+
return this.contract.read.endTime() as Promise<bigint>;
|
|
1633
|
+
}
|
|
1634
|
+
|
|
1635
|
+
/**
|
|
1636
|
+
* ethBuyHelper
|
|
1637
|
+
* view
|
|
1638
|
+
*/
|
|
1639
|
+
async ethBuyHelper(amount: bigint): Promise<bigint> {
|
|
1640
|
+
return this.contract.read.ethBuyHelper([amount] as const) as Promise<bigint>;
|
|
1641
|
+
}
|
|
1642
|
+
|
|
1643
|
+
/**
|
|
1644
|
+
* getLatestPrice
|
|
1645
|
+
* view
|
|
1646
|
+
*/
|
|
1647
|
+
async getLatestPrice(): Promise<bigint> {
|
|
1648
|
+
return this.contract.read.getLatestPrice() as Promise<bigint>;
|
|
1649
|
+
}
|
|
1650
|
+
|
|
1651
|
+
/**
|
|
1652
|
+
* hasClaimed
|
|
1653
|
+
* view
|
|
1654
|
+
*/
|
|
1655
|
+
async hasClaimed(arg0: `0x${string}`): Promise<boolean> {
|
|
1656
|
+
return this.contract.read.hasClaimed([arg0] as const) as Promise<boolean>;
|
|
1657
|
+
}
|
|
1658
|
+
|
|
1659
|
+
/**
|
|
1660
|
+
* isBlacklisted
|
|
1661
|
+
* view
|
|
1662
|
+
*/
|
|
1663
|
+
async isBlacklisted(arg0: `0x${string}`): Promise<boolean> {
|
|
1664
|
+
return this.contract.read.isBlacklisted([arg0] as const) as Promise<boolean>;
|
|
1665
|
+
}
|
|
1666
|
+
|
|
1667
|
+
/**
|
|
1668
|
+
* isWhitelisted
|
|
1669
|
+
* view
|
|
1670
|
+
*/
|
|
1671
|
+
async isWhitelisted(arg0: `0x${string}`): Promise<boolean> {
|
|
1672
|
+
return this.contract.read.isWhitelisted([arg0] as const) as Promise<boolean>;
|
|
1673
|
+
}
|
|
1674
|
+
|
|
1675
|
+
/**
|
|
1676
|
+
* maxTokensToBuy
|
|
1677
|
+
* view
|
|
1678
|
+
*/
|
|
1679
|
+
async maxTokensToBuy(): Promise<bigint> {
|
|
1680
|
+
return this.contract.read.maxTokensToBuy() as Promise<bigint>;
|
|
1681
|
+
}
|
|
1682
|
+
|
|
1683
|
+
/**
|
|
1684
|
+
* owner
|
|
1685
|
+
* view
|
|
1686
|
+
*/
|
|
1687
|
+
async owner(): Promise<`0x${string}`> {
|
|
1688
|
+
return this.contract.read.owner() as Promise<`0x${string}`>;
|
|
1689
|
+
}
|
|
1690
|
+
|
|
1691
|
+
/**
|
|
1692
|
+
* paused
|
|
1693
|
+
* view
|
|
1694
|
+
*/
|
|
1695
|
+
async paused(): Promise<boolean> {
|
|
1696
|
+
return this.contract.read.paused() as Promise<boolean>;
|
|
1697
|
+
}
|
|
1698
|
+
|
|
1699
|
+
/**
|
|
1700
|
+
* paymentWallet
|
|
1701
|
+
* view
|
|
1702
|
+
*/
|
|
1703
|
+
async paymentWallet(): Promise<`0x${string}`> {
|
|
1704
|
+
return this.contract.read.paymentWallet() as Promise<`0x${string}`>;
|
|
1705
|
+
}
|
|
1706
|
+
|
|
1707
|
+
/**
|
|
1708
|
+
* percentages
|
|
1709
|
+
* view
|
|
1710
|
+
*/
|
|
1711
|
+
async percentages(arg0: bigint): Promise<bigint> {
|
|
1712
|
+
return this.contract.read.percentages([arg0] as const) as Promise<bigint>;
|
|
1713
|
+
}
|
|
1714
|
+
|
|
1715
|
+
/**
|
|
1716
|
+
* prevCheckpoints
|
|
1717
|
+
* view
|
|
1718
|
+
*/
|
|
1719
|
+
async prevCheckpoints(arg0: bigint): Promise<bigint> {
|
|
1720
|
+
return this.contract.read.prevCheckpoints([arg0] as const) as Promise<bigint>;
|
|
1721
|
+
}
|
|
1722
|
+
|
|
1723
|
+
/**
|
|
1724
|
+
* remainingTokensTracker
|
|
1725
|
+
* view
|
|
1726
|
+
*/
|
|
1727
|
+
async remainingTokensTracker(arg0: bigint): Promise<bigint> {
|
|
1728
|
+
return this.contract.read.remainingTokensTracker([arg0] as const) as Promise<bigint>;
|
|
1729
|
+
}
|
|
1730
|
+
|
|
1731
|
+
/**
|
|
1732
|
+
* roundDetails
|
|
1733
|
+
* view
|
|
1734
|
+
*/
|
|
1735
|
+
async roundDetails(_no: bigint): Promise<bigint[]> {
|
|
1736
|
+
return this.contract.read.roundDetails([_no] as const) as Promise<bigint[]>;
|
|
1737
|
+
}
|
|
1738
|
+
|
|
1739
|
+
/**
|
|
1740
|
+
* rounds
|
|
1741
|
+
* view
|
|
1742
|
+
*/
|
|
1743
|
+
async rounds(arg0: bigint, arg1: bigint): Promise<bigint> {
|
|
1744
|
+
return this.contract.read.rounds([arg0, arg1] as const) as Promise<bigint>;
|
|
1745
|
+
}
|
|
1746
|
+
|
|
1747
|
+
/**
|
|
1748
|
+
* saleToken
|
|
1749
|
+
* view
|
|
1750
|
+
*/
|
|
1751
|
+
async saleToken(): Promise<`0x${string}`> {
|
|
1752
|
+
return this.contract.read.saleToken() as Promise<`0x${string}`>;
|
|
1753
|
+
}
|
|
1754
|
+
|
|
1755
|
+
/**
|
|
1756
|
+
* stakeingWhitelistStatus
|
|
1757
|
+
* view
|
|
1758
|
+
*/
|
|
1759
|
+
async stakeingWhitelistStatus(): Promise<boolean> {
|
|
1760
|
+
return this.contract.read.stakeingWhitelistStatus() as Promise<boolean>;
|
|
1761
|
+
}
|
|
1762
|
+
|
|
1763
|
+
/**
|
|
1764
|
+
* stakingManagerInterface
|
|
1765
|
+
* view
|
|
1766
|
+
*/
|
|
1767
|
+
async stakingManagerInterface(): Promise<`0x${string}`> {
|
|
1768
|
+
return this.contract.read.stakingManagerInterface() as Promise<`0x${string}`>;
|
|
1769
|
+
}
|
|
1770
|
+
|
|
1771
|
+
/**
|
|
1772
|
+
* startTime
|
|
1773
|
+
* view
|
|
1774
|
+
*/
|
|
1775
|
+
async startTime(): Promise<bigint> {
|
|
1776
|
+
return this.contract.read.startTime() as Promise<bigint>;
|
|
1777
|
+
}
|
|
1778
|
+
|
|
1779
|
+
/**
|
|
1780
|
+
* timeConstant
|
|
1781
|
+
* view
|
|
1782
|
+
*/
|
|
1783
|
+
async timeConstant(): Promise<bigint> {
|
|
1784
|
+
return this.contract.read.timeConstant() as Promise<bigint>;
|
|
1785
|
+
}
|
|
1786
|
+
|
|
1787
|
+
/**
|
|
1788
|
+
* totalBoughtAndStaked
|
|
1789
|
+
* view
|
|
1790
|
+
*/
|
|
1791
|
+
async totalBoughtAndStaked(): Promise<bigint> {
|
|
1792
|
+
return this.contract.read.totalBoughtAndStaked() as Promise<bigint>;
|
|
1793
|
+
}
|
|
1794
|
+
|
|
1795
|
+
/**
|
|
1796
|
+
* totalTokensSold
|
|
1797
|
+
* view
|
|
1798
|
+
*/
|
|
1799
|
+
async totalTokensSold(): Promise<bigint> {
|
|
1800
|
+
return this.contract.read.totalTokensSold() as Promise<bigint>;
|
|
1801
|
+
}
|
|
1802
|
+
|
|
1803
|
+
/**
|
|
1804
|
+
* trackRemainingTokens
|
|
1805
|
+
* view
|
|
1806
|
+
*/
|
|
1807
|
+
async trackRemainingTokens(): Promise<bigint[]> {
|
|
1808
|
+
return this.contract.read.trackRemainingTokens() as Promise<bigint[]>;
|
|
1809
|
+
}
|
|
1810
|
+
|
|
1811
|
+
/**
|
|
1812
|
+
* usdRaised
|
|
1813
|
+
* view
|
|
1814
|
+
*/
|
|
1815
|
+
async usdRaised(): Promise<bigint> {
|
|
1816
|
+
return this.contract.read.usdRaised() as Promise<bigint>;
|
|
1817
|
+
}
|
|
1818
|
+
|
|
1819
|
+
/**
|
|
1820
|
+
* usdtBuyHelper
|
|
1821
|
+
* view
|
|
1822
|
+
*/
|
|
1823
|
+
async usdtBuyHelper(amount: bigint): Promise<bigint> {
|
|
1824
|
+
return this.contract.read.usdtBuyHelper([amount] as const) as Promise<bigint>;
|
|
1825
|
+
}
|
|
1826
|
+
|
|
1827
|
+
/**
|
|
1828
|
+
* userDeposits
|
|
1829
|
+
* view
|
|
1830
|
+
*/
|
|
1831
|
+
async userDeposits(arg0: `0x${string}`): Promise<bigint> {
|
|
1832
|
+
return this.contract.read.userDeposits([arg0] as const) as Promise<bigint>;
|
|
1833
|
+
}
|
|
1834
|
+
|
|
1835
|
+
/**
|
|
1836
|
+
* wallets
|
|
1837
|
+
* view
|
|
1838
|
+
*/
|
|
1839
|
+
async wallets(arg0: bigint): Promise<`0x${string}`> {
|
|
1840
|
+
return this.contract.read.wallets([arg0] as const) as Promise<`0x${string}`>;
|
|
1841
|
+
}
|
|
1842
|
+
|
|
1843
|
+
/**
|
|
1844
|
+
* wertWhitelisted
|
|
1845
|
+
* view
|
|
1846
|
+
*/
|
|
1847
|
+
async wertWhitelisted(arg0: `0x${string}`): Promise<boolean> {
|
|
1848
|
+
return this.contract.read.wertWhitelisted([arg0] as const) as Promise<boolean>;
|
|
1849
|
+
}
|
|
1850
|
+
|
|
1851
|
+
/**
|
|
1852
|
+
* whitelistClaimOnly
|
|
1853
|
+
* view
|
|
1854
|
+
*/
|
|
1855
|
+
async whitelistClaimOnly(): Promise<boolean> {
|
|
1856
|
+
return this.contract.read.whitelistClaimOnly() as Promise<boolean>;
|
|
1857
|
+
}
|
|
1858
|
+
|
|
1859
|
+
/**
|
|
1860
|
+
* blacklistUsers
|
|
1861
|
+
* nonpayable
|
|
1862
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1863
|
+
*/
|
|
1864
|
+
async blacklistUsers(_usersToBlacklist: `0x${string}`[], options?: {
|
|
1865
|
+
accessList?: import('viem').AccessList;
|
|
1866
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1867
|
+
chain?: import('viem').Chain | null;
|
|
1868
|
+
dataSuffix?: `0x${string}`;
|
|
1869
|
+
gas?: bigint;
|
|
1870
|
+
gasPrice?: bigint;
|
|
1871
|
+
maxFeePerGas?: bigint;
|
|
1872
|
+
maxPriorityFeePerGas?: bigint;
|
|
1873
|
+
nonce?: number;
|
|
1874
|
+
value?: bigint;
|
|
1875
|
+
}): Promise<`0x${string}`> {
|
|
1876
|
+
if (!this.contract.write) {
|
|
1877
|
+
throw new Error('Wallet client is required for write operations');
|
|
1878
|
+
}
|
|
1879
|
+
return this.contract.write.blacklistUsers([_usersToBlacklist] as const, options) as Promise<`0x${string}`>;
|
|
1880
|
+
}
|
|
1881
|
+
|
|
1882
|
+
/**
|
|
1883
|
+
* buyWithETHWert
|
|
1884
|
+
* payable
|
|
1885
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1886
|
+
*/
|
|
1887
|
+
async buyWithETHWert(_user: `0x${string}`, _amount: bigint, stake: boolean, options?: {
|
|
1888
|
+
accessList?: import('viem').AccessList;
|
|
1889
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1890
|
+
chain?: import('viem').Chain | null;
|
|
1891
|
+
dataSuffix?: `0x${string}`;
|
|
1892
|
+
gas?: bigint;
|
|
1893
|
+
gasPrice?: bigint;
|
|
1894
|
+
maxFeePerGas?: bigint;
|
|
1895
|
+
maxPriorityFeePerGas?: bigint;
|
|
1896
|
+
nonce?: number;
|
|
1897
|
+
value?: bigint;
|
|
1898
|
+
}): Promise<`0x${string}`> {
|
|
1899
|
+
if (!this.contract.write) {
|
|
1900
|
+
throw new Error('Wallet client is required for write operations');
|
|
1901
|
+
}
|
|
1902
|
+
return this.contract.write.buyWithETHWert([_user, _amount, stake] as const, options) as Promise<`0x${string}`>;
|
|
1903
|
+
}
|
|
1904
|
+
|
|
1905
|
+
/**
|
|
1906
|
+
* buyWithEth
|
|
1907
|
+
* payable
|
|
1908
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1909
|
+
*/
|
|
1910
|
+
async buyWithEth(amount: bigint, stake: boolean, options?: {
|
|
1911
|
+
accessList?: import('viem').AccessList;
|
|
1912
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1913
|
+
chain?: import('viem').Chain | null;
|
|
1914
|
+
dataSuffix?: `0x${string}`;
|
|
1915
|
+
gas?: bigint;
|
|
1916
|
+
gasPrice?: bigint;
|
|
1917
|
+
maxFeePerGas?: bigint;
|
|
1918
|
+
maxPriorityFeePerGas?: bigint;
|
|
1919
|
+
nonce?: number;
|
|
1920
|
+
value?: bigint;
|
|
1921
|
+
}): Promise<`0x${string}`> {
|
|
1922
|
+
if (!this.contract.write) {
|
|
1923
|
+
throw new Error('Wallet client is required for write operations');
|
|
1924
|
+
}
|
|
1925
|
+
return this.contract.write.buyWithEth([amount, stake] as const, options) as Promise<`0x${string}`>;
|
|
1926
|
+
}
|
|
1927
|
+
|
|
1928
|
+
/**
|
|
1929
|
+
* buyWithUSDC
|
|
1930
|
+
* nonpayable
|
|
1931
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1932
|
+
*/
|
|
1933
|
+
async buyWithUSDC(amount: bigint, stake: boolean, options?: {
|
|
1934
|
+
accessList?: import('viem').AccessList;
|
|
1935
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1936
|
+
chain?: import('viem').Chain | null;
|
|
1937
|
+
dataSuffix?: `0x${string}`;
|
|
1938
|
+
gas?: bigint;
|
|
1939
|
+
gasPrice?: bigint;
|
|
1940
|
+
maxFeePerGas?: bigint;
|
|
1941
|
+
maxPriorityFeePerGas?: bigint;
|
|
1942
|
+
nonce?: number;
|
|
1943
|
+
value?: bigint;
|
|
1944
|
+
}): Promise<`0x${string}`> {
|
|
1945
|
+
if (!this.contract.write) {
|
|
1946
|
+
throw new Error('Wallet client is required for write operations');
|
|
1947
|
+
}
|
|
1948
|
+
return this.contract.write.buyWithUSDC([amount, stake] as const, options) as Promise<`0x${string}`>;
|
|
1949
|
+
}
|
|
1950
|
+
|
|
1951
|
+
/**
|
|
1952
|
+
* buyWithUSDT
|
|
1953
|
+
* nonpayable
|
|
1954
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1955
|
+
*/
|
|
1956
|
+
async buyWithUSDT(amount: bigint, stake: boolean, options?: {
|
|
1957
|
+
accessList?: import('viem').AccessList;
|
|
1958
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1959
|
+
chain?: import('viem').Chain | null;
|
|
1960
|
+
dataSuffix?: `0x${string}`;
|
|
1961
|
+
gas?: bigint;
|
|
1962
|
+
gasPrice?: bigint;
|
|
1963
|
+
maxFeePerGas?: bigint;
|
|
1964
|
+
maxPriorityFeePerGas?: bigint;
|
|
1965
|
+
nonce?: number;
|
|
1966
|
+
value?: bigint;
|
|
1967
|
+
}): Promise<`0x${string}`> {
|
|
1968
|
+
if (!this.contract.write) {
|
|
1969
|
+
throw new Error('Wallet client is required for write operations');
|
|
1970
|
+
}
|
|
1971
|
+
return this.contract.write.buyWithUSDT([amount, stake] as const, options) as Promise<`0x${string}`>;
|
|
1972
|
+
}
|
|
1973
|
+
|
|
1974
|
+
/**
|
|
1975
|
+
* changeClaimStart
|
|
1976
|
+
* nonpayable
|
|
1977
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1978
|
+
*/
|
|
1979
|
+
async changeClaimStart(_claimStart: bigint, options?: {
|
|
1980
|
+
accessList?: import('viem').AccessList;
|
|
1981
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1982
|
+
chain?: import('viem').Chain | null;
|
|
1983
|
+
dataSuffix?: `0x${string}`;
|
|
1984
|
+
gas?: bigint;
|
|
1985
|
+
gasPrice?: bigint;
|
|
1986
|
+
maxFeePerGas?: bigint;
|
|
1987
|
+
maxPriorityFeePerGas?: bigint;
|
|
1988
|
+
nonce?: number;
|
|
1989
|
+
value?: bigint;
|
|
1990
|
+
}): Promise<`0x${string}`> {
|
|
1991
|
+
if (!this.contract.write) {
|
|
1992
|
+
throw new Error('Wallet client is required for write operations');
|
|
1993
|
+
}
|
|
1994
|
+
return this.contract.write.changeClaimStart([_claimStart] as const, options) as Promise<`0x${string}`>;
|
|
1995
|
+
}
|
|
1996
|
+
|
|
1997
|
+
/**
|
|
1998
|
+
* changeMaxTokensToBuy
|
|
1999
|
+
* nonpayable
|
|
2000
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2001
|
+
*/
|
|
2002
|
+
async changeMaxTokensToBuy(_maxTokensToBuy: bigint, options?: {
|
|
2003
|
+
accessList?: import('viem').AccessList;
|
|
2004
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2005
|
+
chain?: import('viem').Chain | null;
|
|
2006
|
+
dataSuffix?: `0x${string}`;
|
|
2007
|
+
gas?: bigint;
|
|
2008
|
+
gasPrice?: bigint;
|
|
2009
|
+
maxFeePerGas?: bigint;
|
|
2010
|
+
maxPriorityFeePerGas?: bigint;
|
|
2011
|
+
nonce?: number;
|
|
2012
|
+
value?: bigint;
|
|
2013
|
+
}): Promise<`0x${string}`> {
|
|
2014
|
+
if (!this.contract.write) {
|
|
2015
|
+
throw new Error('Wallet client is required for write operations');
|
|
2016
|
+
}
|
|
2017
|
+
return this.contract.write.changeMaxTokensToBuy([_maxTokensToBuy] as const, options) as Promise<`0x${string}`>;
|
|
2018
|
+
}
|
|
2019
|
+
|
|
2020
|
+
/**
|
|
2021
|
+
* changePaymentWallet
|
|
2022
|
+
* nonpayable
|
|
2023
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2024
|
+
*/
|
|
2025
|
+
async changePaymentWallet(_newPaymentWallet: `0x${string}`, options?: {
|
|
2026
|
+
accessList?: import('viem').AccessList;
|
|
2027
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2028
|
+
chain?: import('viem').Chain | null;
|
|
2029
|
+
dataSuffix?: `0x${string}`;
|
|
2030
|
+
gas?: bigint;
|
|
2031
|
+
gasPrice?: bigint;
|
|
2032
|
+
maxFeePerGas?: bigint;
|
|
2033
|
+
maxPriorityFeePerGas?: bigint;
|
|
2034
|
+
nonce?: number;
|
|
2035
|
+
value?: bigint;
|
|
2036
|
+
}): Promise<`0x${string}`> {
|
|
2037
|
+
if (!this.contract.write) {
|
|
2038
|
+
throw new Error('Wallet client is required for write operations');
|
|
2039
|
+
}
|
|
2040
|
+
return this.contract.write.changePaymentWallet([_newPaymentWallet] as const, options) as Promise<`0x${string}`>;
|
|
2041
|
+
}
|
|
2042
|
+
|
|
2043
|
+
/**
|
|
2044
|
+
* changeRoundsData
|
|
2045
|
+
* nonpayable
|
|
2046
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2047
|
+
*/
|
|
2048
|
+
async changeRoundsData(_rounds: bigint[][], options?: {
|
|
2049
|
+
accessList?: import('viem').AccessList;
|
|
2050
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2051
|
+
chain?: import('viem').Chain | null;
|
|
2052
|
+
dataSuffix?: `0x${string}`;
|
|
2053
|
+
gas?: bigint;
|
|
2054
|
+
gasPrice?: bigint;
|
|
2055
|
+
maxFeePerGas?: bigint;
|
|
2056
|
+
maxPriorityFeePerGas?: bigint;
|
|
2057
|
+
nonce?: number;
|
|
2058
|
+
value?: bigint;
|
|
2059
|
+
}): Promise<`0x${string}`> {
|
|
2060
|
+
if (!this.contract.write) {
|
|
2061
|
+
throw new Error('Wallet client is required for write operations');
|
|
2062
|
+
}
|
|
2063
|
+
return this.contract.write.changeRoundsData([_rounds] as const, options) as Promise<`0x${string}`>;
|
|
2064
|
+
}
|
|
2065
|
+
|
|
2066
|
+
/**
|
|
2067
|
+
* changeSaleTimes
|
|
2068
|
+
* nonpayable
|
|
2069
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2070
|
+
*/
|
|
2071
|
+
async changeSaleTimes(_startTime: bigint, _endTime: bigint, options?: {
|
|
2072
|
+
accessList?: import('viem').AccessList;
|
|
2073
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2074
|
+
chain?: import('viem').Chain | null;
|
|
2075
|
+
dataSuffix?: `0x${string}`;
|
|
2076
|
+
gas?: bigint;
|
|
2077
|
+
gasPrice?: bigint;
|
|
2078
|
+
maxFeePerGas?: bigint;
|
|
2079
|
+
maxPriorityFeePerGas?: bigint;
|
|
2080
|
+
nonce?: number;
|
|
2081
|
+
value?: bigint;
|
|
2082
|
+
}): Promise<`0x${string}`> {
|
|
2083
|
+
if (!this.contract.write) {
|
|
2084
|
+
throw new Error('Wallet client is required for write operations');
|
|
2085
|
+
}
|
|
2086
|
+
return this.contract.write.changeSaleTimes([_startTime, _endTime] as const, options) as Promise<`0x${string}`>;
|
|
2087
|
+
}
|
|
2088
|
+
|
|
2089
|
+
/**
|
|
2090
|
+
* claim
|
|
2091
|
+
* nonpayable
|
|
2092
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2093
|
+
*/
|
|
2094
|
+
async claim(options?: {
|
|
2095
|
+
accessList?: import('viem').AccessList;
|
|
2096
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2097
|
+
chain?: import('viem').Chain | null;
|
|
2098
|
+
dataSuffix?: `0x${string}`;
|
|
2099
|
+
gas?: bigint;
|
|
2100
|
+
gasPrice?: bigint;
|
|
2101
|
+
maxFeePerGas?: bigint;
|
|
2102
|
+
maxPriorityFeePerGas?: bigint;
|
|
2103
|
+
nonce?: number;
|
|
2104
|
+
value?: bigint;
|
|
2105
|
+
}): Promise<`0x${string}`> {
|
|
2106
|
+
if (!this.contract.write) {
|
|
2107
|
+
throw new Error('Wallet client is required for write operations');
|
|
2108
|
+
}
|
|
2109
|
+
return this.contract.write.claim(options) as Promise<`0x${string}`>;
|
|
2110
|
+
}
|
|
2111
|
+
|
|
2112
|
+
/**
|
|
2113
|
+
* claimAndStake
|
|
2114
|
+
* nonpayable
|
|
2115
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2116
|
+
*/
|
|
2117
|
+
async claimAndStake(options?: {
|
|
2118
|
+
accessList?: import('viem').AccessList;
|
|
2119
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2120
|
+
chain?: import('viem').Chain | null;
|
|
2121
|
+
dataSuffix?: `0x${string}`;
|
|
2122
|
+
gas?: bigint;
|
|
2123
|
+
gasPrice?: bigint;
|
|
2124
|
+
maxFeePerGas?: bigint;
|
|
2125
|
+
maxPriorityFeePerGas?: bigint;
|
|
2126
|
+
nonce?: number;
|
|
2127
|
+
value?: bigint;
|
|
2128
|
+
}): Promise<`0x${string}`> {
|
|
2129
|
+
if (!this.contract.write) {
|
|
2130
|
+
throw new Error('Wallet client is required for write operations');
|
|
2131
|
+
}
|
|
2132
|
+
return this.contract.write.claimAndStake(options) as Promise<`0x${string}`>;
|
|
2133
|
+
}
|
|
2134
|
+
|
|
2135
|
+
/**
|
|
2136
|
+
* incrementCurrentStep
|
|
2137
|
+
* nonpayable
|
|
2138
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2139
|
+
*/
|
|
2140
|
+
async incrementCurrentStep(options?: {
|
|
2141
|
+
accessList?: import('viem').AccessList;
|
|
2142
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2143
|
+
chain?: import('viem').Chain | null;
|
|
2144
|
+
dataSuffix?: `0x${string}`;
|
|
2145
|
+
gas?: bigint;
|
|
2146
|
+
gasPrice?: bigint;
|
|
2147
|
+
maxFeePerGas?: bigint;
|
|
2148
|
+
maxPriorityFeePerGas?: bigint;
|
|
2149
|
+
nonce?: number;
|
|
2150
|
+
value?: bigint;
|
|
2151
|
+
}): Promise<`0x${string}`> {
|
|
2152
|
+
if (!this.contract.write) {
|
|
2153
|
+
throw new Error('Wallet client is required for write operations');
|
|
2154
|
+
}
|
|
2155
|
+
return this.contract.write.incrementCurrentStep(options) as Promise<`0x${string}`>;
|
|
2156
|
+
}
|
|
2157
|
+
|
|
2158
|
+
/**
|
|
2159
|
+
* pause
|
|
2160
|
+
* nonpayable
|
|
2161
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2162
|
+
*/
|
|
2163
|
+
async pause(options?: {
|
|
2164
|
+
accessList?: import('viem').AccessList;
|
|
2165
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2166
|
+
chain?: import('viem').Chain | null;
|
|
2167
|
+
dataSuffix?: `0x${string}`;
|
|
2168
|
+
gas?: bigint;
|
|
2169
|
+
gasPrice?: bigint;
|
|
2170
|
+
maxFeePerGas?: bigint;
|
|
2171
|
+
maxPriorityFeePerGas?: bigint;
|
|
2172
|
+
nonce?: number;
|
|
2173
|
+
value?: bigint;
|
|
2174
|
+
}): Promise<`0x${string}`> {
|
|
2175
|
+
if (!this.contract.write) {
|
|
2176
|
+
throw new Error('Wallet client is required for write operations');
|
|
2177
|
+
}
|
|
2178
|
+
return this.contract.write.pause(options) as Promise<`0x${string}`>;
|
|
2179
|
+
}
|
|
2180
|
+
|
|
2181
|
+
/**
|
|
2182
|
+
* removeFromBlacklist
|
|
2183
|
+
* nonpayable
|
|
2184
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2185
|
+
*/
|
|
2186
|
+
async removeFromBlacklist(_userToRemoveFromBlacklist: `0x${string}`[], options?: {
|
|
2187
|
+
accessList?: import('viem').AccessList;
|
|
2188
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2189
|
+
chain?: import('viem').Chain | null;
|
|
2190
|
+
dataSuffix?: `0x${string}`;
|
|
2191
|
+
gas?: bigint;
|
|
2192
|
+
gasPrice?: bigint;
|
|
2193
|
+
maxFeePerGas?: bigint;
|
|
2194
|
+
maxPriorityFeePerGas?: bigint;
|
|
2195
|
+
nonce?: number;
|
|
2196
|
+
value?: bigint;
|
|
2197
|
+
}): Promise<`0x${string}`> {
|
|
2198
|
+
if (!this.contract.write) {
|
|
2199
|
+
throw new Error('Wallet client is required for write operations');
|
|
2200
|
+
}
|
|
2201
|
+
return this.contract.write.removeFromBlacklist([_userToRemoveFromBlacklist] as const, options) as Promise<`0x${string}`>;
|
|
2202
|
+
}
|
|
2203
|
+
|
|
2204
|
+
/**
|
|
2205
|
+
* removeFromWhitelist
|
|
2206
|
+
* nonpayable
|
|
2207
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2208
|
+
*/
|
|
2209
|
+
async removeFromWhitelist(_userToRemoveFromWhitelist: `0x${string}`[], options?: {
|
|
2210
|
+
accessList?: import('viem').AccessList;
|
|
2211
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2212
|
+
chain?: import('viem').Chain | null;
|
|
2213
|
+
dataSuffix?: `0x${string}`;
|
|
2214
|
+
gas?: bigint;
|
|
2215
|
+
gasPrice?: bigint;
|
|
2216
|
+
maxFeePerGas?: bigint;
|
|
2217
|
+
maxPriorityFeePerGas?: bigint;
|
|
2218
|
+
nonce?: number;
|
|
2219
|
+
value?: bigint;
|
|
2220
|
+
}): Promise<`0x${string}`> {
|
|
2221
|
+
if (!this.contract.write) {
|
|
2222
|
+
throw new Error('Wallet client is required for write operations');
|
|
2223
|
+
}
|
|
2224
|
+
return this.contract.write.removeFromWhitelist([_userToRemoveFromWhitelist] as const, options) as Promise<`0x${string}`>;
|
|
2225
|
+
}
|
|
2226
|
+
|
|
2227
|
+
/**
|
|
2228
|
+
* removeFromWhitelistForWERT
|
|
2229
|
+
* nonpayable
|
|
2230
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2231
|
+
*/
|
|
2232
|
+
async removeFromWhitelistForWERT(_addressesToRemoveFromWhitelist: `0x${string}`[], options?: {
|
|
2233
|
+
accessList?: import('viem').AccessList;
|
|
2234
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2235
|
+
chain?: import('viem').Chain | null;
|
|
2236
|
+
dataSuffix?: `0x${string}`;
|
|
2237
|
+
gas?: bigint;
|
|
2238
|
+
gasPrice?: bigint;
|
|
2239
|
+
maxFeePerGas?: bigint;
|
|
2240
|
+
maxPriorityFeePerGas?: bigint;
|
|
2241
|
+
nonce?: number;
|
|
2242
|
+
value?: bigint;
|
|
2243
|
+
}): Promise<`0x${string}`> {
|
|
2244
|
+
if (!this.contract.write) {
|
|
2245
|
+
throw new Error('Wallet client is required for write operations');
|
|
2246
|
+
}
|
|
2247
|
+
return this.contract.write.removeFromWhitelistForWERT([_addressesToRemoveFromWhitelist] as const, options) as Promise<`0x${string}`>;
|
|
2248
|
+
}
|
|
2249
|
+
|
|
2250
|
+
/**
|
|
2251
|
+
* renounceOwnership
|
|
2252
|
+
* nonpayable
|
|
2253
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2254
|
+
*/
|
|
2255
|
+
async renounceOwnership(options?: {
|
|
2256
|
+
accessList?: import('viem').AccessList;
|
|
2257
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2258
|
+
chain?: import('viem').Chain | null;
|
|
2259
|
+
dataSuffix?: `0x${string}`;
|
|
2260
|
+
gas?: bigint;
|
|
2261
|
+
gasPrice?: bigint;
|
|
2262
|
+
maxFeePerGas?: bigint;
|
|
2263
|
+
maxPriorityFeePerGas?: bigint;
|
|
2264
|
+
nonce?: number;
|
|
2265
|
+
value?: bigint;
|
|
2266
|
+
}): Promise<`0x${string}`> {
|
|
2267
|
+
if (!this.contract.write) {
|
|
2268
|
+
throw new Error('Wallet client is required for write operations');
|
|
2269
|
+
}
|
|
2270
|
+
return this.contract.write.renounceOwnership(options) as Promise<`0x${string}`>;
|
|
2271
|
+
}
|
|
2272
|
+
|
|
2273
|
+
/**
|
|
2274
|
+
* setAdmin
|
|
2275
|
+
* nonpayable
|
|
2276
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2277
|
+
*/
|
|
2278
|
+
async setAdmin(_admin: `0x${string}`, options?: {
|
|
2279
|
+
accessList?: import('viem').AccessList;
|
|
2280
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2281
|
+
chain?: import('viem').Chain | null;
|
|
2282
|
+
dataSuffix?: `0x${string}`;
|
|
2283
|
+
gas?: bigint;
|
|
2284
|
+
gasPrice?: bigint;
|
|
2285
|
+
maxFeePerGas?: bigint;
|
|
2286
|
+
maxPriorityFeePerGas?: bigint;
|
|
2287
|
+
nonce?: number;
|
|
2288
|
+
value?: bigint;
|
|
2289
|
+
}): Promise<`0x${string}`> {
|
|
2290
|
+
if (!this.contract.write) {
|
|
2291
|
+
throw new Error('Wallet client is required for write operations');
|
|
2292
|
+
}
|
|
2293
|
+
return this.contract.write.setAdmin([_admin] as const, options) as Promise<`0x${string}`>;
|
|
2294
|
+
}
|
|
2295
|
+
|
|
2296
|
+
/**
|
|
2297
|
+
* setClaimWhitelistStatus
|
|
2298
|
+
* nonpayable
|
|
2299
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2300
|
+
*/
|
|
2301
|
+
async setClaimWhitelistStatus(_status: boolean, options?: {
|
|
2302
|
+
accessList?: import('viem').AccessList;
|
|
2303
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2304
|
+
chain?: import('viem').Chain | null;
|
|
2305
|
+
dataSuffix?: `0x${string}`;
|
|
2306
|
+
gas?: bigint;
|
|
2307
|
+
gasPrice?: bigint;
|
|
2308
|
+
maxFeePerGas?: bigint;
|
|
2309
|
+
maxPriorityFeePerGas?: bigint;
|
|
2310
|
+
nonce?: number;
|
|
2311
|
+
value?: bigint;
|
|
2312
|
+
}): Promise<`0x${string}`> {
|
|
2313
|
+
if (!this.contract.write) {
|
|
2314
|
+
throw new Error('Wallet client is required for write operations');
|
|
2315
|
+
}
|
|
2316
|
+
return this.contract.write.setClaimWhitelistStatus([_status] as const, options) as Promise<`0x${string}`>;
|
|
2317
|
+
}
|
|
2318
|
+
|
|
2319
|
+
/**
|
|
2320
|
+
* setCurrentStep
|
|
2321
|
+
* nonpayable
|
|
2322
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2323
|
+
*/
|
|
2324
|
+
async setCurrentStep(_step: bigint, _checkpoint: bigint, options?: {
|
|
2325
|
+
accessList?: import('viem').AccessList;
|
|
2326
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2327
|
+
chain?: import('viem').Chain | null;
|
|
2328
|
+
dataSuffix?: `0x${string}`;
|
|
2329
|
+
gas?: bigint;
|
|
2330
|
+
gasPrice?: bigint;
|
|
2331
|
+
maxFeePerGas?: bigint;
|
|
2332
|
+
maxPriorityFeePerGas?: bigint;
|
|
2333
|
+
nonce?: number;
|
|
2334
|
+
value?: bigint;
|
|
2335
|
+
}): Promise<`0x${string}`> {
|
|
2336
|
+
if (!this.contract.write) {
|
|
2337
|
+
throw new Error('Wallet client is required for write operations');
|
|
2338
|
+
}
|
|
2339
|
+
return this.contract.write.setCurrentStep([_step, _checkpoint] as const, options) as Promise<`0x${string}`>;
|
|
2340
|
+
}
|
|
2341
|
+
|
|
2342
|
+
/**
|
|
2343
|
+
* setDynamicTimeFlag
|
|
2344
|
+
* nonpayable
|
|
2345
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2346
|
+
*/
|
|
2347
|
+
async setDynamicTimeFlag(_dynamicTimeFlag: boolean, options?: {
|
|
2348
|
+
accessList?: import('viem').AccessList;
|
|
2349
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2350
|
+
chain?: import('viem').Chain | null;
|
|
2351
|
+
dataSuffix?: `0x${string}`;
|
|
2352
|
+
gas?: bigint;
|
|
2353
|
+
gasPrice?: bigint;
|
|
2354
|
+
maxFeePerGas?: bigint;
|
|
2355
|
+
maxPriorityFeePerGas?: bigint;
|
|
2356
|
+
nonce?: number;
|
|
2357
|
+
value?: bigint;
|
|
2358
|
+
}): Promise<`0x${string}`> {
|
|
2359
|
+
if (!this.contract.write) {
|
|
2360
|
+
throw new Error('Wallet client is required for write operations');
|
|
2361
|
+
}
|
|
2362
|
+
return this.contract.write.setDynamicTimeFlag([_dynamicTimeFlag] as const, options) as Promise<`0x${string}`>;
|
|
2363
|
+
}
|
|
2364
|
+
|
|
2365
|
+
/**
|
|
2366
|
+
* setRemainingTokensArray
|
|
2367
|
+
* nonpayable
|
|
2368
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2369
|
+
*/
|
|
2370
|
+
async setRemainingTokensArray(_unsoldTokens: bigint[], options?: {
|
|
2371
|
+
accessList?: import('viem').AccessList;
|
|
2372
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2373
|
+
chain?: import('viem').Chain | null;
|
|
2374
|
+
dataSuffix?: `0x${string}`;
|
|
2375
|
+
gas?: bigint;
|
|
2376
|
+
gasPrice?: bigint;
|
|
2377
|
+
maxFeePerGas?: bigint;
|
|
2378
|
+
maxPriorityFeePerGas?: bigint;
|
|
2379
|
+
nonce?: number;
|
|
2380
|
+
value?: bigint;
|
|
2381
|
+
}): Promise<`0x${string}`> {
|
|
2382
|
+
if (!this.contract.write) {
|
|
2383
|
+
throw new Error('Wallet client is required for write operations');
|
|
2384
|
+
}
|
|
2385
|
+
return this.contract.write.setRemainingTokensArray([_unsoldTokens] as const, options) as Promise<`0x${string}`>;
|
|
2386
|
+
}
|
|
2387
|
+
|
|
2388
|
+
/**
|
|
2389
|
+
* setSplits
|
|
2390
|
+
* nonpayable
|
|
2391
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2392
|
+
*/
|
|
2393
|
+
async setSplits(_wallets: `0x${string}`[], _percentages: bigint[], options?: {
|
|
2394
|
+
accessList?: import('viem').AccessList;
|
|
2395
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2396
|
+
chain?: import('viem').Chain | null;
|
|
2397
|
+
dataSuffix?: `0x${string}`;
|
|
2398
|
+
gas?: bigint;
|
|
2399
|
+
gasPrice?: bigint;
|
|
2400
|
+
maxFeePerGas?: bigint;
|
|
2401
|
+
maxPriorityFeePerGas?: bigint;
|
|
2402
|
+
nonce?: number;
|
|
2403
|
+
value?: bigint;
|
|
2404
|
+
}): Promise<`0x${string}`> {
|
|
2405
|
+
if (!this.contract.write) {
|
|
2406
|
+
throw new Error('Wallet client is required for write operations');
|
|
2407
|
+
}
|
|
2408
|
+
return this.contract.write.setSplits([_wallets, _percentages] as const, options) as Promise<`0x${string}`>;
|
|
2409
|
+
}
|
|
2410
|
+
|
|
2411
|
+
/**
|
|
2412
|
+
* setStakeingWhitelistStatus
|
|
2413
|
+
* nonpayable
|
|
2414
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2415
|
+
*/
|
|
2416
|
+
async setStakeingWhitelistStatus(_status: boolean, options?: {
|
|
2417
|
+
accessList?: import('viem').AccessList;
|
|
2418
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2419
|
+
chain?: import('viem').Chain | null;
|
|
2420
|
+
dataSuffix?: `0x${string}`;
|
|
2421
|
+
gas?: bigint;
|
|
2422
|
+
gasPrice?: bigint;
|
|
2423
|
+
maxFeePerGas?: bigint;
|
|
2424
|
+
maxPriorityFeePerGas?: bigint;
|
|
2425
|
+
nonce?: number;
|
|
2426
|
+
value?: bigint;
|
|
2427
|
+
}): Promise<`0x${string}`> {
|
|
2428
|
+
if (!this.contract.write) {
|
|
2429
|
+
throw new Error('Wallet client is required for write operations');
|
|
2430
|
+
}
|
|
2431
|
+
return this.contract.write.setStakeingWhitelistStatus([_status] as const, options) as Promise<`0x${string}`>;
|
|
2432
|
+
}
|
|
2433
|
+
|
|
2434
|
+
/**
|
|
2435
|
+
* setStakingManager
|
|
2436
|
+
* nonpayable
|
|
2437
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2438
|
+
*/
|
|
2439
|
+
async setStakingManager(_stakingManagerAddress: `0x${string}`, options?: {
|
|
2440
|
+
accessList?: import('viem').AccessList;
|
|
2441
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2442
|
+
chain?: import('viem').Chain | null;
|
|
2443
|
+
dataSuffix?: `0x${string}`;
|
|
2444
|
+
gas?: bigint;
|
|
2445
|
+
gasPrice?: bigint;
|
|
2446
|
+
maxFeePerGas?: bigint;
|
|
2447
|
+
maxPriorityFeePerGas?: bigint;
|
|
2448
|
+
nonce?: number;
|
|
2449
|
+
value?: bigint;
|
|
2450
|
+
}): Promise<`0x${string}`> {
|
|
2451
|
+
if (!this.contract.write) {
|
|
2452
|
+
throw new Error('Wallet client is required for write operations');
|
|
2453
|
+
}
|
|
2454
|
+
return this.contract.write.setStakingManager([_stakingManagerAddress] as const, options) as Promise<`0x${string}`>;
|
|
2455
|
+
}
|
|
2456
|
+
|
|
2457
|
+
/**
|
|
2458
|
+
* setTimeConstant
|
|
2459
|
+
* nonpayable
|
|
2460
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2461
|
+
*/
|
|
2462
|
+
async setTimeConstant(_timeConstant: bigint, options?: {
|
|
2463
|
+
accessList?: import('viem').AccessList;
|
|
2464
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2465
|
+
chain?: import('viem').Chain | null;
|
|
2466
|
+
dataSuffix?: `0x${string}`;
|
|
2467
|
+
gas?: bigint;
|
|
2468
|
+
gasPrice?: bigint;
|
|
2469
|
+
maxFeePerGas?: bigint;
|
|
2470
|
+
maxPriorityFeePerGas?: bigint;
|
|
2471
|
+
nonce?: number;
|
|
2472
|
+
value?: bigint;
|
|
2473
|
+
}): Promise<`0x${string}`> {
|
|
2474
|
+
if (!this.contract.write) {
|
|
2475
|
+
throw new Error('Wallet client is required for write operations');
|
|
2476
|
+
}
|
|
2477
|
+
return this.contract.write.setTimeConstant([_timeConstant] as const, options) as Promise<`0x${string}`>;
|
|
2478
|
+
}
|
|
2479
|
+
|
|
2480
|
+
/**
|
|
2481
|
+
* setUSDCInterface
|
|
2482
|
+
* nonpayable
|
|
2483
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2484
|
+
*/
|
|
2485
|
+
async setUSDCInterface(_usdc: `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<`0x${string}`> {
|
|
2497
|
+
if (!this.contract.write) {
|
|
2498
|
+
throw new Error('Wallet client is required for write operations');
|
|
2499
|
+
}
|
|
2500
|
+
return this.contract.write.setUSDCInterface([_usdc] as const, options) as Promise<`0x${string}`>;
|
|
2501
|
+
}
|
|
2502
|
+
|
|
2503
|
+
/**
|
|
2504
|
+
* startClaim
|
|
2505
|
+
* nonpayable
|
|
2506
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2507
|
+
*/
|
|
2508
|
+
async startClaim(_claimStart: bigint, noOfTokens: bigint, _saleToken: `0x${string}`, _stakingManagerAddress: `0x${string}`, options?: {
|
|
2509
|
+
accessList?: import('viem').AccessList;
|
|
2510
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2511
|
+
chain?: import('viem').Chain | null;
|
|
2512
|
+
dataSuffix?: `0x${string}`;
|
|
2513
|
+
gas?: bigint;
|
|
2514
|
+
gasPrice?: bigint;
|
|
2515
|
+
maxFeePerGas?: bigint;
|
|
2516
|
+
maxPriorityFeePerGas?: bigint;
|
|
2517
|
+
nonce?: number;
|
|
2518
|
+
value?: bigint;
|
|
2519
|
+
}): Promise<`0x${string}`> {
|
|
2520
|
+
if (!this.contract.write) {
|
|
2521
|
+
throw new Error('Wallet client is required for write operations');
|
|
2522
|
+
}
|
|
2523
|
+
return this.contract.write.startClaim([_claimStart, noOfTokens, _saleToken, _stakingManagerAddress] as const, options) as Promise<`0x${string}`>;
|
|
2524
|
+
}
|
|
2525
|
+
|
|
2526
|
+
/**
|
|
2527
|
+
* tokenTransfer
|
|
2528
|
+
* nonpayable
|
|
2529
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2530
|
+
*/
|
|
2531
|
+
async tokenTransfer(amount: bigint, options?: {
|
|
2532
|
+
accessList?: import('viem').AccessList;
|
|
2533
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2534
|
+
chain?: import('viem').Chain | null;
|
|
2535
|
+
dataSuffix?: `0x${string}`;
|
|
2536
|
+
gas?: bigint;
|
|
2537
|
+
gasPrice?: bigint;
|
|
2538
|
+
maxFeePerGas?: bigint;
|
|
2539
|
+
maxPriorityFeePerGas?: bigint;
|
|
2540
|
+
nonce?: number;
|
|
2541
|
+
value?: bigint;
|
|
2542
|
+
}): Promise<`0x${string}`> {
|
|
2543
|
+
if (!this.contract.write) {
|
|
2544
|
+
throw new Error('Wallet client is required for write operations');
|
|
2545
|
+
}
|
|
2546
|
+
return this.contract.write.tokenTransfer([amount] as const, options) as Promise<`0x${string}`>;
|
|
2547
|
+
}
|
|
2548
|
+
|
|
2549
|
+
/**
|
|
2550
|
+
* transferOwnership
|
|
2551
|
+
* nonpayable
|
|
2552
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2553
|
+
*/
|
|
2554
|
+
async transferOwnership(newOwner: `0x${string}`, options?: {
|
|
2555
|
+
accessList?: import('viem').AccessList;
|
|
2556
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2557
|
+
chain?: import('viem').Chain | null;
|
|
2558
|
+
dataSuffix?: `0x${string}`;
|
|
2559
|
+
gas?: bigint;
|
|
2560
|
+
gasPrice?: bigint;
|
|
2561
|
+
maxFeePerGas?: bigint;
|
|
2562
|
+
maxPriorityFeePerGas?: bigint;
|
|
2563
|
+
nonce?: number;
|
|
2564
|
+
value?: bigint;
|
|
2565
|
+
}): Promise<`0x${string}`> {
|
|
2566
|
+
if (!this.contract.write) {
|
|
2567
|
+
throw new Error('Wallet client is required for write operations');
|
|
2568
|
+
}
|
|
2569
|
+
return this.contract.write.transferOwnership([newOwner] as const, options) as Promise<`0x${string}`>;
|
|
2570
|
+
}
|
|
2571
|
+
|
|
2572
|
+
/**
|
|
2573
|
+
* unpause
|
|
2574
|
+
* nonpayable
|
|
2575
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2576
|
+
*/
|
|
2577
|
+
async unpause(options?: {
|
|
2578
|
+
accessList?: import('viem').AccessList;
|
|
2579
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2580
|
+
chain?: import('viem').Chain | null;
|
|
2581
|
+
dataSuffix?: `0x${string}`;
|
|
2582
|
+
gas?: bigint;
|
|
2583
|
+
gasPrice?: bigint;
|
|
2584
|
+
maxFeePerGas?: bigint;
|
|
2585
|
+
maxPriorityFeePerGas?: bigint;
|
|
2586
|
+
nonce?: number;
|
|
2587
|
+
value?: bigint;
|
|
2588
|
+
}): Promise<`0x${string}`> {
|
|
2589
|
+
if (!this.contract.write) {
|
|
2590
|
+
throw new Error('Wallet client is required for write operations');
|
|
2591
|
+
}
|
|
2592
|
+
return this.contract.write.unpause(options) as Promise<`0x${string}`>;
|
|
2593
|
+
}
|
|
2594
|
+
|
|
2595
|
+
/**
|
|
2596
|
+
* updateFromBSC
|
|
2597
|
+
* nonpayable
|
|
2598
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2599
|
+
*/
|
|
2600
|
+
async updateFromBSC(_users: `0x${string}`[], _userDeposits: bigint[], options?: {
|
|
2601
|
+
accessList?: import('viem').AccessList;
|
|
2602
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2603
|
+
chain?: import('viem').Chain | null;
|
|
2604
|
+
dataSuffix?: `0x${string}`;
|
|
2605
|
+
gas?: bigint;
|
|
2606
|
+
gasPrice?: bigint;
|
|
2607
|
+
maxFeePerGas?: bigint;
|
|
2608
|
+
maxPriorityFeePerGas?: bigint;
|
|
2609
|
+
nonce?: number;
|
|
2610
|
+
value?: bigint;
|
|
2611
|
+
}): Promise<`0x${string}`> {
|
|
2612
|
+
if (!this.contract.write) {
|
|
2613
|
+
throw new Error('Wallet client is required for write operations');
|
|
2614
|
+
}
|
|
2615
|
+
return this.contract.write.updateFromBSC([_users, _userDeposits] as const, options) as Promise<`0x${string}`>;
|
|
2616
|
+
}
|
|
2617
|
+
|
|
2618
|
+
/**
|
|
2619
|
+
* whitelistUsers
|
|
2620
|
+
* nonpayable
|
|
2621
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2622
|
+
*/
|
|
2623
|
+
async whitelistUsers(_usersToWhitelist: `0x${string}`[], options?: {
|
|
2624
|
+
accessList?: import('viem').AccessList;
|
|
2625
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2626
|
+
chain?: import('viem').Chain | null;
|
|
2627
|
+
dataSuffix?: `0x${string}`;
|
|
2628
|
+
gas?: bigint;
|
|
2629
|
+
gasPrice?: bigint;
|
|
2630
|
+
maxFeePerGas?: bigint;
|
|
2631
|
+
maxPriorityFeePerGas?: bigint;
|
|
2632
|
+
nonce?: number;
|
|
2633
|
+
value?: bigint;
|
|
2634
|
+
}): Promise<`0x${string}`> {
|
|
2635
|
+
if (!this.contract.write) {
|
|
2636
|
+
throw new Error('Wallet client is required for write operations');
|
|
2637
|
+
}
|
|
2638
|
+
return this.contract.write.whitelistUsers([_usersToWhitelist] as const, options) as Promise<`0x${string}`>;
|
|
2639
|
+
}
|
|
2640
|
+
|
|
2641
|
+
/**
|
|
2642
|
+
* whitelistUsersForWERT
|
|
2643
|
+
* nonpayable
|
|
2644
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2645
|
+
*/
|
|
2646
|
+
async whitelistUsersForWERT(_addressesToWhitelist: `0x${string}`[], options?: {
|
|
2647
|
+
accessList?: import('viem').AccessList;
|
|
2648
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2649
|
+
chain?: import('viem').Chain | null;
|
|
2650
|
+
dataSuffix?: `0x${string}`;
|
|
2651
|
+
gas?: bigint;
|
|
2652
|
+
gasPrice?: bigint;
|
|
2653
|
+
maxFeePerGas?: bigint;
|
|
2654
|
+
maxPriorityFeePerGas?: bigint;
|
|
2655
|
+
nonce?: number;
|
|
2656
|
+
value?: bigint;
|
|
2657
|
+
}): Promise<`0x${string}`> {
|
|
2658
|
+
if (!this.contract.write) {
|
|
2659
|
+
throw new Error('Wallet client is required for write operations');
|
|
2660
|
+
}
|
|
2661
|
+
return this.contract.write.whitelistUsersForWERT([_addressesToWhitelist] as const, options) as Promise<`0x${string}`>;
|
|
2662
|
+
}
|
|
2663
|
+
|
|
2664
|
+
|
|
2665
|
+
|
|
2666
|
+
/**
|
|
2667
|
+
* Simulate contract write operations (dry-run without sending transaction)
|
|
2668
|
+
*
|
|
2669
|
+
* @example
|
|
2670
|
+
* const result = await contract.simulate.transfer('0x...', 1000n);
|
|
2671
|
+
* console.log('Gas estimate:', result.request.gas);
|
|
2672
|
+
* console.log('Would succeed:', result.result);
|
|
2673
|
+
*/
|
|
2674
|
+
get simulate() {
|
|
2675
|
+
const contract = this.contract;
|
|
2676
|
+
if (!contract.simulate) {
|
|
2677
|
+
throw new Error('Public client is required for simulation');
|
|
2678
|
+
}
|
|
2679
|
+
return {
|
|
2680
|
+
/**
|
|
2681
|
+
* Simulate blacklistUsers
|
|
2682
|
+
* Returns gas estimate and result without sending transaction
|
|
2683
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2684
|
+
*/
|
|
2685
|
+
async blacklistUsers(_usersToBlacklist: `0x${string}`[], options?: {
|
|
2686
|
+
accessList?: import('viem').AccessList;
|
|
2687
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2688
|
+
chain?: import('viem').Chain | null;
|
|
2689
|
+
dataSuffix?: `0x${string}`;
|
|
2690
|
+
gas?: bigint;
|
|
2691
|
+
gasPrice?: bigint;
|
|
2692
|
+
maxFeePerGas?: bigint;
|
|
2693
|
+
maxPriorityFeePerGas?: bigint;
|
|
2694
|
+
nonce?: number;
|
|
2695
|
+
value?: bigint;
|
|
2696
|
+
}): Promise<void> {
|
|
2697
|
+
return contract.simulate.blacklistUsers([_usersToBlacklist] as const, options) as Promise<void>;
|
|
2698
|
+
},
|
|
2699
|
+
/**
|
|
2700
|
+
* Simulate buyWithETHWert
|
|
2701
|
+
* Returns gas estimate and result without sending transaction
|
|
2702
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2703
|
+
*/
|
|
2704
|
+
async buyWithETHWert(_user: `0x${string}`, _amount: bigint, stake: boolean, options?: {
|
|
2705
|
+
accessList?: import('viem').AccessList;
|
|
2706
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2707
|
+
chain?: import('viem').Chain | null;
|
|
2708
|
+
dataSuffix?: `0x${string}`;
|
|
2709
|
+
gas?: bigint;
|
|
2710
|
+
gasPrice?: bigint;
|
|
2711
|
+
maxFeePerGas?: bigint;
|
|
2712
|
+
maxPriorityFeePerGas?: bigint;
|
|
2713
|
+
nonce?: number;
|
|
2714
|
+
value?: bigint;
|
|
2715
|
+
}): Promise<boolean> {
|
|
2716
|
+
return contract.simulate.buyWithETHWert([_user, _amount, stake] as const, options) as Promise<boolean>;
|
|
2717
|
+
},
|
|
2718
|
+
/**
|
|
2719
|
+
* Simulate buyWithEth
|
|
2720
|
+
* Returns gas estimate and result without sending transaction
|
|
2721
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2722
|
+
*/
|
|
2723
|
+
async buyWithEth(amount: bigint, stake: boolean, options?: {
|
|
2724
|
+
accessList?: import('viem').AccessList;
|
|
2725
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2726
|
+
chain?: import('viem').Chain | null;
|
|
2727
|
+
dataSuffix?: `0x${string}`;
|
|
2728
|
+
gas?: bigint;
|
|
2729
|
+
gasPrice?: bigint;
|
|
2730
|
+
maxFeePerGas?: bigint;
|
|
2731
|
+
maxPriorityFeePerGas?: bigint;
|
|
2732
|
+
nonce?: number;
|
|
2733
|
+
value?: bigint;
|
|
2734
|
+
}): Promise<boolean> {
|
|
2735
|
+
return contract.simulate.buyWithEth([amount, stake] as const, options) as Promise<boolean>;
|
|
2736
|
+
},
|
|
2737
|
+
/**
|
|
2738
|
+
* Simulate buyWithUSDC
|
|
2739
|
+
* Returns gas estimate and result without sending transaction
|
|
2740
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2741
|
+
*/
|
|
2742
|
+
async buyWithUSDC(amount: bigint, stake: boolean, options?: {
|
|
2743
|
+
accessList?: import('viem').AccessList;
|
|
2744
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2745
|
+
chain?: import('viem').Chain | null;
|
|
2746
|
+
dataSuffix?: `0x${string}`;
|
|
2747
|
+
gas?: bigint;
|
|
2748
|
+
gasPrice?: bigint;
|
|
2749
|
+
maxFeePerGas?: bigint;
|
|
2750
|
+
maxPriorityFeePerGas?: bigint;
|
|
2751
|
+
nonce?: number;
|
|
2752
|
+
value?: bigint;
|
|
2753
|
+
}): Promise<boolean> {
|
|
2754
|
+
return contract.simulate.buyWithUSDC([amount, stake] as const, options) as Promise<boolean>;
|
|
2755
|
+
},
|
|
2756
|
+
/**
|
|
2757
|
+
* Simulate buyWithUSDT
|
|
2758
|
+
* Returns gas estimate and result without sending transaction
|
|
2759
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2760
|
+
*/
|
|
2761
|
+
async buyWithUSDT(amount: bigint, stake: boolean, options?: {
|
|
2762
|
+
accessList?: import('viem').AccessList;
|
|
2763
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2764
|
+
chain?: import('viem').Chain | null;
|
|
2765
|
+
dataSuffix?: `0x${string}`;
|
|
2766
|
+
gas?: bigint;
|
|
2767
|
+
gasPrice?: bigint;
|
|
2768
|
+
maxFeePerGas?: bigint;
|
|
2769
|
+
maxPriorityFeePerGas?: bigint;
|
|
2770
|
+
nonce?: number;
|
|
2771
|
+
value?: bigint;
|
|
2772
|
+
}): Promise<boolean> {
|
|
2773
|
+
return contract.simulate.buyWithUSDT([amount, stake] as const, options) as Promise<boolean>;
|
|
2774
|
+
},
|
|
2775
|
+
/**
|
|
2776
|
+
* Simulate changeClaimStart
|
|
2777
|
+
* Returns gas estimate and result without sending transaction
|
|
2778
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2779
|
+
*/
|
|
2780
|
+
async changeClaimStart(_claimStart: bigint, options?: {
|
|
2781
|
+
accessList?: import('viem').AccessList;
|
|
2782
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2783
|
+
chain?: import('viem').Chain | null;
|
|
2784
|
+
dataSuffix?: `0x${string}`;
|
|
2785
|
+
gas?: bigint;
|
|
2786
|
+
gasPrice?: bigint;
|
|
2787
|
+
maxFeePerGas?: bigint;
|
|
2788
|
+
maxPriorityFeePerGas?: bigint;
|
|
2789
|
+
nonce?: number;
|
|
2790
|
+
value?: bigint;
|
|
2791
|
+
}): Promise<boolean> {
|
|
2792
|
+
return contract.simulate.changeClaimStart([_claimStart] as const, options) as Promise<boolean>;
|
|
2793
|
+
},
|
|
2794
|
+
/**
|
|
2795
|
+
* Simulate changeMaxTokensToBuy
|
|
2796
|
+
* Returns gas estimate and result without sending transaction
|
|
2797
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2798
|
+
*/
|
|
2799
|
+
async changeMaxTokensToBuy(_maxTokensToBuy: bigint, options?: {
|
|
2800
|
+
accessList?: import('viem').AccessList;
|
|
2801
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2802
|
+
chain?: import('viem').Chain | null;
|
|
2803
|
+
dataSuffix?: `0x${string}`;
|
|
2804
|
+
gas?: bigint;
|
|
2805
|
+
gasPrice?: bigint;
|
|
2806
|
+
maxFeePerGas?: bigint;
|
|
2807
|
+
maxPriorityFeePerGas?: bigint;
|
|
2808
|
+
nonce?: number;
|
|
2809
|
+
value?: bigint;
|
|
2810
|
+
}): Promise<void> {
|
|
2811
|
+
return contract.simulate.changeMaxTokensToBuy([_maxTokensToBuy] as const, options) as Promise<void>;
|
|
2812
|
+
},
|
|
2813
|
+
/**
|
|
2814
|
+
* Simulate changePaymentWallet
|
|
2815
|
+
* Returns gas estimate and result without sending transaction
|
|
2816
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2817
|
+
*/
|
|
2818
|
+
async changePaymentWallet(_newPaymentWallet: `0x${string}`, options?: {
|
|
2819
|
+
accessList?: import('viem').AccessList;
|
|
2820
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2821
|
+
chain?: import('viem').Chain | null;
|
|
2822
|
+
dataSuffix?: `0x${string}`;
|
|
2823
|
+
gas?: bigint;
|
|
2824
|
+
gasPrice?: bigint;
|
|
2825
|
+
maxFeePerGas?: bigint;
|
|
2826
|
+
maxPriorityFeePerGas?: bigint;
|
|
2827
|
+
nonce?: number;
|
|
2828
|
+
value?: bigint;
|
|
2829
|
+
}): Promise<void> {
|
|
2830
|
+
return contract.simulate.changePaymentWallet([_newPaymentWallet] as const, options) as Promise<void>;
|
|
2831
|
+
},
|
|
2832
|
+
/**
|
|
2833
|
+
* Simulate changeRoundsData
|
|
2834
|
+
* Returns gas estimate and result without sending transaction
|
|
2835
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2836
|
+
*/
|
|
2837
|
+
async changeRoundsData(_rounds: bigint[][], options?: {
|
|
2838
|
+
accessList?: import('viem').AccessList;
|
|
2839
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2840
|
+
chain?: import('viem').Chain | null;
|
|
2841
|
+
dataSuffix?: `0x${string}`;
|
|
2842
|
+
gas?: bigint;
|
|
2843
|
+
gasPrice?: bigint;
|
|
2844
|
+
maxFeePerGas?: bigint;
|
|
2845
|
+
maxPriorityFeePerGas?: bigint;
|
|
2846
|
+
nonce?: number;
|
|
2847
|
+
value?: bigint;
|
|
2848
|
+
}): Promise<void> {
|
|
2849
|
+
return contract.simulate.changeRoundsData([_rounds] as const, options) as Promise<void>;
|
|
2850
|
+
},
|
|
2851
|
+
/**
|
|
2852
|
+
* Simulate changeSaleTimes
|
|
2853
|
+
* Returns gas estimate and result without sending transaction
|
|
2854
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2855
|
+
*/
|
|
2856
|
+
async changeSaleTimes(_startTime: bigint, _endTime: bigint, options?: {
|
|
2857
|
+
accessList?: import('viem').AccessList;
|
|
2858
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2859
|
+
chain?: import('viem').Chain | null;
|
|
2860
|
+
dataSuffix?: `0x${string}`;
|
|
2861
|
+
gas?: bigint;
|
|
2862
|
+
gasPrice?: bigint;
|
|
2863
|
+
maxFeePerGas?: bigint;
|
|
2864
|
+
maxPriorityFeePerGas?: bigint;
|
|
2865
|
+
nonce?: number;
|
|
2866
|
+
value?: bigint;
|
|
2867
|
+
}): Promise<void> {
|
|
2868
|
+
return contract.simulate.changeSaleTimes([_startTime, _endTime] as const, options) as Promise<void>;
|
|
2869
|
+
},
|
|
2870
|
+
/**
|
|
2871
|
+
* Simulate claim
|
|
2872
|
+
* Returns gas estimate and result without sending transaction
|
|
2873
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2874
|
+
*/
|
|
2875
|
+
async claim(options?: {
|
|
2876
|
+
accessList?: import('viem').AccessList;
|
|
2877
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2878
|
+
chain?: import('viem').Chain | null;
|
|
2879
|
+
dataSuffix?: `0x${string}`;
|
|
2880
|
+
gas?: bigint;
|
|
2881
|
+
gasPrice?: bigint;
|
|
2882
|
+
maxFeePerGas?: bigint;
|
|
2883
|
+
maxPriorityFeePerGas?: bigint;
|
|
2884
|
+
nonce?: number;
|
|
2885
|
+
value?: bigint;
|
|
2886
|
+
}): Promise<boolean> {
|
|
2887
|
+
return contract.simulate.claim(options) as Promise<boolean>;
|
|
2888
|
+
},
|
|
2889
|
+
/**
|
|
2890
|
+
* Simulate claimAndStake
|
|
2891
|
+
* Returns gas estimate and result without sending transaction
|
|
2892
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2893
|
+
*/
|
|
2894
|
+
async claimAndStake(options?: {
|
|
2895
|
+
accessList?: import('viem').AccessList;
|
|
2896
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2897
|
+
chain?: import('viem').Chain | null;
|
|
2898
|
+
dataSuffix?: `0x${string}`;
|
|
2899
|
+
gas?: bigint;
|
|
2900
|
+
gasPrice?: bigint;
|
|
2901
|
+
maxFeePerGas?: bigint;
|
|
2902
|
+
maxPriorityFeePerGas?: bigint;
|
|
2903
|
+
nonce?: number;
|
|
2904
|
+
value?: bigint;
|
|
2905
|
+
}): Promise<boolean> {
|
|
2906
|
+
return contract.simulate.claimAndStake(options) as Promise<boolean>;
|
|
2907
|
+
},
|
|
2908
|
+
/**
|
|
2909
|
+
* Simulate incrementCurrentStep
|
|
2910
|
+
* Returns gas estimate and result without sending transaction
|
|
2911
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2912
|
+
*/
|
|
2913
|
+
async incrementCurrentStep(options?: {
|
|
2914
|
+
accessList?: import('viem').AccessList;
|
|
2915
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2916
|
+
chain?: import('viem').Chain | null;
|
|
2917
|
+
dataSuffix?: `0x${string}`;
|
|
2918
|
+
gas?: bigint;
|
|
2919
|
+
gasPrice?: bigint;
|
|
2920
|
+
maxFeePerGas?: bigint;
|
|
2921
|
+
maxPriorityFeePerGas?: bigint;
|
|
2922
|
+
nonce?: number;
|
|
2923
|
+
value?: bigint;
|
|
2924
|
+
}): Promise<void> {
|
|
2925
|
+
return contract.simulate.incrementCurrentStep(options) as Promise<void>;
|
|
2926
|
+
},
|
|
2927
|
+
/**
|
|
2928
|
+
* Simulate pause
|
|
2929
|
+
* Returns gas estimate and result without sending transaction
|
|
2930
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2931
|
+
*/
|
|
2932
|
+
async pause(options?: {
|
|
2933
|
+
accessList?: import('viem').AccessList;
|
|
2934
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2935
|
+
chain?: import('viem').Chain | null;
|
|
2936
|
+
dataSuffix?: `0x${string}`;
|
|
2937
|
+
gas?: bigint;
|
|
2938
|
+
gasPrice?: bigint;
|
|
2939
|
+
maxFeePerGas?: bigint;
|
|
2940
|
+
maxPriorityFeePerGas?: bigint;
|
|
2941
|
+
nonce?: number;
|
|
2942
|
+
value?: bigint;
|
|
2943
|
+
}): Promise<void> {
|
|
2944
|
+
return contract.simulate.pause(options) as Promise<void>;
|
|
2945
|
+
},
|
|
2946
|
+
/**
|
|
2947
|
+
* Simulate removeFromBlacklist
|
|
2948
|
+
* Returns gas estimate and result without sending transaction
|
|
2949
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2950
|
+
*/
|
|
2951
|
+
async removeFromBlacklist(_userToRemoveFromBlacklist: `0x${string}`[], options?: {
|
|
2952
|
+
accessList?: import('viem').AccessList;
|
|
2953
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2954
|
+
chain?: import('viem').Chain | null;
|
|
2955
|
+
dataSuffix?: `0x${string}`;
|
|
2956
|
+
gas?: bigint;
|
|
2957
|
+
gasPrice?: bigint;
|
|
2958
|
+
maxFeePerGas?: bigint;
|
|
2959
|
+
maxPriorityFeePerGas?: bigint;
|
|
2960
|
+
nonce?: number;
|
|
2961
|
+
value?: bigint;
|
|
2962
|
+
}): Promise<void> {
|
|
2963
|
+
return contract.simulate.removeFromBlacklist([_userToRemoveFromBlacklist] as const, options) as Promise<void>;
|
|
2964
|
+
},
|
|
2965
|
+
/**
|
|
2966
|
+
* Simulate removeFromWhitelist
|
|
2967
|
+
* Returns gas estimate and result without sending transaction
|
|
2968
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2969
|
+
*/
|
|
2970
|
+
async removeFromWhitelist(_userToRemoveFromWhitelist: `0x${string}`[], options?: {
|
|
2971
|
+
accessList?: import('viem').AccessList;
|
|
2972
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2973
|
+
chain?: import('viem').Chain | null;
|
|
2974
|
+
dataSuffix?: `0x${string}`;
|
|
2975
|
+
gas?: bigint;
|
|
2976
|
+
gasPrice?: bigint;
|
|
2977
|
+
maxFeePerGas?: bigint;
|
|
2978
|
+
maxPriorityFeePerGas?: bigint;
|
|
2979
|
+
nonce?: number;
|
|
2980
|
+
value?: bigint;
|
|
2981
|
+
}): Promise<void> {
|
|
2982
|
+
return contract.simulate.removeFromWhitelist([_userToRemoveFromWhitelist] as const, options) as Promise<void>;
|
|
2983
|
+
},
|
|
2984
|
+
/**
|
|
2985
|
+
* Simulate removeFromWhitelistForWERT
|
|
2986
|
+
* Returns gas estimate and result without sending transaction
|
|
2987
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2988
|
+
*/
|
|
2989
|
+
async removeFromWhitelistForWERT(_addressesToRemoveFromWhitelist: `0x${string}`[], options?: {
|
|
2990
|
+
accessList?: import('viem').AccessList;
|
|
2991
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2992
|
+
chain?: import('viem').Chain | null;
|
|
2993
|
+
dataSuffix?: `0x${string}`;
|
|
2994
|
+
gas?: bigint;
|
|
2995
|
+
gasPrice?: bigint;
|
|
2996
|
+
maxFeePerGas?: bigint;
|
|
2997
|
+
maxPriorityFeePerGas?: bigint;
|
|
2998
|
+
nonce?: number;
|
|
2999
|
+
value?: bigint;
|
|
3000
|
+
}): Promise<void> {
|
|
3001
|
+
return contract.simulate.removeFromWhitelistForWERT([_addressesToRemoveFromWhitelist] as const, options) as Promise<void>;
|
|
3002
|
+
},
|
|
3003
|
+
/**
|
|
3004
|
+
* Simulate renounceOwnership
|
|
3005
|
+
* Returns gas estimate and result without sending transaction
|
|
3006
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3007
|
+
*/
|
|
3008
|
+
async renounceOwnership(options?: {
|
|
3009
|
+
accessList?: import('viem').AccessList;
|
|
3010
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3011
|
+
chain?: import('viem').Chain | null;
|
|
3012
|
+
dataSuffix?: `0x${string}`;
|
|
3013
|
+
gas?: bigint;
|
|
3014
|
+
gasPrice?: bigint;
|
|
3015
|
+
maxFeePerGas?: bigint;
|
|
3016
|
+
maxPriorityFeePerGas?: bigint;
|
|
3017
|
+
nonce?: number;
|
|
3018
|
+
value?: bigint;
|
|
3019
|
+
}): Promise<void> {
|
|
3020
|
+
return contract.simulate.renounceOwnership(options) as Promise<void>;
|
|
3021
|
+
},
|
|
3022
|
+
/**
|
|
3023
|
+
* Simulate setAdmin
|
|
3024
|
+
* Returns gas estimate and result without sending transaction
|
|
3025
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3026
|
+
*/
|
|
3027
|
+
async setAdmin(_admin: `0x${string}`, options?: {
|
|
3028
|
+
accessList?: import('viem').AccessList;
|
|
3029
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3030
|
+
chain?: import('viem').Chain | null;
|
|
3031
|
+
dataSuffix?: `0x${string}`;
|
|
3032
|
+
gas?: bigint;
|
|
3033
|
+
gasPrice?: bigint;
|
|
3034
|
+
maxFeePerGas?: bigint;
|
|
3035
|
+
maxPriorityFeePerGas?: bigint;
|
|
3036
|
+
nonce?: number;
|
|
3037
|
+
value?: bigint;
|
|
3038
|
+
}): Promise<void> {
|
|
3039
|
+
return contract.simulate.setAdmin([_admin] as const, options) as Promise<void>;
|
|
3040
|
+
},
|
|
3041
|
+
/**
|
|
3042
|
+
* Simulate setClaimWhitelistStatus
|
|
3043
|
+
* Returns gas estimate and result without sending transaction
|
|
3044
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3045
|
+
*/
|
|
3046
|
+
async setClaimWhitelistStatus(_status: boolean, options?: {
|
|
3047
|
+
accessList?: import('viem').AccessList;
|
|
3048
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3049
|
+
chain?: import('viem').Chain | null;
|
|
3050
|
+
dataSuffix?: `0x${string}`;
|
|
3051
|
+
gas?: bigint;
|
|
3052
|
+
gasPrice?: bigint;
|
|
3053
|
+
maxFeePerGas?: bigint;
|
|
3054
|
+
maxPriorityFeePerGas?: bigint;
|
|
3055
|
+
nonce?: number;
|
|
3056
|
+
value?: bigint;
|
|
3057
|
+
}): Promise<void> {
|
|
3058
|
+
return contract.simulate.setClaimWhitelistStatus([_status] as const, options) as Promise<void>;
|
|
3059
|
+
},
|
|
3060
|
+
/**
|
|
3061
|
+
* Simulate setCurrentStep
|
|
3062
|
+
* Returns gas estimate and result without sending transaction
|
|
3063
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3064
|
+
*/
|
|
3065
|
+
async setCurrentStep(_step: bigint, _checkpoint: bigint, options?: {
|
|
3066
|
+
accessList?: import('viem').AccessList;
|
|
3067
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3068
|
+
chain?: import('viem').Chain | null;
|
|
3069
|
+
dataSuffix?: `0x${string}`;
|
|
3070
|
+
gas?: bigint;
|
|
3071
|
+
gasPrice?: bigint;
|
|
3072
|
+
maxFeePerGas?: bigint;
|
|
3073
|
+
maxPriorityFeePerGas?: bigint;
|
|
3074
|
+
nonce?: number;
|
|
3075
|
+
value?: bigint;
|
|
3076
|
+
}): Promise<void> {
|
|
3077
|
+
return contract.simulate.setCurrentStep([_step, _checkpoint] as const, options) as Promise<void>;
|
|
3078
|
+
},
|
|
3079
|
+
/**
|
|
3080
|
+
* Simulate setDynamicTimeFlag
|
|
3081
|
+
* Returns gas estimate and result without sending transaction
|
|
3082
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3083
|
+
*/
|
|
3084
|
+
async setDynamicTimeFlag(_dynamicTimeFlag: boolean, options?: {
|
|
3085
|
+
accessList?: import('viem').AccessList;
|
|
3086
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3087
|
+
chain?: import('viem').Chain | null;
|
|
3088
|
+
dataSuffix?: `0x${string}`;
|
|
3089
|
+
gas?: bigint;
|
|
3090
|
+
gasPrice?: bigint;
|
|
3091
|
+
maxFeePerGas?: bigint;
|
|
3092
|
+
maxPriorityFeePerGas?: bigint;
|
|
3093
|
+
nonce?: number;
|
|
3094
|
+
value?: bigint;
|
|
3095
|
+
}): Promise<void> {
|
|
3096
|
+
return contract.simulate.setDynamicTimeFlag([_dynamicTimeFlag] as const, options) as Promise<void>;
|
|
3097
|
+
},
|
|
3098
|
+
/**
|
|
3099
|
+
* Simulate setRemainingTokensArray
|
|
3100
|
+
* Returns gas estimate and result without sending transaction
|
|
3101
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3102
|
+
*/
|
|
3103
|
+
async setRemainingTokensArray(_unsoldTokens: bigint[], options?: {
|
|
3104
|
+
accessList?: import('viem').AccessList;
|
|
3105
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3106
|
+
chain?: import('viem').Chain | null;
|
|
3107
|
+
dataSuffix?: `0x${string}`;
|
|
3108
|
+
gas?: bigint;
|
|
3109
|
+
gasPrice?: bigint;
|
|
3110
|
+
maxFeePerGas?: bigint;
|
|
3111
|
+
maxPriorityFeePerGas?: bigint;
|
|
3112
|
+
nonce?: number;
|
|
3113
|
+
value?: bigint;
|
|
3114
|
+
}): Promise<void> {
|
|
3115
|
+
return contract.simulate.setRemainingTokensArray([_unsoldTokens] as const, options) as Promise<void>;
|
|
3116
|
+
},
|
|
3117
|
+
/**
|
|
3118
|
+
* Simulate setSplits
|
|
3119
|
+
* Returns gas estimate and result without sending transaction
|
|
3120
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3121
|
+
*/
|
|
3122
|
+
async setSplits(_wallets: `0x${string}`[], _percentages: bigint[], options?: {
|
|
3123
|
+
accessList?: import('viem').AccessList;
|
|
3124
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3125
|
+
chain?: import('viem').Chain | null;
|
|
3126
|
+
dataSuffix?: `0x${string}`;
|
|
3127
|
+
gas?: bigint;
|
|
3128
|
+
gasPrice?: bigint;
|
|
3129
|
+
maxFeePerGas?: bigint;
|
|
3130
|
+
maxPriorityFeePerGas?: bigint;
|
|
3131
|
+
nonce?: number;
|
|
3132
|
+
value?: bigint;
|
|
3133
|
+
}): Promise<void> {
|
|
3134
|
+
return contract.simulate.setSplits([_wallets, _percentages] as const, options) as Promise<void>;
|
|
3135
|
+
},
|
|
3136
|
+
/**
|
|
3137
|
+
* Simulate setStakeingWhitelistStatus
|
|
3138
|
+
* Returns gas estimate and result without sending transaction
|
|
3139
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3140
|
+
*/
|
|
3141
|
+
async setStakeingWhitelistStatus(_status: boolean, options?: {
|
|
3142
|
+
accessList?: import('viem').AccessList;
|
|
3143
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3144
|
+
chain?: import('viem').Chain | null;
|
|
3145
|
+
dataSuffix?: `0x${string}`;
|
|
3146
|
+
gas?: bigint;
|
|
3147
|
+
gasPrice?: bigint;
|
|
3148
|
+
maxFeePerGas?: bigint;
|
|
3149
|
+
maxPriorityFeePerGas?: bigint;
|
|
3150
|
+
nonce?: number;
|
|
3151
|
+
value?: bigint;
|
|
3152
|
+
}): Promise<void> {
|
|
3153
|
+
return contract.simulate.setStakeingWhitelistStatus([_status] as const, options) as Promise<void>;
|
|
3154
|
+
},
|
|
3155
|
+
/**
|
|
3156
|
+
* Simulate setStakingManager
|
|
3157
|
+
* Returns gas estimate and result without sending transaction
|
|
3158
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3159
|
+
*/
|
|
3160
|
+
async setStakingManager(_stakingManagerAddress: `0x${string}`, options?: {
|
|
3161
|
+
accessList?: import('viem').AccessList;
|
|
3162
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3163
|
+
chain?: import('viem').Chain | null;
|
|
3164
|
+
dataSuffix?: `0x${string}`;
|
|
3165
|
+
gas?: bigint;
|
|
3166
|
+
gasPrice?: bigint;
|
|
3167
|
+
maxFeePerGas?: bigint;
|
|
3168
|
+
maxPriorityFeePerGas?: bigint;
|
|
3169
|
+
nonce?: number;
|
|
3170
|
+
value?: bigint;
|
|
3171
|
+
}): Promise<void> {
|
|
3172
|
+
return contract.simulate.setStakingManager([_stakingManagerAddress] as const, options) as Promise<void>;
|
|
3173
|
+
},
|
|
3174
|
+
/**
|
|
3175
|
+
* Simulate setTimeConstant
|
|
3176
|
+
* Returns gas estimate and result without sending transaction
|
|
3177
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3178
|
+
*/
|
|
3179
|
+
async setTimeConstant(_timeConstant: bigint, options?: {
|
|
3180
|
+
accessList?: import('viem').AccessList;
|
|
3181
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3182
|
+
chain?: import('viem').Chain | null;
|
|
3183
|
+
dataSuffix?: `0x${string}`;
|
|
3184
|
+
gas?: bigint;
|
|
3185
|
+
gasPrice?: bigint;
|
|
3186
|
+
maxFeePerGas?: bigint;
|
|
3187
|
+
maxPriorityFeePerGas?: bigint;
|
|
3188
|
+
nonce?: number;
|
|
3189
|
+
value?: bigint;
|
|
3190
|
+
}): Promise<void> {
|
|
3191
|
+
return contract.simulate.setTimeConstant([_timeConstant] as const, options) as Promise<void>;
|
|
3192
|
+
},
|
|
3193
|
+
/**
|
|
3194
|
+
* Simulate setUSDCInterface
|
|
3195
|
+
* Returns gas estimate and result without sending transaction
|
|
3196
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3197
|
+
*/
|
|
3198
|
+
async setUSDCInterface(_usdc: `0x${string}`, options?: {
|
|
3199
|
+
accessList?: import('viem').AccessList;
|
|
3200
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3201
|
+
chain?: import('viem').Chain | null;
|
|
3202
|
+
dataSuffix?: `0x${string}`;
|
|
3203
|
+
gas?: bigint;
|
|
3204
|
+
gasPrice?: bigint;
|
|
3205
|
+
maxFeePerGas?: bigint;
|
|
3206
|
+
maxPriorityFeePerGas?: bigint;
|
|
3207
|
+
nonce?: number;
|
|
3208
|
+
value?: bigint;
|
|
3209
|
+
}): Promise<void> {
|
|
3210
|
+
return contract.simulate.setUSDCInterface([_usdc] as const, options) as Promise<void>;
|
|
3211
|
+
},
|
|
3212
|
+
/**
|
|
3213
|
+
* Simulate startClaim
|
|
3214
|
+
* Returns gas estimate and result without sending transaction
|
|
3215
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3216
|
+
*/
|
|
3217
|
+
async startClaim(_claimStart: bigint, noOfTokens: bigint, _saleToken: `0x${string}`, _stakingManagerAddress: `0x${string}`, options?: {
|
|
3218
|
+
accessList?: import('viem').AccessList;
|
|
3219
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3220
|
+
chain?: import('viem').Chain | null;
|
|
3221
|
+
dataSuffix?: `0x${string}`;
|
|
3222
|
+
gas?: bigint;
|
|
3223
|
+
gasPrice?: bigint;
|
|
3224
|
+
maxFeePerGas?: bigint;
|
|
3225
|
+
maxPriorityFeePerGas?: bigint;
|
|
3226
|
+
nonce?: number;
|
|
3227
|
+
value?: bigint;
|
|
3228
|
+
}): Promise<boolean> {
|
|
3229
|
+
return contract.simulate.startClaim([_claimStart, noOfTokens, _saleToken, _stakingManagerAddress] as const, options) as Promise<boolean>;
|
|
3230
|
+
},
|
|
3231
|
+
/**
|
|
3232
|
+
* Simulate tokenTransfer
|
|
3233
|
+
* Returns gas estimate and result without sending transaction
|
|
3234
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3235
|
+
*/
|
|
3236
|
+
async tokenTransfer(amount: bigint, options?: {
|
|
3237
|
+
accessList?: import('viem').AccessList;
|
|
3238
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3239
|
+
chain?: import('viem').Chain | null;
|
|
3240
|
+
dataSuffix?: `0x${string}`;
|
|
3241
|
+
gas?: bigint;
|
|
3242
|
+
gasPrice?: bigint;
|
|
3243
|
+
maxFeePerGas?: bigint;
|
|
3244
|
+
maxPriorityFeePerGas?: bigint;
|
|
3245
|
+
nonce?: number;
|
|
3246
|
+
value?: bigint;
|
|
3247
|
+
}): Promise<void> {
|
|
3248
|
+
return contract.simulate.tokenTransfer([amount] as const, options) as Promise<void>;
|
|
3249
|
+
},
|
|
3250
|
+
/**
|
|
3251
|
+
* Simulate transferOwnership
|
|
3252
|
+
* Returns gas estimate and result without sending transaction
|
|
3253
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3254
|
+
*/
|
|
3255
|
+
async transferOwnership(newOwner: `0x${string}`, options?: {
|
|
3256
|
+
accessList?: import('viem').AccessList;
|
|
3257
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3258
|
+
chain?: import('viem').Chain | null;
|
|
3259
|
+
dataSuffix?: `0x${string}`;
|
|
3260
|
+
gas?: bigint;
|
|
3261
|
+
gasPrice?: bigint;
|
|
3262
|
+
maxFeePerGas?: bigint;
|
|
3263
|
+
maxPriorityFeePerGas?: bigint;
|
|
3264
|
+
nonce?: number;
|
|
3265
|
+
value?: bigint;
|
|
3266
|
+
}): Promise<void> {
|
|
3267
|
+
return contract.simulate.transferOwnership([newOwner] as const, options) as Promise<void>;
|
|
3268
|
+
},
|
|
3269
|
+
/**
|
|
3270
|
+
* Simulate unpause
|
|
3271
|
+
* Returns gas estimate and result without sending transaction
|
|
3272
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3273
|
+
*/
|
|
3274
|
+
async unpause(options?: {
|
|
3275
|
+
accessList?: import('viem').AccessList;
|
|
3276
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3277
|
+
chain?: import('viem').Chain | null;
|
|
3278
|
+
dataSuffix?: `0x${string}`;
|
|
3279
|
+
gas?: bigint;
|
|
3280
|
+
gasPrice?: bigint;
|
|
3281
|
+
maxFeePerGas?: bigint;
|
|
3282
|
+
maxPriorityFeePerGas?: bigint;
|
|
3283
|
+
nonce?: number;
|
|
3284
|
+
value?: bigint;
|
|
3285
|
+
}): Promise<void> {
|
|
3286
|
+
return contract.simulate.unpause(options) as Promise<void>;
|
|
3287
|
+
},
|
|
3288
|
+
/**
|
|
3289
|
+
* Simulate updateFromBSC
|
|
3290
|
+
* Returns gas estimate and result without sending transaction
|
|
3291
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3292
|
+
*/
|
|
3293
|
+
async updateFromBSC(_users: `0x${string}`[], _userDeposits: bigint[], options?: {
|
|
3294
|
+
accessList?: import('viem').AccessList;
|
|
3295
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3296
|
+
chain?: import('viem').Chain | null;
|
|
3297
|
+
dataSuffix?: `0x${string}`;
|
|
3298
|
+
gas?: bigint;
|
|
3299
|
+
gasPrice?: bigint;
|
|
3300
|
+
maxFeePerGas?: bigint;
|
|
3301
|
+
maxPriorityFeePerGas?: bigint;
|
|
3302
|
+
nonce?: number;
|
|
3303
|
+
value?: bigint;
|
|
3304
|
+
}): Promise<void> {
|
|
3305
|
+
return contract.simulate.updateFromBSC([_users, _userDeposits] as const, options) as Promise<void>;
|
|
3306
|
+
},
|
|
3307
|
+
/**
|
|
3308
|
+
* Simulate whitelistUsers
|
|
3309
|
+
* Returns gas estimate and result without sending transaction
|
|
3310
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3311
|
+
*/
|
|
3312
|
+
async whitelistUsers(_usersToWhitelist: `0x${string}`[], options?: {
|
|
3313
|
+
accessList?: import('viem').AccessList;
|
|
3314
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3315
|
+
chain?: import('viem').Chain | null;
|
|
3316
|
+
dataSuffix?: `0x${string}`;
|
|
3317
|
+
gas?: bigint;
|
|
3318
|
+
gasPrice?: bigint;
|
|
3319
|
+
maxFeePerGas?: bigint;
|
|
3320
|
+
maxPriorityFeePerGas?: bigint;
|
|
3321
|
+
nonce?: number;
|
|
3322
|
+
value?: bigint;
|
|
3323
|
+
}): Promise<void> {
|
|
3324
|
+
return contract.simulate.whitelistUsers([_usersToWhitelist] as const, options) as Promise<void>;
|
|
3325
|
+
},
|
|
3326
|
+
/**
|
|
3327
|
+
* Simulate whitelistUsersForWERT
|
|
3328
|
+
* Returns gas estimate and result without sending transaction
|
|
3329
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3330
|
+
*/
|
|
3331
|
+
async whitelistUsersForWERT(_addressesToWhitelist: `0x${string}`[], options?: {
|
|
3332
|
+
accessList?: import('viem').AccessList;
|
|
3333
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3334
|
+
chain?: import('viem').Chain | null;
|
|
3335
|
+
dataSuffix?: `0x${string}`;
|
|
3336
|
+
gas?: bigint;
|
|
3337
|
+
gasPrice?: bigint;
|
|
3338
|
+
maxFeePerGas?: bigint;
|
|
3339
|
+
maxPriorityFeePerGas?: bigint;
|
|
3340
|
+
nonce?: number;
|
|
3341
|
+
value?: bigint;
|
|
3342
|
+
}): Promise<void> {
|
|
3343
|
+
return contract.simulate.whitelistUsersForWERT([_addressesToWhitelist] as const, options) as Promise<void>;
|
|
3344
|
+
}
|
|
3345
|
+
};
|
|
3346
|
+
}
|
|
3347
|
+
|
|
3348
|
+
/**
|
|
3349
|
+
* Watch contract events
|
|
3350
|
+
*
|
|
3351
|
+
* @example
|
|
3352
|
+
* // Watch all Transfer events
|
|
3353
|
+
* const unwatch = contract.watch.Transfer((event) => {
|
|
3354
|
+
* console.log('Transfer:', event);
|
|
3355
|
+
* });
|
|
3356
|
+
*
|
|
3357
|
+
* // Stop watching
|
|
3358
|
+
* unwatch();
|
|
3359
|
+
*/
|
|
3360
|
+
get watch() {
|
|
3361
|
+
return {
|
|
3362
|
+
/**
|
|
3363
|
+
* Watch ClaimStartUpdated events
|
|
3364
|
+
* @param callback Function to call when event is emitted
|
|
3365
|
+
* @param filter Optional filter for indexed parameters
|
|
3366
|
+
* @returns Unwatch function to stop listening
|
|
3367
|
+
*/
|
|
3368
|
+
ClaimStartUpdated: (callback: (event: { prevValue: bigint; newValue: bigint; timestamp: bigint }) => void) => {
|
|
3369
|
+
return this.publicClient.watchContractEvent({
|
|
3370
|
+
address: this.contractAddress,
|
|
3371
|
+
abi: PresaleV2_jsonAbi,
|
|
3372
|
+
eventName: 'ClaimStartUpdated',
|
|
3373
|
+
|
|
3374
|
+
onLogs: (logs: any[]) => {
|
|
3375
|
+
logs.forEach((log: any) => {
|
|
3376
|
+
callback(log.args as any);
|
|
3377
|
+
});
|
|
3378
|
+
},
|
|
3379
|
+
}) as () => void;
|
|
3380
|
+
},
|
|
3381
|
+
/**
|
|
3382
|
+
* Watch Initialized events
|
|
3383
|
+
* @param callback Function to call when event is emitted
|
|
3384
|
+
* @param filter Optional filter for indexed parameters
|
|
3385
|
+
* @returns Unwatch function to stop listening
|
|
3386
|
+
*/
|
|
3387
|
+
Initialized: (callback: (event: { version: bigint }) => void) => {
|
|
3388
|
+
return this.publicClient.watchContractEvent({
|
|
3389
|
+
address: this.contractAddress,
|
|
3390
|
+
abi: PresaleV2_jsonAbi,
|
|
3391
|
+
eventName: 'Initialized',
|
|
3392
|
+
|
|
3393
|
+
onLogs: (logs: any[]) => {
|
|
3394
|
+
logs.forEach((log: any) => {
|
|
3395
|
+
callback(log.args as any);
|
|
3396
|
+
});
|
|
3397
|
+
},
|
|
3398
|
+
}) as () => void;
|
|
3399
|
+
},
|
|
3400
|
+
/**
|
|
3401
|
+
* Watch MaxTokensUpdated events
|
|
3402
|
+
* @param callback Function to call when event is emitted
|
|
3403
|
+
* @param filter Optional filter for indexed parameters
|
|
3404
|
+
* @returns Unwatch function to stop listening
|
|
3405
|
+
*/
|
|
3406
|
+
MaxTokensUpdated: (callback: (event: { prevValue: bigint; newValue: bigint; timestamp: bigint }) => void) => {
|
|
3407
|
+
return this.publicClient.watchContractEvent({
|
|
3408
|
+
address: this.contractAddress,
|
|
3409
|
+
abi: PresaleV2_jsonAbi,
|
|
3410
|
+
eventName: 'MaxTokensUpdated',
|
|
3411
|
+
|
|
3412
|
+
onLogs: (logs: any[]) => {
|
|
3413
|
+
logs.forEach((log: any) => {
|
|
3414
|
+
callback(log.args as any);
|
|
3415
|
+
});
|
|
3416
|
+
},
|
|
3417
|
+
}) as () => void;
|
|
3418
|
+
},
|
|
3419
|
+
/**
|
|
3420
|
+
* Watch OwnershipTransferred events
|
|
3421
|
+
* @param callback Function to call when event is emitted
|
|
3422
|
+
* @param filter Optional filter for indexed parameters
|
|
3423
|
+
* @returns Unwatch function to stop listening
|
|
3424
|
+
*/
|
|
3425
|
+
OwnershipTransferred: (callback: (event: { previousOwner: `0x${string}`; newOwner: `0x${string}` }) => void, filter?: { previousOwner: `0x${string}`; newOwner: `0x${string}` }) => {
|
|
3426
|
+
return this.publicClient.watchContractEvent({
|
|
3427
|
+
address: this.contractAddress,
|
|
3428
|
+
abi: PresaleV2_jsonAbi,
|
|
3429
|
+
eventName: 'OwnershipTransferred',
|
|
3430
|
+
args: filter,
|
|
3431
|
+
onLogs: (logs: any[]) => {
|
|
3432
|
+
logs.forEach((log: any) => {
|
|
3433
|
+
callback(log.args as any);
|
|
3434
|
+
});
|
|
3435
|
+
},
|
|
3436
|
+
}) as () => void;
|
|
3437
|
+
},
|
|
3438
|
+
/**
|
|
3439
|
+
* Watch Paused events
|
|
3440
|
+
* @param callback Function to call when event is emitted
|
|
3441
|
+
* @param filter Optional filter for indexed parameters
|
|
3442
|
+
* @returns Unwatch function to stop listening
|
|
3443
|
+
*/
|
|
3444
|
+
Paused: (callback: (event: { account: `0x${string}` }) => void) => {
|
|
3445
|
+
return this.publicClient.watchContractEvent({
|
|
3446
|
+
address: this.contractAddress,
|
|
3447
|
+
abi: PresaleV2_jsonAbi,
|
|
3448
|
+
eventName: 'Paused',
|
|
3449
|
+
|
|
3450
|
+
onLogs: (logs: any[]) => {
|
|
3451
|
+
logs.forEach((log: any) => {
|
|
3452
|
+
callback(log.args as any);
|
|
3453
|
+
});
|
|
3454
|
+
},
|
|
3455
|
+
}) as () => void;
|
|
3456
|
+
},
|
|
3457
|
+
/**
|
|
3458
|
+
* Watch SaleTimeSet events
|
|
3459
|
+
* @param callback Function to call when event is emitted
|
|
3460
|
+
* @param filter Optional filter for indexed parameters
|
|
3461
|
+
* @returns Unwatch function to stop listening
|
|
3462
|
+
*/
|
|
3463
|
+
SaleTimeSet: (callback: (event: { _start: bigint; _end: bigint; timestamp: bigint }) => void) => {
|
|
3464
|
+
return this.publicClient.watchContractEvent({
|
|
3465
|
+
address: this.contractAddress,
|
|
3466
|
+
abi: PresaleV2_jsonAbi,
|
|
3467
|
+
eventName: 'SaleTimeSet',
|
|
3468
|
+
|
|
3469
|
+
onLogs: (logs: any[]) => {
|
|
3470
|
+
logs.forEach((log: any) => {
|
|
3471
|
+
callback(log.args as any);
|
|
3472
|
+
});
|
|
3473
|
+
},
|
|
3474
|
+
}) as () => void;
|
|
3475
|
+
},
|
|
3476
|
+
/**
|
|
3477
|
+
* Watch SaleTimeUpdated events
|
|
3478
|
+
* @param callback Function to call when event is emitted
|
|
3479
|
+
* @param filter Optional filter for indexed parameters
|
|
3480
|
+
* @returns Unwatch function to stop listening
|
|
3481
|
+
*/
|
|
3482
|
+
SaleTimeUpdated: (callback: (event: { key: `0x${string}`; prevValue: bigint; newValue: bigint; timestamp: bigint }) => void, filter?: { key: `0x${string}` }) => {
|
|
3483
|
+
return this.publicClient.watchContractEvent({
|
|
3484
|
+
address: this.contractAddress,
|
|
3485
|
+
abi: PresaleV2_jsonAbi,
|
|
3486
|
+
eventName: 'SaleTimeUpdated',
|
|
3487
|
+
args: filter,
|
|
3488
|
+
onLogs: (logs: any[]) => {
|
|
3489
|
+
logs.forEach((log: any) => {
|
|
3490
|
+
callback(log.args as any);
|
|
3491
|
+
});
|
|
3492
|
+
},
|
|
3493
|
+
}) as () => void;
|
|
3494
|
+
},
|
|
3495
|
+
/**
|
|
3496
|
+
* Watch TokensAdded events
|
|
3497
|
+
* @param callback Function to call when event is emitted
|
|
3498
|
+
* @param filter Optional filter for indexed parameters
|
|
3499
|
+
* @returns Unwatch function to stop listening
|
|
3500
|
+
*/
|
|
3501
|
+
TokensAdded: (callback: (event: { token: `0x${string}`; noOfTokens: bigint; timestamp: bigint }) => void, filter?: { token: `0x${string}` }) => {
|
|
3502
|
+
return this.publicClient.watchContractEvent({
|
|
3503
|
+
address: this.contractAddress,
|
|
3504
|
+
abi: PresaleV2_jsonAbi,
|
|
3505
|
+
eventName: 'TokensAdded',
|
|
3506
|
+
args: filter,
|
|
3507
|
+
onLogs: (logs: any[]) => {
|
|
3508
|
+
logs.forEach((log: any) => {
|
|
3509
|
+
callback(log.args as any);
|
|
3510
|
+
});
|
|
3511
|
+
},
|
|
3512
|
+
}) as () => void;
|
|
3513
|
+
},
|
|
3514
|
+
/**
|
|
3515
|
+
* Watch TokensBought events
|
|
3516
|
+
* @param callback Function to call when event is emitted
|
|
3517
|
+
* @param filter Optional filter for indexed parameters
|
|
3518
|
+
* @returns Unwatch function to stop listening
|
|
3519
|
+
*/
|
|
3520
|
+
TokensBought: (callback: (event: { user: `0x${string}`; tokensBought: bigint; purchaseToken: `0x${string}`; amountPaid: bigint; usdEq: bigint; timestamp: bigint }) => void, filter?: { user: `0x${string}`; tokensBought: bigint; purchaseToken: `0x${string}` }) => {
|
|
3521
|
+
return this.publicClient.watchContractEvent({
|
|
3522
|
+
address: this.contractAddress,
|
|
3523
|
+
abi: PresaleV2_jsonAbi,
|
|
3524
|
+
eventName: 'TokensBought',
|
|
3525
|
+
args: filter,
|
|
3526
|
+
onLogs: (logs: any[]) => {
|
|
3527
|
+
logs.forEach((log: any) => {
|
|
3528
|
+
callback(log.args as any);
|
|
3529
|
+
});
|
|
3530
|
+
},
|
|
3531
|
+
}) as () => void;
|
|
3532
|
+
},
|
|
3533
|
+
/**
|
|
3534
|
+
* Watch TokensBoughtAndStaked events
|
|
3535
|
+
* @param callback Function to call when event is emitted
|
|
3536
|
+
* @param filter Optional filter for indexed parameters
|
|
3537
|
+
* @returns Unwatch function to stop listening
|
|
3538
|
+
*/
|
|
3539
|
+
TokensBoughtAndStaked: (callback: (event: { user: `0x${string}`; tokensBought: bigint; purchaseToken: `0x${string}`; amountPaid: bigint; usdEq: bigint; timestamp: bigint }) => void, filter?: { user: `0x${string}`; tokensBought: bigint; purchaseToken: `0x${string}` }) => {
|
|
3540
|
+
return this.publicClient.watchContractEvent({
|
|
3541
|
+
address: this.contractAddress,
|
|
3542
|
+
abi: PresaleV2_jsonAbi,
|
|
3543
|
+
eventName: 'TokensBoughtAndStaked',
|
|
3544
|
+
args: filter,
|
|
3545
|
+
onLogs: (logs: any[]) => {
|
|
3546
|
+
logs.forEach((log: any) => {
|
|
3547
|
+
callback(log.args as any);
|
|
3548
|
+
});
|
|
3549
|
+
},
|
|
3550
|
+
}) as () => void;
|
|
3551
|
+
},
|
|
3552
|
+
/**
|
|
3553
|
+
* Watch TokensClaimed events
|
|
3554
|
+
* @param callback Function to call when event is emitted
|
|
3555
|
+
* @param filter Optional filter for indexed parameters
|
|
3556
|
+
* @returns Unwatch function to stop listening
|
|
3557
|
+
*/
|
|
3558
|
+
TokensClaimed: (callback: (event: { user: `0x${string}`; amount: bigint; timestamp: bigint }) => void, filter?: { user: `0x${string}` }) => {
|
|
3559
|
+
return this.publicClient.watchContractEvent({
|
|
3560
|
+
address: this.contractAddress,
|
|
3561
|
+
abi: PresaleV2_jsonAbi,
|
|
3562
|
+
eventName: 'TokensClaimed',
|
|
3563
|
+
args: filter,
|
|
3564
|
+
onLogs: (logs: any[]) => {
|
|
3565
|
+
logs.forEach((log: any) => {
|
|
3566
|
+
callback(log.args as any);
|
|
3567
|
+
});
|
|
3568
|
+
},
|
|
3569
|
+
}) as () => void;
|
|
3570
|
+
},
|
|
3571
|
+
/**
|
|
3572
|
+
* Watch TokensClaimedAndStaked events
|
|
3573
|
+
* @param callback Function to call when event is emitted
|
|
3574
|
+
* @param filter Optional filter for indexed parameters
|
|
3575
|
+
* @returns Unwatch function to stop listening
|
|
3576
|
+
*/
|
|
3577
|
+
TokensClaimedAndStaked: (callback: (event: { user: `0x${string}`; amount: bigint; timestamp: bigint }) => void, filter?: { user: `0x${string}` }) => {
|
|
3578
|
+
return this.publicClient.watchContractEvent({
|
|
3579
|
+
address: this.contractAddress,
|
|
3580
|
+
abi: PresaleV2_jsonAbi,
|
|
3581
|
+
eventName: 'TokensClaimedAndStaked',
|
|
3582
|
+
args: filter,
|
|
3583
|
+
onLogs: (logs: any[]) => {
|
|
3584
|
+
logs.forEach((log: any) => {
|
|
3585
|
+
callback(log.args as any);
|
|
3586
|
+
});
|
|
3587
|
+
},
|
|
3588
|
+
}) as () => void;
|
|
3589
|
+
},
|
|
3590
|
+
/**
|
|
3591
|
+
* Watch Unpaused events
|
|
3592
|
+
* @param callback Function to call when event is emitted
|
|
3593
|
+
* @param filter Optional filter for indexed parameters
|
|
3594
|
+
* @returns Unwatch function to stop listening
|
|
3595
|
+
*/
|
|
3596
|
+
Unpaused: (callback: (event: { account: `0x${string}` }) => void) => {
|
|
3597
|
+
return this.publicClient.watchContractEvent({
|
|
3598
|
+
address: this.contractAddress,
|
|
3599
|
+
abi: PresaleV2_jsonAbi,
|
|
3600
|
+
eventName: 'Unpaused',
|
|
3601
|
+
|
|
3602
|
+
onLogs: (logs: any[]) => {
|
|
3603
|
+
logs.forEach((log: any) => {
|
|
3604
|
+
callback(log.args as any);
|
|
3605
|
+
});
|
|
3606
|
+
},
|
|
3607
|
+
}) as () => void;
|
|
3608
|
+
}
|
|
3609
|
+
};
|
|
3610
|
+
}
|
|
3611
|
+
}
|