@gitmyabi/walletsimple 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/WalletSimple_json.d.ts +1117 -0
- package/contracts/WalletSimple_json.js +1099 -0
- package/contracts/WalletSimple_json.ts +1459 -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,1459 @@
|
|
|
1
|
+
import type { Abi, Address, PublicClient, WalletClient, GetContractReturnType } from 'viem';
|
|
2
|
+
import { getContract } from 'viem';
|
|
3
|
+
|
|
4
|
+
/**
|
|
5
|
+
* WalletSimple_json ABI
|
|
6
|
+
*
|
|
7
|
+
* This ABI is typed using viem's type system for full type safety.
|
|
8
|
+
*/
|
|
9
|
+
export const WalletSimple_jsonAbi = [
|
|
10
|
+
{
|
|
11
|
+
"anonymous": false,
|
|
12
|
+
"inputs": [
|
|
13
|
+
{
|
|
14
|
+
"indexed": false,
|
|
15
|
+
"internalType": "address",
|
|
16
|
+
"name": "msgSender",
|
|
17
|
+
"type": "address"
|
|
18
|
+
},
|
|
19
|
+
{
|
|
20
|
+
"indexed": false,
|
|
21
|
+
"internalType": "address",
|
|
22
|
+
"name": "otherSigner",
|
|
23
|
+
"type": "address"
|
|
24
|
+
},
|
|
25
|
+
{
|
|
26
|
+
"indexed": false,
|
|
27
|
+
"internalType": "bytes32",
|
|
28
|
+
"name": "operation",
|
|
29
|
+
"type": "bytes32"
|
|
30
|
+
}
|
|
31
|
+
],
|
|
32
|
+
"name": "BatchTransacted",
|
|
33
|
+
"type": "event"
|
|
34
|
+
},
|
|
35
|
+
{
|
|
36
|
+
"anonymous": false,
|
|
37
|
+
"inputs": [
|
|
38
|
+
{
|
|
39
|
+
"indexed": false,
|
|
40
|
+
"internalType": "address",
|
|
41
|
+
"name": "sender",
|
|
42
|
+
"type": "address"
|
|
43
|
+
},
|
|
44
|
+
{
|
|
45
|
+
"indexed": false,
|
|
46
|
+
"internalType": "address",
|
|
47
|
+
"name": "recipient",
|
|
48
|
+
"type": "address"
|
|
49
|
+
},
|
|
50
|
+
{
|
|
51
|
+
"indexed": false,
|
|
52
|
+
"internalType": "uint256",
|
|
53
|
+
"name": "value",
|
|
54
|
+
"type": "uint256"
|
|
55
|
+
}
|
|
56
|
+
],
|
|
57
|
+
"name": "BatchTransfer",
|
|
58
|
+
"type": "event"
|
|
59
|
+
},
|
|
60
|
+
{
|
|
61
|
+
"anonymous": false,
|
|
62
|
+
"inputs": [
|
|
63
|
+
{
|
|
64
|
+
"indexed": false,
|
|
65
|
+
"internalType": "address",
|
|
66
|
+
"name": "from",
|
|
67
|
+
"type": "address"
|
|
68
|
+
},
|
|
69
|
+
{
|
|
70
|
+
"indexed": false,
|
|
71
|
+
"internalType": "uint256",
|
|
72
|
+
"name": "value",
|
|
73
|
+
"type": "uint256"
|
|
74
|
+
},
|
|
75
|
+
{
|
|
76
|
+
"indexed": false,
|
|
77
|
+
"internalType": "bytes",
|
|
78
|
+
"name": "data",
|
|
79
|
+
"type": "bytes"
|
|
80
|
+
}
|
|
81
|
+
],
|
|
82
|
+
"name": "Deposited",
|
|
83
|
+
"type": "event"
|
|
84
|
+
},
|
|
85
|
+
{
|
|
86
|
+
"anonymous": false,
|
|
87
|
+
"inputs": [
|
|
88
|
+
{
|
|
89
|
+
"indexed": false,
|
|
90
|
+
"internalType": "address",
|
|
91
|
+
"name": "msgSender",
|
|
92
|
+
"type": "address"
|
|
93
|
+
}
|
|
94
|
+
],
|
|
95
|
+
"name": "SafeModeActivated",
|
|
96
|
+
"type": "event"
|
|
97
|
+
},
|
|
98
|
+
{
|
|
99
|
+
"anonymous": false,
|
|
100
|
+
"inputs": [
|
|
101
|
+
{
|
|
102
|
+
"indexed": false,
|
|
103
|
+
"internalType": "address",
|
|
104
|
+
"name": "msgSender",
|
|
105
|
+
"type": "address"
|
|
106
|
+
},
|
|
107
|
+
{
|
|
108
|
+
"indexed": false,
|
|
109
|
+
"internalType": "address",
|
|
110
|
+
"name": "otherSigner",
|
|
111
|
+
"type": "address"
|
|
112
|
+
},
|
|
113
|
+
{
|
|
114
|
+
"indexed": false,
|
|
115
|
+
"internalType": "bytes32",
|
|
116
|
+
"name": "operation",
|
|
117
|
+
"type": "bytes32"
|
|
118
|
+
},
|
|
119
|
+
{
|
|
120
|
+
"indexed": false,
|
|
121
|
+
"internalType": "address",
|
|
122
|
+
"name": "toAddress",
|
|
123
|
+
"type": "address"
|
|
124
|
+
},
|
|
125
|
+
{
|
|
126
|
+
"indexed": false,
|
|
127
|
+
"internalType": "uint256",
|
|
128
|
+
"name": "value",
|
|
129
|
+
"type": "uint256"
|
|
130
|
+
},
|
|
131
|
+
{
|
|
132
|
+
"indexed": false,
|
|
133
|
+
"internalType": "bytes",
|
|
134
|
+
"name": "data",
|
|
135
|
+
"type": "bytes"
|
|
136
|
+
}
|
|
137
|
+
],
|
|
138
|
+
"name": "Transacted",
|
|
139
|
+
"type": "event"
|
|
140
|
+
},
|
|
141
|
+
{
|
|
142
|
+
"stateMutability": "payable",
|
|
143
|
+
"type": "fallback"
|
|
144
|
+
},
|
|
145
|
+
{
|
|
146
|
+
"inputs": [],
|
|
147
|
+
"name": "activateSafeMode",
|
|
148
|
+
"outputs": [],
|
|
149
|
+
"stateMutability": "nonpayable",
|
|
150
|
+
"type": "function"
|
|
151
|
+
},
|
|
152
|
+
{
|
|
153
|
+
"inputs": [
|
|
154
|
+
{
|
|
155
|
+
"internalType": "address payable",
|
|
156
|
+
"name": "forwarderAddress",
|
|
157
|
+
"type": "address"
|
|
158
|
+
},
|
|
159
|
+
{
|
|
160
|
+
"internalType": "address",
|
|
161
|
+
"name": "tokenContractAddress",
|
|
162
|
+
"type": "address"
|
|
163
|
+
},
|
|
164
|
+
{
|
|
165
|
+
"internalType": "uint256[]",
|
|
166
|
+
"name": "tokenIds",
|
|
167
|
+
"type": "uint256[]"
|
|
168
|
+
}
|
|
169
|
+
],
|
|
170
|
+
"name": "batchFlushERC1155ForwarderTokens",
|
|
171
|
+
"outputs": [],
|
|
172
|
+
"stateMutability": "nonpayable",
|
|
173
|
+
"type": "function"
|
|
174
|
+
},
|
|
175
|
+
{
|
|
176
|
+
"inputs": [
|
|
177
|
+
{
|
|
178
|
+
"internalType": "address payable",
|
|
179
|
+
"name": "forwarderAddress",
|
|
180
|
+
"type": "address"
|
|
181
|
+
},
|
|
182
|
+
{
|
|
183
|
+
"internalType": "address",
|
|
184
|
+
"name": "tokenContractAddress",
|
|
185
|
+
"type": "address"
|
|
186
|
+
},
|
|
187
|
+
{
|
|
188
|
+
"internalType": "uint256",
|
|
189
|
+
"name": "tokenId",
|
|
190
|
+
"type": "uint256"
|
|
191
|
+
}
|
|
192
|
+
],
|
|
193
|
+
"name": "flushERC1155ForwarderTokens",
|
|
194
|
+
"outputs": [],
|
|
195
|
+
"stateMutability": "nonpayable",
|
|
196
|
+
"type": "function"
|
|
197
|
+
},
|
|
198
|
+
{
|
|
199
|
+
"inputs": [
|
|
200
|
+
{
|
|
201
|
+
"internalType": "address payable",
|
|
202
|
+
"name": "forwarderAddress",
|
|
203
|
+
"type": "address"
|
|
204
|
+
},
|
|
205
|
+
{
|
|
206
|
+
"internalType": "address",
|
|
207
|
+
"name": "tokenContractAddress",
|
|
208
|
+
"type": "address"
|
|
209
|
+
},
|
|
210
|
+
{
|
|
211
|
+
"internalType": "uint256",
|
|
212
|
+
"name": "tokenId",
|
|
213
|
+
"type": "uint256"
|
|
214
|
+
}
|
|
215
|
+
],
|
|
216
|
+
"name": "flushERC721ForwarderTokens",
|
|
217
|
+
"outputs": [],
|
|
218
|
+
"stateMutability": "nonpayable",
|
|
219
|
+
"type": "function"
|
|
220
|
+
},
|
|
221
|
+
{
|
|
222
|
+
"inputs": [
|
|
223
|
+
{
|
|
224
|
+
"internalType": "address payable",
|
|
225
|
+
"name": "forwarderAddress",
|
|
226
|
+
"type": "address"
|
|
227
|
+
},
|
|
228
|
+
{
|
|
229
|
+
"internalType": "address",
|
|
230
|
+
"name": "tokenContractAddress",
|
|
231
|
+
"type": "address"
|
|
232
|
+
}
|
|
233
|
+
],
|
|
234
|
+
"name": "flushForwarderTokens",
|
|
235
|
+
"outputs": [],
|
|
236
|
+
"stateMutability": "nonpayable",
|
|
237
|
+
"type": "function"
|
|
238
|
+
},
|
|
239
|
+
{
|
|
240
|
+
"inputs": [],
|
|
241
|
+
"name": "getNextSequenceId",
|
|
242
|
+
"outputs": [
|
|
243
|
+
{
|
|
244
|
+
"internalType": "uint256",
|
|
245
|
+
"name": "",
|
|
246
|
+
"type": "uint256"
|
|
247
|
+
}
|
|
248
|
+
],
|
|
249
|
+
"stateMutability": "view",
|
|
250
|
+
"type": "function"
|
|
251
|
+
},
|
|
252
|
+
{
|
|
253
|
+
"inputs": [
|
|
254
|
+
{
|
|
255
|
+
"internalType": "address[]",
|
|
256
|
+
"name": "allowedSigners",
|
|
257
|
+
"type": "address[]"
|
|
258
|
+
}
|
|
259
|
+
],
|
|
260
|
+
"name": "init",
|
|
261
|
+
"outputs": [],
|
|
262
|
+
"stateMutability": "nonpayable",
|
|
263
|
+
"type": "function"
|
|
264
|
+
},
|
|
265
|
+
{
|
|
266
|
+
"inputs": [],
|
|
267
|
+
"name": "initialized",
|
|
268
|
+
"outputs": [
|
|
269
|
+
{
|
|
270
|
+
"internalType": "bool",
|
|
271
|
+
"name": "",
|
|
272
|
+
"type": "bool"
|
|
273
|
+
}
|
|
274
|
+
],
|
|
275
|
+
"stateMutability": "view",
|
|
276
|
+
"type": "function"
|
|
277
|
+
},
|
|
278
|
+
{
|
|
279
|
+
"inputs": [
|
|
280
|
+
{
|
|
281
|
+
"internalType": "address",
|
|
282
|
+
"name": "signer",
|
|
283
|
+
"type": "address"
|
|
284
|
+
}
|
|
285
|
+
],
|
|
286
|
+
"name": "isSigner",
|
|
287
|
+
"outputs": [
|
|
288
|
+
{
|
|
289
|
+
"internalType": "bool",
|
|
290
|
+
"name": "",
|
|
291
|
+
"type": "bool"
|
|
292
|
+
}
|
|
293
|
+
],
|
|
294
|
+
"stateMutability": "view",
|
|
295
|
+
"type": "function"
|
|
296
|
+
},
|
|
297
|
+
{
|
|
298
|
+
"inputs": [
|
|
299
|
+
{
|
|
300
|
+
"internalType": "address",
|
|
301
|
+
"name": "_operator",
|
|
302
|
+
"type": "address"
|
|
303
|
+
},
|
|
304
|
+
{
|
|
305
|
+
"internalType": "address",
|
|
306
|
+
"name": "_from",
|
|
307
|
+
"type": "address"
|
|
308
|
+
},
|
|
309
|
+
{
|
|
310
|
+
"internalType": "uint256[]",
|
|
311
|
+
"name": "ids",
|
|
312
|
+
"type": "uint256[]"
|
|
313
|
+
},
|
|
314
|
+
{
|
|
315
|
+
"internalType": "uint256[]",
|
|
316
|
+
"name": "values",
|
|
317
|
+
"type": "uint256[]"
|
|
318
|
+
},
|
|
319
|
+
{
|
|
320
|
+
"internalType": "bytes",
|
|
321
|
+
"name": "data",
|
|
322
|
+
"type": "bytes"
|
|
323
|
+
}
|
|
324
|
+
],
|
|
325
|
+
"name": "onERC1155BatchReceived",
|
|
326
|
+
"outputs": [
|
|
327
|
+
{
|
|
328
|
+
"internalType": "bytes4",
|
|
329
|
+
"name": "",
|
|
330
|
+
"type": "bytes4"
|
|
331
|
+
}
|
|
332
|
+
],
|
|
333
|
+
"stateMutability": "nonpayable",
|
|
334
|
+
"type": "function"
|
|
335
|
+
},
|
|
336
|
+
{
|
|
337
|
+
"inputs": [
|
|
338
|
+
{
|
|
339
|
+
"internalType": "address",
|
|
340
|
+
"name": "_operator",
|
|
341
|
+
"type": "address"
|
|
342
|
+
},
|
|
343
|
+
{
|
|
344
|
+
"internalType": "address",
|
|
345
|
+
"name": "_from",
|
|
346
|
+
"type": "address"
|
|
347
|
+
},
|
|
348
|
+
{
|
|
349
|
+
"internalType": "uint256",
|
|
350
|
+
"name": "id",
|
|
351
|
+
"type": "uint256"
|
|
352
|
+
},
|
|
353
|
+
{
|
|
354
|
+
"internalType": "uint256",
|
|
355
|
+
"name": "value",
|
|
356
|
+
"type": "uint256"
|
|
357
|
+
},
|
|
358
|
+
{
|
|
359
|
+
"internalType": "bytes",
|
|
360
|
+
"name": "data",
|
|
361
|
+
"type": "bytes"
|
|
362
|
+
}
|
|
363
|
+
],
|
|
364
|
+
"name": "onERC1155Received",
|
|
365
|
+
"outputs": [
|
|
366
|
+
{
|
|
367
|
+
"internalType": "bytes4",
|
|
368
|
+
"name": "",
|
|
369
|
+
"type": "bytes4"
|
|
370
|
+
}
|
|
371
|
+
],
|
|
372
|
+
"stateMutability": "nonpayable",
|
|
373
|
+
"type": "function"
|
|
374
|
+
},
|
|
375
|
+
{
|
|
376
|
+
"inputs": [
|
|
377
|
+
{
|
|
378
|
+
"internalType": "address",
|
|
379
|
+
"name": "_operator",
|
|
380
|
+
"type": "address"
|
|
381
|
+
},
|
|
382
|
+
{
|
|
383
|
+
"internalType": "address",
|
|
384
|
+
"name": "_from",
|
|
385
|
+
"type": "address"
|
|
386
|
+
},
|
|
387
|
+
{
|
|
388
|
+
"internalType": "uint256",
|
|
389
|
+
"name": "_tokenId",
|
|
390
|
+
"type": "uint256"
|
|
391
|
+
},
|
|
392
|
+
{
|
|
393
|
+
"internalType": "bytes",
|
|
394
|
+
"name": "_data",
|
|
395
|
+
"type": "bytes"
|
|
396
|
+
}
|
|
397
|
+
],
|
|
398
|
+
"name": "onERC721Received",
|
|
399
|
+
"outputs": [
|
|
400
|
+
{
|
|
401
|
+
"internalType": "bytes4",
|
|
402
|
+
"name": "",
|
|
403
|
+
"type": "bytes4"
|
|
404
|
+
}
|
|
405
|
+
],
|
|
406
|
+
"stateMutability": "nonpayable",
|
|
407
|
+
"type": "function"
|
|
408
|
+
},
|
|
409
|
+
{
|
|
410
|
+
"inputs": [],
|
|
411
|
+
"name": "safeMode",
|
|
412
|
+
"outputs": [
|
|
413
|
+
{
|
|
414
|
+
"internalType": "bool",
|
|
415
|
+
"name": "",
|
|
416
|
+
"type": "bool"
|
|
417
|
+
}
|
|
418
|
+
],
|
|
419
|
+
"stateMutability": "view",
|
|
420
|
+
"type": "function"
|
|
421
|
+
},
|
|
422
|
+
{
|
|
423
|
+
"inputs": [
|
|
424
|
+
{
|
|
425
|
+
"internalType": "address",
|
|
426
|
+
"name": "toAddress",
|
|
427
|
+
"type": "address"
|
|
428
|
+
},
|
|
429
|
+
{
|
|
430
|
+
"internalType": "uint256",
|
|
431
|
+
"name": "value",
|
|
432
|
+
"type": "uint256"
|
|
433
|
+
},
|
|
434
|
+
{
|
|
435
|
+
"internalType": "bytes",
|
|
436
|
+
"name": "data",
|
|
437
|
+
"type": "bytes"
|
|
438
|
+
},
|
|
439
|
+
{
|
|
440
|
+
"internalType": "uint256",
|
|
441
|
+
"name": "expireTime",
|
|
442
|
+
"type": "uint256"
|
|
443
|
+
},
|
|
444
|
+
{
|
|
445
|
+
"internalType": "uint256",
|
|
446
|
+
"name": "sequenceId",
|
|
447
|
+
"type": "uint256"
|
|
448
|
+
},
|
|
449
|
+
{
|
|
450
|
+
"internalType": "bytes",
|
|
451
|
+
"name": "signature",
|
|
452
|
+
"type": "bytes"
|
|
453
|
+
}
|
|
454
|
+
],
|
|
455
|
+
"name": "sendMultiSig",
|
|
456
|
+
"outputs": [],
|
|
457
|
+
"stateMutability": "nonpayable",
|
|
458
|
+
"type": "function"
|
|
459
|
+
},
|
|
460
|
+
{
|
|
461
|
+
"inputs": [
|
|
462
|
+
{
|
|
463
|
+
"internalType": "address[]",
|
|
464
|
+
"name": "recipients",
|
|
465
|
+
"type": "address[]"
|
|
466
|
+
},
|
|
467
|
+
{
|
|
468
|
+
"internalType": "uint256[]",
|
|
469
|
+
"name": "values",
|
|
470
|
+
"type": "uint256[]"
|
|
471
|
+
},
|
|
472
|
+
{
|
|
473
|
+
"internalType": "uint256",
|
|
474
|
+
"name": "expireTime",
|
|
475
|
+
"type": "uint256"
|
|
476
|
+
},
|
|
477
|
+
{
|
|
478
|
+
"internalType": "uint256",
|
|
479
|
+
"name": "sequenceId",
|
|
480
|
+
"type": "uint256"
|
|
481
|
+
},
|
|
482
|
+
{
|
|
483
|
+
"internalType": "bytes",
|
|
484
|
+
"name": "signature",
|
|
485
|
+
"type": "bytes"
|
|
486
|
+
}
|
|
487
|
+
],
|
|
488
|
+
"name": "sendMultiSigBatch",
|
|
489
|
+
"outputs": [],
|
|
490
|
+
"stateMutability": "nonpayable",
|
|
491
|
+
"type": "function"
|
|
492
|
+
},
|
|
493
|
+
{
|
|
494
|
+
"inputs": [
|
|
495
|
+
{
|
|
496
|
+
"internalType": "address",
|
|
497
|
+
"name": "toAddress",
|
|
498
|
+
"type": "address"
|
|
499
|
+
},
|
|
500
|
+
{
|
|
501
|
+
"internalType": "uint256",
|
|
502
|
+
"name": "value",
|
|
503
|
+
"type": "uint256"
|
|
504
|
+
},
|
|
505
|
+
{
|
|
506
|
+
"internalType": "address",
|
|
507
|
+
"name": "tokenContractAddress",
|
|
508
|
+
"type": "address"
|
|
509
|
+
},
|
|
510
|
+
{
|
|
511
|
+
"internalType": "uint256",
|
|
512
|
+
"name": "expireTime",
|
|
513
|
+
"type": "uint256"
|
|
514
|
+
},
|
|
515
|
+
{
|
|
516
|
+
"internalType": "uint256",
|
|
517
|
+
"name": "sequenceId",
|
|
518
|
+
"type": "uint256"
|
|
519
|
+
},
|
|
520
|
+
{
|
|
521
|
+
"internalType": "bytes",
|
|
522
|
+
"name": "signature",
|
|
523
|
+
"type": "bytes"
|
|
524
|
+
}
|
|
525
|
+
],
|
|
526
|
+
"name": "sendMultiSigToken",
|
|
527
|
+
"outputs": [],
|
|
528
|
+
"stateMutability": "nonpayable",
|
|
529
|
+
"type": "function"
|
|
530
|
+
},
|
|
531
|
+
{
|
|
532
|
+
"inputs": [
|
|
533
|
+
{
|
|
534
|
+
"internalType": "address",
|
|
535
|
+
"name": "forwarderAddress",
|
|
536
|
+
"type": "address"
|
|
537
|
+
},
|
|
538
|
+
{
|
|
539
|
+
"internalType": "bool",
|
|
540
|
+
"name": "autoFlush",
|
|
541
|
+
"type": "bool"
|
|
542
|
+
}
|
|
543
|
+
],
|
|
544
|
+
"name": "setAutoFlush1155",
|
|
545
|
+
"outputs": [],
|
|
546
|
+
"stateMutability": "nonpayable",
|
|
547
|
+
"type": "function"
|
|
548
|
+
},
|
|
549
|
+
{
|
|
550
|
+
"inputs": [
|
|
551
|
+
{
|
|
552
|
+
"internalType": "address",
|
|
553
|
+
"name": "forwarderAddress",
|
|
554
|
+
"type": "address"
|
|
555
|
+
},
|
|
556
|
+
{
|
|
557
|
+
"internalType": "bool",
|
|
558
|
+
"name": "autoFlush",
|
|
559
|
+
"type": "bool"
|
|
560
|
+
}
|
|
561
|
+
],
|
|
562
|
+
"name": "setAutoFlush721",
|
|
563
|
+
"outputs": [],
|
|
564
|
+
"stateMutability": "nonpayable",
|
|
565
|
+
"type": "function"
|
|
566
|
+
},
|
|
567
|
+
{
|
|
568
|
+
"inputs": [
|
|
569
|
+
{
|
|
570
|
+
"internalType": "address",
|
|
571
|
+
"name": "",
|
|
572
|
+
"type": "address"
|
|
573
|
+
}
|
|
574
|
+
],
|
|
575
|
+
"name": "signers",
|
|
576
|
+
"outputs": [
|
|
577
|
+
{
|
|
578
|
+
"internalType": "bool",
|
|
579
|
+
"name": "",
|
|
580
|
+
"type": "bool"
|
|
581
|
+
}
|
|
582
|
+
],
|
|
583
|
+
"stateMutability": "view",
|
|
584
|
+
"type": "function"
|
|
585
|
+
},
|
|
586
|
+
{
|
|
587
|
+
"inputs": [
|
|
588
|
+
{
|
|
589
|
+
"internalType": "bytes4",
|
|
590
|
+
"name": "interfaceId",
|
|
591
|
+
"type": "bytes4"
|
|
592
|
+
}
|
|
593
|
+
],
|
|
594
|
+
"name": "supportsInterface",
|
|
595
|
+
"outputs": [
|
|
596
|
+
{
|
|
597
|
+
"internalType": "bool",
|
|
598
|
+
"name": "",
|
|
599
|
+
"type": "bool"
|
|
600
|
+
}
|
|
601
|
+
],
|
|
602
|
+
"stateMutability": "view",
|
|
603
|
+
"type": "function"
|
|
604
|
+
},
|
|
605
|
+
{
|
|
606
|
+
"stateMutability": "payable",
|
|
607
|
+
"type": "receive"
|
|
608
|
+
}
|
|
609
|
+
] as const satisfies Abi;
|
|
610
|
+
|
|
611
|
+
/**
|
|
612
|
+
* Type-safe ABI for WalletSimple_json
|
|
613
|
+
*/
|
|
614
|
+
export type WalletSimple_jsonAbi = typeof WalletSimple_jsonAbi;
|
|
615
|
+
|
|
616
|
+
/**
|
|
617
|
+
* Contract instance type for WalletSimple_json
|
|
618
|
+
*/
|
|
619
|
+
// Use any for contract type to avoid complex viem type issues
|
|
620
|
+
// The runtime behavior is type-safe through viem's ABI typing
|
|
621
|
+
export type WalletSimple_jsonContract = any;
|
|
622
|
+
|
|
623
|
+
/**
|
|
624
|
+
* WalletSimple_json Contract Class
|
|
625
|
+
*
|
|
626
|
+
* Provides a class-based API similar to TypeChain for interacting with the contract.
|
|
627
|
+
*
|
|
628
|
+
* @example
|
|
629
|
+
* ```typescript
|
|
630
|
+
* import { createPublicClient, createWalletClient, http } from 'viem';
|
|
631
|
+
* import { mainnet } from 'viem/chains';
|
|
632
|
+
* import { WalletSimple_json } from 'WalletSimple_json';
|
|
633
|
+
*
|
|
634
|
+
* const publicClient = createPublicClient({ chain: mainnet, transport: http() });
|
|
635
|
+
* const walletClient = createWalletClient({ chain: mainnet, transport: http() });
|
|
636
|
+
*
|
|
637
|
+
* const contract = new WalletSimple_json('0x...', { publicClient, walletClient });
|
|
638
|
+
*
|
|
639
|
+
* // Read functions
|
|
640
|
+
* const result = await contract.balanceOf('0x...');
|
|
641
|
+
*
|
|
642
|
+
* // Write functions
|
|
643
|
+
* const hash = await contract.transfer('0x...', 1000n);
|
|
644
|
+
*
|
|
645
|
+
* // Simulate transactions (dry-run)
|
|
646
|
+
* const simulation = await contract.simulate.transfer('0x...', 1000n);
|
|
647
|
+
* console.log('Gas estimate:', simulation.request.gas);
|
|
648
|
+
*
|
|
649
|
+
* // Watch events
|
|
650
|
+
* const unwatch = contract.watch.Transfer((event) => {
|
|
651
|
+
* console.log('Transfer event:', event);
|
|
652
|
+
* });
|
|
653
|
+
* ```
|
|
654
|
+
*/
|
|
655
|
+
export class WalletSimple_json {
|
|
656
|
+
private contract: WalletSimple_jsonContract;
|
|
657
|
+
private contractAddress: Address;
|
|
658
|
+
private publicClient: PublicClient;
|
|
659
|
+
|
|
660
|
+
constructor(
|
|
661
|
+
address: Address,
|
|
662
|
+
clients: {
|
|
663
|
+
publicClient: PublicClient;
|
|
664
|
+
walletClient?: WalletClient;
|
|
665
|
+
}
|
|
666
|
+
) {
|
|
667
|
+
this.contractAddress = address;
|
|
668
|
+
this.publicClient = clients.publicClient;
|
|
669
|
+
this.contract = getContract({
|
|
670
|
+
address,
|
|
671
|
+
abi: WalletSimple_jsonAbi,
|
|
672
|
+
client: {
|
|
673
|
+
public: clients.publicClient,
|
|
674
|
+
wallet: clients.walletClient,
|
|
675
|
+
},
|
|
676
|
+
});
|
|
677
|
+
}
|
|
678
|
+
|
|
679
|
+
/**
|
|
680
|
+
* Get the contract address
|
|
681
|
+
*/
|
|
682
|
+
get address(): Address {
|
|
683
|
+
return this.contractAddress;
|
|
684
|
+
}
|
|
685
|
+
|
|
686
|
+
/**
|
|
687
|
+
* Get the underlying viem contract instance
|
|
688
|
+
*/
|
|
689
|
+
getContract(): WalletSimple_jsonContract {
|
|
690
|
+
return this.contract;
|
|
691
|
+
}
|
|
692
|
+
|
|
693
|
+
/**
|
|
694
|
+
* getNextSequenceId
|
|
695
|
+
* view
|
|
696
|
+
*/
|
|
697
|
+
async getNextSequenceId(): Promise<bigint> {
|
|
698
|
+
return this.contract.read.getNextSequenceId() as Promise<bigint>;
|
|
699
|
+
}
|
|
700
|
+
|
|
701
|
+
/**
|
|
702
|
+
* initialized
|
|
703
|
+
* view
|
|
704
|
+
*/
|
|
705
|
+
async initialized(): Promise<boolean> {
|
|
706
|
+
return this.contract.read.initialized() as Promise<boolean>;
|
|
707
|
+
}
|
|
708
|
+
|
|
709
|
+
/**
|
|
710
|
+
* isSigner
|
|
711
|
+
* view
|
|
712
|
+
*/
|
|
713
|
+
async isSigner(signer: `0x${string}`): Promise<boolean> {
|
|
714
|
+
return this.contract.read.isSigner([signer] as const) as Promise<boolean>;
|
|
715
|
+
}
|
|
716
|
+
|
|
717
|
+
/**
|
|
718
|
+
* safeMode
|
|
719
|
+
* view
|
|
720
|
+
*/
|
|
721
|
+
async safeMode(): Promise<boolean> {
|
|
722
|
+
return this.contract.read.safeMode() as Promise<boolean>;
|
|
723
|
+
}
|
|
724
|
+
|
|
725
|
+
/**
|
|
726
|
+
* signers
|
|
727
|
+
* view
|
|
728
|
+
*/
|
|
729
|
+
async signers(arg0: `0x${string}`): Promise<boolean> {
|
|
730
|
+
return this.contract.read.signers([arg0] as const) as Promise<boolean>;
|
|
731
|
+
}
|
|
732
|
+
|
|
733
|
+
/**
|
|
734
|
+
* supportsInterface
|
|
735
|
+
* view
|
|
736
|
+
*/
|
|
737
|
+
async supportsInterface(interfaceId: `0x${string}`): Promise<boolean> {
|
|
738
|
+
return this.contract.read.supportsInterface([interfaceId] as const) as Promise<boolean>;
|
|
739
|
+
}
|
|
740
|
+
|
|
741
|
+
/**
|
|
742
|
+
* activateSafeMode
|
|
743
|
+
* nonpayable
|
|
744
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
745
|
+
*/
|
|
746
|
+
async activateSafeMode(options?: {
|
|
747
|
+
accessList?: import('viem').AccessList;
|
|
748
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
749
|
+
chain?: import('viem').Chain | null;
|
|
750
|
+
dataSuffix?: `0x${string}`;
|
|
751
|
+
gas?: bigint;
|
|
752
|
+
gasPrice?: bigint;
|
|
753
|
+
maxFeePerGas?: bigint;
|
|
754
|
+
maxPriorityFeePerGas?: bigint;
|
|
755
|
+
nonce?: number;
|
|
756
|
+
value?: bigint;
|
|
757
|
+
}): Promise<`0x${string}`> {
|
|
758
|
+
if (!this.contract.write) {
|
|
759
|
+
throw new Error('Wallet client is required for write operations');
|
|
760
|
+
}
|
|
761
|
+
return this.contract.write.activateSafeMode(options) as Promise<`0x${string}`>;
|
|
762
|
+
}
|
|
763
|
+
|
|
764
|
+
/**
|
|
765
|
+
* batchFlushERC1155ForwarderTokens
|
|
766
|
+
* nonpayable
|
|
767
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
768
|
+
*/
|
|
769
|
+
async batchFlushERC1155ForwarderTokens(forwarderAddress: `0x${string}`, tokenContractAddress: `0x${string}`, tokenIds: bigint[], options?: {
|
|
770
|
+
accessList?: import('viem').AccessList;
|
|
771
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
772
|
+
chain?: import('viem').Chain | null;
|
|
773
|
+
dataSuffix?: `0x${string}`;
|
|
774
|
+
gas?: bigint;
|
|
775
|
+
gasPrice?: bigint;
|
|
776
|
+
maxFeePerGas?: bigint;
|
|
777
|
+
maxPriorityFeePerGas?: bigint;
|
|
778
|
+
nonce?: number;
|
|
779
|
+
value?: bigint;
|
|
780
|
+
}): Promise<`0x${string}`> {
|
|
781
|
+
if (!this.contract.write) {
|
|
782
|
+
throw new Error('Wallet client is required for write operations');
|
|
783
|
+
}
|
|
784
|
+
return this.contract.write.batchFlushERC1155ForwarderTokens([forwarderAddress, tokenContractAddress, tokenIds] as const, options) as Promise<`0x${string}`>;
|
|
785
|
+
}
|
|
786
|
+
|
|
787
|
+
/**
|
|
788
|
+
* flushERC1155ForwarderTokens
|
|
789
|
+
* nonpayable
|
|
790
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
791
|
+
*/
|
|
792
|
+
async flushERC1155ForwarderTokens(forwarderAddress: `0x${string}`, tokenContractAddress: `0x${string}`, tokenId: bigint, options?: {
|
|
793
|
+
accessList?: import('viem').AccessList;
|
|
794
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
795
|
+
chain?: import('viem').Chain | null;
|
|
796
|
+
dataSuffix?: `0x${string}`;
|
|
797
|
+
gas?: bigint;
|
|
798
|
+
gasPrice?: bigint;
|
|
799
|
+
maxFeePerGas?: bigint;
|
|
800
|
+
maxPriorityFeePerGas?: bigint;
|
|
801
|
+
nonce?: number;
|
|
802
|
+
value?: bigint;
|
|
803
|
+
}): Promise<`0x${string}`> {
|
|
804
|
+
if (!this.contract.write) {
|
|
805
|
+
throw new Error('Wallet client is required for write operations');
|
|
806
|
+
}
|
|
807
|
+
return this.contract.write.flushERC1155ForwarderTokens([forwarderAddress, tokenContractAddress, tokenId] as const, options) as Promise<`0x${string}`>;
|
|
808
|
+
}
|
|
809
|
+
|
|
810
|
+
/**
|
|
811
|
+
* flushERC721ForwarderTokens
|
|
812
|
+
* nonpayable
|
|
813
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
814
|
+
*/
|
|
815
|
+
async flushERC721ForwarderTokens(forwarderAddress: `0x${string}`, tokenContractAddress: `0x${string}`, tokenId: bigint, options?: {
|
|
816
|
+
accessList?: import('viem').AccessList;
|
|
817
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
818
|
+
chain?: import('viem').Chain | null;
|
|
819
|
+
dataSuffix?: `0x${string}`;
|
|
820
|
+
gas?: bigint;
|
|
821
|
+
gasPrice?: bigint;
|
|
822
|
+
maxFeePerGas?: bigint;
|
|
823
|
+
maxPriorityFeePerGas?: bigint;
|
|
824
|
+
nonce?: number;
|
|
825
|
+
value?: bigint;
|
|
826
|
+
}): Promise<`0x${string}`> {
|
|
827
|
+
if (!this.contract.write) {
|
|
828
|
+
throw new Error('Wallet client is required for write operations');
|
|
829
|
+
}
|
|
830
|
+
return this.contract.write.flushERC721ForwarderTokens([forwarderAddress, tokenContractAddress, tokenId] as const, options) as Promise<`0x${string}`>;
|
|
831
|
+
}
|
|
832
|
+
|
|
833
|
+
/**
|
|
834
|
+
* flushForwarderTokens
|
|
835
|
+
* nonpayable
|
|
836
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
837
|
+
*/
|
|
838
|
+
async flushForwarderTokens(forwarderAddress: `0x${string}`, tokenContractAddress: `0x${string}`, options?: {
|
|
839
|
+
accessList?: import('viem').AccessList;
|
|
840
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
841
|
+
chain?: import('viem').Chain | null;
|
|
842
|
+
dataSuffix?: `0x${string}`;
|
|
843
|
+
gas?: bigint;
|
|
844
|
+
gasPrice?: bigint;
|
|
845
|
+
maxFeePerGas?: bigint;
|
|
846
|
+
maxPriorityFeePerGas?: bigint;
|
|
847
|
+
nonce?: number;
|
|
848
|
+
value?: bigint;
|
|
849
|
+
}): Promise<`0x${string}`> {
|
|
850
|
+
if (!this.contract.write) {
|
|
851
|
+
throw new Error('Wallet client is required for write operations');
|
|
852
|
+
}
|
|
853
|
+
return this.contract.write.flushForwarderTokens([forwarderAddress, tokenContractAddress] as const, options) as Promise<`0x${string}`>;
|
|
854
|
+
}
|
|
855
|
+
|
|
856
|
+
/**
|
|
857
|
+
* init
|
|
858
|
+
* nonpayable
|
|
859
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
860
|
+
*/
|
|
861
|
+
async init(allowedSigners: `0x${string}`[], options?: {
|
|
862
|
+
accessList?: import('viem').AccessList;
|
|
863
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
864
|
+
chain?: import('viem').Chain | null;
|
|
865
|
+
dataSuffix?: `0x${string}`;
|
|
866
|
+
gas?: bigint;
|
|
867
|
+
gasPrice?: bigint;
|
|
868
|
+
maxFeePerGas?: bigint;
|
|
869
|
+
maxPriorityFeePerGas?: bigint;
|
|
870
|
+
nonce?: number;
|
|
871
|
+
value?: bigint;
|
|
872
|
+
}): Promise<`0x${string}`> {
|
|
873
|
+
if (!this.contract.write) {
|
|
874
|
+
throw new Error('Wallet client is required for write operations');
|
|
875
|
+
}
|
|
876
|
+
return this.contract.write.init([allowedSigners] as const, options) as Promise<`0x${string}`>;
|
|
877
|
+
}
|
|
878
|
+
|
|
879
|
+
/**
|
|
880
|
+
* onERC1155BatchReceived
|
|
881
|
+
* nonpayable
|
|
882
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
883
|
+
*/
|
|
884
|
+
async onERC1155BatchReceived(_operator: `0x${string}`, _from: `0x${string}`, ids: bigint[], values: bigint[], data: `0x${string}`, options?: {
|
|
885
|
+
accessList?: import('viem').AccessList;
|
|
886
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
887
|
+
chain?: import('viem').Chain | null;
|
|
888
|
+
dataSuffix?: `0x${string}`;
|
|
889
|
+
gas?: bigint;
|
|
890
|
+
gasPrice?: bigint;
|
|
891
|
+
maxFeePerGas?: bigint;
|
|
892
|
+
maxPriorityFeePerGas?: bigint;
|
|
893
|
+
nonce?: number;
|
|
894
|
+
value?: bigint;
|
|
895
|
+
}): Promise<`0x${string}`> {
|
|
896
|
+
if (!this.contract.write) {
|
|
897
|
+
throw new Error('Wallet client is required for write operations');
|
|
898
|
+
}
|
|
899
|
+
return this.contract.write.onERC1155BatchReceived([_operator, _from, ids, values, data] as const, options) as Promise<`0x${string}`>;
|
|
900
|
+
}
|
|
901
|
+
|
|
902
|
+
/**
|
|
903
|
+
* onERC1155Received
|
|
904
|
+
* nonpayable
|
|
905
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
906
|
+
*/
|
|
907
|
+
async onERC1155Received(_operator: `0x${string}`, _from: `0x${string}`, id: bigint, value: bigint, data: `0x${string}`, options?: {
|
|
908
|
+
accessList?: import('viem').AccessList;
|
|
909
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
910
|
+
chain?: import('viem').Chain | null;
|
|
911
|
+
dataSuffix?: `0x${string}`;
|
|
912
|
+
gas?: bigint;
|
|
913
|
+
gasPrice?: bigint;
|
|
914
|
+
maxFeePerGas?: bigint;
|
|
915
|
+
maxPriorityFeePerGas?: bigint;
|
|
916
|
+
nonce?: number;
|
|
917
|
+
value?: bigint;
|
|
918
|
+
}): Promise<`0x${string}`> {
|
|
919
|
+
if (!this.contract.write) {
|
|
920
|
+
throw new Error('Wallet client is required for write operations');
|
|
921
|
+
}
|
|
922
|
+
return this.contract.write.onERC1155Received([_operator, _from, id, value, data] as const, options) as Promise<`0x${string}`>;
|
|
923
|
+
}
|
|
924
|
+
|
|
925
|
+
/**
|
|
926
|
+
* onERC721Received
|
|
927
|
+
* nonpayable
|
|
928
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
929
|
+
*/
|
|
930
|
+
async onERC721Received(_operator: `0x${string}`, _from: `0x${string}`, _tokenId: bigint, _data: `0x${string}`, options?: {
|
|
931
|
+
accessList?: import('viem').AccessList;
|
|
932
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
933
|
+
chain?: import('viem').Chain | null;
|
|
934
|
+
dataSuffix?: `0x${string}`;
|
|
935
|
+
gas?: bigint;
|
|
936
|
+
gasPrice?: bigint;
|
|
937
|
+
maxFeePerGas?: bigint;
|
|
938
|
+
maxPriorityFeePerGas?: bigint;
|
|
939
|
+
nonce?: number;
|
|
940
|
+
value?: bigint;
|
|
941
|
+
}): Promise<`0x${string}`> {
|
|
942
|
+
if (!this.contract.write) {
|
|
943
|
+
throw new Error('Wallet client is required for write operations');
|
|
944
|
+
}
|
|
945
|
+
return this.contract.write.onERC721Received([_operator, _from, _tokenId, _data] as const, options) as Promise<`0x${string}`>;
|
|
946
|
+
}
|
|
947
|
+
|
|
948
|
+
/**
|
|
949
|
+
* sendMultiSig
|
|
950
|
+
* nonpayable
|
|
951
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
952
|
+
*/
|
|
953
|
+
async sendMultiSig(toAddress: `0x${string}`, value: bigint, data: `0x${string}`, expireTime: bigint, sequenceId: bigint, signature: `0x${string}`, options?: {
|
|
954
|
+
accessList?: import('viem').AccessList;
|
|
955
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
956
|
+
chain?: import('viem').Chain | null;
|
|
957
|
+
dataSuffix?: `0x${string}`;
|
|
958
|
+
gas?: bigint;
|
|
959
|
+
gasPrice?: bigint;
|
|
960
|
+
maxFeePerGas?: bigint;
|
|
961
|
+
maxPriorityFeePerGas?: bigint;
|
|
962
|
+
nonce?: number;
|
|
963
|
+
value?: bigint;
|
|
964
|
+
}): Promise<`0x${string}`> {
|
|
965
|
+
if (!this.contract.write) {
|
|
966
|
+
throw new Error('Wallet client is required for write operations');
|
|
967
|
+
}
|
|
968
|
+
return this.contract.write.sendMultiSig([toAddress, value, data, expireTime, sequenceId, signature] as const, options) as Promise<`0x${string}`>;
|
|
969
|
+
}
|
|
970
|
+
|
|
971
|
+
/**
|
|
972
|
+
* sendMultiSigBatch
|
|
973
|
+
* nonpayable
|
|
974
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
975
|
+
*/
|
|
976
|
+
async sendMultiSigBatch(recipients: `0x${string}`[], values: bigint[], expireTime: bigint, sequenceId: bigint, signature: `0x${string}`, options?: {
|
|
977
|
+
accessList?: import('viem').AccessList;
|
|
978
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
979
|
+
chain?: import('viem').Chain | null;
|
|
980
|
+
dataSuffix?: `0x${string}`;
|
|
981
|
+
gas?: bigint;
|
|
982
|
+
gasPrice?: bigint;
|
|
983
|
+
maxFeePerGas?: bigint;
|
|
984
|
+
maxPriorityFeePerGas?: bigint;
|
|
985
|
+
nonce?: number;
|
|
986
|
+
value?: bigint;
|
|
987
|
+
}): Promise<`0x${string}`> {
|
|
988
|
+
if (!this.contract.write) {
|
|
989
|
+
throw new Error('Wallet client is required for write operations');
|
|
990
|
+
}
|
|
991
|
+
return this.contract.write.sendMultiSigBatch([recipients, values, expireTime, sequenceId, signature] as const, options) as Promise<`0x${string}`>;
|
|
992
|
+
}
|
|
993
|
+
|
|
994
|
+
/**
|
|
995
|
+
* sendMultiSigToken
|
|
996
|
+
* nonpayable
|
|
997
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
998
|
+
*/
|
|
999
|
+
async sendMultiSigToken(toAddress: `0x${string}`, value: bigint, tokenContractAddress: `0x${string}`, expireTime: bigint, sequenceId: bigint, signature: `0x${string}`, options?: {
|
|
1000
|
+
accessList?: import('viem').AccessList;
|
|
1001
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1002
|
+
chain?: import('viem').Chain | null;
|
|
1003
|
+
dataSuffix?: `0x${string}`;
|
|
1004
|
+
gas?: bigint;
|
|
1005
|
+
gasPrice?: bigint;
|
|
1006
|
+
maxFeePerGas?: bigint;
|
|
1007
|
+
maxPriorityFeePerGas?: bigint;
|
|
1008
|
+
nonce?: number;
|
|
1009
|
+
value?: bigint;
|
|
1010
|
+
}): Promise<`0x${string}`> {
|
|
1011
|
+
if (!this.contract.write) {
|
|
1012
|
+
throw new Error('Wallet client is required for write operations');
|
|
1013
|
+
}
|
|
1014
|
+
return this.contract.write.sendMultiSigToken([toAddress, value, tokenContractAddress, expireTime, sequenceId, signature] as const, options) as Promise<`0x${string}`>;
|
|
1015
|
+
}
|
|
1016
|
+
|
|
1017
|
+
/**
|
|
1018
|
+
* setAutoFlush1155
|
|
1019
|
+
* nonpayable
|
|
1020
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1021
|
+
*/
|
|
1022
|
+
async setAutoFlush1155(forwarderAddress: `0x${string}`, autoFlush: boolean, options?: {
|
|
1023
|
+
accessList?: import('viem').AccessList;
|
|
1024
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1025
|
+
chain?: import('viem').Chain | null;
|
|
1026
|
+
dataSuffix?: `0x${string}`;
|
|
1027
|
+
gas?: bigint;
|
|
1028
|
+
gasPrice?: bigint;
|
|
1029
|
+
maxFeePerGas?: bigint;
|
|
1030
|
+
maxPriorityFeePerGas?: bigint;
|
|
1031
|
+
nonce?: number;
|
|
1032
|
+
value?: bigint;
|
|
1033
|
+
}): Promise<`0x${string}`> {
|
|
1034
|
+
if (!this.contract.write) {
|
|
1035
|
+
throw new Error('Wallet client is required for write operations');
|
|
1036
|
+
}
|
|
1037
|
+
return this.contract.write.setAutoFlush1155([forwarderAddress, autoFlush] as const, options) as Promise<`0x${string}`>;
|
|
1038
|
+
}
|
|
1039
|
+
|
|
1040
|
+
/**
|
|
1041
|
+
* setAutoFlush721
|
|
1042
|
+
* nonpayable
|
|
1043
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1044
|
+
*/
|
|
1045
|
+
async setAutoFlush721(forwarderAddress: `0x${string}`, autoFlush: boolean, options?: {
|
|
1046
|
+
accessList?: import('viem').AccessList;
|
|
1047
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1048
|
+
chain?: import('viem').Chain | null;
|
|
1049
|
+
dataSuffix?: `0x${string}`;
|
|
1050
|
+
gas?: bigint;
|
|
1051
|
+
gasPrice?: bigint;
|
|
1052
|
+
maxFeePerGas?: bigint;
|
|
1053
|
+
maxPriorityFeePerGas?: bigint;
|
|
1054
|
+
nonce?: number;
|
|
1055
|
+
value?: bigint;
|
|
1056
|
+
}): Promise<`0x${string}`> {
|
|
1057
|
+
if (!this.contract.write) {
|
|
1058
|
+
throw new Error('Wallet client is required for write operations');
|
|
1059
|
+
}
|
|
1060
|
+
return this.contract.write.setAutoFlush721([forwarderAddress, autoFlush] as const, options) as Promise<`0x${string}`>;
|
|
1061
|
+
}
|
|
1062
|
+
|
|
1063
|
+
|
|
1064
|
+
|
|
1065
|
+
/**
|
|
1066
|
+
* Simulate contract write operations (dry-run without sending transaction)
|
|
1067
|
+
*
|
|
1068
|
+
* @example
|
|
1069
|
+
* const result = await contract.simulate.transfer('0x...', 1000n);
|
|
1070
|
+
* console.log('Gas estimate:', result.request.gas);
|
|
1071
|
+
* console.log('Would succeed:', result.result);
|
|
1072
|
+
*/
|
|
1073
|
+
get simulate() {
|
|
1074
|
+
const contract = this.contract;
|
|
1075
|
+
if (!contract.simulate) {
|
|
1076
|
+
throw new Error('Public client is required for simulation');
|
|
1077
|
+
}
|
|
1078
|
+
return {
|
|
1079
|
+
/**
|
|
1080
|
+
* Simulate activateSafeMode
|
|
1081
|
+
* Returns gas estimate and result without sending transaction
|
|
1082
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1083
|
+
*/
|
|
1084
|
+
async activateSafeMode(options?: {
|
|
1085
|
+
accessList?: import('viem').AccessList;
|
|
1086
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1087
|
+
chain?: import('viem').Chain | null;
|
|
1088
|
+
dataSuffix?: `0x${string}`;
|
|
1089
|
+
gas?: bigint;
|
|
1090
|
+
gasPrice?: bigint;
|
|
1091
|
+
maxFeePerGas?: bigint;
|
|
1092
|
+
maxPriorityFeePerGas?: bigint;
|
|
1093
|
+
nonce?: number;
|
|
1094
|
+
value?: bigint;
|
|
1095
|
+
}): Promise<void> {
|
|
1096
|
+
return contract.simulate.activateSafeMode(options) as Promise<void>;
|
|
1097
|
+
},
|
|
1098
|
+
/**
|
|
1099
|
+
* Simulate batchFlushERC1155ForwarderTokens
|
|
1100
|
+
* Returns gas estimate and result without sending transaction
|
|
1101
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1102
|
+
*/
|
|
1103
|
+
async batchFlushERC1155ForwarderTokens(forwarderAddress: `0x${string}`, tokenContractAddress: `0x${string}`, tokenIds: bigint[], options?: {
|
|
1104
|
+
accessList?: import('viem').AccessList;
|
|
1105
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1106
|
+
chain?: import('viem').Chain | null;
|
|
1107
|
+
dataSuffix?: `0x${string}`;
|
|
1108
|
+
gas?: bigint;
|
|
1109
|
+
gasPrice?: bigint;
|
|
1110
|
+
maxFeePerGas?: bigint;
|
|
1111
|
+
maxPriorityFeePerGas?: bigint;
|
|
1112
|
+
nonce?: number;
|
|
1113
|
+
value?: bigint;
|
|
1114
|
+
}): Promise<void> {
|
|
1115
|
+
return contract.simulate.batchFlushERC1155ForwarderTokens([forwarderAddress, tokenContractAddress, tokenIds] as const, options) as Promise<void>;
|
|
1116
|
+
},
|
|
1117
|
+
/**
|
|
1118
|
+
* Simulate flushERC1155ForwarderTokens
|
|
1119
|
+
* Returns gas estimate and result without sending transaction
|
|
1120
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1121
|
+
*/
|
|
1122
|
+
async flushERC1155ForwarderTokens(forwarderAddress: `0x${string}`, tokenContractAddress: `0x${string}`, tokenId: bigint, options?: {
|
|
1123
|
+
accessList?: import('viem').AccessList;
|
|
1124
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1125
|
+
chain?: import('viem').Chain | null;
|
|
1126
|
+
dataSuffix?: `0x${string}`;
|
|
1127
|
+
gas?: bigint;
|
|
1128
|
+
gasPrice?: bigint;
|
|
1129
|
+
maxFeePerGas?: bigint;
|
|
1130
|
+
maxPriorityFeePerGas?: bigint;
|
|
1131
|
+
nonce?: number;
|
|
1132
|
+
value?: bigint;
|
|
1133
|
+
}): Promise<void> {
|
|
1134
|
+
return contract.simulate.flushERC1155ForwarderTokens([forwarderAddress, tokenContractAddress, tokenId] as const, options) as Promise<void>;
|
|
1135
|
+
},
|
|
1136
|
+
/**
|
|
1137
|
+
* Simulate flushERC721ForwarderTokens
|
|
1138
|
+
* Returns gas estimate and result without sending transaction
|
|
1139
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1140
|
+
*/
|
|
1141
|
+
async flushERC721ForwarderTokens(forwarderAddress: `0x${string}`, tokenContractAddress: `0x${string}`, tokenId: bigint, options?: {
|
|
1142
|
+
accessList?: import('viem').AccessList;
|
|
1143
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1144
|
+
chain?: import('viem').Chain | null;
|
|
1145
|
+
dataSuffix?: `0x${string}`;
|
|
1146
|
+
gas?: bigint;
|
|
1147
|
+
gasPrice?: bigint;
|
|
1148
|
+
maxFeePerGas?: bigint;
|
|
1149
|
+
maxPriorityFeePerGas?: bigint;
|
|
1150
|
+
nonce?: number;
|
|
1151
|
+
value?: bigint;
|
|
1152
|
+
}): Promise<void> {
|
|
1153
|
+
return contract.simulate.flushERC721ForwarderTokens([forwarderAddress, tokenContractAddress, tokenId] as const, options) as Promise<void>;
|
|
1154
|
+
},
|
|
1155
|
+
/**
|
|
1156
|
+
* Simulate flushForwarderTokens
|
|
1157
|
+
* Returns gas estimate and result without sending transaction
|
|
1158
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1159
|
+
*/
|
|
1160
|
+
async flushForwarderTokens(forwarderAddress: `0x${string}`, tokenContractAddress: `0x${string}`, options?: {
|
|
1161
|
+
accessList?: import('viem').AccessList;
|
|
1162
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1163
|
+
chain?: import('viem').Chain | null;
|
|
1164
|
+
dataSuffix?: `0x${string}`;
|
|
1165
|
+
gas?: bigint;
|
|
1166
|
+
gasPrice?: bigint;
|
|
1167
|
+
maxFeePerGas?: bigint;
|
|
1168
|
+
maxPriorityFeePerGas?: bigint;
|
|
1169
|
+
nonce?: number;
|
|
1170
|
+
value?: bigint;
|
|
1171
|
+
}): Promise<void> {
|
|
1172
|
+
return contract.simulate.flushForwarderTokens([forwarderAddress, tokenContractAddress] as const, options) as Promise<void>;
|
|
1173
|
+
},
|
|
1174
|
+
/**
|
|
1175
|
+
* Simulate init
|
|
1176
|
+
* Returns gas estimate and result without sending transaction
|
|
1177
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1178
|
+
*/
|
|
1179
|
+
async init(allowedSigners: `0x${string}`[], options?: {
|
|
1180
|
+
accessList?: import('viem').AccessList;
|
|
1181
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1182
|
+
chain?: import('viem').Chain | null;
|
|
1183
|
+
dataSuffix?: `0x${string}`;
|
|
1184
|
+
gas?: bigint;
|
|
1185
|
+
gasPrice?: bigint;
|
|
1186
|
+
maxFeePerGas?: bigint;
|
|
1187
|
+
maxPriorityFeePerGas?: bigint;
|
|
1188
|
+
nonce?: number;
|
|
1189
|
+
value?: bigint;
|
|
1190
|
+
}): Promise<void> {
|
|
1191
|
+
return contract.simulate.init([allowedSigners] as const, options) as Promise<void>;
|
|
1192
|
+
},
|
|
1193
|
+
/**
|
|
1194
|
+
* Simulate onERC1155BatchReceived
|
|
1195
|
+
* Returns gas estimate and result without sending transaction
|
|
1196
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1197
|
+
*/
|
|
1198
|
+
async onERC1155BatchReceived(_operator: `0x${string}`, _from: `0x${string}`, ids: bigint[], values: bigint[], data: `0x${string}`, options?: {
|
|
1199
|
+
accessList?: import('viem').AccessList;
|
|
1200
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1201
|
+
chain?: import('viem').Chain | null;
|
|
1202
|
+
dataSuffix?: `0x${string}`;
|
|
1203
|
+
gas?: bigint;
|
|
1204
|
+
gasPrice?: bigint;
|
|
1205
|
+
maxFeePerGas?: bigint;
|
|
1206
|
+
maxPriorityFeePerGas?: bigint;
|
|
1207
|
+
nonce?: number;
|
|
1208
|
+
value?: bigint;
|
|
1209
|
+
}): Promise<`0x${string}`> {
|
|
1210
|
+
return contract.simulate.onERC1155BatchReceived([_operator, _from, ids, values, data] as const, options) as Promise<`0x${string}`>;
|
|
1211
|
+
},
|
|
1212
|
+
/**
|
|
1213
|
+
* Simulate onERC1155Received
|
|
1214
|
+
* Returns gas estimate and result without sending transaction
|
|
1215
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1216
|
+
*/
|
|
1217
|
+
async onERC1155Received(_operator: `0x${string}`, _from: `0x${string}`, id: bigint, value: bigint, data: `0x${string}`, options?: {
|
|
1218
|
+
accessList?: import('viem').AccessList;
|
|
1219
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1220
|
+
chain?: import('viem').Chain | null;
|
|
1221
|
+
dataSuffix?: `0x${string}`;
|
|
1222
|
+
gas?: bigint;
|
|
1223
|
+
gasPrice?: bigint;
|
|
1224
|
+
maxFeePerGas?: bigint;
|
|
1225
|
+
maxPriorityFeePerGas?: bigint;
|
|
1226
|
+
nonce?: number;
|
|
1227
|
+
value?: bigint;
|
|
1228
|
+
}): Promise<`0x${string}`> {
|
|
1229
|
+
return contract.simulate.onERC1155Received([_operator, _from, id, value, data] as const, options) as Promise<`0x${string}`>;
|
|
1230
|
+
},
|
|
1231
|
+
/**
|
|
1232
|
+
* Simulate onERC721Received
|
|
1233
|
+
* Returns gas estimate and result without sending transaction
|
|
1234
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1235
|
+
*/
|
|
1236
|
+
async onERC721Received(_operator: `0x${string}`, _from: `0x${string}`, _tokenId: bigint, _data: `0x${string}`, options?: {
|
|
1237
|
+
accessList?: import('viem').AccessList;
|
|
1238
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1239
|
+
chain?: import('viem').Chain | null;
|
|
1240
|
+
dataSuffix?: `0x${string}`;
|
|
1241
|
+
gas?: bigint;
|
|
1242
|
+
gasPrice?: bigint;
|
|
1243
|
+
maxFeePerGas?: bigint;
|
|
1244
|
+
maxPriorityFeePerGas?: bigint;
|
|
1245
|
+
nonce?: number;
|
|
1246
|
+
value?: bigint;
|
|
1247
|
+
}): Promise<`0x${string}`> {
|
|
1248
|
+
return contract.simulate.onERC721Received([_operator, _from, _tokenId, _data] as const, options) as Promise<`0x${string}`>;
|
|
1249
|
+
},
|
|
1250
|
+
/**
|
|
1251
|
+
* Simulate sendMultiSig
|
|
1252
|
+
* Returns gas estimate and result without sending transaction
|
|
1253
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1254
|
+
*/
|
|
1255
|
+
async sendMultiSig(toAddress: `0x${string}`, value: bigint, data: `0x${string}`, expireTime: bigint, sequenceId: bigint, signature: `0x${string}`, options?: {
|
|
1256
|
+
accessList?: import('viem').AccessList;
|
|
1257
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1258
|
+
chain?: import('viem').Chain | null;
|
|
1259
|
+
dataSuffix?: `0x${string}`;
|
|
1260
|
+
gas?: bigint;
|
|
1261
|
+
gasPrice?: bigint;
|
|
1262
|
+
maxFeePerGas?: bigint;
|
|
1263
|
+
maxPriorityFeePerGas?: bigint;
|
|
1264
|
+
nonce?: number;
|
|
1265
|
+
value?: bigint;
|
|
1266
|
+
}): Promise<void> {
|
|
1267
|
+
return contract.simulate.sendMultiSig([toAddress, value, data, expireTime, sequenceId, signature] as const, options) as Promise<void>;
|
|
1268
|
+
},
|
|
1269
|
+
/**
|
|
1270
|
+
* Simulate sendMultiSigBatch
|
|
1271
|
+
* Returns gas estimate and result without sending transaction
|
|
1272
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1273
|
+
*/
|
|
1274
|
+
async sendMultiSigBatch(recipients: `0x${string}`[], values: bigint[], expireTime: bigint, sequenceId: bigint, signature: `0x${string}`, options?: {
|
|
1275
|
+
accessList?: import('viem').AccessList;
|
|
1276
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1277
|
+
chain?: import('viem').Chain | null;
|
|
1278
|
+
dataSuffix?: `0x${string}`;
|
|
1279
|
+
gas?: bigint;
|
|
1280
|
+
gasPrice?: bigint;
|
|
1281
|
+
maxFeePerGas?: bigint;
|
|
1282
|
+
maxPriorityFeePerGas?: bigint;
|
|
1283
|
+
nonce?: number;
|
|
1284
|
+
value?: bigint;
|
|
1285
|
+
}): Promise<void> {
|
|
1286
|
+
return contract.simulate.sendMultiSigBatch([recipients, values, expireTime, sequenceId, signature] as const, options) as Promise<void>;
|
|
1287
|
+
},
|
|
1288
|
+
/**
|
|
1289
|
+
* Simulate sendMultiSigToken
|
|
1290
|
+
* Returns gas estimate and result without sending transaction
|
|
1291
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1292
|
+
*/
|
|
1293
|
+
async sendMultiSigToken(toAddress: `0x${string}`, value: bigint, tokenContractAddress: `0x${string}`, expireTime: bigint, sequenceId: bigint, signature: `0x${string}`, options?: {
|
|
1294
|
+
accessList?: import('viem').AccessList;
|
|
1295
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1296
|
+
chain?: import('viem').Chain | null;
|
|
1297
|
+
dataSuffix?: `0x${string}`;
|
|
1298
|
+
gas?: bigint;
|
|
1299
|
+
gasPrice?: bigint;
|
|
1300
|
+
maxFeePerGas?: bigint;
|
|
1301
|
+
maxPriorityFeePerGas?: bigint;
|
|
1302
|
+
nonce?: number;
|
|
1303
|
+
value?: bigint;
|
|
1304
|
+
}): Promise<void> {
|
|
1305
|
+
return contract.simulate.sendMultiSigToken([toAddress, value, tokenContractAddress, expireTime, sequenceId, signature] as const, options) as Promise<void>;
|
|
1306
|
+
},
|
|
1307
|
+
/**
|
|
1308
|
+
* Simulate setAutoFlush1155
|
|
1309
|
+
* Returns gas estimate and result without sending transaction
|
|
1310
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1311
|
+
*/
|
|
1312
|
+
async setAutoFlush1155(forwarderAddress: `0x${string}`, autoFlush: boolean, options?: {
|
|
1313
|
+
accessList?: import('viem').AccessList;
|
|
1314
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1315
|
+
chain?: import('viem').Chain | null;
|
|
1316
|
+
dataSuffix?: `0x${string}`;
|
|
1317
|
+
gas?: bigint;
|
|
1318
|
+
gasPrice?: bigint;
|
|
1319
|
+
maxFeePerGas?: bigint;
|
|
1320
|
+
maxPriorityFeePerGas?: bigint;
|
|
1321
|
+
nonce?: number;
|
|
1322
|
+
value?: bigint;
|
|
1323
|
+
}): Promise<void> {
|
|
1324
|
+
return contract.simulate.setAutoFlush1155([forwarderAddress, autoFlush] as const, options) as Promise<void>;
|
|
1325
|
+
},
|
|
1326
|
+
/**
|
|
1327
|
+
* Simulate setAutoFlush721
|
|
1328
|
+
* Returns gas estimate and result without sending transaction
|
|
1329
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1330
|
+
*/
|
|
1331
|
+
async setAutoFlush721(forwarderAddress: `0x${string}`, autoFlush: boolean, options?: {
|
|
1332
|
+
accessList?: import('viem').AccessList;
|
|
1333
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1334
|
+
chain?: import('viem').Chain | null;
|
|
1335
|
+
dataSuffix?: `0x${string}`;
|
|
1336
|
+
gas?: bigint;
|
|
1337
|
+
gasPrice?: bigint;
|
|
1338
|
+
maxFeePerGas?: bigint;
|
|
1339
|
+
maxPriorityFeePerGas?: bigint;
|
|
1340
|
+
nonce?: number;
|
|
1341
|
+
value?: bigint;
|
|
1342
|
+
}): Promise<void> {
|
|
1343
|
+
return contract.simulate.setAutoFlush721([forwarderAddress, autoFlush] as const, options) as Promise<void>;
|
|
1344
|
+
}
|
|
1345
|
+
};
|
|
1346
|
+
}
|
|
1347
|
+
|
|
1348
|
+
/**
|
|
1349
|
+
* Watch contract events
|
|
1350
|
+
*
|
|
1351
|
+
* @example
|
|
1352
|
+
* // Watch all Transfer events
|
|
1353
|
+
* const unwatch = contract.watch.Transfer((event) => {
|
|
1354
|
+
* console.log('Transfer:', event);
|
|
1355
|
+
* });
|
|
1356
|
+
*
|
|
1357
|
+
* // Stop watching
|
|
1358
|
+
* unwatch();
|
|
1359
|
+
*/
|
|
1360
|
+
get watch() {
|
|
1361
|
+
return {
|
|
1362
|
+
/**
|
|
1363
|
+
* Watch BatchTransacted events
|
|
1364
|
+
* @param callback Function to call when event is emitted
|
|
1365
|
+
* @param filter Optional filter for indexed parameters
|
|
1366
|
+
* @returns Unwatch function to stop listening
|
|
1367
|
+
*/
|
|
1368
|
+
BatchTransacted: (callback: (event: { msgSender: `0x${string}`; otherSigner: `0x${string}`; operation: `0x${string}` }) => void) => {
|
|
1369
|
+
return this.publicClient.watchContractEvent({
|
|
1370
|
+
address: this.contractAddress,
|
|
1371
|
+
abi: WalletSimple_jsonAbi,
|
|
1372
|
+
eventName: 'BatchTransacted',
|
|
1373
|
+
|
|
1374
|
+
onLogs: (logs: any[]) => {
|
|
1375
|
+
logs.forEach((log: any) => {
|
|
1376
|
+
callback(log.args as any);
|
|
1377
|
+
});
|
|
1378
|
+
},
|
|
1379
|
+
}) as () => void;
|
|
1380
|
+
},
|
|
1381
|
+
/**
|
|
1382
|
+
* Watch BatchTransfer events
|
|
1383
|
+
* @param callback Function to call when event is emitted
|
|
1384
|
+
* @param filter Optional filter for indexed parameters
|
|
1385
|
+
* @returns Unwatch function to stop listening
|
|
1386
|
+
*/
|
|
1387
|
+
BatchTransfer: (callback: (event: { sender: `0x${string}`; recipient: `0x${string}`; value: bigint }) => void) => {
|
|
1388
|
+
return this.publicClient.watchContractEvent({
|
|
1389
|
+
address: this.contractAddress,
|
|
1390
|
+
abi: WalletSimple_jsonAbi,
|
|
1391
|
+
eventName: 'BatchTransfer',
|
|
1392
|
+
|
|
1393
|
+
onLogs: (logs: any[]) => {
|
|
1394
|
+
logs.forEach((log: any) => {
|
|
1395
|
+
callback(log.args as any);
|
|
1396
|
+
});
|
|
1397
|
+
},
|
|
1398
|
+
}) as () => void;
|
|
1399
|
+
},
|
|
1400
|
+
/**
|
|
1401
|
+
* Watch Deposited events
|
|
1402
|
+
* @param callback Function to call when event is emitted
|
|
1403
|
+
* @param filter Optional filter for indexed parameters
|
|
1404
|
+
* @returns Unwatch function to stop listening
|
|
1405
|
+
*/
|
|
1406
|
+
Deposited: (callback: (event: { from: `0x${string}`; value: bigint; data: `0x${string}` }) => void) => {
|
|
1407
|
+
return this.publicClient.watchContractEvent({
|
|
1408
|
+
address: this.contractAddress,
|
|
1409
|
+
abi: WalletSimple_jsonAbi,
|
|
1410
|
+
eventName: 'Deposited',
|
|
1411
|
+
|
|
1412
|
+
onLogs: (logs: any[]) => {
|
|
1413
|
+
logs.forEach((log: any) => {
|
|
1414
|
+
callback(log.args as any);
|
|
1415
|
+
});
|
|
1416
|
+
},
|
|
1417
|
+
}) as () => void;
|
|
1418
|
+
},
|
|
1419
|
+
/**
|
|
1420
|
+
* Watch SafeModeActivated events
|
|
1421
|
+
* @param callback Function to call when event is emitted
|
|
1422
|
+
* @param filter Optional filter for indexed parameters
|
|
1423
|
+
* @returns Unwatch function to stop listening
|
|
1424
|
+
*/
|
|
1425
|
+
SafeModeActivated: (callback: (event: { msgSender: `0x${string}` }) => void) => {
|
|
1426
|
+
return this.publicClient.watchContractEvent({
|
|
1427
|
+
address: this.contractAddress,
|
|
1428
|
+
abi: WalletSimple_jsonAbi,
|
|
1429
|
+
eventName: 'SafeModeActivated',
|
|
1430
|
+
|
|
1431
|
+
onLogs: (logs: any[]) => {
|
|
1432
|
+
logs.forEach((log: any) => {
|
|
1433
|
+
callback(log.args as any);
|
|
1434
|
+
});
|
|
1435
|
+
},
|
|
1436
|
+
}) as () => void;
|
|
1437
|
+
},
|
|
1438
|
+
/**
|
|
1439
|
+
* Watch Transacted events
|
|
1440
|
+
* @param callback Function to call when event is emitted
|
|
1441
|
+
* @param filter Optional filter for indexed parameters
|
|
1442
|
+
* @returns Unwatch function to stop listening
|
|
1443
|
+
*/
|
|
1444
|
+
Transacted: (callback: (event: { msgSender: `0x${string}`; otherSigner: `0x${string}`; operation: `0x${string}`; toAddress: `0x${string}`; value: bigint; data: `0x${string}` }) => void) => {
|
|
1445
|
+
return this.publicClient.watchContractEvent({
|
|
1446
|
+
address: this.contractAddress,
|
|
1447
|
+
abi: WalletSimple_jsonAbi,
|
|
1448
|
+
eventName: 'Transacted',
|
|
1449
|
+
|
|
1450
|
+
onLogs: (logs: any[]) => {
|
|
1451
|
+
logs.forEach((log: any) => {
|
|
1452
|
+
callback(log.args as any);
|
|
1453
|
+
});
|
|
1454
|
+
},
|
|
1455
|
+
}) as () => void;
|
|
1456
|
+
}
|
|
1457
|
+
};
|
|
1458
|
+
}
|
|
1459
|
+
}
|