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