@gitmyabi/walletsimple 1.0.31 → 1.0.32
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 +3 -3
- package/contracts/WalletSimple_json.d.ts +730 -127
- package/contracts/WalletSimple_json.js +690 -132
- package/contracts/WalletSimple_json.ts +921 -152
- package/package.json +3 -3
|
@@ -8,269 +8,606 @@ import { getContract } from 'viem';
|
|
|
8
8
|
*/
|
|
9
9
|
export const WalletSimple_jsonAbi = [
|
|
10
10
|
{
|
|
11
|
-
"
|
|
11
|
+
"anonymous": false,
|
|
12
12
|
"inputs": [
|
|
13
13
|
{
|
|
14
|
-
"
|
|
14
|
+
"indexed": false,
|
|
15
|
+
"internalType": "address",
|
|
16
|
+
"name": "msgSender",
|
|
15
17
|
"type": "address"
|
|
16
18
|
},
|
|
17
19
|
{
|
|
18
|
-
"
|
|
19
|
-
"
|
|
20
|
+
"indexed": false,
|
|
21
|
+
"internalType": "address",
|
|
22
|
+
"name": "otherSigner",
|
|
23
|
+
"type": "address"
|
|
20
24
|
},
|
|
21
25
|
{
|
|
22
|
-
"
|
|
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",
|
|
23
42
|
"type": "address"
|
|
24
43
|
},
|
|
25
44
|
{
|
|
26
|
-
"
|
|
45
|
+
"indexed": false,
|
|
46
|
+
"internalType": "address",
|
|
47
|
+
"name": "recipient",
|
|
48
|
+
"type": "address"
|
|
49
|
+
},
|
|
50
|
+
{
|
|
51
|
+
"indexed": false,
|
|
52
|
+
"internalType": "uint256",
|
|
53
|
+
"name": "value",
|
|
27
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"
|
|
28
68
|
},
|
|
29
69
|
{
|
|
30
|
-
"
|
|
70
|
+
"indexed": false,
|
|
71
|
+
"internalType": "uint256",
|
|
72
|
+
"name": "value",
|
|
31
73
|
"type": "uint256"
|
|
32
74
|
},
|
|
33
75
|
{
|
|
34
|
-
"
|
|
76
|
+
"indexed": false,
|
|
77
|
+
"internalType": "bytes",
|
|
78
|
+
"name": "data",
|
|
35
79
|
"type": "bytes"
|
|
36
80
|
}
|
|
37
81
|
],
|
|
38
|
-
"name": "
|
|
39
|
-
"
|
|
40
|
-
"payable": false,
|
|
41
|
-
"stateMutability": "nonpayable",
|
|
42
|
-
"type": "function"
|
|
82
|
+
"name": "Deposited",
|
|
83
|
+
"type": "event"
|
|
43
84
|
},
|
|
44
85
|
{
|
|
45
|
-
"
|
|
86
|
+
"anonymous": false,
|
|
46
87
|
"inputs": [
|
|
47
88
|
{
|
|
48
|
-
"
|
|
49
|
-
"
|
|
89
|
+
"indexed": false,
|
|
90
|
+
"internalType": "address",
|
|
91
|
+
"name": "msgSender",
|
|
92
|
+
"type": "address"
|
|
50
93
|
}
|
|
51
94
|
],
|
|
52
|
-
"name": "
|
|
53
|
-
"
|
|
95
|
+
"name": "SafeModeActivated",
|
|
96
|
+
"type": "event"
|
|
97
|
+
},
|
|
98
|
+
{
|
|
99
|
+
"anonymous": false,
|
|
100
|
+
"inputs": [
|
|
54
101
|
{
|
|
55
|
-
"
|
|
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",
|
|
56
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"
|
|
57
136
|
}
|
|
58
137
|
],
|
|
59
|
-
"
|
|
60
|
-
"
|
|
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",
|
|
61
150
|
"type": "function"
|
|
62
151
|
},
|
|
63
152
|
{
|
|
64
|
-
"constant": false,
|
|
65
153
|
"inputs": [
|
|
66
154
|
{
|
|
155
|
+
"internalType": "address payable",
|
|
67
156
|
"name": "forwarderAddress",
|
|
68
157
|
"type": "address"
|
|
69
158
|
},
|
|
70
159
|
{
|
|
160
|
+
"internalType": "address",
|
|
71
161
|
"name": "tokenContractAddress",
|
|
72
162
|
"type": "address"
|
|
163
|
+
},
|
|
164
|
+
{
|
|
165
|
+
"internalType": "uint256[]",
|
|
166
|
+
"name": "tokenIds",
|
|
167
|
+
"type": "uint256[]"
|
|
73
168
|
}
|
|
74
169
|
],
|
|
75
|
-
"name": "
|
|
170
|
+
"name": "batchFlushERC1155ForwarderTokens",
|
|
76
171
|
"outputs": [],
|
|
77
|
-
"payable": false,
|
|
78
172
|
"stateMutability": "nonpayable",
|
|
79
173
|
"type": "function"
|
|
80
174
|
},
|
|
81
175
|
{
|
|
82
|
-
"constant": false,
|
|
83
176
|
"inputs": [
|
|
84
177
|
{
|
|
85
|
-
"
|
|
178
|
+
"internalType": "address payable",
|
|
179
|
+
"name": "forwarderAddress",
|
|
86
180
|
"type": "address"
|
|
87
181
|
},
|
|
88
182
|
{
|
|
89
|
-
"
|
|
90
|
-
"
|
|
91
|
-
|
|
92
|
-
{
|
|
93
|
-
"name": "data",
|
|
94
|
-
"type": "bytes"
|
|
183
|
+
"internalType": "address",
|
|
184
|
+
"name": "tokenContractAddress",
|
|
185
|
+
"type": "address"
|
|
95
186
|
},
|
|
96
187
|
{
|
|
97
|
-
"
|
|
188
|
+
"internalType": "uint256",
|
|
189
|
+
"name": "tokenId",
|
|
98
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"
|
|
99
204
|
},
|
|
100
205
|
{
|
|
101
|
-
"
|
|
102
|
-
"
|
|
206
|
+
"internalType": "address",
|
|
207
|
+
"name": "tokenContractAddress",
|
|
208
|
+
"type": "address"
|
|
103
209
|
},
|
|
104
210
|
{
|
|
105
|
-
"
|
|
106
|
-
"
|
|
211
|
+
"internalType": "uint256",
|
|
212
|
+
"name": "tokenId",
|
|
213
|
+
"type": "uint256"
|
|
107
214
|
}
|
|
108
215
|
],
|
|
109
|
-
"name": "
|
|
216
|
+
"name": "flushERC721ForwarderTokens",
|
|
110
217
|
"outputs": [],
|
|
111
|
-
"payable": false,
|
|
112
218
|
"stateMutability": "nonpayable",
|
|
113
219
|
"type": "function"
|
|
114
220
|
},
|
|
115
221
|
{
|
|
116
|
-
"constant": true,
|
|
117
222
|
"inputs": [
|
|
118
223
|
{
|
|
119
|
-
"
|
|
224
|
+
"internalType": "address payable",
|
|
225
|
+
"name": "forwarderAddress",
|
|
120
226
|
"type": "address"
|
|
121
|
-
}
|
|
122
|
-
],
|
|
123
|
-
"name": "isSigner",
|
|
124
|
-
"outputs": [
|
|
227
|
+
},
|
|
125
228
|
{
|
|
126
|
-
"
|
|
127
|
-
"
|
|
229
|
+
"internalType": "address",
|
|
230
|
+
"name": "tokenContractAddress",
|
|
231
|
+
"type": "address"
|
|
128
232
|
}
|
|
129
233
|
],
|
|
130
|
-
"
|
|
131
|
-
"
|
|
234
|
+
"name": "flushForwarderTokens",
|
|
235
|
+
"outputs": [],
|
|
236
|
+
"stateMutability": "nonpayable",
|
|
132
237
|
"type": "function"
|
|
133
238
|
},
|
|
134
239
|
{
|
|
135
|
-
"constant": true,
|
|
136
240
|
"inputs": [],
|
|
137
241
|
"name": "getNextSequenceId",
|
|
138
242
|
"outputs": [
|
|
139
243
|
{
|
|
244
|
+
"internalType": "uint256",
|
|
140
245
|
"name": "",
|
|
141
246
|
"type": "uint256"
|
|
142
247
|
}
|
|
143
248
|
],
|
|
144
|
-
"payable": false,
|
|
145
249
|
"stateMutability": "view",
|
|
146
250
|
"type": "function"
|
|
147
251
|
},
|
|
148
252
|
{
|
|
149
|
-
"
|
|
150
|
-
"inputs": [],
|
|
151
|
-
"name": "createForwarder",
|
|
152
|
-
"outputs": [
|
|
253
|
+
"inputs": [
|
|
153
254
|
{
|
|
154
|
-
"
|
|
155
|
-
"
|
|
255
|
+
"internalType": "address[]",
|
|
256
|
+
"name": "allowedSigners",
|
|
257
|
+
"type": "address[]"
|
|
156
258
|
}
|
|
157
259
|
],
|
|
158
|
-
"
|
|
260
|
+
"name": "init",
|
|
261
|
+
"outputs": [],
|
|
159
262
|
"stateMutability": "nonpayable",
|
|
160
263
|
"type": "function"
|
|
161
264
|
},
|
|
162
265
|
{
|
|
163
|
-
"constant": true,
|
|
164
266
|
"inputs": [],
|
|
165
|
-
"name": "
|
|
267
|
+
"name": "initialized",
|
|
166
268
|
"outputs": [
|
|
167
269
|
{
|
|
270
|
+
"internalType": "bool",
|
|
168
271
|
"name": "",
|
|
169
272
|
"type": "bool"
|
|
170
273
|
}
|
|
171
274
|
],
|
|
172
|
-
"payable": false,
|
|
173
275
|
"stateMutability": "view",
|
|
174
276
|
"type": "function"
|
|
175
277
|
},
|
|
176
278
|
{
|
|
177
|
-
"
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
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",
|
|
183
295
|
"type": "function"
|
|
184
296
|
},
|
|
185
297
|
{
|
|
186
298
|
"inputs": [
|
|
187
299
|
{
|
|
188
|
-
"
|
|
189
|
-
"
|
|
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"
|
|
190
331
|
}
|
|
191
332
|
],
|
|
192
|
-
"payable": false,
|
|
193
333
|
"stateMutability": "nonpayable",
|
|
194
|
-
"type": "
|
|
195
|
-
},
|
|
196
|
-
{
|
|
197
|
-
"payable": true,
|
|
198
|
-
"stateMutability": "payable",
|
|
199
|
-
"type": "fallback"
|
|
334
|
+
"type": "function"
|
|
200
335
|
},
|
|
201
336
|
{
|
|
202
|
-
"anonymous": false,
|
|
203
337
|
"inputs": [
|
|
204
338
|
{
|
|
205
|
-
"
|
|
206
|
-
"name": "
|
|
339
|
+
"internalType": "address",
|
|
340
|
+
"name": "_operator",
|
|
207
341
|
"type": "address"
|
|
208
342
|
},
|
|
209
343
|
{
|
|
210
|
-
"
|
|
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",
|
|
211
355
|
"name": "value",
|
|
212
356
|
"type": "uint256"
|
|
213
357
|
},
|
|
214
358
|
{
|
|
215
|
-
"
|
|
359
|
+
"internalType": "bytes",
|
|
216
360
|
"name": "data",
|
|
217
361
|
"type": "bytes"
|
|
218
362
|
}
|
|
219
363
|
],
|
|
220
|
-
"name": "
|
|
221
|
-
"
|
|
222
|
-
},
|
|
223
|
-
{
|
|
224
|
-
"anonymous": false,
|
|
225
|
-
"inputs": [
|
|
364
|
+
"name": "onERC1155Received",
|
|
365
|
+
"outputs": [
|
|
226
366
|
{
|
|
227
|
-
"
|
|
228
|
-
"name": "
|
|
229
|
-
"type": "
|
|
367
|
+
"internalType": "bytes4",
|
|
368
|
+
"name": "",
|
|
369
|
+
"type": "bytes4"
|
|
230
370
|
}
|
|
231
371
|
],
|
|
232
|
-
"
|
|
233
|
-
"type": "
|
|
372
|
+
"stateMutability": "nonpayable",
|
|
373
|
+
"type": "function"
|
|
234
374
|
},
|
|
235
375
|
{
|
|
236
|
-
"anonymous": false,
|
|
237
376
|
"inputs": [
|
|
238
377
|
{
|
|
239
|
-
"
|
|
240
|
-
"name": "
|
|
241
|
-
"type": "address"
|
|
242
|
-
},
|
|
243
|
-
{
|
|
244
|
-
"indexed": false,
|
|
245
|
-
"name": "otherSigner",
|
|
378
|
+
"internalType": "address",
|
|
379
|
+
"name": "_operator",
|
|
246
380
|
"type": "address"
|
|
247
381
|
},
|
|
248
382
|
{
|
|
249
|
-
"
|
|
250
|
-
"name": "
|
|
251
|
-
"type": "bytes32"
|
|
252
|
-
},
|
|
253
|
-
{
|
|
254
|
-
"indexed": false,
|
|
255
|
-
"name": "toAddress",
|
|
383
|
+
"internalType": "address",
|
|
384
|
+
"name": "_from",
|
|
256
385
|
"type": "address"
|
|
257
386
|
},
|
|
258
387
|
{
|
|
259
|
-
"
|
|
260
|
-
"name": "
|
|
388
|
+
"internalType": "uint256",
|
|
389
|
+
"name": "_tokenId",
|
|
261
390
|
"type": "uint256"
|
|
262
391
|
},
|
|
263
392
|
{
|
|
264
|
-
"
|
|
265
|
-
"name": "
|
|
393
|
+
"internalType": "bytes",
|
|
394
|
+
"name": "_data",
|
|
266
395
|
"type": "bytes"
|
|
267
396
|
}
|
|
268
397
|
],
|
|
269
|
-
"name": "
|
|
270
|
-
"
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
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
|
+
|
|
274
611
|
/**
|
|
275
612
|
* Type-safe ABI for WalletSimple_json
|
|
276
613
|
*/
|
|
@@ -354,11 +691,19 @@ export class WalletSimple_json {
|
|
|
354
691
|
}
|
|
355
692
|
|
|
356
693
|
/**
|
|
357
|
-
*
|
|
694
|
+
* getNextSequenceId
|
|
695
|
+
* view
|
|
696
|
+
*/
|
|
697
|
+
async getNextSequenceId(): Promise<bigint> {
|
|
698
|
+
return this.contract.read.getNextSequenceId() as Promise<bigint>;
|
|
699
|
+
}
|
|
700
|
+
|
|
701
|
+
/**
|
|
702
|
+
* initialized
|
|
358
703
|
* view
|
|
359
704
|
*/
|
|
360
|
-
async
|
|
361
|
-
return this.contract.read.
|
|
705
|
+
async initialized(): Promise<boolean> {
|
|
706
|
+
return this.contract.read.initialized() as Promise<boolean>;
|
|
362
707
|
}
|
|
363
708
|
|
|
364
709
|
/**
|
|
@@ -370,27 +715,242 @@ export class WalletSimple_json {
|
|
|
370
715
|
}
|
|
371
716
|
|
|
372
717
|
/**
|
|
373
|
-
*
|
|
374
|
-
* view
|
|
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.)
|
|
375
906
|
*/
|
|
376
|
-
async
|
|
377
|
-
|
|
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}`>;
|
|
378
923
|
}
|
|
379
924
|
|
|
380
925
|
/**
|
|
381
|
-
*
|
|
382
|
-
*
|
|
926
|
+
* onERC721Received
|
|
927
|
+
* nonpayable
|
|
928
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
383
929
|
*/
|
|
384
|
-
async
|
|
385
|
-
|
|
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}`>;
|
|
386
946
|
}
|
|
387
947
|
|
|
388
948
|
/**
|
|
389
|
-
*
|
|
949
|
+
* sendMultiSig
|
|
390
950
|
* nonpayable
|
|
391
951
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
392
952
|
*/
|
|
393
|
-
async
|
|
953
|
+
async sendMultiSig(toAddress: `0x${string}`, value: bigint, data: `0x${string}`, expireTime: bigint, sequenceId: bigint, signature: `0x${string}`, options?: {
|
|
394
954
|
accessList?: import('viem').AccessList;
|
|
395
955
|
authorizationList?: import('viem').AuthorizationList;
|
|
396
956
|
chain?: import('viem').Chain | null;
|
|
@@ -405,15 +965,15 @@ export class WalletSimple_json {
|
|
|
405
965
|
if (!this.contract.write) {
|
|
406
966
|
throw new Error('Wallet client is required for write operations');
|
|
407
967
|
}
|
|
408
|
-
return this.contract.write.
|
|
968
|
+
return this.contract.write.sendMultiSig([toAddress, value, data, expireTime, sequenceId, signature] as const, options) as Promise<`0x${string}`>;
|
|
409
969
|
}
|
|
410
970
|
|
|
411
971
|
/**
|
|
412
|
-
*
|
|
972
|
+
* sendMultiSigBatch
|
|
413
973
|
* nonpayable
|
|
414
974
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
415
975
|
*/
|
|
416
|
-
async
|
|
976
|
+
async sendMultiSigBatch(recipients: `0x${string}`[], values: bigint[], expireTime: bigint, sequenceId: bigint, signature: `0x${string}`, options?: {
|
|
417
977
|
accessList?: import('viem').AccessList;
|
|
418
978
|
authorizationList?: import('viem').AuthorizationList;
|
|
419
979
|
chain?: import('viem').Chain | null;
|
|
@@ -428,15 +988,15 @@ export class WalletSimple_json {
|
|
|
428
988
|
if (!this.contract.write) {
|
|
429
989
|
throw new Error('Wallet client is required for write operations');
|
|
430
990
|
}
|
|
431
|
-
return this.contract.write.
|
|
991
|
+
return this.contract.write.sendMultiSigBatch([recipients, values, expireTime, sequenceId, signature] as const, options) as Promise<`0x${string}`>;
|
|
432
992
|
}
|
|
433
993
|
|
|
434
994
|
/**
|
|
435
|
-
*
|
|
995
|
+
* sendMultiSigToken
|
|
436
996
|
* nonpayable
|
|
437
997
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
438
998
|
*/
|
|
439
|
-
async
|
|
999
|
+
async sendMultiSigToken(toAddress: `0x${string}`, value: bigint, tokenContractAddress: `0x${string}`, expireTime: bigint, sequenceId: bigint, signature: `0x${string}`, options?: {
|
|
440
1000
|
accessList?: import('viem').AccessList;
|
|
441
1001
|
authorizationList?: import('viem').AuthorizationList;
|
|
442
1002
|
chain?: import('viem').Chain | null;
|
|
@@ -451,15 +1011,15 @@ export class WalletSimple_json {
|
|
|
451
1011
|
if (!this.contract.write) {
|
|
452
1012
|
throw new Error('Wallet client is required for write operations');
|
|
453
1013
|
}
|
|
454
|
-
return this.contract.write.
|
|
1014
|
+
return this.contract.write.sendMultiSigToken([toAddress, value, tokenContractAddress, expireTime, sequenceId, signature] as const, options) as Promise<`0x${string}`>;
|
|
455
1015
|
}
|
|
456
1016
|
|
|
457
1017
|
/**
|
|
458
|
-
*
|
|
1018
|
+
* setAutoFlush1155
|
|
459
1019
|
* nonpayable
|
|
460
1020
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
461
1021
|
*/
|
|
462
|
-
async
|
|
1022
|
+
async setAutoFlush1155(forwarderAddress: `0x${string}`, autoFlush: boolean, options?: {
|
|
463
1023
|
accessList?: import('viem').AccessList;
|
|
464
1024
|
authorizationList?: import('viem').AuthorizationList;
|
|
465
1025
|
chain?: import('viem').Chain | null;
|
|
@@ -474,15 +1034,15 @@ export class WalletSimple_json {
|
|
|
474
1034
|
if (!this.contract.write) {
|
|
475
1035
|
throw new Error('Wallet client is required for write operations');
|
|
476
1036
|
}
|
|
477
|
-
return this.contract.write.
|
|
1037
|
+
return this.contract.write.setAutoFlush1155([forwarderAddress, autoFlush] as const, options) as Promise<`0x${string}`>;
|
|
478
1038
|
}
|
|
479
1039
|
|
|
480
1040
|
/**
|
|
481
|
-
*
|
|
1041
|
+
* setAutoFlush721
|
|
482
1042
|
* nonpayable
|
|
483
1043
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
484
1044
|
*/
|
|
485
|
-
async
|
|
1045
|
+
async setAutoFlush721(forwarderAddress: `0x${string}`, autoFlush: boolean, options?: {
|
|
486
1046
|
accessList?: import('viem').AccessList;
|
|
487
1047
|
authorizationList?: import('viem').AuthorizationList;
|
|
488
1048
|
chain?: import('viem').Chain | null;
|
|
@@ -497,7 +1057,7 @@ export class WalletSimple_json {
|
|
|
497
1057
|
if (!this.contract.write) {
|
|
498
1058
|
throw new Error('Wallet client is required for write operations');
|
|
499
1059
|
}
|
|
500
|
-
return this.contract.write.
|
|
1060
|
+
return this.contract.write.setAutoFlush721([forwarderAddress, autoFlush] as const, options) as Promise<`0x${string}`>;
|
|
501
1061
|
}
|
|
502
1062
|
|
|
503
1063
|
|
|
@@ -517,11 +1077,11 @@ export class WalletSimple_json {
|
|
|
517
1077
|
}
|
|
518
1078
|
return {
|
|
519
1079
|
/**
|
|
520
|
-
* Simulate
|
|
1080
|
+
* Simulate activateSafeMode
|
|
521
1081
|
* Returns gas estimate and result without sending transaction
|
|
522
1082
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
523
1083
|
*/
|
|
524
|
-
async
|
|
1084
|
+
async activateSafeMode(options?: {
|
|
525
1085
|
accessList?: import('viem').AccessList;
|
|
526
1086
|
authorizationList?: import('viem').AuthorizationList;
|
|
527
1087
|
chain?: import('viem').Chain | null;
|
|
@@ -533,7 +1093,64 @@ export class WalletSimple_json {
|
|
|
533
1093
|
nonce?: number;
|
|
534
1094
|
value?: bigint;
|
|
535
1095
|
}): Promise<void> {
|
|
536
|
-
return contract.simulate.
|
|
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>;
|
|
537
1154
|
},
|
|
538
1155
|
/**
|
|
539
1156
|
* Simulate flushForwarderTokens
|
|
@@ -554,6 +1171,82 @@ export class WalletSimple_json {
|
|
|
554
1171
|
}): Promise<void> {
|
|
555
1172
|
return contract.simulate.flushForwarderTokens([forwarderAddress, tokenContractAddress] as const, options) as Promise<void>;
|
|
556
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
|
+
},
|
|
557
1250
|
/**
|
|
558
1251
|
* Simulate sendMultiSig
|
|
559
1252
|
* Returns gas estimate and result without sending transaction
|
|
@@ -574,11 +1267,11 @@ export class WalletSimple_json {
|
|
|
574
1267
|
return contract.simulate.sendMultiSig([toAddress, value, data, expireTime, sequenceId, signature] as const, options) as Promise<void>;
|
|
575
1268
|
},
|
|
576
1269
|
/**
|
|
577
|
-
* Simulate
|
|
1270
|
+
* Simulate sendMultiSigBatch
|
|
578
1271
|
* Returns gas estimate and result without sending transaction
|
|
579
1272
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
580
1273
|
*/
|
|
581
|
-
async
|
|
1274
|
+
async sendMultiSigBatch(recipients: `0x${string}`[], values: bigint[], expireTime: bigint, sequenceId: bigint, signature: `0x${string}`, options?: {
|
|
582
1275
|
accessList?: import('viem').AccessList;
|
|
583
1276
|
authorizationList?: import('viem').AuthorizationList;
|
|
584
1277
|
chain?: import('viem').Chain | null;
|
|
@@ -589,15 +1282,15 @@ export class WalletSimple_json {
|
|
|
589
1282
|
maxPriorityFeePerGas?: bigint;
|
|
590
1283
|
nonce?: number;
|
|
591
1284
|
value?: bigint;
|
|
592
|
-
}): Promise
|
|
593
|
-
return contract.simulate.
|
|
1285
|
+
}): Promise<void> {
|
|
1286
|
+
return contract.simulate.sendMultiSigBatch([recipients, values, expireTime, sequenceId, signature] as const, options) as Promise<void>;
|
|
594
1287
|
},
|
|
595
1288
|
/**
|
|
596
|
-
* Simulate
|
|
1289
|
+
* Simulate sendMultiSigToken
|
|
597
1290
|
* Returns gas estimate and result without sending transaction
|
|
598
1291
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
599
1292
|
*/
|
|
600
|
-
async
|
|
1293
|
+
async sendMultiSigToken(toAddress: `0x${string}`, value: bigint, tokenContractAddress: `0x${string}`, expireTime: bigint, sequenceId: bigint, signature: `0x${string}`, options?: {
|
|
601
1294
|
accessList?: import('viem').AccessList;
|
|
602
1295
|
authorizationList?: import('viem').AuthorizationList;
|
|
603
1296
|
chain?: import('viem').Chain | null;
|
|
@@ -609,7 +1302,45 @@ export class WalletSimple_json {
|
|
|
609
1302
|
nonce?: number;
|
|
610
1303
|
value?: bigint;
|
|
611
1304
|
}): Promise<void> {
|
|
612
|
-
return contract.simulate.
|
|
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>;
|
|
613
1344
|
}
|
|
614
1345
|
};
|
|
615
1346
|
}
|
|
@@ -628,6 +1359,44 @@ export class WalletSimple_json {
|
|
|
628
1359
|
*/
|
|
629
1360
|
get watch() {
|
|
630
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
|
+
},
|
|
631
1400
|
/**
|
|
632
1401
|
* Watch Deposited events
|
|
633
1402
|
* @param callback Function to call when event is emitted
|