@gitmyabi/curvegauge 1.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +108 -0
- package/contracts/CurveGauge_json.d.ts +1590 -0
- package/contracts/CurveGauge_json.js +1824 -0
- package/contracts/CurveGauge_json.ts +2184 -0
- package/contracts/index.d.ts +2 -0
- package/contracts/index.js +7 -0
- package/contracts/index.ts +3 -0
- package/index.d.ts +1 -0
- package/index.js +19 -0
- package/package.json +43 -0
|
@@ -0,0 +1,1824 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.CurveGauge_json = exports.CurveGauge_jsonAbi = void 0;
|
|
4
|
+
const viem_1 = require("viem");
|
|
5
|
+
/**
|
|
6
|
+
* CurveGauge_json ABI
|
|
7
|
+
*
|
|
8
|
+
* This ABI is typed using viem's type system for full type safety.
|
|
9
|
+
*/
|
|
10
|
+
exports.CurveGauge_jsonAbi = [
|
|
11
|
+
{
|
|
12
|
+
"inputs": [],
|
|
13
|
+
"stateMutability": "nonpayable",
|
|
14
|
+
"type": "constructor"
|
|
15
|
+
},
|
|
16
|
+
{
|
|
17
|
+
"inputs": [
|
|
18
|
+
{
|
|
19
|
+
"internalType": "bytes32",
|
|
20
|
+
"name": "stateId",
|
|
21
|
+
"type": "bytes32"
|
|
22
|
+
}
|
|
23
|
+
],
|
|
24
|
+
"name": "AlreadyInState",
|
|
25
|
+
"type": "error"
|
|
26
|
+
},
|
|
27
|
+
{
|
|
28
|
+
"inputs": [],
|
|
29
|
+
"name": "ArrayLengthMismatch",
|
|
30
|
+
"type": "error"
|
|
31
|
+
},
|
|
32
|
+
{
|
|
33
|
+
"inputs": [
|
|
34
|
+
{
|
|
35
|
+
"internalType": "bytes32",
|
|
36
|
+
"name": "toStateId",
|
|
37
|
+
"type": "bytes32"
|
|
38
|
+
},
|
|
39
|
+
{
|
|
40
|
+
"internalType": "bytes32",
|
|
41
|
+
"name": "currentStateId",
|
|
42
|
+
"type": "bytes32"
|
|
43
|
+
}
|
|
44
|
+
],
|
|
45
|
+
"name": "CannotEnterStateWithLowerHeight",
|
|
46
|
+
"type": "error"
|
|
47
|
+
},
|
|
48
|
+
{
|
|
49
|
+
"inputs": [],
|
|
50
|
+
"name": "CannotExitFromNoAllocationState",
|
|
51
|
+
"type": "error"
|
|
52
|
+
},
|
|
53
|
+
{
|
|
54
|
+
"inputs": [
|
|
55
|
+
{
|
|
56
|
+
"internalType": "bytes32",
|
|
57
|
+
"name": "toStateId",
|
|
58
|
+
"type": "bytes32"
|
|
59
|
+
},
|
|
60
|
+
{
|
|
61
|
+
"internalType": "bytes32",
|
|
62
|
+
"name": "currentStateId",
|
|
63
|
+
"type": "bytes32"
|
|
64
|
+
}
|
|
65
|
+
],
|
|
66
|
+
"name": "CannotExitToStateWithHigherHeight",
|
|
67
|
+
"type": "error"
|
|
68
|
+
},
|
|
69
|
+
{
|
|
70
|
+
"inputs": [],
|
|
71
|
+
"name": "EmergencyExitUnavailable",
|
|
72
|
+
"type": "error"
|
|
73
|
+
},
|
|
74
|
+
{
|
|
75
|
+
"inputs": [],
|
|
76
|
+
"name": "EmergencyModeActivated",
|
|
77
|
+
"type": "error"
|
|
78
|
+
},
|
|
79
|
+
{
|
|
80
|
+
"inputs": [],
|
|
81
|
+
"name": "EnterUnavailable",
|
|
82
|
+
"type": "error"
|
|
83
|
+
},
|
|
84
|
+
{
|
|
85
|
+
"inputs": [],
|
|
86
|
+
"name": "InconsistentState",
|
|
87
|
+
"type": "error"
|
|
88
|
+
},
|
|
89
|
+
{
|
|
90
|
+
"inputs": [],
|
|
91
|
+
"name": "IncorrectAmount",
|
|
92
|
+
"type": "error"
|
|
93
|
+
},
|
|
94
|
+
{
|
|
95
|
+
"inputs": [
|
|
96
|
+
{
|
|
97
|
+
"internalType": "uint256",
|
|
98
|
+
"name": "navDelta",
|
|
99
|
+
"type": "uint256"
|
|
100
|
+
},
|
|
101
|
+
{
|
|
102
|
+
"internalType": "uint256",
|
|
103
|
+
"name": "maxSlippageCached",
|
|
104
|
+
"type": "uint256"
|
|
105
|
+
}
|
|
106
|
+
],
|
|
107
|
+
"name": "IncorrectSlippage",
|
|
108
|
+
"type": "error"
|
|
109
|
+
},
|
|
110
|
+
{
|
|
111
|
+
"inputs": [
|
|
112
|
+
{
|
|
113
|
+
"internalType": "bytes32",
|
|
114
|
+
"name": "stateId",
|
|
115
|
+
"type": "bytes32"
|
|
116
|
+
}
|
|
117
|
+
],
|
|
118
|
+
"name": "IncorrectStateId",
|
|
119
|
+
"type": "error"
|
|
120
|
+
},
|
|
121
|
+
{
|
|
122
|
+
"inputs": [],
|
|
123
|
+
"name": "InvalidInitialization",
|
|
124
|
+
"type": "error"
|
|
125
|
+
},
|
|
126
|
+
{
|
|
127
|
+
"inputs": [],
|
|
128
|
+
"name": "NavResolutionModeActivated",
|
|
129
|
+
"type": "error"
|
|
130
|
+
},
|
|
131
|
+
{
|
|
132
|
+
"inputs": [],
|
|
133
|
+
"name": "NavResolutionModeNotActivated",
|
|
134
|
+
"type": "error"
|
|
135
|
+
},
|
|
136
|
+
{
|
|
137
|
+
"inputs": [
|
|
138
|
+
{
|
|
139
|
+
"internalType": "bytes32",
|
|
140
|
+
"name": "currentStateId",
|
|
141
|
+
"type": "bytes32"
|
|
142
|
+
},
|
|
143
|
+
{
|
|
144
|
+
"internalType": "uint256",
|
|
145
|
+
"name": "currentStateBitmask",
|
|
146
|
+
"type": "uint256"
|
|
147
|
+
}
|
|
148
|
+
],
|
|
149
|
+
"name": "NotInTargetState",
|
|
150
|
+
"type": "error"
|
|
151
|
+
},
|
|
152
|
+
{
|
|
153
|
+
"inputs": [],
|
|
154
|
+
"name": "NotInitializing",
|
|
155
|
+
"type": "error"
|
|
156
|
+
},
|
|
157
|
+
{
|
|
158
|
+
"inputs": [
|
|
159
|
+
{
|
|
160
|
+
"internalType": "address",
|
|
161
|
+
"name": "token",
|
|
162
|
+
"type": "address"
|
|
163
|
+
}
|
|
164
|
+
],
|
|
165
|
+
"name": "NotWhitelistedToken",
|
|
166
|
+
"type": "error"
|
|
167
|
+
},
|
|
168
|
+
{
|
|
169
|
+
"inputs": [],
|
|
170
|
+
"name": "ReentrancyGuardReentrantCall",
|
|
171
|
+
"type": "error"
|
|
172
|
+
},
|
|
173
|
+
{
|
|
174
|
+
"inputs": [],
|
|
175
|
+
"name": "ReshufflingModeDisabled",
|
|
176
|
+
"type": "error"
|
|
177
|
+
},
|
|
178
|
+
{
|
|
179
|
+
"inputs": [
|
|
180
|
+
{
|
|
181
|
+
"internalType": "address",
|
|
182
|
+
"name": "token",
|
|
183
|
+
"type": "address"
|
|
184
|
+
}
|
|
185
|
+
],
|
|
186
|
+
"name": "SafeERC20FailedOperation",
|
|
187
|
+
"type": "error"
|
|
188
|
+
},
|
|
189
|
+
{
|
|
190
|
+
"inputs": [
|
|
191
|
+
{
|
|
192
|
+
"internalType": "uint256",
|
|
193
|
+
"name": "navBefore",
|
|
194
|
+
"type": "uint256"
|
|
195
|
+
},
|
|
196
|
+
{
|
|
197
|
+
"internalType": "uint256",
|
|
198
|
+
"name": "navAfter",
|
|
199
|
+
"type": "uint256"
|
|
200
|
+
},
|
|
201
|
+
{
|
|
202
|
+
"internalType": "uint256",
|
|
203
|
+
"name": "minNavDelta",
|
|
204
|
+
"type": "uint256"
|
|
205
|
+
}
|
|
206
|
+
],
|
|
207
|
+
"name": "SlippageCheckFailed",
|
|
208
|
+
"type": "error"
|
|
209
|
+
},
|
|
210
|
+
{
|
|
211
|
+
"inputs": [
|
|
212
|
+
{
|
|
213
|
+
"internalType": "bytes32",
|
|
214
|
+
"name": "stateId",
|
|
215
|
+
"type": "bytes32"
|
|
216
|
+
}
|
|
217
|
+
],
|
|
218
|
+
"name": "StateAlreadyExists",
|
|
219
|
+
"type": "error"
|
|
220
|
+
},
|
|
221
|
+
{
|
|
222
|
+
"inputs": [
|
|
223
|
+
{
|
|
224
|
+
"internalType": "bytes32",
|
|
225
|
+
"name": "stateId",
|
|
226
|
+
"type": "bytes32"
|
|
227
|
+
}
|
|
228
|
+
],
|
|
229
|
+
"name": "StateHasZeroBitmask",
|
|
230
|
+
"type": "error"
|
|
231
|
+
},
|
|
232
|
+
{
|
|
233
|
+
"inputs": [
|
|
234
|
+
{
|
|
235
|
+
"internalType": "bytes32",
|
|
236
|
+
"name": "stateId",
|
|
237
|
+
"type": "bytes32"
|
|
238
|
+
}
|
|
239
|
+
],
|
|
240
|
+
"name": "StateNotFound",
|
|
241
|
+
"type": "error"
|
|
242
|
+
},
|
|
243
|
+
{
|
|
244
|
+
"inputs": [],
|
|
245
|
+
"name": "TargetStateAlreadySet",
|
|
246
|
+
"type": "error"
|
|
247
|
+
},
|
|
248
|
+
{
|
|
249
|
+
"inputs": [
|
|
250
|
+
{
|
|
251
|
+
"internalType": "address",
|
|
252
|
+
"name": "value",
|
|
253
|
+
"type": "address"
|
|
254
|
+
}
|
|
255
|
+
],
|
|
256
|
+
"name": "TokenAlreadySet",
|
|
257
|
+
"type": "error"
|
|
258
|
+
},
|
|
259
|
+
{
|
|
260
|
+
"inputs": [
|
|
261
|
+
{
|
|
262
|
+
"internalType": "address",
|
|
263
|
+
"name": "token",
|
|
264
|
+
"type": "address"
|
|
265
|
+
}
|
|
266
|
+
],
|
|
267
|
+
"name": "TokenNotFound",
|
|
268
|
+
"type": "error"
|
|
269
|
+
},
|
|
270
|
+
{
|
|
271
|
+
"inputs": [],
|
|
272
|
+
"name": "TreasuryNotSet",
|
|
273
|
+
"type": "error"
|
|
274
|
+
},
|
|
275
|
+
{
|
|
276
|
+
"inputs": [],
|
|
277
|
+
"name": "Unauthorized",
|
|
278
|
+
"type": "error"
|
|
279
|
+
},
|
|
280
|
+
{
|
|
281
|
+
"inputs": [],
|
|
282
|
+
"name": "ZeroAddress",
|
|
283
|
+
"type": "error"
|
|
284
|
+
},
|
|
285
|
+
{
|
|
286
|
+
"inputs": [],
|
|
287
|
+
"name": "ZeroArrayLength",
|
|
288
|
+
"type": "error"
|
|
289
|
+
},
|
|
290
|
+
{
|
|
291
|
+
"inputs": [],
|
|
292
|
+
"name": "ZeroState",
|
|
293
|
+
"type": "error"
|
|
294
|
+
},
|
|
295
|
+
{
|
|
296
|
+
"anonymous": false,
|
|
297
|
+
"inputs": [
|
|
298
|
+
{
|
|
299
|
+
"indexed": false,
|
|
300
|
+
"internalType": "bytes32",
|
|
301
|
+
"name": "toStateId",
|
|
302
|
+
"type": "bytes32"
|
|
303
|
+
}
|
|
304
|
+
],
|
|
305
|
+
"name": "EmergencyExitFailed",
|
|
306
|
+
"type": "event"
|
|
307
|
+
},
|
|
308
|
+
{
|
|
309
|
+
"anonymous": false,
|
|
310
|
+
"inputs": [
|
|
311
|
+
{
|
|
312
|
+
"indexed": false,
|
|
313
|
+
"internalType": "uint256",
|
|
314
|
+
"name": "oldEmergencyExitMaxSlippage",
|
|
315
|
+
"type": "uint256"
|
|
316
|
+
},
|
|
317
|
+
{
|
|
318
|
+
"indexed": false,
|
|
319
|
+
"internalType": "uint256",
|
|
320
|
+
"name": "newEmergencyExitMaxSlippage",
|
|
321
|
+
"type": "uint256"
|
|
322
|
+
}
|
|
323
|
+
],
|
|
324
|
+
"name": "EmergencyExitMaxSlippageUpdated",
|
|
325
|
+
"type": "event"
|
|
326
|
+
},
|
|
327
|
+
{
|
|
328
|
+
"anonymous": false,
|
|
329
|
+
"inputs": [
|
|
330
|
+
{
|
|
331
|
+
"indexed": false,
|
|
332
|
+
"internalType": "bytes32",
|
|
333
|
+
"name": "toStateId",
|
|
334
|
+
"type": "bytes32"
|
|
335
|
+
}
|
|
336
|
+
],
|
|
337
|
+
"name": "EmergencyExitSucceeded",
|
|
338
|
+
"type": "event"
|
|
339
|
+
},
|
|
340
|
+
{
|
|
341
|
+
"anonymous": false,
|
|
342
|
+
"inputs": [
|
|
343
|
+
{
|
|
344
|
+
"indexed": false,
|
|
345
|
+
"internalType": "bytes32",
|
|
346
|
+
"name": "toStateId",
|
|
347
|
+
"type": "bytes32"
|
|
348
|
+
}
|
|
349
|
+
],
|
|
350
|
+
"name": "EmergencyExited",
|
|
351
|
+
"type": "event"
|
|
352
|
+
},
|
|
353
|
+
{
|
|
354
|
+
"anonymous": false,
|
|
355
|
+
"inputs": [
|
|
356
|
+
{
|
|
357
|
+
"indexed": false,
|
|
358
|
+
"internalType": "bool",
|
|
359
|
+
"name": "isEmergencyMode",
|
|
360
|
+
"type": "bool"
|
|
361
|
+
}
|
|
362
|
+
],
|
|
363
|
+
"name": "EmergencyModeUpdated",
|
|
364
|
+
"type": "event"
|
|
365
|
+
},
|
|
366
|
+
{
|
|
367
|
+
"anonymous": false,
|
|
368
|
+
"inputs": [
|
|
369
|
+
{
|
|
370
|
+
"indexed": false,
|
|
371
|
+
"internalType": "uint256",
|
|
372
|
+
"name": "oldEnterMaxSlippage",
|
|
373
|
+
"type": "uint256"
|
|
374
|
+
},
|
|
375
|
+
{
|
|
376
|
+
"indexed": false,
|
|
377
|
+
"internalType": "uint256",
|
|
378
|
+
"name": "newEnterMaxSlippage",
|
|
379
|
+
"type": "uint256"
|
|
380
|
+
}
|
|
381
|
+
],
|
|
382
|
+
"name": "EnterMaxSlippageUpdated",
|
|
383
|
+
"type": "event"
|
|
384
|
+
},
|
|
385
|
+
{
|
|
386
|
+
"anonymous": false,
|
|
387
|
+
"inputs": [
|
|
388
|
+
{
|
|
389
|
+
"indexed": false,
|
|
390
|
+
"internalType": "uint256",
|
|
391
|
+
"name": "navBefore",
|
|
392
|
+
"type": "uint256"
|
|
393
|
+
},
|
|
394
|
+
{
|
|
395
|
+
"indexed": false,
|
|
396
|
+
"internalType": "uint256",
|
|
397
|
+
"name": "navAfter",
|
|
398
|
+
"type": "uint256"
|
|
399
|
+
},
|
|
400
|
+
{
|
|
401
|
+
"indexed": false,
|
|
402
|
+
"internalType": "bool",
|
|
403
|
+
"name": "hasRemainder",
|
|
404
|
+
"type": "bool"
|
|
405
|
+
}
|
|
406
|
+
],
|
|
407
|
+
"name": "Entered",
|
|
408
|
+
"type": "event"
|
|
409
|
+
},
|
|
410
|
+
{
|
|
411
|
+
"anonymous": false,
|
|
412
|
+
"inputs": [
|
|
413
|
+
{
|
|
414
|
+
"indexed": false,
|
|
415
|
+
"internalType": "uint256",
|
|
416
|
+
"name": "oldExitMaxSlippage",
|
|
417
|
+
"type": "uint256"
|
|
418
|
+
},
|
|
419
|
+
{
|
|
420
|
+
"indexed": false,
|
|
421
|
+
"internalType": "uint256",
|
|
422
|
+
"name": "newExitMaxSlippage",
|
|
423
|
+
"type": "uint256"
|
|
424
|
+
}
|
|
425
|
+
],
|
|
426
|
+
"name": "ExitMaxSlippageUpdated",
|
|
427
|
+
"type": "event"
|
|
428
|
+
},
|
|
429
|
+
{
|
|
430
|
+
"anonymous": false,
|
|
431
|
+
"inputs": [
|
|
432
|
+
{
|
|
433
|
+
"indexed": false,
|
|
434
|
+
"internalType": "uint256",
|
|
435
|
+
"name": "navBefore",
|
|
436
|
+
"type": "uint256"
|
|
437
|
+
},
|
|
438
|
+
{
|
|
439
|
+
"indexed": false,
|
|
440
|
+
"internalType": "uint256",
|
|
441
|
+
"name": "navAfter",
|
|
442
|
+
"type": "uint256"
|
|
443
|
+
},
|
|
444
|
+
{
|
|
445
|
+
"indexed": false,
|
|
446
|
+
"internalType": "bytes32",
|
|
447
|
+
"name": "stateId",
|
|
448
|
+
"type": "bytes32"
|
|
449
|
+
}
|
|
450
|
+
],
|
|
451
|
+
"name": "Exited",
|
|
452
|
+
"type": "event"
|
|
453
|
+
},
|
|
454
|
+
{
|
|
455
|
+
"anonymous": false,
|
|
456
|
+
"inputs": [
|
|
457
|
+
{
|
|
458
|
+
"indexed": false,
|
|
459
|
+
"internalType": "bytes32",
|
|
460
|
+
"name": "stateId",
|
|
461
|
+
"type": "bytes32"
|
|
462
|
+
},
|
|
463
|
+
{
|
|
464
|
+
"indexed": false,
|
|
465
|
+
"internalType": "uint256",
|
|
466
|
+
"name": "navAfter",
|
|
467
|
+
"type": "uint256"
|
|
468
|
+
}
|
|
469
|
+
],
|
|
470
|
+
"name": "Harvested",
|
|
471
|
+
"type": "event"
|
|
472
|
+
},
|
|
473
|
+
{
|
|
474
|
+
"anonymous": false,
|
|
475
|
+
"inputs": [
|
|
476
|
+
{
|
|
477
|
+
"indexed": false,
|
|
478
|
+
"internalType": "uint64",
|
|
479
|
+
"name": "version",
|
|
480
|
+
"type": "uint64"
|
|
481
|
+
}
|
|
482
|
+
],
|
|
483
|
+
"name": "Initialized",
|
|
484
|
+
"type": "event"
|
|
485
|
+
},
|
|
486
|
+
{
|
|
487
|
+
"anonymous": false,
|
|
488
|
+
"inputs": [
|
|
489
|
+
{
|
|
490
|
+
"indexed": false,
|
|
491
|
+
"internalType": "address",
|
|
492
|
+
"name": "",
|
|
493
|
+
"type": "address"
|
|
494
|
+
}
|
|
495
|
+
],
|
|
496
|
+
"name": "InputTokenSet",
|
|
497
|
+
"type": "event"
|
|
498
|
+
},
|
|
499
|
+
{
|
|
500
|
+
"anonymous": false,
|
|
501
|
+
"inputs": [
|
|
502
|
+
{
|
|
503
|
+
"indexed": false,
|
|
504
|
+
"internalType": "bool",
|
|
505
|
+
"name": "isNavResolutionMode",
|
|
506
|
+
"type": "bool"
|
|
507
|
+
}
|
|
508
|
+
],
|
|
509
|
+
"name": "NavResolutionModeUpdated",
|
|
510
|
+
"type": "event"
|
|
511
|
+
},
|
|
512
|
+
{
|
|
513
|
+
"anonymous": false,
|
|
514
|
+
"inputs": [
|
|
515
|
+
{
|
|
516
|
+
"indexed": false,
|
|
517
|
+
"internalType": "address",
|
|
518
|
+
"name": "",
|
|
519
|
+
"type": "address"
|
|
520
|
+
}
|
|
521
|
+
],
|
|
522
|
+
"name": "OutputTokenSet",
|
|
523
|
+
"type": "event"
|
|
524
|
+
},
|
|
525
|
+
{
|
|
526
|
+
"anonymous": false,
|
|
527
|
+
"inputs": [
|
|
528
|
+
{
|
|
529
|
+
"indexed": false,
|
|
530
|
+
"internalType": "bytes32",
|
|
531
|
+
"name": "stateId",
|
|
532
|
+
"type": "bytes32"
|
|
533
|
+
}
|
|
534
|
+
],
|
|
535
|
+
"name": "ReenteredToState",
|
|
536
|
+
"type": "event"
|
|
537
|
+
},
|
|
538
|
+
{
|
|
539
|
+
"anonymous": false,
|
|
540
|
+
"inputs": [
|
|
541
|
+
{
|
|
542
|
+
"indexed": false,
|
|
543
|
+
"internalType": "bytes32",
|
|
544
|
+
"name": "oldStateId",
|
|
545
|
+
"type": "bytes32"
|
|
546
|
+
},
|
|
547
|
+
{
|
|
548
|
+
"indexed": false,
|
|
549
|
+
"internalType": "bytes32",
|
|
550
|
+
"name": "newStateId",
|
|
551
|
+
"type": "bytes32"
|
|
552
|
+
},
|
|
553
|
+
{
|
|
554
|
+
"indexed": false,
|
|
555
|
+
"internalType": "uint256",
|
|
556
|
+
"name": "newStateBitmask",
|
|
557
|
+
"type": "uint256"
|
|
558
|
+
}
|
|
559
|
+
],
|
|
560
|
+
"name": "StateUpdated",
|
|
561
|
+
"type": "event"
|
|
562
|
+
},
|
|
563
|
+
{
|
|
564
|
+
"inputs": [
|
|
565
|
+
{
|
|
566
|
+
"internalType": "bytes32",
|
|
567
|
+
"name": "acceptedStateId",
|
|
568
|
+
"type": "bytes32"
|
|
569
|
+
}
|
|
570
|
+
],
|
|
571
|
+
"name": "acceptNav",
|
|
572
|
+
"outputs": [
|
|
573
|
+
{
|
|
574
|
+
"internalType": "uint256",
|
|
575
|
+
"name": "",
|
|
576
|
+
"type": "uint256"
|
|
577
|
+
}
|
|
578
|
+
],
|
|
579
|
+
"stateMutability": "nonpayable",
|
|
580
|
+
"type": "function"
|
|
581
|
+
},
|
|
582
|
+
{
|
|
583
|
+
"inputs": [],
|
|
584
|
+
"name": "currentStateId",
|
|
585
|
+
"outputs": [
|
|
586
|
+
{
|
|
587
|
+
"internalType": "bytes32",
|
|
588
|
+
"name": "",
|
|
589
|
+
"type": "bytes32"
|
|
590
|
+
}
|
|
591
|
+
],
|
|
592
|
+
"stateMutability": "view",
|
|
593
|
+
"type": "function"
|
|
594
|
+
},
|
|
595
|
+
{
|
|
596
|
+
"inputs": [],
|
|
597
|
+
"name": "currentStateNav",
|
|
598
|
+
"outputs": [
|
|
599
|
+
{
|
|
600
|
+
"internalType": "uint256",
|
|
601
|
+
"name": "",
|
|
602
|
+
"type": "uint256"
|
|
603
|
+
}
|
|
604
|
+
],
|
|
605
|
+
"stateMutability": "view",
|
|
606
|
+
"type": "function"
|
|
607
|
+
},
|
|
608
|
+
{
|
|
609
|
+
"inputs": [
|
|
610
|
+
{
|
|
611
|
+
"internalType": "bytes32",
|
|
612
|
+
"name": "toStateId",
|
|
613
|
+
"type": "bytes32"
|
|
614
|
+
},
|
|
615
|
+
{
|
|
616
|
+
"internalType": "uint256",
|
|
617
|
+
"name": "share",
|
|
618
|
+
"type": "uint256"
|
|
619
|
+
},
|
|
620
|
+
{
|
|
621
|
+
"internalType": "uint256",
|
|
622
|
+
"name": "minNavDelta",
|
|
623
|
+
"type": "uint256"
|
|
624
|
+
}
|
|
625
|
+
],
|
|
626
|
+
"name": "emergencyExit",
|
|
627
|
+
"outputs": [],
|
|
628
|
+
"stateMutability": "payable",
|
|
629
|
+
"type": "function"
|
|
630
|
+
},
|
|
631
|
+
{
|
|
632
|
+
"inputs": [],
|
|
633
|
+
"name": "emergencyExitMaxSlippage",
|
|
634
|
+
"outputs": [
|
|
635
|
+
{
|
|
636
|
+
"internalType": "uint256",
|
|
637
|
+
"name": "",
|
|
638
|
+
"type": "uint256"
|
|
639
|
+
}
|
|
640
|
+
],
|
|
641
|
+
"stateMutability": "view",
|
|
642
|
+
"type": "function"
|
|
643
|
+
},
|
|
644
|
+
{
|
|
645
|
+
"inputs": [
|
|
646
|
+
{
|
|
647
|
+
"internalType": "uint256[]",
|
|
648
|
+
"name": "amounts",
|
|
649
|
+
"type": "uint256[]"
|
|
650
|
+
},
|
|
651
|
+
{
|
|
652
|
+
"internalType": "uint256",
|
|
653
|
+
"name": "minNavDelta",
|
|
654
|
+
"type": "uint256"
|
|
655
|
+
}
|
|
656
|
+
],
|
|
657
|
+
"name": "enter",
|
|
658
|
+
"outputs": [
|
|
659
|
+
{
|
|
660
|
+
"internalType": "uint256",
|
|
661
|
+
"name": "",
|
|
662
|
+
"type": "uint256"
|
|
663
|
+
},
|
|
664
|
+
{
|
|
665
|
+
"internalType": "bool",
|
|
666
|
+
"name": "",
|
|
667
|
+
"type": "bool"
|
|
668
|
+
},
|
|
669
|
+
{
|
|
670
|
+
"internalType": "uint256[]",
|
|
671
|
+
"name": "",
|
|
672
|
+
"type": "uint256[]"
|
|
673
|
+
}
|
|
674
|
+
],
|
|
675
|
+
"stateMutability": "payable",
|
|
676
|
+
"type": "function"
|
|
677
|
+
},
|
|
678
|
+
{
|
|
679
|
+
"inputs": [],
|
|
680
|
+
"name": "enterMaxSlippage",
|
|
681
|
+
"outputs": [
|
|
682
|
+
{
|
|
683
|
+
"internalType": "uint256",
|
|
684
|
+
"name": "",
|
|
685
|
+
"type": "uint256"
|
|
686
|
+
}
|
|
687
|
+
],
|
|
688
|
+
"stateMutability": "view",
|
|
689
|
+
"type": "function"
|
|
690
|
+
},
|
|
691
|
+
{
|
|
692
|
+
"inputs": [
|
|
693
|
+
{
|
|
694
|
+
"internalType": "uint256",
|
|
695
|
+
"name": "share",
|
|
696
|
+
"type": "uint256"
|
|
697
|
+
},
|
|
698
|
+
{
|
|
699
|
+
"internalType": "uint256",
|
|
700
|
+
"name": "maxNavDelta",
|
|
701
|
+
"type": "uint256"
|
|
702
|
+
}
|
|
703
|
+
],
|
|
704
|
+
"name": "exit",
|
|
705
|
+
"outputs": [
|
|
706
|
+
{
|
|
707
|
+
"internalType": "address[]",
|
|
708
|
+
"name": "",
|
|
709
|
+
"type": "address[]"
|
|
710
|
+
},
|
|
711
|
+
{
|
|
712
|
+
"internalType": "uint256[]",
|
|
713
|
+
"name": "",
|
|
714
|
+
"type": "uint256[]"
|
|
715
|
+
}
|
|
716
|
+
],
|
|
717
|
+
"stateMutability": "payable",
|
|
718
|
+
"type": "function"
|
|
719
|
+
},
|
|
720
|
+
{
|
|
721
|
+
"inputs": [],
|
|
722
|
+
"name": "exitMaxSlippage",
|
|
723
|
+
"outputs": [
|
|
724
|
+
{
|
|
725
|
+
"internalType": "uint256",
|
|
726
|
+
"name": "",
|
|
727
|
+
"type": "uint256"
|
|
728
|
+
}
|
|
729
|
+
],
|
|
730
|
+
"stateMutability": "view",
|
|
731
|
+
"type": "function"
|
|
732
|
+
},
|
|
733
|
+
{
|
|
734
|
+
"inputs": [],
|
|
735
|
+
"name": "gauge",
|
|
736
|
+
"outputs": [
|
|
737
|
+
{
|
|
738
|
+
"internalType": "address",
|
|
739
|
+
"name": "",
|
|
740
|
+
"type": "address"
|
|
741
|
+
}
|
|
742
|
+
],
|
|
743
|
+
"stateMutability": "view",
|
|
744
|
+
"type": "function"
|
|
745
|
+
},
|
|
746
|
+
{
|
|
747
|
+
"inputs": [],
|
|
748
|
+
"name": "getInputTokens",
|
|
749
|
+
"outputs": [
|
|
750
|
+
{
|
|
751
|
+
"internalType": "address[]",
|
|
752
|
+
"name": "",
|
|
753
|
+
"type": "address[]"
|
|
754
|
+
}
|
|
755
|
+
],
|
|
756
|
+
"stateMutability": "view",
|
|
757
|
+
"type": "function"
|
|
758
|
+
},
|
|
759
|
+
{
|
|
760
|
+
"inputs": [],
|
|
761
|
+
"name": "getOutputTokens",
|
|
762
|
+
"outputs": [
|
|
763
|
+
{
|
|
764
|
+
"internalType": "address[]",
|
|
765
|
+
"name": "",
|
|
766
|
+
"type": "address[]"
|
|
767
|
+
}
|
|
768
|
+
],
|
|
769
|
+
"stateMutability": "view",
|
|
770
|
+
"type": "function"
|
|
771
|
+
},
|
|
772
|
+
{
|
|
773
|
+
"inputs": [],
|
|
774
|
+
"name": "getStateIds",
|
|
775
|
+
"outputs": [
|
|
776
|
+
{
|
|
777
|
+
"internalType": "bytes32[]",
|
|
778
|
+
"name": "",
|
|
779
|
+
"type": "bytes32[]"
|
|
780
|
+
}
|
|
781
|
+
],
|
|
782
|
+
"stateMutability": "view",
|
|
783
|
+
"type": "function"
|
|
784
|
+
},
|
|
785
|
+
{
|
|
786
|
+
"inputs": [
|
|
787
|
+
{
|
|
788
|
+
"internalType": "address",
|
|
789
|
+
"name": "token",
|
|
790
|
+
"type": "address"
|
|
791
|
+
},
|
|
792
|
+
{
|
|
793
|
+
"internalType": "uint256",
|
|
794
|
+
"name": "amount",
|
|
795
|
+
"type": "uint256"
|
|
796
|
+
}
|
|
797
|
+
],
|
|
798
|
+
"name": "getTokenAmountInNotion",
|
|
799
|
+
"outputs": [
|
|
800
|
+
{
|
|
801
|
+
"internalType": "uint256",
|
|
802
|
+
"name": "",
|
|
803
|
+
"type": "uint256"
|
|
804
|
+
}
|
|
805
|
+
],
|
|
806
|
+
"stateMutability": "view",
|
|
807
|
+
"type": "function"
|
|
808
|
+
},
|
|
809
|
+
{
|
|
810
|
+
"inputs": [],
|
|
811
|
+
"name": "harvest",
|
|
812
|
+
"outputs": [
|
|
813
|
+
{
|
|
814
|
+
"internalType": "uint256",
|
|
815
|
+
"name": "",
|
|
816
|
+
"type": "uint256"
|
|
817
|
+
}
|
|
818
|
+
],
|
|
819
|
+
"stateMutability": "payable",
|
|
820
|
+
"type": "function"
|
|
821
|
+
},
|
|
822
|
+
{
|
|
823
|
+
"inputs": [
|
|
824
|
+
{
|
|
825
|
+
"internalType": "address",
|
|
826
|
+
"name": "strategyContainer",
|
|
827
|
+
"type": "address"
|
|
828
|
+
},
|
|
829
|
+
{
|
|
830
|
+
"internalType": "address",
|
|
831
|
+
"name": "_gauge",
|
|
832
|
+
"type": "address"
|
|
833
|
+
},
|
|
834
|
+
{
|
|
835
|
+
"internalType": "uint256",
|
|
836
|
+
"name": "_enterMaxSlippage",
|
|
837
|
+
"type": "uint256"
|
|
838
|
+
},
|
|
839
|
+
{
|
|
840
|
+
"internalType": "uint256",
|
|
841
|
+
"name": "_exitMaxSlippage",
|
|
842
|
+
"type": "uint256"
|
|
843
|
+
},
|
|
844
|
+
{
|
|
845
|
+
"internalType": "uint256",
|
|
846
|
+
"name": "_emergencyExitMaxSlippage",
|
|
847
|
+
"type": "uint256"
|
|
848
|
+
}
|
|
849
|
+
],
|
|
850
|
+
"name": "initialize",
|
|
851
|
+
"outputs": [],
|
|
852
|
+
"stateMutability": "nonpayable",
|
|
853
|
+
"type": "function"
|
|
854
|
+
},
|
|
855
|
+
{
|
|
856
|
+
"inputs": [],
|
|
857
|
+
"name": "isNavResolutionMode",
|
|
858
|
+
"outputs": [
|
|
859
|
+
{
|
|
860
|
+
"internalType": "bool",
|
|
861
|
+
"name": "",
|
|
862
|
+
"type": "bool"
|
|
863
|
+
}
|
|
864
|
+
],
|
|
865
|
+
"stateMutability": "view",
|
|
866
|
+
"type": "function"
|
|
867
|
+
},
|
|
868
|
+
{
|
|
869
|
+
"inputs": [],
|
|
870
|
+
"name": "lastStoredGaugeBalance",
|
|
871
|
+
"outputs": [
|
|
872
|
+
{
|
|
873
|
+
"internalType": "uint256",
|
|
874
|
+
"name": "",
|
|
875
|
+
"type": "uint256"
|
|
876
|
+
}
|
|
877
|
+
],
|
|
878
|
+
"stateMutability": "view",
|
|
879
|
+
"type": "function"
|
|
880
|
+
},
|
|
881
|
+
{
|
|
882
|
+
"inputs": [],
|
|
883
|
+
"name": "lastStoredVirtualPrice",
|
|
884
|
+
"outputs": [
|
|
885
|
+
{
|
|
886
|
+
"internalType": "uint256",
|
|
887
|
+
"name": "",
|
|
888
|
+
"type": "uint256"
|
|
889
|
+
}
|
|
890
|
+
],
|
|
891
|
+
"stateMutability": "view",
|
|
892
|
+
"type": "function"
|
|
893
|
+
},
|
|
894
|
+
{
|
|
895
|
+
"inputs": [],
|
|
896
|
+
"name": "lpToken",
|
|
897
|
+
"outputs": [
|
|
898
|
+
{
|
|
899
|
+
"internalType": "address",
|
|
900
|
+
"name": "",
|
|
901
|
+
"type": "address"
|
|
902
|
+
}
|
|
903
|
+
],
|
|
904
|
+
"stateMutability": "view",
|
|
905
|
+
"type": "function"
|
|
906
|
+
},
|
|
907
|
+
{
|
|
908
|
+
"inputs": [
|
|
909
|
+
{
|
|
910
|
+
"internalType": "bytes32",
|
|
911
|
+
"name": "stateId",
|
|
912
|
+
"type": "bytes32"
|
|
913
|
+
},
|
|
914
|
+
{
|
|
915
|
+
"internalType": "uint256",
|
|
916
|
+
"name": "minNavDelta",
|
|
917
|
+
"type": "uint256"
|
|
918
|
+
}
|
|
919
|
+
],
|
|
920
|
+
"name": "reenterToState",
|
|
921
|
+
"outputs": [],
|
|
922
|
+
"stateMutability": "payable",
|
|
923
|
+
"type": "function"
|
|
924
|
+
},
|
|
925
|
+
{
|
|
926
|
+
"inputs": [
|
|
927
|
+
{
|
|
928
|
+
"internalType": "uint256",
|
|
929
|
+
"name": "_emergencyExitMaxSlippage",
|
|
930
|
+
"type": "uint256"
|
|
931
|
+
}
|
|
932
|
+
],
|
|
933
|
+
"name": "setEmergencyExitMaxSlippage",
|
|
934
|
+
"outputs": [],
|
|
935
|
+
"stateMutability": "nonpayable",
|
|
936
|
+
"type": "function"
|
|
937
|
+
},
|
|
938
|
+
{
|
|
939
|
+
"inputs": [
|
|
940
|
+
{
|
|
941
|
+
"internalType": "uint256",
|
|
942
|
+
"name": "_enterMaxSlippage",
|
|
943
|
+
"type": "uint256"
|
|
944
|
+
}
|
|
945
|
+
],
|
|
946
|
+
"name": "setEnterMaxSlippage",
|
|
947
|
+
"outputs": [],
|
|
948
|
+
"stateMutability": "nonpayable",
|
|
949
|
+
"type": "function"
|
|
950
|
+
},
|
|
951
|
+
{
|
|
952
|
+
"inputs": [
|
|
953
|
+
{
|
|
954
|
+
"internalType": "uint256",
|
|
955
|
+
"name": "_exitMaxSlippage",
|
|
956
|
+
"type": "uint256"
|
|
957
|
+
}
|
|
958
|
+
],
|
|
959
|
+
"name": "setExitMaxSlippage",
|
|
960
|
+
"outputs": [],
|
|
961
|
+
"stateMutability": "nonpayable",
|
|
962
|
+
"type": "function"
|
|
963
|
+
},
|
|
964
|
+
{
|
|
965
|
+
"inputs": [
|
|
966
|
+
{
|
|
967
|
+
"internalType": "address[]",
|
|
968
|
+
"name": "inputTokens",
|
|
969
|
+
"type": "address[]"
|
|
970
|
+
}
|
|
971
|
+
],
|
|
972
|
+
"name": "setInputTokens",
|
|
973
|
+
"outputs": [],
|
|
974
|
+
"stateMutability": "nonpayable",
|
|
975
|
+
"type": "function"
|
|
976
|
+
},
|
|
977
|
+
{
|
|
978
|
+
"inputs": [
|
|
979
|
+
{
|
|
980
|
+
"internalType": "address[]",
|
|
981
|
+
"name": "outputTokens",
|
|
982
|
+
"type": "address[]"
|
|
983
|
+
}
|
|
984
|
+
],
|
|
985
|
+
"name": "setOutputTokens",
|
|
986
|
+
"outputs": [],
|
|
987
|
+
"stateMutability": "nonpayable",
|
|
988
|
+
"type": "function"
|
|
989
|
+
},
|
|
990
|
+
{
|
|
991
|
+
"inputs": [
|
|
992
|
+
{
|
|
993
|
+
"internalType": "bytes32",
|
|
994
|
+
"name": "stateId",
|
|
995
|
+
"type": "bytes32"
|
|
996
|
+
}
|
|
997
|
+
],
|
|
998
|
+
"name": "stateBitmask",
|
|
999
|
+
"outputs": [
|
|
1000
|
+
{
|
|
1001
|
+
"internalType": "uint256",
|
|
1002
|
+
"name": "",
|
|
1003
|
+
"type": "uint256"
|
|
1004
|
+
}
|
|
1005
|
+
],
|
|
1006
|
+
"stateMutability": "view",
|
|
1007
|
+
"type": "function"
|
|
1008
|
+
},
|
|
1009
|
+
{
|
|
1010
|
+
"inputs": [
|
|
1011
|
+
{
|
|
1012
|
+
"internalType": "bytes32",
|
|
1013
|
+
"name": "stateId",
|
|
1014
|
+
"type": "bytes32"
|
|
1015
|
+
}
|
|
1016
|
+
],
|
|
1017
|
+
"name": "stateNav",
|
|
1018
|
+
"outputs": [
|
|
1019
|
+
{
|
|
1020
|
+
"internalType": "uint256",
|
|
1021
|
+
"name": "",
|
|
1022
|
+
"type": "uint256"
|
|
1023
|
+
}
|
|
1024
|
+
],
|
|
1025
|
+
"stateMutability": "view",
|
|
1026
|
+
"type": "function"
|
|
1027
|
+
},
|
|
1028
|
+
{
|
|
1029
|
+
"inputs": [
|
|
1030
|
+
{
|
|
1031
|
+
"internalType": "bytes32",
|
|
1032
|
+
"name": "toStateId",
|
|
1033
|
+
"type": "bytes32"
|
|
1034
|
+
},
|
|
1035
|
+
{
|
|
1036
|
+
"internalType": "uint256",
|
|
1037
|
+
"name": "share",
|
|
1038
|
+
"type": "uint256"
|
|
1039
|
+
}
|
|
1040
|
+
],
|
|
1041
|
+
"name": "tryEmergencyExit",
|
|
1042
|
+
"outputs": [],
|
|
1043
|
+
"stateMutability": "nonpayable",
|
|
1044
|
+
"type": "function"
|
|
1045
|
+
},
|
|
1046
|
+
{
|
|
1047
|
+
"inputs": [],
|
|
1048
|
+
"name": "underlyingAsset0",
|
|
1049
|
+
"outputs": [
|
|
1050
|
+
{
|
|
1051
|
+
"internalType": "address",
|
|
1052
|
+
"name": "",
|
|
1053
|
+
"type": "address"
|
|
1054
|
+
}
|
|
1055
|
+
],
|
|
1056
|
+
"stateMutability": "view",
|
|
1057
|
+
"type": "function"
|
|
1058
|
+
},
|
|
1059
|
+
{
|
|
1060
|
+
"inputs": [],
|
|
1061
|
+
"name": "underlyingAsset1",
|
|
1062
|
+
"outputs": [
|
|
1063
|
+
{
|
|
1064
|
+
"internalType": "address",
|
|
1065
|
+
"name": "",
|
|
1066
|
+
"type": "address"
|
|
1067
|
+
}
|
|
1068
|
+
],
|
|
1069
|
+
"stateMutability": "view",
|
|
1070
|
+
"type": "function"
|
|
1071
|
+
}
|
|
1072
|
+
];
|
|
1073
|
+
/**
|
|
1074
|
+
* CurveGauge_json Contract Class
|
|
1075
|
+
*
|
|
1076
|
+
* Provides a class-based API similar to TypeChain for interacting with the contract.
|
|
1077
|
+
*
|
|
1078
|
+
* @example
|
|
1079
|
+
* ```typescript
|
|
1080
|
+
* import { createPublicClient, createWalletClient, http } from 'viem';
|
|
1081
|
+
* import { mainnet } from 'viem/chains';
|
|
1082
|
+
* import { CurveGauge_json } from 'CurveGauge_json';
|
|
1083
|
+
*
|
|
1084
|
+
* const publicClient = createPublicClient({ chain: mainnet, transport: http() });
|
|
1085
|
+
* const walletClient = createWalletClient({ chain: mainnet, transport: http() });
|
|
1086
|
+
*
|
|
1087
|
+
* const contract = new CurveGauge_json('0x...', { publicClient, walletClient });
|
|
1088
|
+
*
|
|
1089
|
+
* // Read functions
|
|
1090
|
+
* const result = await contract.balanceOf('0x...');
|
|
1091
|
+
*
|
|
1092
|
+
* // Write functions
|
|
1093
|
+
* const hash = await contract.transfer('0x...', 1000n);
|
|
1094
|
+
*
|
|
1095
|
+
* // Simulate transactions (dry-run)
|
|
1096
|
+
* const simulation = await contract.simulate.transfer('0x...', 1000n);
|
|
1097
|
+
* console.log('Gas estimate:', simulation.request.gas);
|
|
1098
|
+
*
|
|
1099
|
+
* // Watch events
|
|
1100
|
+
* const unwatch = contract.watch.Transfer((event) => {
|
|
1101
|
+
* console.log('Transfer event:', event);
|
|
1102
|
+
* });
|
|
1103
|
+
* ```
|
|
1104
|
+
*/
|
|
1105
|
+
class CurveGauge_json {
|
|
1106
|
+
constructor(address, clients) {
|
|
1107
|
+
this.contractAddress = address;
|
|
1108
|
+
this.publicClient = clients.publicClient;
|
|
1109
|
+
this.contract = (0, viem_1.getContract)({
|
|
1110
|
+
address,
|
|
1111
|
+
abi: exports.CurveGauge_jsonAbi,
|
|
1112
|
+
client: {
|
|
1113
|
+
public: clients.publicClient,
|
|
1114
|
+
wallet: clients.walletClient,
|
|
1115
|
+
},
|
|
1116
|
+
});
|
|
1117
|
+
}
|
|
1118
|
+
/**
|
|
1119
|
+
* Get the contract address
|
|
1120
|
+
*/
|
|
1121
|
+
get address() {
|
|
1122
|
+
return this.contractAddress;
|
|
1123
|
+
}
|
|
1124
|
+
/**
|
|
1125
|
+
* Get the underlying viem contract instance
|
|
1126
|
+
*/
|
|
1127
|
+
getContract() {
|
|
1128
|
+
return this.contract;
|
|
1129
|
+
}
|
|
1130
|
+
/**
|
|
1131
|
+
* currentStateId
|
|
1132
|
+
* view
|
|
1133
|
+
*/
|
|
1134
|
+
async currentStateId() {
|
|
1135
|
+
return this.contract.read.currentStateId();
|
|
1136
|
+
}
|
|
1137
|
+
/**
|
|
1138
|
+
* currentStateNav
|
|
1139
|
+
* view
|
|
1140
|
+
*/
|
|
1141
|
+
async currentStateNav() {
|
|
1142
|
+
return this.contract.read.currentStateNav();
|
|
1143
|
+
}
|
|
1144
|
+
/**
|
|
1145
|
+
* emergencyExitMaxSlippage
|
|
1146
|
+
* view
|
|
1147
|
+
*/
|
|
1148
|
+
async emergencyExitMaxSlippage() {
|
|
1149
|
+
return this.contract.read.emergencyExitMaxSlippage();
|
|
1150
|
+
}
|
|
1151
|
+
/**
|
|
1152
|
+
* enterMaxSlippage
|
|
1153
|
+
* view
|
|
1154
|
+
*/
|
|
1155
|
+
async enterMaxSlippage() {
|
|
1156
|
+
return this.contract.read.enterMaxSlippage();
|
|
1157
|
+
}
|
|
1158
|
+
/**
|
|
1159
|
+
* exitMaxSlippage
|
|
1160
|
+
* view
|
|
1161
|
+
*/
|
|
1162
|
+
async exitMaxSlippage() {
|
|
1163
|
+
return this.contract.read.exitMaxSlippage();
|
|
1164
|
+
}
|
|
1165
|
+
/**
|
|
1166
|
+
* gauge
|
|
1167
|
+
* view
|
|
1168
|
+
*/
|
|
1169
|
+
async gauge() {
|
|
1170
|
+
return this.contract.read.gauge();
|
|
1171
|
+
}
|
|
1172
|
+
/**
|
|
1173
|
+
* getInputTokens
|
|
1174
|
+
* view
|
|
1175
|
+
*/
|
|
1176
|
+
async getInputTokens() {
|
|
1177
|
+
return this.contract.read.getInputTokens();
|
|
1178
|
+
}
|
|
1179
|
+
/**
|
|
1180
|
+
* getOutputTokens
|
|
1181
|
+
* view
|
|
1182
|
+
*/
|
|
1183
|
+
async getOutputTokens() {
|
|
1184
|
+
return this.contract.read.getOutputTokens();
|
|
1185
|
+
}
|
|
1186
|
+
/**
|
|
1187
|
+
* getStateIds
|
|
1188
|
+
* view
|
|
1189
|
+
*/
|
|
1190
|
+
async getStateIds() {
|
|
1191
|
+
return this.contract.read.getStateIds();
|
|
1192
|
+
}
|
|
1193
|
+
/**
|
|
1194
|
+
* getTokenAmountInNotion
|
|
1195
|
+
* view
|
|
1196
|
+
*/
|
|
1197
|
+
async getTokenAmountInNotion(token, amount) {
|
|
1198
|
+
return this.contract.read.getTokenAmountInNotion([token, amount]);
|
|
1199
|
+
}
|
|
1200
|
+
/**
|
|
1201
|
+
* isNavResolutionMode
|
|
1202
|
+
* view
|
|
1203
|
+
*/
|
|
1204
|
+
async isNavResolutionMode() {
|
|
1205
|
+
return this.contract.read.isNavResolutionMode();
|
|
1206
|
+
}
|
|
1207
|
+
/**
|
|
1208
|
+
* lastStoredGaugeBalance
|
|
1209
|
+
* view
|
|
1210
|
+
*/
|
|
1211
|
+
async lastStoredGaugeBalance() {
|
|
1212
|
+
return this.contract.read.lastStoredGaugeBalance();
|
|
1213
|
+
}
|
|
1214
|
+
/**
|
|
1215
|
+
* lastStoredVirtualPrice
|
|
1216
|
+
* view
|
|
1217
|
+
*/
|
|
1218
|
+
async lastStoredVirtualPrice() {
|
|
1219
|
+
return this.contract.read.lastStoredVirtualPrice();
|
|
1220
|
+
}
|
|
1221
|
+
/**
|
|
1222
|
+
* lpToken
|
|
1223
|
+
* view
|
|
1224
|
+
*/
|
|
1225
|
+
async lpToken() {
|
|
1226
|
+
return this.contract.read.lpToken();
|
|
1227
|
+
}
|
|
1228
|
+
/**
|
|
1229
|
+
* stateBitmask
|
|
1230
|
+
* view
|
|
1231
|
+
*/
|
|
1232
|
+
async stateBitmask(stateId) {
|
|
1233
|
+
return this.contract.read.stateBitmask([stateId]);
|
|
1234
|
+
}
|
|
1235
|
+
/**
|
|
1236
|
+
* stateNav
|
|
1237
|
+
* view
|
|
1238
|
+
*/
|
|
1239
|
+
async stateNav(stateId) {
|
|
1240
|
+
return this.contract.read.stateNav([stateId]);
|
|
1241
|
+
}
|
|
1242
|
+
/**
|
|
1243
|
+
* underlyingAsset0
|
|
1244
|
+
* view
|
|
1245
|
+
*/
|
|
1246
|
+
async underlyingAsset0() {
|
|
1247
|
+
return this.contract.read.underlyingAsset0();
|
|
1248
|
+
}
|
|
1249
|
+
/**
|
|
1250
|
+
* underlyingAsset1
|
|
1251
|
+
* view
|
|
1252
|
+
*/
|
|
1253
|
+
async underlyingAsset1() {
|
|
1254
|
+
return this.contract.read.underlyingAsset1();
|
|
1255
|
+
}
|
|
1256
|
+
/**
|
|
1257
|
+
* acceptNav
|
|
1258
|
+
* nonpayable
|
|
1259
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1260
|
+
*/
|
|
1261
|
+
async acceptNav(acceptedStateId, options) {
|
|
1262
|
+
if (!this.contract.write) {
|
|
1263
|
+
throw new Error('Wallet client is required for write operations');
|
|
1264
|
+
}
|
|
1265
|
+
return this.contract.write.acceptNav([acceptedStateId], options);
|
|
1266
|
+
}
|
|
1267
|
+
/**
|
|
1268
|
+
* emergencyExit
|
|
1269
|
+
* payable
|
|
1270
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1271
|
+
*/
|
|
1272
|
+
async emergencyExit(toStateId, share, minNavDelta, options) {
|
|
1273
|
+
if (!this.contract.write) {
|
|
1274
|
+
throw new Error('Wallet client is required for write operations');
|
|
1275
|
+
}
|
|
1276
|
+
return this.contract.write.emergencyExit([toStateId, share, minNavDelta], options);
|
|
1277
|
+
}
|
|
1278
|
+
/**
|
|
1279
|
+
* enter
|
|
1280
|
+
* payable
|
|
1281
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1282
|
+
*/
|
|
1283
|
+
async enter(amounts, minNavDelta, options) {
|
|
1284
|
+
if (!this.contract.write) {
|
|
1285
|
+
throw new Error('Wallet client is required for write operations');
|
|
1286
|
+
}
|
|
1287
|
+
return this.contract.write.enter([amounts, minNavDelta], options);
|
|
1288
|
+
}
|
|
1289
|
+
/**
|
|
1290
|
+
* exit
|
|
1291
|
+
* payable
|
|
1292
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1293
|
+
*/
|
|
1294
|
+
async exit(share, maxNavDelta, options) {
|
|
1295
|
+
if (!this.contract.write) {
|
|
1296
|
+
throw new Error('Wallet client is required for write operations');
|
|
1297
|
+
}
|
|
1298
|
+
return this.contract.write.exit([share, maxNavDelta], options);
|
|
1299
|
+
}
|
|
1300
|
+
/**
|
|
1301
|
+
* harvest
|
|
1302
|
+
* payable
|
|
1303
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1304
|
+
*/
|
|
1305
|
+
async harvest(options) {
|
|
1306
|
+
if (!this.contract.write) {
|
|
1307
|
+
throw new Error('Wallet client is required for write operations');
|
|
1308
|
+
}
|
|
1309
|
+
return this.contract.write.harvest(options);
|
|
1310
|
+
}
|
|
1311
|
+
/**
|
|
1312
|
+
* initialize
|
|
1313
|
+
* nonpayable
|
|
1314
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1315
|
+
*/
|
|
1316
|
+
async initialize(strategyContainer, _gauge, _enterMaxSlippage, _exitMaxSlippage, _emergencyExitMaxSlippage, options) {
|
|
1317
|
+
if (!this.contract.write) {
|
|
1318
|
+
throw new Error('Wallet client is required for write operations');
|
|
1319
|
+
}
|
|
1320
|
+
return this.contract.write.initialize([strategyContainer, _gauge, _enterMaxSlippage, _exitMaxSlippage, _emergencyExitMaxSlippage], options);
|
|
1321
|
+
}
|
|
1322
|
+
/**
|
|
1323
|
+
* reenterToState
|
|
1324
|
+
* payable
|
|
1325
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1326
|
+
*/
|
|
1327
|
+
async reenterToState(stateId, minNavDelta, options) {
|
|
1328
|
+
if (!this.contract.write) {
|
|
1329
|
+
throw new Error('Wallet client is required for write operations');
|
|
1330
|
+
}
|
|
1331
|
+
return this.contract.write.reenterToState([stateId, minNavDelta], options);
|
|
1332
|
+
}
|
|
1333
|
+
/**
|
|
1334
|
+
* setEmergencyExitMaxSlippage
|
|
1335
|
+
* nonpayable
|
|
1336
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1337
|
+
*/
|
|
1338
|
+
async setEmergencyExitMaxSlippage(_emergencyExitMaxSlippage, options) {
|
|
1339
|
+
if (!this.contract.write) {
|
|
1340
|
+
throw new Error('Wallet client is required for write operations');
|
|
1341
|
+
}
|
|
1342
|
+
return this.contract.write.setEmergencyExitMaxSlippage([_emergencyExitMaxSlippage], options);
|
|
1343
|
+
}
|
|
1344
|
+
/**
|
|
1345
|
+
* setEnterMaxSlippage
|
|
1346
|
+
* nonpayable
|
|
1347
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1348
|
+
*/
|
|
1349
|
+
async setEnterMaxSlippage(_enterMaxSlippage, options) {
|
|
1350
|
+
if (!this.contract.write) {
|
|
1351
|
+
throw new Error('Wallet client is required for write operations');
|
|
1352
|
+
}
|
|
1353
|
+
return this.contract.write.setEnterMaxSlippage([_enterMaxSlippage], options);
|
|
1354
|
+
}
|
|
1355
|
+
/**
|
|
1356
|
+
* setExitMaxSlippage
|
|
1357
|
+
* nonpayable
|
|
1358
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1359
|
+
*/
|
|
1360
|
+
async setExitMaxSlippage(_exitMaxSlippage, options) {
|
|
1361
|
+
if (!this.contract.write) {
|
|
1362
|
+
throw new Error('Wallet client is required for write operations');
|
|
1363
|
+
}
|
|
1364
|
+
return this.contract.write.setExitMaxSlippage([_exitMaxSlippage], options);
|
|
1365
|
+
}
|
|
1366
|
+
/**
|
|
1367
|
+
* setInputTokens
|
|
1368
|
+
* nonpayable
|
|
1369
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1370
|
+
*/
|
|
1371
|
+
async setInputTokens(inputTokens, options) {
|
|
1372
|
+
if (!this.contract.write) {
|
|
1373
|
+
throw new Error('Wallet client is required for write operations');
|
|
1374
|
+
}
|
|
1375
|
+
return this.contract.write.setInputTokens([inputTokens], options);
|
|
1376
|
+
}
|
|
1377
|
+
/**
|
|
1378
|
+
* setOutputTokens
|
|
1379
|
+
* nonpayable
|
|
1380
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1381
|
+
*/
|
|
1382
|
+
async setOutputTokens(outputTokens, options) {
|
|
1383
|
+
if (!this.contract.write) {
|
|
1384
|
+
throw new Error('Wallet client is required for write operations');
|
|
1385
|
+
}
|
|
1386
|
+
return this.contract.write.setOutputTokens([outputTokens], options);
|
|
1387
|
+
}
|
|
1388
|
+
/**
|
|
1389
|
+
* tryEmergencyExit
|
|
1390
|
+
* nonpayable
|
|
1391
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1392
|
+
*/
|
|
1393
|
+
async tryEmergencyExit(toStateId, share, options) {
|
|
1394
|
+
if (!this.contract.write) {
|
|
1395
|
+
throw new Error('Wallet client is required for write operations');
|
|
1396
|
+
}
|
|
1397
|
+
return this.contract.write.tryEmergencyExit([toStateId, share], options);
|
|
1398
|
+
}
|
|
1399
|
+
/**
|
|
1400
|
+
* Simulate contract write operations (dry-run without sending transaction)
|
|
1401
|
+
*
|
|
1402
|
+
* @example
|
|
1403
|
+
* const result = await contract.simulate.transfer('0x...', 1000n);
|
|
1404
|
+
* console.log('Gas estimate:', result.request.gas);
|
|
1405
|
+
* console.log('Would succeed:', result.result);
|
|
1406
|
+
*/
|
|
1407
|
+
get simulate() {
|
|
1408
|
+
const contract = this.contract;
|
|
1409
|
+
if (!contract.simulate) {
|
|
1410
|
+
throw new Error('Public client is required for simulation');
|
|
1411
|
+
}
|
|
1412
|
+
return {
|
|
1413
|
+
/**
|
|
1414
|
+
* Simulate acceptNav
|
|
1415
|
+
* Returns gas estimate and result without sending transaction
|
|
1416
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1417
|
+
*/
|
|
1418
|
+
async acceptNav(acceptedStateId, options) {
|
|
1419
|
+
return contract.simulate.acceptNav([acceptedStateId], options);
|
|
1420
|
+
},
|
|
1421
|
+
/**
|
|
1422
|
+
* Simulate emergencyExit
|
|
1423
|
+
* Returns gas estimate and result without sending transaction
|
|
1424
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1425
|
+
*/
|
|
1426
|
+
async emergencyExit(toStateId, share, minNavDelta, options) {
|
|
1427
|
+
return contract.simulate.emergencyExit([toStateId, share, minNavDelta], options);
|
|
1428
|
+
},
|
|
1429
|
+
/**
|
|
1430
|
+
* Simulate enter
|
|
1431
|
+
* Returns gas estimate and result without sending transaction
|
|
1432
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1433
|
+
*/
|
|
1434
|
+
async enter(amounts, minNavDelta, options) {
|
|
1435
|
+
return contract.simulate.enter([amounts, minNavDelta], options);
|
|
1436
|
+
},
|
|
1437
|
+
/**
|
|
1438
|
+
* Simulate exit
|
|
1439
|
+
* Returns gas estimate and result without sending transaction
|
|
1440
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1441
|
+
*/
|
|
1442
|
+
async exit(share, maxNavDelta, options) {
|
|
1443
|
+
return contract.simulate.exit([share, maxNavDelta], options);
|
|
1444
|
+
},
|
|
1445
|
+
/**
|
|
1446
|
+
* Simulate harvest
|
|
1447
|
+
* Returns gas estimate and result without sending transaction
|
|
1448
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1449
|
+
*/
|
|
1450
|
+
async harvest(options) {
|
|
1451
|
+
return contract.simulate.harvest(options);
|
|
1452
|
+
},
|
|
1453
|
+
/**
|
|
1454
|
+
* Simulate initialize
|
|
1455
|
+
* Returns gas estimate and result without sending transaction
|
|
1456
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1457
|
+
*/
|
|
1458
|
+
async initialize(strategyContainer, _gauge, _enterMaxSlippage, _exitMaxSlippage, _emergencyExitMaxSlippage, options) {
|
|
1459
|
+
return contract.simulate.initialize([strategyContainer, _gauge, _enterMaxSlippage, _exitMaxSlippage, _emergencyExitMaxSlippage], options);
|
|
1460
|
+
},
|
|
1461
|
+
/**
|
|
1462
|
+
* Simulate reenterToState
|
|
1463
|
+
* Returns gas estimate and result without sending transaction
|
|
1464
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1465
|
+
*/
|
|
1466
|
+
async reenterToState(stateId, minNavDelta, options) {
|
|
1467
|
+
return contract.simulate.reenterToState([stateId, minNavDelta], options);
|
|
1468
|
+
},
|
|
1469
|
+
/**
|
|
1470
|
+
* Simulate setEmergencyExitMaxSlippage
|
|
1471
|
+
* Returns gas estimate and result without sending transaction
|
|
1472
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1473
|
+
*/
|
|
1474
|
+
async setEmergencyExitMaxSlippage(_emergencyExitMaxSlippage, options) {
|
|
1475
|
+
return contract.simulate.setEmergencyExitMaxSlippage([_emergencyExitMaxSlippage], options);
|
|
1476
|
+
},
|
|
1477
|
+
/**
|
|
1478
|
+
* Simulate setEnterMaxSlippage
|
|
1479
|
+
* Returns gas estimate and result without sending transaction
|
|
1480
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1481
|
+
*/
|
|
1482
|
+
async setEnterMaxSlippage(_enterMaxSlippage, options) {
|
|
1483
|
+
return contract.simulate.setEnterMaxSlippage([_enterMaxSlippage], options);
|
|
1484
|
+
},
|
|
1485
|
+
/**
|
|
1486
|
+
* Simulate setExitMaxSlippage
|
|
1487
|
+
* Returns gas estimate and result without sending transaction
|
|
1488
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1489
|
+
*/
|
|
1490
|
+
async setExitMaxSlippage(_exitMaxSlippage, options) {
|
|
1491
|
+
return contract.simulate.setExitMaxSlippage([_exitMaxSlippage], options);
|
|
1492
|
+
},
|
|
1493
|
+
/**
|
|
1494
|
+
* Simulate setInputTokens
|
|
1495
|
+
* Returns gas estimate and result without sending transaction
|
|
1496
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1497
|
+
*/
|
|
1498
|
+
async setInputTokens(inputTokens, options) {
|
|
1499
|
+
return contract.simulate.setInputTokens([inputTokens], options);
|
|
1500
|
+
},
|
|
1501
|
+
/**
|
|
1502
|
+
* Simulate setOutputTokens
|
|
1503
|
+
* Returns gas estimate and result without sending transaction
|
|
1504
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1505
|
+
*/
|
|
1506
|
+
async setOutputTokens(outputTokens, options) {
|
|
1507
|
+
return contract.simulate.setOutputTokens([outputTokens], options);
|
|
1508
|
+
},
|
|
1509
|
+
/**
|
|
1510
|
+
* Simulate tryEmergencyExit
|
|
1511
|
+
* Returns gas estimate and result without sending transaction
|
|
1512
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1513
|
+
*/
|
|
1514
|
+
async tryEmergencyExit(toStateId, share, options) {
|
|
1515
|
+
return contract.simulate.tryEmergencyExit([toStateId, share], options);
|
|
1516
|
+
}
|
|
1517
|
+
};
|
|
1518
|
+
}
|
|
1519
|
+
/**
|
|
1520
|
+
* Watch contract events
|
|
1521
|
+
*
|
|
1522
|
+
* @example
|
|
1523
|
+
* // Watch all Transfer events
|
|
1524
|
+
* const unwatch = contract.watch.Transfer((event) => {
|
|
1525
|
+
* console.log('Transfer:', event);
|
|
1526
|
+
* });
|
|
1527
|
+
*
|
|
1528
|
+
* // Stop watching
|
|
1529
|
+
* unwatch();
|
|
1530
|
+
*/
|
|
1531
|
+
get watch() {
|
|
1532
|
+
return {
|
|
1533
|
+
/**
|
|
1534
|
+
* Watch EmergencyExitFailed events
|
|
1535
|
+
* @param callback Function to call when event is emitted
|
|
1536
|
+
* @param filter Optional filter for indexed parameters
|
|
1537
|
+
* @returns Unwatch function to stop listening
|
|
1538
|
+
*/
|
|
1539
|
+
EmergencyExitFailed: (callback) => {
|
|
1540
|
+
return this.publicClient.watchContractEvent({
|
|
1541
|
+
address: this.contractAddress,
|
|
1542
|
+
abi: exports.CurveGauge_jsonAbi,
|
|
1543
|
+
eventName: 'EmergencyExitFailed',
|
|
1544
|
+
onLogs: (logs) => {
|
|
1545
|
+
logs.forEach((log) => {
|
|
1546
|
+
callback(log.args);
|
|
1547
|
+
});
|
|
1548
|
+
},
|
|
1549
|
+
});
|
|
1550
|
+
},
|
|
1551
|
+
/**
|
|
1552
|
+
* Watch EmergencyExitMaxSlippageUpdated events
|
|
1553
|
+
* @param callback Function to call when event is emitted
|
|
1554
|
+
* @param filter Optional filter for indexed parameters
|
|
1555
|
+
* @returns Unwatch function to stop listening
|
|
1556
|
+
*/
|
|
1557
|
+
EmergencyExitMaxSlippageUpdated: (callback) => {
|
|
1558
|
+
return this.publicClient.watchContractEvent({
|
|
1559
|
+
address: this.contractAddress,
|
|
1560
|
+
abi: exports.CurveGauge_jsonAbi,
|
|
1561
|
+
eventName: 'EmergencyExitMaxSlippageUpdated',
|
|
1562
|
+
onLogs: (logs) => {
|
|
1563
|
+
logs.forEach((log) => {
|
|
1564
|
+
callback(log.args);
|
|
1565
|
+
});
|
|
1566
|
+
},
|
|
1567
|
+
});
|
|
1568
|
+
},
|
|
1569
|
+
/**
|
|
1570
|
+
* Watch EmergencyExitSucceeded events
|
|
1571
|
+
* @param callback Function to call when event is emitted
|
|
1572
|
+
* @param filter Optional filter for indexed parameters
|
|
1573
|
+
* @returns Unwatch function to stop listening
|
|
1574
|
+
*/
|
|
1575
|
+
EmergencyExitSucceeded: (callback) => {
|
|
1576
|
+
return this.publicClient.watchContractEvent({
|
|
1577
|
+
address: this.contractAddress,
|
|
1578
|
+
abi: exports.CurveGauge_jsonAbi,
|
|
1579
|
+
eventName: 'EmergencyExitSucceeded',
|
|
1580
|
+
onLogs: (logs) => {
|
|
1581
|
+
logs.forEach((log) => {
|
|
1582
|
+
callback(log.args);
|
|
1583
|
+
});
|
|
1584
|
+
},
|
|
1585
|
+
});
|
|
1586
|
+
},
|
|
1587
|
+
/**
|
|
1588
|
+
* Watch EmergencyExited events
|
|
1589
|
+
* @param callback Function to call when event is emitted
|
|
1590
|
+
* @param filter Optional filter for indexed parameters
|
|
1591
|
+
* @returns Unwatch function to stop listening
|
|
1592
|
+
*/
|
|
1593
|
+
EmergencyExited: (callback) => {
|
|
1594
|
+
return this.publicClient.watchContractEvent({
|
|
1595
|
+
address: this.contractAddress,
|
|
1596
|
+
abi: exports.CurveGauge_jsonAbi,
|
|
1597
|
+
eventName: 'EmergencyExited',
|
|
1598
|
+
onLogs: (logs) => {
|
|
1599
|
+
logs.forEach((log) => {
|
|
1600
|
+
callback(log.args);
|
|
1601
|
+
});
|
|
1602
|
+
},
|
|
1603
|
+
});
|
|
1604
|
+
},
|
|
1605
|
+
/**
|
|
1606
|
+
* Watch EmergencyModeUpdated events
|
|
1607
|
+
* @param callback Function to call when event is emitted
|
|
1608
|
+
* @param filter Optional filter for indexed parameters
|
|
1609
|
+
* @returns Unwatch function to stop listening
|
|
1610
|
+
*/
|
|
1611
|
+
EmergencyModeUpdated: (callback) => {
|
|
1612
|
+
return this.publicClient.watchContractEvent({
|
|
1613
|
+
address: this.contractAddress,
|
|
1614
|
+
abi: exports.CurveGauge_jsonAbi,
|
|
1615
|
+
eventName: 'EmergencyModeUpdated',
|
|
1616
|
+
onLogs: (logs) => {
|
|
1617
|
+
logs.forEach((log) => {
|
|
1618
|
+
callback(log.args);
|
|
1619
|
+
});
|
|
1620
|
+
},
|
|
1621
|
+
});
|
|
1622
|
+
},
|
|
1623
|
+
/**
|
|
1624
|
+
* Watch EnterMaxSlippageUpdated events
|
|
1625
|
+
* @param callback Function to call when event is emitted
|
|
1626
|
+
* @param filter Optional filter for indexed parameters
|
|
1627
|
+
* @returns Unwatch function to stop listening
|
|
1628
|
+
*/
|
|
1629
|
+
EnterMaxSlippageUpdated: (callback) => {
|
|
1630
|
+
return this.publicClient.watchContractEvent({
|
|
1631
|
+
address: this.contractAddress,
|
|
1632
|
+
abi: exports.CurveGauge_jsonAbi,
|
|
1633
|
+
eventName: 'EnterMaxSlippageUpdated',
|
|
1634
|
+
onLogs: (logs) => {
|
|
1635
|
+
logs.forEach((log) => {
|
|
1636
|
+
callback(log.args);
|
|
1637
|
+
});
|
|
1638
|
+
},
|
|
1639
|
+
});
|
|
1640
|
+
},
|
|
1641
|
+
/**
|
|
1642
|
+
* Watch Entered events
|
|
1643
|
+
* @param callback Function to call when event is emitted
|
|
1644
|
+
* @param filter Optional filter for indexed parameters
|
|
1645
|
+
* @returns Unwatch function to stop listening
|
|
1646
|
+
*/
|
|
1647
|
+
Entered: (callback) => {
|
|
1648
|
+
return this.publicClient.watchContractEvent({
|
|
1649
|
+
address: this.contractAddress,
|
|
1650
|
+
abi: exports.CurveGauge_jsonAbi,
|
|
1651
|
+
eventName: 'Entered',
|
|
1652
|
+
onLogs: (logs) => {
|
|
1653
|
+
logs.forEach((log) => {
|
|
1654
|
+
callback(log.args);
|
|
1655
|
+
});
|
|
1656
|
+
},
|
|
1657
|
+
});
|
|
1658
|
+
},
|
|
1659
|
+
/**
|
|
1660
|
+
* Watch ExitMaxSlippageUpdated events
|
|
1661
|
+
* @param callback Function to call when event is emitted
|
|
1662
|
+
* @param filter Optional filter for indexed parameters
|
|
1663
|
+
* @returns Unwatch function to stop listening
|
|
1664
|
+
*/
|
|
1665
|
+
ExitMaxSlippageUpdated: (callback) => {
|
|
1666
|
+
return this.publicClient.watchContractEvent({
|
|
1667
|
+
address: this.contractAddress,
|
|
1668
|
+
abi: exports.CurveGauge_jsonAbi,
|
|
1669
|
+
eventName: 'ExitMaxSlippageUpdated',
|
|
1670
|
+
onLogs: (logs) => {
|
|
1671
|
+
logs.forEach((log) => {
|
|
1672
|
+
callback(log.args);
|
|
1673
|
+
});
|
|
1674
|
+
},
|
|
1675
|
+
});
|
|
1676
|
+
},
|
|
1677
|
+
/**
|
|
1678
|
+
* Watch Exited events
|
|
1679
|
+
* @param callback Function to call when event is emitted
|
|
1680
|
+
* @param filter Optional filter for indexed parameters
|
|
1681
|
+
* @returns Unwatch function to stop listening
|
|
1682
|
+
*/
|
|
1683
|
+
Exited: (callback) => {
|
|
1684
|
+
return this.publicClient.watchContractEvent({
|
|
1685
|
+
address: this.contractAddress,
|
|
1686
|
+
abi: exports.CurveGauge_jsonAbi,
|
|
1687
|
+
eventName: 'Exited',
|
|
1688
|
+
onLogs: (logs) => {
|
|
1689
|
+
logs.forEach((log) => {
|
|
1690
|
+
callback(log.args);
|
|
1691
|
+
});
|
|
1692
|
+
},
|
|
1693
|
+
});
|
|
1694
|
+
},
|
|
1695
|
+
/**
|
|
1696
|
+
* Watch Harvested events
|
|
1697
|
+
* @param callback Function to call when event is emitted
|
|
1698
|
+
* @param filter Optional filter for indexed parameters
|
|
1699
|
+
* @returns Unwatch function to stop listening
|
|
1700
|
+
*/
|
|
1701
|
+
Harvested: (callback) => {
|
|
1702
|
+
return this.publicClient.watchContractEvent({
|
|
1703
|
+
address: this.contractAddress,
|
|
1704
|
+
abi: exports.CurveGauge_jsonAbi,
|
|
1705
|
+
eventName: 'Harvested',
|
|
1706
|
+
onLogs: (logs) => {
|
|
1707
|
+
logs.forEach((log) => {
|
|
1708
|
+
callback(log.args);
|
|
1709
|
+
});
|
|
1710
|
+
},
|
|
1711
|
+
});
|
|
1712
|
+
},
|
|
1713
|
+
/**
|
|
1714
|
+
* Watch Initialized events
|
|
1715
|
+
* @param callback Function to call when event is emitted
|
|
1716
|
+
* @param filter Optional filter for indexed parameters
|
|
1717
|
+
* @returns Unwatch function to stop listening
|
|
1718
|
+
*/
|
|
1719
|
+
Initialized: (callback) => {
|
|
1720
|
+
return this.publicClient.watchContractEvent({
|
|
1721
|
+
address: this.contractAddress,
|
|
1722
|
+
abi: exports.CurveGauge_jsonAbi,
|
|
1723
|
+
eventName: 'Initialized',
|
|
1724
|
+
onLogs: (logs) => {
|
|
1725
|
+
logs.forEach((log) => {
|
|
1726
|
+
callback(log.args);
|
|
1727
|
+
});
|
|
1728
|
+
},
|
|
1729
|
+
});
|
|
1730
|
+
},
|
|
1731
|
+
/**
|
|
1732
|
+
* Watch InputTokenSet events
|
|
1733
|
+
* @param callback Function to call when event is emitted
|
|
1734
|
+
* @param filter Optional filter for indexed parameters
|
|
1735
|
+
* @returns Unwatch function to stop listening
|
|
1736
|
+
*/
|
|
1737
|
+
InputTokenSet: (callback) => {
|
|
1738
|
+
return this.publicClient.watchContractEvent({
|
|
1739
|
+
address: this.contractAddress,
|
|
1740
|
+
abi: exports.CurveGauge_jsonAbi,
|
|
1741
|
+
eventName: 'InputTokenSet',
|
|
1742
|
+
onLogs: (logs) => {
|
|
1743
|
+
logs.forEach((log) => {
|
|
1744
|
+
callback(log.args);
|
|
1745
|
+
});
|
|
1746
|
+
},
|
|
1747
|
+
});
|
|
1748
|
+
},
|
|
1749
|
+
/**
|
|
1750
|
+
* Watch NavResolutionModeUpdated events
|
|
1751
|
+
* @param callback Function to call when event is emitted
|
|
1752
|
+
* @param filter Optional filter for indexed parameters
|
|
1753
|
+
* @returns Unwatch function to stop listening
|
|
1754
|
+
*/
|
|
1755
|
+
NavResolutionModeUpdated: (callback) => {
|
|
1756
|
+
return this.publicClient.watchContractEvent({
|
|
1757
|
+
address: this.contractAddress,
|
|
1758
|
+
abi: exports.CurveGauge_jsonAbi,
|
|
1759
|
+
eventName: 'NavResolutionModeUpdated',
|
|
1760
|
+
onLogs: (logs) => {
|
|
1761
|
+
logs.forEach((log) => {
|
|
1762
|
+
callback(log.args);
|
|
1763
|
+
});
|
|
1764
|
+
},
|
|
1765
|
+
});
|
|
1766
|
+
},
|
|
1767
|
+
/**
|
|
1768
|
+
* Watch OutputTokenSet events
|
|
1769
|
+
* @param callback Function to call when event is emitted
|
|
1770
|
+
* @param filter Optional filter for indexed parameters
|
|
1771
|
+
* @returns Unwatch function to stop listening
|
|
1772
|
+
*/
|
|
1773
|
+
OutputTokenSet: (callback) => {
|
|
1774
|
+
return this.publicClient.watchContractEvent({
|
|
1775
|
+
address: this.contractAddress,
|
|
1776
|
+
abi: exports.CurveGauge_jsonAbi,
|
|
1777
|
+
eventName: 'OutputTokenSet',
|
|
1778
|
+
onLogs: (logs) => {
|
|
1779
|
+
logs.forEach((log) => {
|
|
1780
|
+
callback(log.args);
|
|
1781
|
+
});
|
|
1782
|
+
},
|
|
1783
|
+
});
|
|
1784
|
+
},
|
|
1785
|
+
/**
|
|
1786
|
+
* Watch ReenteredToState events
|
|
1787
|
+
* @param callback Function to call when event is emitted
|
|
1788
|
+
* @param filter Optional filter for indexed parameters
|
|
1789
|
+
* @returns Unwatch function to stop listening
|
|
1790
|
+
*/
|
|
1791
|
+
ReenteredToState: (callback) => {
|
|
1792
|
+
return this.publicClient.watchContractEvent({
|
|
1793
|
+
address: this.contractAddress,
|
|
1794
|
+
abi: exports.CurveGauge_jsonAbi,
|
|
1795
|
+
eventName: 'ReenteredToState',
|
|
1796
|
+
onLogs: (logs) => {
|
|
1797
|
+
logs.forEach((log) => {
|
|
1798
|
+
callback(log.args);
|
|
1799
|
+
});
|
|
1800
|
+
},
|
|
1801
|
+
});
|
|
1802
|
+
},
|
|
1803
|
+
/**
|
|
1804
|
+
* Watch StateUpdated events
|
|
1805
|
+
* @param callback Function to call when event is emitted
|
|
1806
|
+
* @param filter Optional filter for indexed parameters
|
|
1807
|
+
* @returns Unwatch function to stop listening
|
|
1808
|
+
*/
|
|
1809
|
+
StateUpdated: (callback) => {
|
|
1810
|
+
return this.publicClient.watchContractEvent({
|
|
1811
|
+
address: this.contractAddress,
|
|
1812
|
+
abi: exports.CurveGauge_jsonAbi,
|
|
1813
|
+
eventName: 'StateUpdated',
|
|
1814
|
+
onLogs: (logs) => {
|
|
1815
|
+
logs.forEach((log) => {
|
|
1816
|
+
callback(log.args);
|
|
1817
|
+
});
|
|
1818
|
+
},
|
|
1819
|
+
});
|
|
1820
|
+
}
|
|
1821
|
+
};
|
|
1822
|
+
}
|
|
1823
|
+
}
|
|
1824
|
+
exports.CurveGauge_json = CurveGauge_json;
|