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