@gitmyabi/yogapetz 0.0.0-stage → 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 +107 -2
- package/contracts/TransparentUpgradeableProxy.d.ts +401 -0
- package/contracts/TransparentUpgradeableProxy.js +398 -0
- package/contracts/TransparentUpgradeableProxy.ts +542 -0
- package/contracts/Yogapetz.d.ts +3164 -0
- package/contracts/Yogapetz.js +3349 -0
- package/contracts/Yogapetz.ts +4191 -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 +40 -3
|
@@ -0,0 +1,4191 @@
|
|
|
1
|
+
import type { Abi, Address, PublicClient, WalletClient, GetContractReturnType } from 'viem';
|
|
2
|
+
import { getContract } from 'viem';
|
|
3
|
+
|
|
4
|
+
|
|
5
|
+
/**
|
|
6
|
+
* IERC721AUpgradeable.TokenOwnership struct type
|
|
7
|
+
*/
|
|
8
|
+
export type IERC721AUpgradeable_TokenOwnership = {
|
|
9
|
+
addr: `0x${string}`;
|
|
10
|
+
startTimestamp: bigint;
|
|
11
|
+
burned: boolean;
|
|
12
|
+
extraData: bigint;
|
|
13
|
+
};
|
|
14
|
+
|
|
15
|
+
/**
|
|
16
|
+
* CollectionSecurityPolicy struct type
|
|
17
|
+
*/
|
|
18
|
+
export type CollectionSecurityPolicy = {
|
|
19
|
+
transferSecurityLevel: bigint;
|
|
20
|
+
operatorWhitelistId: bigint;
|
|
21
|
+
permittedContractReceiversId: bigint;
|
|
22
|
+
};
|
|
23
|
+
/**
|
|
24
|
+
* Yogapetz ABI
|
|
25
|
+
*
|
|
26
|
+
* This ABI is typed using viem's type system for full type safety.
|
|
27
|
+
*/
|
|
28
|
+
export const YogapetzAbi = [
|
|
29
|
+
{
|
|
30
|
+
"inputs": [],
|
|
31
|
+
"stateMutability": "nonpayable",
|
|
32
|
+
"type": "constructor"
|
|
33
|
+
},
|
|
34
|
+
{
|
|
35
|
+
"inputs": [],
|
|
36
|
+
"name": "ApprovalCallerNotOwnerNorApproved",
|
|
37
|
+
"type": "error"
|
|
38
|
+
},
|
|
39
|
+
{
|
|
40
|
+
"inputs": [],
|
|
41
|
+
"name": "ApprovalQueryForNonexistentToken",
|
|
42
|
+
"type": "error"
|
|
43
|
+
},
|
|
44
|
+
{
|
|
45
|
+
"inputs": [],
|
|
46
|
+
"name": "ApproveToCaller",
|
|
47
|
+
"type": "error"
|
|
48
|
+
},
|
|
49
|
+
{
|
|
50
|
+
"inputs": [],
|
|
51
|
+
"name": "BalanceQueryForZeroAddress",
|
|
52
|
+
"type": "error"
|
|
53
|
+
},
|
|
54
|
+
{
|
|
55
|
+
"inputs": [],
|
|
56
|
+
"name": "CreatorTokenBase__InvalidTransferValidatorContract",
|
|
57
|
+
"type": "error"
|
|
58
|
+
},
|
|
59
|
+
{
|
|
60
|
+
"inputs": [],
|
|
61
|
+
"name": "CreatorTokenBase__SetTransferValidatorFirst",
|
|
62
|
+
"type": "error"
|
|
63
|
+
},
|
|
64
|
+
{
|
|
65
|
+
"inputs": [],
|
|
66
|
+
"name": "InvalidQueryRange",
|
|
67
|
+
"type": "error"
|
|
68
|
+
},
|
|
69
|
+
{
|
|
70
|
+
"inputs": [],
|
|
71
|
+
"name": "MintERC2309QuantityExceedsLimit",
|
|
72
|
+
"type": "error"
|
|
73
|
+
},
|
|
74
|
+
{
|
|
75
|
+
"inputs": [],
|
|
76
|
+
"name": "MintToZeroAddress",
|
|
77
|
+
"type": "error"
|
|
78
|
+
},
|
|
79
|
+
{
|
|
80
|
+
"inputs": [],
|
|
81
|
+
"name": "MintZeroQuantity",
|
|
82
|
+
"type": "error"
|
|
83
|
+
},
|
|
84
|
+
{
|
|
85
|
+
"inputs": [
|
|
86
|
+
{
|
|
87
|
+
"internalType": "address",
|
|
88
|
+
"name": "operator",
|
|
89
|
+
"type": "address"
|
|
90
|
+
}
|
|
91
|
+
],
|
|
92
|
+
"name": "OperatorNotAllowed",
|
|
93
|
+
"type": "error"
|
|
94
|
+
},
|
|
95
|
+
{
|
|
96
|
+
"inputs": [],
|
|
97
|
+
"name": "OwnerQueryForNonexistentToken",
|
|
98
|
+
"type": "error"
|
|
99
|
+
},
|
|
100
|
+
{
|
|
101
|
+
"inputs": [],
|
|
102
|
+
"name": "OwnershipNotInitializedForExtraData",
|
|
103
|
+
"type": "error"
|
|
104
|
+
},
|
|
105
|
+
{
|
|
106
|
+
"inputs": [],
|
|
107
|
+
"name": "ShouldNotMintToBurnAddress",
|
|
108
|
+
"type": "error"
|
|
109
|
+
},
|
|
110
|
+
{
|
|
111
|
+
"inputs": [],
|
|
112
|
+
"name": "TransferCallerNotOwnerNorApproved",
|
|
113
|
+
"type": "error"
|
|
114
|
+
},
|
|
115
|
+
{
|
|
116
|
+
"inputs": [],
|
|
117
|
+
"name": "TransferFromIncorrectOwner",
|
|
118
|
+
"type": "error"
|
|
119
|
+
},
|
|
120
|
+
{
|
|
121
|
+
"inputs": [],
|
|
122
|
+
"name": "TransferToNonERC721ReceiverImplementer",
|
|
123
|
+
"type": "error"
|
|
124
|
+
},
|
|
125
|
+
{
|
|
126
|
+
"inputs": [],
|
|
127
|
+
"name": "TransferToZeroAddress",
|
|
128
|
+
"type": "error"
|
|
129
|
+
},
|
|
130
|
+
{
|
|
131
|
+
"inputs": [],
|
|
132
|
+
"name": "URIQueryForNonexistentToken",
|
|
133
|
+
"type": "error"
|
|
134
|
+
},
|
|
135
|
+
{
|
|
136
|
+
"anonymous": false,
|
|
137
|
+
"inputs": [
|
|
138
|
+
{
|
|
139
|
+
"indexed": true,
|
|
140
|
+
"internalType": "address",
|
|
141
|
+
"name": "owner",
|
|
142
|
+
"type": "address"
|
|
143
|
+
},
|
|
144
|
+
{
|
|
145
|
+
"indexed": true,
|
|
146
|
+
"internalType": "address",
|
|
147
|
+
"name": "approved",
|
|
148
|
+
"type": "address"
|
|
149
|
+
},
|
|
150
|
+
{
|
|
151
|
+
"indexed": true,
|
|
152
|
+
"internalType": "uint256",
|
|
153
|
+
"name": "tokenId",
|
|
154
|
+
"type": "uint256"
|
|
155
|
+
}
|
|
156
|
+
],
|
|
157
|
+
"name": "Approval",
|
|
158
|
+
"type": "event"
|
|
159
|
+
},
|
|
160
|
+
{
|
|
161
|
+
"anonymous": false,
|
|
162
|
+
"inputs": [
|
|
163
|
+
{
|
|
164
|
+
"indexed": true,
|
|
165
|
+
"internalType": "address",
|
|
166
|
+
"name": "owner",
|
|
167
|
+
"type": "address"
|
|
168
|
+
},
|
|
169
|
+
{
|
|
170
|
+
"indexed": true,
|
|
171
|
+
"internalType": "address",
|
|
172
|
+
"name": "operator",
|
|
173
|
+
"type": "address"
|
|
174
|
+
},
|
|
175
|
+
{
|
|
176
|
+
"indexed": false,
|
|
177
|
+
"internalType": "bool",
|
|
178
|
+
"name": "approved",
|
|
179
|
+
"type": "bool"
|
|
180
|
+
}
|
|
181
|
+
],
|
|
182
|
+
"name": "ApprovalForAll",
|
|
183
|
+
"type": "event"
|
|
184
|
+
},
|
|
185
|
+
{
|
|
186
|
+
"anonymous": false,
|
|
187
|
+
"inputs": [
|
|
188
|
+
{
|
|
189
|
+
"indexed": true,
|
|
190
|
+
"internalType": "uint256",
|
|
191
|
+
"name": "tokenId",
|
|
192
|
+
"type": "uint256"
|
|
193
|
+
},
|
|
194
|
+
{
|
|
195
|
+
"indexed": false,
|
|
196
|
+
"internalType": "string",
|
|
197
|
+
"name": "bio",
|
|
198
|
+
"type": "string"
|
|
199
|
+
}
|
|
200
|
+
],
|
|
201
|
+
"name": "BioChange",
|
|
202
|
+
"type": "event"
|
|
203
|
+
},
|
|
204
|
+
{
|
|
205
|
+
"anonymous": false,
|
|
206
|
+
"inputs": [
|
|
207
|
+
{
|
|
208
|
+
"indexed": true,
|
|
209
|
+
"internalType": "uint256",
|
|
210
|
+
"name": "fromTokenId",
|
|
211
|
+
"type": "uint256"
|
|
212
|
+
},
|
|
213
|
+
{
|
|
214
|
+
"indexed": false,
|
|
215
|
+
"internalType": "uint256",
|
|
216
|
+
"name": "toTokenId",
|
|
217
|
+
"type": "uint256"
|
|
218
|
+
},
|
|
219
|
+
{
|
|
220
|
+
"indexed": true,
|
|
221
|
+
"internalType": "address",
|
|
222
|
+
"name": "from",
|
|
223
|
+
"type": "address"
|
|
224
|
+
},
|
|
225
|
+
{
|
|
226
|
+
"indexed": true,
|
|
227
|
+
"internalType": "address",
|
|
228
|
+
"name": "to",
|
|
229
|
+
"type": "address"
|
|
230
|
+
}
|
|
231
|
+
],
|
|
232
|
+
"name": "ConsecutiveTransfer",
|
|
233
|
+
"type": "event"
|
|
234
|
+
},
|
|
235
|
+
{
|
|
236
|
+
"anonymous": false,
|
|
237
|
+
"inputs": [
|
|
238
|
+
{
|
|
239
|
+
"indexed": false,
|
|
240
|
+
"internalType": "uint8",
|
|
241
|
+
"name": "version",
|
|
242
|
+
"type": "uint8"
|
|
243
|
+
}
|
|
244
|
+
],
|
|
245
|
+
"name": "Initialized",
|
|
246
|
+
"type": "event"
|
|
247
|
+
},
|
|
248
|
+
{
|
|
249
|
+
"anonymous": false,
|
|
250
|
+
"inputs": [
|
|
251
|
+
{
|
|
252
|
+
"indexed": false,
|
|
253
|
+
"internalType": "address",
|
|
254
|
+
"name": "from",
|
|
255
|
+
"type": "address"
|
|
256
|
+
},
|
|
257
|
+
{
|
|
258
|
+
"indexed": false,
|
|
259
|
+
"internalType": "address",
|
|
260
|
+
"name": "to",
|
|
261
|
+
"type": "address"
|
|
262
|
+
},
|
|
263
|
+
{
|
|
264
|
+
"indexed": false,
|
|
265
|
+
"internalType": "uint256",
|
|
266
|
+
"name": "tokenId",
|
|
267
|
+
"type": "uint256"
|
|
268
|
+
}
|
|
269
|
+
],
|
|
270
|
+
"name": "KeepTOLTransfer",
|
|
271
|
+
"type": "event"
|
|
272
|
+
},
|
|
273
|
+
{
|
|
274
|
+
"anonymous": false,
|
|
275
|
+
"inputs": [
|
|
276
|
+
{
|
|
277
|
+
"indexed": false,
|
|
278
|
+
"internalType": "uint256",
|
|
279
|
+
"name": "tokenId",
|
|
280
|
+
"type": "uint256"
|
|
281
|
+
}
|
|
282
|
+
],
|
|
283
|
+
"name": "MNPLUnlockedUpgraded",
|
|
284
|
+
"type": "event"
|
|
285
|
+
},
|
|
286
|
+
{
|
|
287
|
+
"anonymous": false,
|
|
288
|
+
"inputs": [
|
|
289
|
+
{
|
|
290
|
+
"indexed": true,
|
|
291
|
+
"internalType": "uint256",
|
|
292
|
+
"name": "tokenId",
|
|
293
|
+
"type": "uint256"
|
|
294
|
+
},
|
|
295
|
+
{
|
|
296
|
+
"indexed": false,
|
|
297
|
+
"internalType": "string",
|
|
298
|
+
"name": "newName",
|
|
299
|
+
"type": "string"
|
|
300
|
+
}
|
|
301
|
+
],
|
|
302
|
+
"name": "NameChange",
|
|
303
|
+
"type": "event"
|
|
304
|
+
},
|
|
305
|
+
{
|
|
306
|
+
"anonymous": false,
|
|
307
|
+
"inputs": [
|
|
308
|
+
{
|
|
309
|
+
"indexed": true,
|
|
310
|
+
"internalType": "address",
|
|
311
|
+
"name": "previousOwner",
|
|
312
|
+
"type": "address"
|
|
313
|
+
},
|
|
314
|
+
{
|
|
315
|
+
"indexed": true,
|
|
316
|
+
"internalType": "address",
|
|
317
|
+
"name": "newOwner",
|
|
318
|
+
"type": "address"
|
|
319
|
+
}
|
|
320
|
+
],
|
|
321
|
+
"name": "OwnershipTransferred",
|
|
322
|
+
"type": "event"
|
|
323
|
+
},
|
|
324
|
+
{
|
|
325
|
+
"anonymous": false,
|
|
326
|
+
"inputs": [
|
|
327
|
+
{
|
|
328
|
+
"indexed": false,
|
|
329
|
+
"internalType": "uint256",
|
|
330
|
+
"name": "tokenId",
|
|
331
|
+
"type": "uint256"
|
|
332
|
+
},
|
|
333
|
+
{
|
|
334
|
+
"indexed": false,
|
|
335
|
+
"internalType": "uint256",
|
|
336
|
+
"name": "amount",
|
|
337
|
+
"type": "uint256"
|
|
338
|
+
}
|
|
339
|
+
],
|
|
340
|
+
"name": "RoyaltyPaid",
|
|
341
|
+
"type": "event"
|
|
342
|
+
},
|
|
343
|
+
{
|
|
344
|
+
"anonymous": false,
|
|
345
|
+
"inputs": [
|
|
346
|
+
{
|
|
347
|
+
"indexed": true,
|
|
348
|
+
"internalType": "uint256",
|
|
349
|
+
"name": "tokenId",
|
|
350
|
+
"type": "uint256"
|
|
351
|
+
}
|
|
352
|
+
],
|
|
353
|
+
"name": "Stake",
|
|
354
|
+
"type": "event"
|
|
355
|
+
},
|
|
356
|
+
{
|
|
357
|
+
"anonymous": false,
|
|
358
|
+
"inputs": [
|
|
359
|
+
{
|
|
360
|
+
"indexed": false,
|
|
361
|
+
"internalType": "uint256",
|
|
362
|
+
"name": "tokenId",
|
|
363
|
+
"type": "uint256"
|
|
364
|
+
},
|
|
365
|
+
{
|
|
366
|
+
"indexed": false,
|
|
367
|
+
"internalType": "bool",
|
|
368
|
+
"name": "isAdminLocked",
|
|
369
|
+
"type": "bool"
|
|
370
|
+
}
|
|
371
|
+
],
|
|
372
|
+
"name": "TokenAdminLockedChanged",
|
|
373
|
+
"type": "event"
|
|
374
|
+
},
|
|
375
|
+
{
|
|
376
|
+
"anonymous": false,
|
|
377
|
+
"inputs": [
|
|
378
|
+
{
|
|
379
|
+
"indexed": true,
|
|
380
|
+
"internalType": "uint256",
|
|
381
|
+
"name": "tokenId",
|
|
382
|
+
"type": "uint256"
|
|
383
|
+
},
|
|
384
|
+
{
|
|
385
|
+
"indexed": true,
|
|
386
|
+
"internalType": "address",
|
|
387
|
+
"name": "approvedContract",
|
|
388
|
+
"type": "address"
|
|
389
|
+
}
|
|
390
|
+
],
|
|
391
|
+
"name": "TokenLocked",
|
|
392
|
+
"type": "event"
|
|
393
|
+
},
|
|
394
|
+
{
|
|
395
|
+
"anonymous": false,
|
|
396
|
+
"inputs": [
|
|
397
|
+
{
|
|
398
|
+
"indexed": true,
|
|
399
|
+
"internalType": "uint256",
|
|
400
|
+
"name": "tokenId",
|
|
401
|
+
"type": "uint256"
|
|
402
|
+
},
|
|
403
|
+
{
|
|
404
|
+
"indexed": true,
|
|
405
|
+
"internalType": "address",
|
|
406
|
+
"name": "approvedContract",
|
|
407
|
+
"type": "address"
|
|
408
|
+
}
|
|
409
|
+
],
|
|
410
|
+
"name": "TokenUnlocked",
|
|
411
|
+
"type": "event"
|
|
412
|
+
},
|
|
413
|
+
{
|
|
414
|
+
"anonymous": false,
|
|
415
|
+
"inputs": [
|
|
416
|
+
{
|
|
417
|
+
"indexed": true,
|
|
418
|
+
"internalType": "address",
|
|
419
|
+
"name": "from",
|
|
420
|
+
"type": "address"
|
|
421
|
+
},
|
|
422
|
+
{
|
|
423
|
+
"indexed": true,
|
|
424
|
+
"internalType": "address",
|
|
425
|
+
"name": "to",
|
|
426
|
+
"type": "address"
|
|
427
|
+
},
|
|
428
|
+
{
|
|
429
|
+
"indexed": true,
|
|
430
|
+
"internalType": "uint256",
|
|
431
|
+
"name": "tokenId",
|
|
432
|
+
"type": "uint256"
|
|
433
|
+
}
|
|
434
|
+
],
|
|
435
|
+
"name": "Transfer",
|
|
436
|
+
"type": "event"
|
|
437
|
+
},
|
|
438
|
+
{
|
|
439
|
+
"anonymous": false,
|
|
440
|
+
"inputs": [
|
|
441
|
+
{
|
|
442
|
+
"indexed": false,
|
|
443
|
+
"internalType": "address",
|
|
444
|
+
"name": "oldValidator",
|
|
445
|
+
"type": "address"
|
|
446
|
+
},
|
|
447
|
+
{
|
|
448
|
+
"indexed": false,
|
|
449
|
+
"internalType": "address",
|
|
450
|
+
"name": "newValidator",
|
|
451
|
+
"type": "address"
|
|
452
|
+
}
|
|
453
|
+
],
|
|
454
|
+
"name": "TransferValidatorUpdated",
|
|
455
|
+
"type": "event"
|
|
456
|
+
},
|
|
457
|
+
{
|
|
458
|
+
"anonymous": false,
|
|
459
|
+
"inputs": [
|
|
460
|
+
{
|
|
461
|
+
"indexed": true,
|
|
462
|
+
"internalType": "uint256",
|
|
463
|
+
"name": "tokenId",
|
|
464
|
+
"type": "uint256"
|
|
465
|
+
},
|
|
466
|
+
{
|
|
467
|
+
"indexed": false,
|
|
468
|
+
"internalType": "uint256",
|
|
469
|
+
"name": "stakedAtTimestamp",
|
|
470
|
+
"type": "uint256"
|
|
471
|
+
},
|
|
472
|
+
{
|
|
473
|
+
"indexed": false,
|
|
474
|
+
"internalType": "uint256",
|
|
475
|
+
"name": "removedFromStakeAtTimestamp",
|
|
476
|
+
"type": "uint256"
|
|
477
|
+
}
|
|
478
|
+
],
|
|
479
|
+
"name": "Unstake",
|
|
480
|
+
"type": "event"
|
|
481
|
+
},
|
|
482
|
+
{
|
|
483
|
+
"inputs": [],
|
|
484
|
+
"name": "DEFAULT_OPERATOR_WHITELIST_ID",
|
|
485
|
+
"outputs": [
|
|
486
|
+
{
|
|
487
|
+
"internalType": "uint120",
|
|
488
|
+
"name": "",
|
|
489
|
+
"type": "uint120"
|
|
490
|
+
}
|
|
491
|
+
],
|
|
492
|
+
"stateMutability": "view",
|
|
493
|
+
"type": "function"
|
|
494
|
+
},
|
|
495
|
+
{
|
|
496
|
+
"inputs": [],
|
|
497
|
+
"name": "DEFAULT_TRANSFER_SECURITY_LEVEL",
|
|
498
|
+
"outputs": [
|
|
499
|
+
{
|
|
500
|
+
"internalType": "enum TransferSecurityLevels",
|
|
501
|
+
"name": "",
|
|
502
|
+
"type": "uint8"
|
|
503
|
+
}
|
|
504
|
+
],
|
|
505
|
+
"stateMutability": "view",
|
|
506
|
+
"type": "function"
|
|
507
|
+
},
|
|
508
|
+
{
|
|
509
|
+
"inputs": [],
|
|
510
|
+
"name": "DEFAULT_TRANSFER_VALIDATOR",
|
|
511
|
+
"outputs": [
|
|
512
|
+
{
|
|
513
|
+
"internalType": "address",
|
|
514
|
+
"name": "",
|
|
515
|
+
"type": "address"
|
|
516
|
+
}
|
|
517
|
+
],
|
|
518
|
+
"stateMutability": "view",
|
|
519
|
+
"type": "function"
|
|
520
|
+
},
|
|
521
|
+
{
|
|
522
|
+
"inputs": [],
|
|
523
|
+
"name": "MAX_SUPPLY",
|
|
524
|
+
"outputs": [
|
|
525
|
+
{
|
|
526
|
+
"internalType": "uint256",
|
|
527
|
+
"name": "",
|
|
528
|
+
"type": "uint256"
|
|
529
|
+
}
|
|
530
|
+
],
|
|
531
|
+
"stateMutability": "view",
|
|
532
|
+
"type": "function"
|
|
533
|
+
},
|
|
534
|
+
{
|
|
535
|
+
"inputs": [],
|
|
536
|
+
"name": "__DefaultOperatorFilterer_init",
|
|
537
|
+
"outputs": [],
|
|
538
|
+
"stateMutability": "nonpayable",
|
|
539
|
+
"type": "function"
|
|
540
|
+
},
|
|
541
|
+
{
|
|
542
|
+
"inputs": [
|
|
543
|
+
{
|
|
544
|
+
"internalType": "address",
|
|
545
|
+
"name": "subscriptionOrRegistrantToCopy",
|
|
546
|
+
"type": "address"
|
|
547
|
+
},
|
|
548
|
+
{
|
|
549
|
+
"internalType": "bool",
|
|
550
|
+
"name": "subscribe",
|
|
551
|
+
"type": "bool"
|
|
552
|
+
}
|
|
553
|
+
],
|
|
554
|
+
"name": "__OperatorFilterer_init",
|
|
555
|
+
"outputs": [],
|
|
556
|
+
"stateMutability": "nonpayable",
|
|
557
|
+
"type": "function"
|
|
558
|
+
},
|
|
559
|
+
{
|
|
560
|
+
"inputs": [
|
|
561
|
+
{
|
|
562
|
+
"internalType": "uint256",
|
|
563
|
+
"name": "",
|
|
564
|
+
"type": "uint256"
|
|
565
|
+
}
|
|
566
|
+
],
|
|
567
|
+
"name": "adminLocked",
|
|
568
|
+
"outputs": [
|
|
569
|
+
{
|
|
570
|
+
"internalType": "bool",
|
|
571
|
+
"name": "",
|
|
572
|
+
"type": "bool"
|
|
573
|
+
}
|
|
574
|
+
],
|
|
575
|
+
"stateMutability": "view",
|
|
576
|
+
"type": "function"
|
|
577
|
+
},
|
|
578
|
+
{
|
|
579
|
+
"inputs": [
|
|
580
|
+
{
|
|
581
|
+
"internalType": "address[]",
|
|
582
|
+
"name": "receivers",
|
|
583
|
+
"type": "address[]"
|
|
584
|
+
},
|
|
585
|
+
{
|
|
586
|
+
"internalType": "uint256[]",
|
|
587
|
+
"name": "amounts",
|
|
588
|
+
"type": "uint256[]"
|
|
589
|
+
}
|
|
590
|
+
],
|
|
591
|
+
"name": "airdropListWithAmounts",
|
|
592
|
+
"outputs": [],
|
|
593
|
+
"stateMutability": "nonpayable",
|
|
594
|
+
"type": "function"
|
|
595
|
+
},
|
|
596
|
+
{
|
|
597
|
+
"inputs": [
|
|
598
|
+
{
|
|
599
|
+
"internalType": "address",
|
|
600
|
+
"name": "to",
|
|
601
|
+
"type": "address"
|
|
602
|
+
},
|
|
603
|
+
{
|
|
604
|
+
"internalType": "uint256",
|
|
605
|
+
"name": "tokenId",
|
|
606
|
+
"type": "uint256"
|
|
607
|
+
}
|
|
608
|
+
],
|
|
609
|
+
"name": "approve",
|
|
610
|
+
"outputs": [],
|
|
611
|
+
"stateMutability": "nonpayable",
|
|
612
|
+
"type": "function"
|
|
613
|
+
},
|
|
614
|
+
{
|
|
615
|
+
"inputs": [
|
|
616
|
+
{
|
|
617
|
+
"internalType": "address",
|
|
618
|
+
"name": "",
|
|
619
|
+
"type": "address"
|
|
620
|
+
}
|
|
621
|
+
],
|
|
622
|
+
"name": "approvedContract",
|
|
623
|
+
"outputs": [
|
|
624
|
+
{
|
|
625
|
+
"internalType": "bool",
|
|
626
|
+
"name": "",
|
|
627
|
+
"type": "bool"
|
|
628
|
+
}
|
|
629
|
+
],
|
|
630
|
+
"stateMutability": "view",
|
|
631
|
+
"type": "function"
|
|
632
|
+
},
|
|
633
|
+
{
|
|
634
|
+
"inputs": [
|
|
635
|
+
{
|
|
636
|
+
"internalType": "address",
|
|
637
|
+
"name": "owner",
|
|
638
|
+
"type": "address"
|
|
639
|
+
}
|
|
640
|
+
],
|
|
641
|
+
"name": "balanceOf",
|
|
642
|
+
"outputs": [
|
|
643
|
+
{
|
|
644
|
+
"internalType": "uint256",
|
|
645
|
+
"name": "",
|
|
646
|
+
"type": "uint256"
|
|
647
|
+
}
|
|
648
|
+
],
|
|
649
|
+
"stateMutability": "view",
|
|
650
|
+
"type": "function"
|
|
651
|
+
},
|
|
652
|
+
{
|
|
653
|
+
"inputs": [],
|
|
654
|
+
"name": "baseTokenURI",
|
|
655
|
+
"outputs": [
|
|
656
|
+
{
|
|
657
|
+
"internalType": "string",
|
|
658
|
+
"name": "",
|
|
659
|
+
"type": "string"
|
|
660
|
+
}
|
|
661
|
+
],
|
|
662
|
+
"stateMutability": "view",
|
|
663
|
+
"type": "function"
|
|
664
|
+
},
|
|
665
|
+
{
|
|
666
|
+
"inputs": [
|
|
667
|
+
{
|
|
668
|
+
"internalType": "uint256",
|
|
669
|
+
"name": "",
|
|
670
|
+
"type": "uint256"
|
|
671
|
+
}
|
|
672
|
+
],
|
|
673
|
+
"name": "bio",
|
|
674
|
+
"outputs": [
|
|
675
|
+
{
|
|
676
|
+
"internalType": "string",
|
|
677
|
+
"name": "",
|
|
678
|
+
"type": "string"
|
|
679
|
+
}
|
|
680
|
+
],
|
|
681
|
+
"stateMutability": "view",
|
|
682
|
+
"type": "function"
|
|
683
|
+
},
|
|
684
|
+
{
|
|
685
|
+
"inputs": [],
|
|
686
|
+
"name": "canStake",
|
|
687
|
+
"outputs": [
|
|
688
|
+
{
|
|
689
|
+
"internalType": "bool",
|
|
690
|
+
"name": "",
|
|
691
|
+
"type": "bool"
|
|
692
|
+
}
|
|
693
|
+
],
|
|
694
|
+
"stateMutability": "view",
|
|
695
|
+
"type": "function"
|
|
696
|
+
},
|
|
697
|
+
{
|
|
698
|
+
"inputs": [
|
|
699
|
+
{
|
|
700
|
+
"internalType": "uint256[]",
|
|
701
|
+
"name": "t2TokenIds",
|
|
702
|
+
"type": "uint256[]"
|
|
703
|
+
}
|
|
704
|
+
],
|
|
705
|
+
"name": "confiscateT2",
|
|
706
|
+
"outputs": [],
|
|
707
|
+
"stateMutability": "nonpayable",
|
|
708
|
+
"type": "function"
|
|
709
|
+
},
|
|
710
|
+
{
|
|
711
|
+
"inputs": [
|
|
712
|
+
{
|
|
713
|
+
"internalType": "address[]",
|
|
714
|
+
"name": "markets",
|
|
715
|
+
"type": "address[]"
|
|
716
|
+
},
|
|
717
|
+
{
|
|
718
|
+
"internalType": "bool",
|
|
719
|
+
"name": "exempted",
|
|
720
|
+
"type": "bool"
|
|
721
|
+
}
|
|
722
|
+
],
|
|
723
|
+
"name": "exemptMarketplaces",
|
|
724
|
+
"outputs": [],
|
|
725
|
+
"stateMutability": "nonpayable",
|
|
726
|
+
"type": "function"
|
|
727
|
+
},
|
|
728
|
+
{
|
|
729
|
+
"inputs": [
|
|
730
|
+
{
|
|
731
|
+
"internalType": "address",
|
|
732
|
+
"name": "",
|
|
733
|
+
"type": "address"
|
|
734
|
+
}
|
|
735
|
+
],
|
|
736
|
+
"name": "exemptedMarketplaces",
|
|
737
|
+
"outputs": [
|
|
738
|
+
{
|
|
739
|
+
"internalType": "bool",
|
|
740
|
+
"name": "",
|
|
741
|
+
"type": "bool"
|
|
742
|
+
}
|
|
743
|
+
],
|
|
744
|
+
"stateMutability": "view",
|
|
745
|
+
"type": "function"
|
|
746
|
+
},
|
|
747
|
+
{
|
|
748
|
+
"inputs": [
|
|
749
|
+
{
|
|
750
|
+
"internalType": "uint256",
|
|
751
|
+
"name": "tokenId",
|
|
752
|
+
"type": "uint256"
|
|
753
|
+
}
|
|
754
|
+
],
|
|
755
|
+
"name": "explicitOwnershipOf",
|
|
756
|
+
"outputs": [
|
|
757
|
+
{
|
|
758
|
+
"components": [
|
|
759
|
+
{
|
|
760
|
+
"internalType": "address",
|
|
761
|
+
"name": "addr",
|
|
762
|
+
"type": "address"
|
|
763
|
+
},
|
|
764
|
+
{
|
|
765
|
+
"internalType": "uint64",
|
|
766
|
+
"name": "startTimestamp",
|
|
767
|
+
"type": "uint64"
|
|
768
|
+
},
|
|
769
|
+
{
|
|
770
|
+
"internalType": "bool",
|
|
771
|
+
"name": "burned",
|
|
772
|
+
"type": "bool"
|
|
773
|
+
},
|
|
774
|
+
{
|
|
775
|
+
"internalType": "uint24",
|
|
776
|
+
"name": "extraData",
|
|
777
|
+
"type": "uint24"
|
|
778
|
+
}
|
|
779
|
+
],
|
|
780
|
+
"internalType": "struct IERC721AUpgradeable.TokenOwnership",
|
|
781
|
+
"name": "",
|
|
782
|
+
"type": "tuple"
|
|
783
|
+
}
|
|
784
|
+
],
|
|
785
|
+
"stateMutability": "view",
|
|
786
|
+
"type": "function"
|
|
787
|
+
},
|
|
788
|
+
{
|
|
789
|
+
"inputs": [
|
|
790
|
+
{
|
|
791
|
+
"internalType": "uint256[]",
|
|
792
|
+
"name": "tokenIds",
|
|
793
|
+
"type": "uint256[]"
|
|
794
|
+
}
|
|
795
|
+
],
|
|
796
|
+
"name": "explicitOwnershipsOf",
|
|
797
|
+
"outputs": [
|
|
798
|
+
{
|
|
799
|
+
"components": [
|
|
800
|
+
{
|
|
801
|
+
"internalType": "address",
|
|
802
|
+
"name": "addr",
|
|
803
|
+
"type": "address"
|
|
804
|
+
},
|
|
805
|
+
{
|
|
806
|
+
"internalType": "uint64",
|
|
807
|
+
"name": "startTimestamp",
|
|
808
|
+
"type": "uint64"
|
|
809
|
+
},
|
|
810
|
+
{
|
|
811
|
+
"internalType": "bool",
|
|
812
|
+
"name": "burned",
|
|
813
|
+
"type": "bool"
|
|
814
|
+
},
|
|
815
|
+
{
|
|
816
|
+
"internalType": "uint24",
|
|
817
|
+
"name": "extraData",
|
|
818
|
+
"type": "uint24"
|
|
819
|
+
}
|
|
820
|
+
],
|
|
821
|
+
"internalType": "struct IERC721AUpgradeable.TokenOwnership[]",
|
|
822
|
+
"name": "",
|
|
823
|
+
"type": "tuple[]"
|
|
824
|
+
}
|
|
825
|
+
],
|
|
826
|
+
"stateMutability": "view",
|
|
827
|
+
"type": "function"
|
|
828
|
+
},
|
|
829
|
+
{
|
|
830
|
+
"inputs": [
|
|
831
|
+
{
|
|
832
|
+
"internalType": "uint256",
|
|
833
|
+
"name": "_id",
|
|
834
|
+
"type": "uint256"
|
|
835
|
+
},
|
|
836
|
+
{
|
|
837
|
+
"internalType": "address",
|
|
838
|
+
"name": "_contract",
|
|
839
|
+
"type": "address"
|
|
840
|
+
}
|
|
841
|
+
],
|
|
842
|
+
"name": "freeId",
|
|
843
|
+
"outputs": [],
|
|
844
|
+
"stateMutability": "nonpayable",
|
|
845
|
+
"type": "function"
|
|
846
|
+
},
|
|
847
|
+
{
|
|
848
|
+
"inputs": [
|
|
849
|
+
{
|
|
850
|
+
"internalType": "uint256",
|
|
851
|
+
"name": "tokenId",
|
|
852
|
+
"type": "uint256"
|
|
853
|
+
}
|
|
854
|
+
],
|
|
855
|
+
"name": "getApproved",
|
|
856
|
+
"outputs": [
|
|
857
|
+
{
|
|
858
|
+
"internalType": "address",
|
|
859
|
+
"name": "",
|
|
860
|
+
"type": "address"
|
|
861
|
+
}
|
|
862
|
+
],
|
|
863
|
+
"stateMutability": "view",
|
|
864
|
+
"type": "function"
|
|
865
|
+
},
|
|
866
|
+
{
|
|
867
|
+
"inputs": [],
|
|
868
|
+
"name": "getPermittedContractReceivers",
|
|
869
|
+
"outputs": [
|
|
870
|
+
{
|
|
871
|
+
"internalType": "address[]",
|
|
872
|
+
"name": "",
|
|
873
|
+
"type": "address[]"
|
|
874
|
+
}
|
|
875
|
+
],
|
|
876
|
+
"stateMutability": "view",
|
|
877
|
+
"type": "function"
|
|
878
|
+
},
|
|
879
|
+
{
|
|
880
|
+
"inputs": [],
|
|
881
|
+
"name": "getSecurityPolicy",
|
|
882
|
+
"outputs": [
|
|
883
|
+
{
|
|
884
|
+
"components": [
|
|
885
|
+
{
|
|
886
|
+
"internalType": "enum TransferSecurityLevels",
|
|
887
|
+
"name": "transferSecurityLevel",
|
|
888
|
+
"type": "uint8"
|
|
889
|
+
},
|
|
890
|
+
{
|
|
891
|
+
"internalType": "uint120",
|
|
892
|
+
"name": "operatorWhitelistId",
|
|
893
|
+
"type": "uint120"
|
|
894
|
+
},
|
|
895
|
+
{
|
|
896
|
+
"internalType": "uint120",
|
|
897
|
+
"name": "permittedContractReceiversId",
|
|
898
|
+
"type": "uint120"
|
|
899
|
+
}
|
|
900
|
+
],
|
|
901
|
+
"internalType": "struct CollectionSecurityPolicy",
|
|
902
|
+
"name": "",
|
|
903
|
+
"type": "tuple"
|
|
904
|
+
}
|
|
905
|
+
],
|
|
906
|
+
"stateMutability": "view",
|
|
907
|
+
"type": "function"
|
|
908
|
+
},
|
|
909
|
+
{
|
|
910
|
+
"inputs": [
|
|
911
|
+
{
|
|
912
|
+
"internalType": "uint256",
|
|
913
|
+
"name": "tokenId",
|
|
914
|
+
"type": "uint256"
|
|
915
|
+
}
|
|
916
|
+
],
|
|
917
|
+
"name": "getTier",
|
|
918
|
+
"outputs": [
|
|
919
|
+
{
|
|
920
|
+
"internalType": "uint256",
|
|
921
|
+
"name": "",
|
|
922
|
+
"type": "uint256"
|
|
923
|
+
}
|
|
924
|
+
],
|
|
925
|
+
"stateMutability": "view",
|
|
926
|
+
"type": "function"
|
|
927
|
+
},
|
|
928
|
+
{
|
|
929
|
+
"inputs": [
|
|
930
|
+
{
|
|
931
|
+
"internalType": "uint256[]",
|
|
932
|
+
"name": "tokenIds",
|
|
933
|
+
"type": "uint256[]"
|
|
934
|
+
}
|
|
935
|
+
],
|
|
936
|
+
"name": "getTierMultiple",
|
|
937
|
+
"outputs": [
|
|
938
|
+
{
|
|
939
|
+
"internalType": "uint256[]",
|
|
940
|
+
"name": "",
|
|
941
|
+
"type": "uint256[]"
|
|
942
|
+
}
|
|
943
|
+
],
|
|
944
|
+
"stateMutability": "view",
|
|
945
|
+
"type": "function"
|
|
946
|
+
},
|
|
947
|
+
{
|
|
948
|
+
"inputs": [],
|
|
949
|
+
"name": "getTransferValidator",
|
|
950
|
+
"outputs": [
|
|
951
|
+
{
|
|
952
|
+
"internalType": "contract ICreatorTokenTransferValidator",
|
|
953
|
+
"name": "",
|
|
954
|
+
"type": "address"
|
|
955
|
+
}
|
|
956
|
+
],
|
|
957
|
+
"stateMutability": "view",
|
|
958
|
+
"type": "function"
|
|
959
|
+
},
|
|
960
|
+
{
|
|
961
|
+
"inputs": [],
|
|
962
|
+
"name": "getWhitelistedOperators",
|
|
963
|
+
"outputs": [
|
|
964
|
+
{
|
|
965
|
+
"internalType": "address[]",
|
|
966
|
+
"name": "",
|
|
967
|
+
"type": "address[]"
|
|
968
|
+
}
|
|
969
|
+
],
|
|
970
|
+
"stateMutability": "view",
|
|
971
|
+
"type": "function"
|
|
972
|
+
},
|
|
973
|
+
{
|
|
974
|
+
"inputs": [],
|
|
975
|
+
"name": "guardianContract",
|
|
976
|
+
"outputs": [
|
|
977
|
+
{
|
|
978
|
+
"internalType": "contract ITOLTransfer",
|
|
979
|
+
"name": "",
|
|
980
|
+
"type": "address"
|
|
981
|
+
}
|
|
982
|
+
],
|
|
983
|
+
"stateMutability": "view",
|
|
984
|
+
"type": "function"
|
|
985
|
+
},
|
|
986
|
+
{
|
|
987
|
+
"inputs": [
|
|
988
|
+
{
|
|
989
|
+
"internalType": "string",
|
|
990
|
+
"name": "baseURI",
|
|
991
|
+
"type": "string"
|
|
992
|
+
}
|
|
993
|
+
],
|
|
994
|
+
"name": "initialize",
|
|
995
|
+
"outputs": [],
|
|
996
|
+
"stateMutability": "nonpayable",
|
|
997
|
+
"type": "function"
|
|
998
|
+
},
|
|
999
|
+
{
|
|
1000
|
+
"inputs": [],
|
|
1001
|
+
"name": "initializeV3",
|
|
1002
|
+
"outputs": [],
|
|
1003
|
+
"stateMutability": "nonpayable",
|
|
1004
|
+
"type": "function"
|
|
1005
|
+
},
|
|
1006
|
+
{
|
|
1007
|
+
"inputs": [
|
|
1008
|
+
{
|
|
1009
|
+
"internalType": "uint256",
|
|
1010
|
+
"name": "tokenId",
|
|
1011
|
+
"type": "uint256"
|
|
1012
|
+
}
|
|
1013
|
+
],
|
|
1014
|
+
"name": "isAdminLocked",
|
|
1015
|
+
"outputs": [
|
|
1016
|
+
{
|
|
1017
|
+
"internalType": "bool",
|
|
1018
|
+
"name": "",
|
|
1019
|
+
"type": "bool"
|
|
1020
|
+
}
|
|
1021
|
+
],
|
|
1022
|
+
"stateMutability": "view",
|
|
1023
|
+
"type": "function"
|
|
1024
|
+
},
|
|
1025
|
+
{
|
|
1026
|
+
"inputs": [
|
|
1027
|
+
{
|
|
1028
|
+
"internalType": "address",
|
|
1029
|
+
"name": "tokenOwner",
|
|
1030
|
+
"type": "address"
|
|
1031
|
+
},
|
|
1032
|
+
{
|
|
1033
|
+
"internalType": "address",
|
|
1034
|
+
"name": "operator",
|
|
1035
|
+
"type": "address"
|
|
1036
|
+
}
|
|
1037
|
+
],
|
|
1038
|
+
"name": "isApprovedForAll",
|
|
1039
|
+
"outputs": [
|
|
1040
|
+
{
|
|
1041
|
+
"internalType": "bool",
|
|
1042
|
+
"name": "",
|
|
1043
|
+
"type": "bool"
|
|
1044
|
+
}
|
|
1045
|
+
],
|
|
1046
|
+
"stateMutability": "view",
|
|
1047
|
+
"type": "function"
|
|
1048
|
+
},
|
|
1049
|
+
{
|
|
1050
|
+
"inputs": [
|
|
1051
|
+
{
|
|
1052
|
+
"internalType": "address",
|
|
1053
|
+
"name": "receiver",
|
|
1054
|
+
"type": "address"
|
|
1055
|
+
}
|
|
1056
|
+
],
|
|
1057
|
+
"name": "isContractReceiverPermitted",
|
|
1058
|
+
"outputs": [
|
|
1059
|
+
{
|
|
1060
|
+
"internalType": "bool",
|
|
1061
|
+
"name": "",
|
|
1062
|
+
"type": "bool"
|
|
1063
|
+
}
|
|
1064
|
+
],
|
|
1065
|
+
"stateMutability": "view",
|
|
1066
|
+
"type": "function"
|
|
1067
|
+
},
|
|
1068
|
+
{
|
|
1069
|
+
"inputs": [
|
|
1070
|
+
{
|
|
1071
|
+
"internalType": "uint256",
|
|
1072
|
+
"name": "tokenId",
|
|
1073
|
+
"type": "uint256"
|
|
1074
|
+
}
|
|
1075
|
+
],
|
|
1076
|
+
"name": "isMNPLTransferLocked",
|
|
1077
|
+
"outputs": [
|
|
1078
|
+
{
|
|
1079
|
+
"internalType": "bool",
|
|
1080
|
+
"name": "",
|
|
1081
|
+
"type": "bool"
|
|
1082
|
+
}
|
|
1083
|
+
],
|
|
1084
|
+
"stateMutability": "view",
|
|
1085
|
+
"type": "function"
|
|
1086
|
+
},
|
|
1087
|
+
{
|
|
1088
|
+
"inputs": [
|
|
1089
|
+
{
|
|
1090
|
+
"internalType": "address",
|
|
1091
|
+
"name": "operator",
|
|
1092
|
+
"type": "address"
|
|
1093
|
+
}
|
|
1094
|
+
],
|
|
1095
|
+
"name": "isOperatorWhitelisted",
|
|
1096
|
+
"outputs": [
|
|
1097
|
+
{
|
|
1098
|
+
"internalType": "bool",
|
|
1099
|
+
"name": "",
|
|
1100
|
+
"type": "bool"
|
|
1101
|
+
}
|
|
1102
|
+
],
|
|
1103
|
+
"stateMutability": "view",
|
|
1104
|
+
"type": "function"
|
|
1105
|
+
},
|
|
1106
|
+
{
|
|
1107
|
+
"inputs": [
|
|
1108
|
+
{
|
|
1109
|
+
"internalType": "uint256",
|
|
1110
|
+
"name": "tokenId",
|
|
1111
|
+
"type": "uint256"
|
|
1112
|
+
}
|
|
1113
|
+
],
|
|
1114
|
+
"name": "isOriginallyMNPL",
|
|
1115
|
+
"outputs": [
|
|
1116
|
+
{
|
|
1117
|
+
"internalType": "bool",
|
|
1118
|
+
"name": "",
|
|
1119
|
+
"type": "bool"
|
|
1120
|
+
}
|
|
1121
|
+
],
|
|
1122
|
+
"stateMutability": "view",
|
|
1123
|
+
"type": "function"
|
|
1124
|
+
},
|
|
1125
|
+
{
|
|
1126
|
+
"inputs": [
|
|
1127
|
+
{
|
|
1128
|
+
"internalType": "address",
|
|
1129
|
+
"name": "caller",
|
|
1130
|
+
"type": "address"
|
|
1131
|
+
},
|
|
1132
|
+
{
|
|
1133
|
+
"internalType": "address",
|
|
1134
|
+
"name": "from",
|
|
1135
|
+
"type": "address"
|
|
1136
|
+
},
|
|
1137
|
+
{
|
|
1138
|
+
"internalType": "address",
|
|
1139
|
+
"name": "to",
|
|
1140
|
+
"type": "address"
|
|
1141
|
+
}
|
|
1142
|
+
],
|
|
1143
|
+
"name": "isTransferAllowed",
|
|
1144
|
+
"outputs": [
|
|
1145
|
+
{
|
|
1146
|
+
"internalType": "bool",
|
|
1147
|
+
"name": "",
|
|
1148
|
+
"type": "bool"
|
|
1149
|
+
}
|
|
1150
|
+
],
|
|
1151
|
+
"stateMutability": "view",
|
|
1152
|
+
"type": "function"
|
|
1153
|
+
},
|
|
1154
|
+
{
|
|
1155
|
+
"inputs": [
|
|
1156
|
+
{
|
|
1157
|
+
"internalType": "uint256",
|
|
1158
|
+
"name": "_id",
|
|
1159
|
+
"type": "uint256"
|
|
1160
|
+
}
|
|
1161
|
+
],
|
|
1162
|
+
"name": "isUnlocked",
|
|
1163
|
+
"outputs": [
|
|
1164
|
+
{
|
|
1165
|
+
"internalType": "bool",
|
|
1166
|
+
"name": "",
|
|
1167
|
+
"type": "bool"
|
|
1168
|
+
}
|
|
1169
|
+
],
|
|
1170
|
+
"stateMutability": "view",
|
|
1171
|
+
"type": "function"
|
|
1172
|
+
},
|
|
1173
|
+
{
|
|
1174
|
+
"inputs": [
|
|
1175
|
+
{
|
|
1176
|
+
"internalType": "uint256[]",
|
|
1177
|
+
"name": "tokenIds",
|
|
1178
|
+
"type": "uint256[]"
|
|
1179
|
+
}
|
|
1180
|
+
],
|
|
1181
|
+
"name": "isUnlockedMultiple",
|
|
1182
|
+
"outputs": [
|
|
1183
|
+
{
|
|
1184
|
+
"internalType": "bool[]",
|
|
1185
|
+
"name": "",
|
|
1186
|
+
"type": "bool[]"
|
|
1187
|
+
}
|
|
1188
|
+
],
|
|
1189
|
+
"stateMutability": "view",
|
|
1190
|
+
"type": "function"
|
|
1191
|
+
},
|
|
1192
|
+
{
|
|
1193
|
+
"inputs": [
|
|
1194
|
+
{
|
|
1195
|
+
"internalType": "address",
|
|
1196
|
+
"name": "from",
|
|
1197
|
+
"type": "address"
|
|
1198
|
+
},
|
|
1199
|
+
{
|
|
1200
|
+
"internalType": "address",
|
|
1201
|
+
"name": "to",
|
|
1202
|
+
"type": "address"
|
|
1203
|
+
},
|
|
1204
|
+
{
|
|
1205
|
+
"internalType": "uint256",
|
|
1206
|
+
"name": "tokenId",
|
|
1207
|
+
"type": "uint256"
|
|
1208
|
+
}
|
|
1209
|
+
],
|
|
1210
|
+
"name": "keepTOLTransferFrom",
|
|
1211
|
+
"outputs": [],
|
|
1212
|
+
"stateMutability": "nonpayable",
|
|
1213
|
+
"type": "function"
|
|
1214
|
+
},
|
|
1215
|
+
{
|
|
1216
|
+
"inputs": [
|
|
1217
|
+
{
|
|
1218
|
+
"internalType": "uint256",
|
|
1219
|
+
"name": "",
|
|
1220
|
+
"type": "uint256"
|
|
1221
|
+
}
|
|
1222
|
+
],
|
|
1223
|
+
"name": "lockCount",
|
|
1224
|
+
"outputs": [
|
|
1225
|
+
{
|
|
1226
|
+
"internalType": "uint256",
|
|
1227
|
+
"name": "",
|
|
1228
|
+
"type": "uint256"
|
|
1229
|
+
}
|
|
1230
|
+
],
|
|
1231
|
+
"stateMutability": "view",
|
|
1232
|
+
"type": "function"
|
|
1233
|
+
},
|
|
1234
|
+
{
|
|
1235
|
+
"inputs": [
|
|
1236
|
+
{
|
|
1237
|
+
"internalType": "uint256",
|
|
1238
|
+
"name": "_id",
|
|
1239
|
+
"type": "uint256"
|
|
1240
|
+
}
|
|
1241
|
+
],
|
|
1242
|
+
"name": "lockId",
|
|
1243
|
+
"outputs": [],
|
|
1244
|
+
"stateMutability": "nonpayable",
|
|
1245
|
+
"type": "function"
|
|
1246
|
+
},
|
|
1247
|
+
{
|
|
1248
|
+
"inputs": [
|
|
1249
|
+
{
|
|
1250
|
+
"internalType": "uint256",
|
|
1251
|
+
"name": "",
|
|
1252
|
+
"type": "uint256"
|
|
1253
|
+
},
|
|
1254
|
+
{
|
|
1255
|
+
"internalType": "uint256",
|
|
1256
|
+
"name": "",
|
|
1257
|
+
"type": "uint256"
|
|
1258
|
+
}
|
|
1259
|
+
],
|
|
1260
|
+
"name": "lockMap",
|
|
1261
|
+
"outputs": [
|
|
1262
|
+
{
|
|
1263
|
+
"internalType": "address",
|
|
1264
|
+
"name": "",
|
|
1265
|
+
"type": "address"
|
|
1266
|
+
}
|
|
1267
|
+
],
|
|
1268
|
+
"stateMutability": "view",
|
|
1269
|
+
"type": "function"
|
|
1270
|
+
},
|
|
1271
|
+
{
|
|
1272
|
+
"inputs": [
|
|
1273
|
+
{
|
|
1274
|
+
"internalType": "uint256",
|
|
1275
|
+
"name": "",
|
|
1276
|
+
"type": "uint256"
|
|
1277
|
+
},
|
|
1278
|
+
{
|
|
1279
|
+
"internalType": "address",
|
|
1280
|
+
"name": "",
|
|
1281
|
+
"type": "address"
|
|
1282
|
+
}
|
|
1283
|
+
],
|
|
1284
|
+
"name": "lockMapIndex",
|
|
1285
|
+
"outputs": [
|
|
1286
|
+
{
|
|
1287
|
+
"internalType": "uint256",
|
|
1288
|
+
"name": "",
|
|
1289
|
+
"type": "uint256"
|
|
1290
|
+
}
|
|
1291
|
+
],
|
|
1292
|
+
"stateMutability": "view",
|
|
1293
|
+
"type": "function"
|
|
1294
|
+
},
|
|
1295
|
+
{
|
|
1296
|
+
"inputs": [
|
|
1297
|
+
{
|
|
1298
|
+
"internalType": "uint256",
|
|
1299
|
+
"name": "",
|
|
1300
|
+
"type": "uint256"
|
|
1301
|
+
}
|
|
1302
|
+
],
|
|
1303
|
+
"name": "mnplUnlocked",
|
|
1304
|
+
"outputs": [
|
|
1305
|
+
{
|
|
1306
|
+
"internalType": "bool",
|
|
1307
|
+
"name": "",
|
|
1308
|
+
"type": "bool"
|
|
1309
|
+
}
|
|
1310
|
+
],
|
|
1311
|
+
"stateMutability": "view",
|
|
1312
|
+
"type": "function"
|
|
1313
|
+
},
|
|
1314
|
+
{
|
|
1315
|
+
"inputs": [
|
|
1316
|
+
{
|
|
1317
|
+
"internalType": "uint256",
|
|
1318
|
+
"name": "",
|
|
1319
|
+
"type": "uint256"
|
|
1320
|
+
}
|
|
1321
|
+
],
|
|
1322
|
+
"name": "mnplUpgraded",
|
|
1323
|
+
"outputs": [
|
|
1324
|
+
{
|
|
1325
|
+
"internalType": "bool",
|
|
1326
|
+
"name": "",
|
|
1327
|
+
"type": "bool"
|
|
1328
|
+
}
|
|
1329
|
+
],
|
|
1330
|
+
"stateMutability": "view",
|
|
1331
|
+
"type": "function"
|
|
1332
|
+
},
|
|
1333
|
+
{
|
|
1334
|
+
"inputs": [],
|
|
1335
|
+
"name": "name",
|
|
1336
|
+
"outputs": [
|
|
1337
|
+
{
|
|
1338
|
+
"internalType": "string",
|
|
1339
|
+
"name": "",
|
|
1340
|
+
"type": "string"
|
|
1341
|
+
}
|
|
1342
|
+
],
|
|
1343
|
+
"stateMutability": "view",
|
|
1344
|
+
"type": "function"
|
|
1345
|
+
},
|
|
1346
|
+
{
|
|
1347
|
+
"inputs": [],
|
|
1348
|
+
"name": "owner",
|
|
1349
|
+
"outputs": [
|
|
1350
|
+
{
|
|
1351
|
+
"internalType": "address",
|
|
1352
|
+
"name": "",
|
|
1353
|
+
"type": "address"
|
|
1354
|
+
}
|
|
1355
|
+
],
|
|
1356
|
+
"stateMutability": "view",
|
|
1357
|
+
"type": "function"
|
|
1358
|
+
},
|
|
1359
|
+
{
|
|
1360
|
+
"inputs": [
|
|
1361
|
+
{
|
|
1362
|
+
"internalType": "uint256",
|
|
1363
|
+
"name": "tokenId",
|
|
1364
|
+
"type": "uint256"
|
|
1365
|
+
}
|
|
1366
|
+
],
|
|
1367
|
+
"name": "ownerOf",
|
|
1368
|
+
"outputs": [
|
|
1369
|
+
{
|
|
1370
|
+
"internalType": "address",
|
|
1371
|
+
"name": "",
|
|
1372
|
+
"type": "address"
|
|
1373
|
+
}
|
|
1374
|
+
],
|
|
1375
|
+
"stateMutability": "view",
|
|
1376
|
+
"type": "function"
|
|
1377
|
+
},
|
|
1378
|
+
{
|
|
1379
|
+
"inputs": [
|
|
1380
|
+
{
|
|
1381
|
+
"internalType": "uint256[]",
|
|
1382
|
+
"name": "tokenIds",
|
|
1383
|
+
"type": "uint256[]"
|
|
1384
|
+
}
|
|
1385
|
+
],
|
|
1386
|
+
"name": "ownerOfMultiple",
|
|
1387
|
+
"outputs": [
|
|
1388
|
+
{
|
|
1389
|
+
"internalType": "address[]",
|
|
1390
|
+
"name": "",
|
|
1391
|
+
"type": "address[]"
|
|
1392
|
+
}
|
|
1393
|
+
],
|
|
1394
|
+
"stateMutability": "view",
|
|
1395
|
+
"type": "function"
|
|
1396
|
+
},
|
|
1397
|
+
{
|
|
1398
|
+
"inputs": [
|
|
1399
|
+
{
|
|
1400
|
+
"internalType": "uint256",
|
|
1401
|
+
"name": "tokenId",
|
|
1402
|
+
"type": "uint256"
|
|
1403
|
+
}
|
|
1404
|
+
],
|
|
1405
|
+
"name": "payRoyalty",
|
|
1406
|
+
"outputs": [],
|
|
1407
|
+
"stateMutability": "payable",
|
|
1408
|
+
"type": "function"
|
|
1409
|
+
},
|
|
1410
|
+
{
|
|
1411
|
+
"inputs": [],
|
|
1412
|
+
"name": "renounceOwnership",
|
|
1413
|
+
"outputs": [],
|
|
1414
|
+
"stateMutability": "nonpayable",
|
|
1415
|
+
"type": "function"
|
|
1416
|
+
},
|
|
1417
|
+
{
|
|
1418
|
+
"inputs": [
|
|
1419
|
+
{
|
|
1420
|
+
"internalType": "address",
|
|
1421
|
+
"name": "from",
|
|
1422
|
+
"type": "address"
|
|
1423
|
+
},
|
|
1424
|
+
{
|
|
1425
|
+
"internalType": "address",
|
|
1426
|
+
"name": "to",
|
|
1427
|
+
"type": "address"
|
|
1428
|
+
},
|
|
1429
|
+
{
|
|
1430
|
+
"internalType": "uint256",
|
|
1431
|
+
"name": "tokenId",
|
|
1432
|
+
"type": "uint256"
|
|
1433
|
+
}
|
|
1434
|
+
],
|
|
1435
|
+
"name": "safeTransferFrom",
|
|
1436
|
+
"outputs": [],
|
|
1437
|
+
"stateMutability": "nonpayable",
|
|
1438
|
+
"type": "function"
|
|
1439
|
+
},
|
|
1440
|
+
{
|
|
1441
|
+
"inputs": [
|
|
1442
|
+
{
|
|
1443
|
+
"internalType": "address",
|
|
1444
|
+
"name": "_from",
|
|
1445
|
+
"type": "address"
|
|
1446
|
+
},
|
|
1447
|
+
{
|
|
1448
|
+
"internalType": "address",
|
|
1449
|
+
"name": "_to",
|
|
1450
|
+
"type": "address"
|
|
1451
|
+
},
|
|
1452
|
+
{
|
|
1453
|
+
"internalType": "uint256",
|
|
1454
|
+
"name": "_tokenId",
|
|
1455
|
+
"type": "uint256"
|
|
1456
|
+
},
|
|
1457
|
+
{
|
|
1458
|
+
"internalType": "bytes",
|
|
1459
|
+
"name": "data",
|
|
1460
|
+
"type": "bytes"
|
|
1461
|
+
}
|
|
1462
|
+
],
|
|
1463
|
+
"name": "safeTransferFrom",
|
|
1464
|
+
"outputs": [],
|
|
1465
|
+
"stateMutability": "nonpayable",
|
|
1466
|
+
"type": "function"
|
|
1467
|
+
},
|
|
1468
|
+
{
|
|
1469
|
+
"inputs": [
|
|
1470
|
+
{
|
|
1471
|
+
"internalType": "uint256",
|
|
1472
|
+
"name": "tokenId",
|
|
1473
|
+
"type": "uint256"
|
|
1474
|
+
},
|
|
1475
|
+
{
|
|
1476
|
+
"internalType": "bool",
|
|
1477
|
+
"name": "isLocked",
|
|
1478
|
+
"type": "bool"
|
|
1479
|
+
}
|
|
1480
|
+
],
|
|
1481
|
+
"name": "setAdminLocked",
|
|
1482
|
+
"outputs": [],
|
|
1483
|
+
"stateMutability": "nonpayable",
|
|
1484
|
+
"type": "function"
|
|
1485
|
+
},
|
|
1486
|
+
{
|
|
1487
|
+
"inputs": [
|
|
1488
|
+
{
|
|
1489
|
+
"internalType": "uint256[]",
|
|
1490
|
+
"name": "tokenIds",
|
|
1491
|
+
"type": "uint256[]"
|
|
1492
|
+
},
|
|
1493
|
+
{
|
|
1494
|
+
"internalType": "bool[]",
|
|
1495
|
+
"name": "isLockeds",
|
|
1496
|
+
"type": "bool[]"
|
|
1497
|
+
}
|
|
1498
|
+
],
|
|
1499
|
+
"name": "setAdminLockedMultiple",
|
|
1500
|
+
"outputs": [],
|
|
1501
|
+
"stateMutability": "nonpayable",
|
|
1502
|
+
"type": "function"
|
|
1503
|
+
},
|
|
1504
|
+
{
|
|
1505
|
+
"inputs": [
|
|
1506
|
+
{
|
|
1507
|
+
"internalType": "address",
|
|
1508
|
+
"name": "operator",
|
|
1509
|
+
"type": "address"
|
|
1510
|
+
},
|
|
1511
|
+
{
|
|
1512
|
+
"internalType": "bool",
|
|
1513
|
+
"name": "approved",
|
|
1514
|
+
"type": "bool"
|
|
1515
|
+
}
|
|
1516
|
+
],
|
|
1517
|
+
"name": "setApprovalForAll",
|
|
1518
|
+
"outputs": [],
|
|
1519
|
+
"stateMutability": "nonpayable",
|
|
1520
|
+
"type": "function"
|
|
1521
|
+
},
|
|
1522
|
+
{
|
|
1523
|
+
"inputs": [
|
|
1524
|
+
{
|
|
1525
|
+
"internalType": "string",
|
|
1526
|
+
"name": "baseURI",
|
|
1527
|
+
"type": "string"
|
|
1528
|
+
}
|
|
1529
|
+
],
|
|
1530
|
+
"name": "setBaseURI",
|
|
1531
|
+
"outputs": [],
|
|
1532
|
+
"stateMutability": "nonpayable",
|
|
1533
|
+
"type": "function"
|
|
1534
|
+
},
|
|
1535
|
+
{
|
|
1536
|
+
"inputs": [
|
|
1537
|
+
{
|
|
1538
|
+
"internalType": "enum TransferSecurityLevels",
|
|
1539
|
+
"name": "level",
|
|
1540
|
+
"type": "uint8"
|
|
1541
|
+
},
|
|
1542
|
+
{
|
|
1543
|
+
"internalType": "uint120",
|
|
1544
|
+
"name": "operatorWhitelistId",
|
|
1545
|
+
"type": "uint120"
|
|
1546
|
+
},
|
|
1547
|
+
{
|
|
1548
|
+
"internalType": "uint120",
|
|
1549
|
+
"name": "permittedContractReceiversAllowlistId",
|
|
1550
|
+
"type": "uint120"
|
|
1551
|
+
}
|
|
1552
|
+
],
|
|
1553
|
+
"name": "setToCustomSecurityPolicy",
|
|
1554
|
+
"outputs": [],
|
|
1555
|
+
"stateMutability": "nonpayable",
|
|
1556
|
+
"type": "function"
|
|
1557
|
+
},
|
|
1558
|
+
{
|
|
1559
|
+
"inputs": [
|
|
1560
|
+
{
|
|
1561
|
+
"internalType": "address",
|
|
1562
|
+
"name": "validator",
|
|
1563
|
+
"type": "address"
|
|
1564
|
+
},
|
|
1565
|
+
{
|
|
1566
|
+
"internalType": "enum TransferSecurityLevels",
|
|
1567
|
+
"name": "level",
|
|
1568
|
+
"type": "uint8"
|
|
1569
|
+
},
|
|
1570
|
+
{
|
|
1571
|
+
"internalType": "uint120",
|
|
1572
|
+
"name": "operatorWhitelistId",
|
|
1573
|
+
"type": "uint120"
|
|
1574
|
+
},
|
|
1575
|
+
{
|
|
1576
|
+
"internalType": "uint120",
|
|
1577
|
+
"name": "permittedContractReceiversAllowlistId",
|
|
1578
|
+
"type": "uint120"
|
|
1579
|
+
}
|
|
1580
|
+
],
|
|
1581
|
+
"name": "setToCustomValidatorAndSecurityPolicy",
|
|
1582
|
+
"outputs": [],
|
|
1583
|
+
"stateMutability": "nonpayable",
|
|
1584
|
+
"type": "function"
|
|
1585
|
+
},
|
|
1586
|
+
{
|
|
1587
|
+
"inputs": [],
|
|
1588
|
+
"name": "setToDefaultSecurityPolicy",
|
|
1589
|
+
"outputs": [],
|
|
1590
|
+
"stateMutability": "nonpayable",
|
|
1591
|
+
"type": "function"
|
|
1592
|
+
},
|
|
1593
|
+
{
|
|
1594
|
+
"inputs": [
|
|
1595
|
+
{
|
|
1596
|
+
"internalType": "uint256[]",
|
|
1597
|
+
"name": "tokenIds",
|
|
1598
|
+
"type": "uint256[]"
|
|
1599
|
+
},
|
|
1600
|
+
{
|
|
1601
|
+
"internalType": "bool",
|
|
1602
|
+
"name": "setStake",
|
|
1603
|
+
"type": "bool"
|
|
1604
|
+
}
|
|
1605
|
+
],
|
|
1606
|
+
"name": "setTokensStakeStatus",
|
|
1607
|
+
"outputs": [],
|
|
1608
|
+
"stateMutability": "payable",
|
|
1609
|
+
"type": "function"
|
|
1610
|
+
},
|
|
1611
|
+
{
|
|
1612
|
+
"inputs": [
|
|
1613
|
+
{
|
|
1614
|
+
"internalType": "address",
|
|
1615
|
+
"name": "transferValidator_",
|
|
1616
|
+
"type": "address"
|
|
1617
|
+
}
|
|
1618
|
+
],
|
|
1619
|
+
"name": "setTransferValidator",
|
|
1620
|
+
"outputs": [],
|
|
1621
|
+
"stateMutability": "nonpayable",
|
|
1622
|
+
"type": "function"
|
|
1623
|
+
},
|
|
1624
|
+
{
|
|
1625
|
+
"inputs": [
|
|
1626
|
+
{
|
|
1627
|
+
"internalType": "address",
|
|
1628
|
+
"name": "guardianAddress",
|
|
1629
|
+
"type": "address"
|
|
1630
|
+
},
|
|
1631
|
+
{
|
|
1632
|
+
"internalType": "uint256",
|
|
1633
|
+
"name": "_tokenIdOrUpIsMNPL",
|
|
1634
|
+
"type": "uint256"
|
|
1635
|
+
},
|
|
1636
|
+
{
|
|
1637
|
+
"internalType": "uint256",
|
|
1638
|
+
"name": "_unlockPrice",
|
|
1639
|
+
"type": "uint256"
|
|
1640
|
+
}
|
|
1641
|
+
],
|
|
1642
|
+
"name": "setupGuardianAndMNPL",
|
|
1643
|
+
"outputs": [],
|
|
1644
|
+
"stateMutability": "nonpayable",
|
|
1645
|
+
"type": "function"
|
|
1646
|
+
},
|
|
1647
|
+
{
|
|
1648
|
+
"inputs": [
|
|
1649
|
+
{
|
|
1650
|
+
"internalType": "bool",
|
|
1651
|
+
"name": "b",
|
|
1652
|
+
"type": "bool"
|
|
1653
|
+
},
|
|
1654
|
+
{
|
|
1655
|
+
"internalType": "uint256",
|
|
1656
|
+
"name": "price",
|
|
1657
|
+
"type": "uint256"
|
|
1658
|
+
}
|
|
1659
|
+
],
|
|
1660
|
+
"name": "setupStaking",
|
|
1661
|
+
"outputs": [],
|
|
1662
|
+
"stateMutability": "nonpayable",
|
|
1663
|
+
"type": "function"
|
|
1664
|
+
},
|
|
1665
|
+
{
|
|
1666
|
+
"inputs": [],
|
|
1667
|
+
"name": "stakePrice",
|
|
1668
|
+
"outputs": [
|
|
1669
|
+
{
|
|
1670
|
+
"internalType": "uint256",
|
|
1671
|
+
"name": "",
|
|
1672
|
+
"type": "uint256"
|
|
1673
|
+
}
|
|
1674
|
+
],
|
|
1675
|
+
"stateMutability": "view",
|
|
1676
|
+
"type": "function"
|
|
1677
|
+
},
|
|
1678
|
+
{
|
|
1679
|
+
"inputs": [
|
|
1680
|
+
{
|
|
1681
|
+
"internalType": "bytes4",
|
|
1682
|
+
"name": "interfaceId",
|
|
1683
|
+
"type": "bytes4"
|
|
1684
|
+
}
|
|
1685
|
+
],
|
|
1686
|
+
"name": "supportsInterface",
|
|
1687
|
+
"outputs": [
|
|
1688
|
+
{
|
|
1689
|
+
"internalType": "bool",
|
|
1690
|
+
"name": "",
|
|
1691
|
+
"type": "bool"
|
|
1692
|
+
}
|
|
1693
|
+
],
|
|
1694
|
+
"stateMutability": "view",
|
|
1695
|
+
"type": "function"
|
|
1696
|
+
},
|
|
1697
|
+
{
|
|
1698
|
+
"inputs": [],
|
|
1699
|
+
"name": "symbol",
|
|
1700
|
+
"outputs": [
|
|
1701
|
+
{
|
|
1702
|
+
"internalType": "string",
|
|
1703
|
+
"name": "",
|
|
1704
|
+
"type": "string"
|
|
1705
|
+
}
|
|
1706
|
+
],
|
|
1707
|
+
"stateMutability": "view",
|
|
1708
|
+
"type": "function"
|
|
1709
|
+
},
|
|
1710
|
+
{
|
|
1711
|
+
"inputs": [],
|
|
1712
|
+
"name": "tokenIdOrUpIsMNPL",
|
|
1713
|
+
"outputs": [
|
|
1714
|
+
{
|
|
1715
|
+
"internalType": "uint256",
|
|
1716
|
+
"name": "",
|
|
1717
|
+
"type": "uint256"
|
|
1718
|
+
}
|
|
1719
|
+
],
|
|
1720
|
+
"stateMutability": "view",
|
|
1721
|
+
"type": "function"
|
|
1722
|
+
},
|
|
1723
|
+
{
|
|
1724
|
+
"inputs": [
|
|
1725
|
+
{
|
|
1726
|
+
"internalType": "uint256",
|
|
1727
|
+
"name": "tokenId",
|
|
1728
|
+
"type": "uint256"
|
|
1729
|
+
}
|
|
1730
|
+
],
|
|
1731
|
+
"name": "tokenURI",
|
|
1732
|
+
"outputs": [
|
|
1733
|
+
{
|
|
1734
|
+
"internalType": "string",
|
|
1735
|
+
"name": "",
|
|
1736
|
+
"type": "string"
|
|
1737
|
+
}
|
|
1738
|
+
],
|
|
1739
|
+
"stateMutability": "view",
|
|
1740
|
+
"type": "function"
|
|
1741
|
+
},
|
|
1742
|
+
{
|
|
1743
|
+
"inputs": [
|
|
1744
|
+
{
|
|
1745
|
+
"internalType": "uint256",
|
|
1746
|
+
"name": "",
|
|
1747
|
+
"type": "uint256"
|
|
1748
|
+
}
|
|
1749
|
+
],
|
|
1750
|
+
"name": "tokensLastStakedAt",
|
|
1751
|
+
"outputs": [
|
|
1752
|
+
{
|
|
1753
|
+
"internalType": "uint256",
|
|
1754
|
+
"name": "",
|
|
1755
|
+
"type": "uint256"
|
|
1756
|
+
}
|
|
1757
|
+
],
|
|
1758
|
+
"stateMutability": "view",
|
|
1759
|
+
"type": "function"
|
|
1760
|
+
},
|
|
1761
|
+
{
|
|
1762
|
+
"inputs": [
|
|
1763
|
+
{
|
|
1764
|
+
"internalType": "uint256[]",
|
|
1765
|
+
"name": "tokenIds",
|
|
1766
|
+
"type": "uint256[]"
|
|
1767
|
+
}
|
|
1768
|
+
],
|
|
1769
|
+
"name": "tokensLastStakedAtMultiple",
|
|
1770
|
+
"outputs": [
|
|
1771
|
+
{
|
|
1772
|
+
"internalType": "uint256[]",
|
|
1773
|
+
"name": "",
|
|
1774
|
+
"type": "uint256[]"
|
|
1775
|
+
}
|
|
1776
|
+
],
|
|
1777
|
+
"stateMutability": "view",
|
|
1778
|
+
"type": "function"
|
|
1779
|
+
},
|
|
1780
|
+
{
|
|
1781
|
+
"inputs": [
|
|
1782
|
+
{
|
|
1783
|
+
"internalType": "address",
|
|
1784
|
+
"name": "owner",
|
|
1785
|
+
"type": "address"
|
|
1786
|
+
}
|
|
1787
|
+
],
|
|
1788
|
+
"name": "tokensOfOwner",
|
|
1789
|
+
"outputs": [
|
|
1790
|
+
{
|
|
1791
|
+
"internalType": "uint256[]",
|
|
1792
|
+
"name": "",
|
|
1793
|
+
"type": "uint256[]"
|
|
1794
|
+
}
|
|
1795
|
+
],
|
|
1796
|
+
"stateMutability": "view",
|
|
1797
|
+
"type": "function"
|
|
1798
|
+
},
|
|
1799
|
+
{
|
|
1800
|
+
"inputs": [
|
|
1801
|
+
{
|
|
1802
|
+
"internalType": "address",
|
|
1803
|
+
"name": "owner",
|
|
1804
|
+
"type": "address"
|
|
1805
|
+
},
|
|
1806
|
+
{
|
|
1807
|
+
"internalType": "uint256",
|
|
1808
|
+
"name": "start",
|
|
1809
|
+
"type": "uint256"
|
|
1810
|
+
},
|
|
1811
|
+
{
|
|
1812
|
+
"internalType": "uint256",
|
|
1813
|
+
"name": "stop",
|
|
1814
|
+
"type": "uint256"
|
|
1815
|
+
}
|
|
1816
|
+
],
|
|
1817
|
+
"name": "tokensOfOwnerIn",
|
|
1818
|
+
"outputs": [
|
|
1819
|
+
{
|
|
1820
|
+
"internalType": "uint256[]",
|
|
1821
|
+
"name": "",
|
|
1822
|
+
"type": "uint256[]"
|
|
1823
|
+
}
|
|
1824
|
+
],
|
|
1825
|
+
"stateMutability": "view",
|
|
1826
|
+
"type": "function"
|
|
1827
|
+
},
|
|
1828
|
+
{
|
|
1829
|
+
"inputs": [],
|
|
1830
|
+
"name": "totalSupply",
|
|
1831
|
+
"outputs": [
|
|
1832
|
+
{
|
|
1833
|
+
"internalType": "uint256",
|
|
1834
|
+
"name": "",
|
|
1835
|
+
"type": "uint256"
|
|
1836
|
+
}
|
|
1837
|
+
],
|
|
1838
|
+
"stateMutability": "view",
|
|
1839
|
+
"type": "function"
|
|
1840
|
+
},
|
|
1841
|
+
{
|
|
1842
|
+
"inputs": [
|
|
1843
|
+
{
|
|
1844
|
+
"internalType": "address",
|
|
1845
|
+
"name": "_from",
|
|
1846
|
+
"type": "address"
|
|
1847
|
+
},
|
|
1848
|
+
{
|
|
1849
|
+
"internalType": "address",
|
|
1850
|
+
"name": "_to",
|
|
1851
|
+
"type": "address"
|
|
1852
|
+
},
|
|
1853
|
+
{
|
|
1854
|
+
"internalType": "uint256",
|
|
1855
|
+
"name": "_tokenId",
|
|
1856
|
+
"type": "uint256"
|
|
1857
|
+
}
|
|
1858
|
+
],
|
|
1859
|
+
"name": "transferFrom",
|
|
1860
|
+
"outputs": [],
|
|
1861
|
+
"stateMutability": "nonpayable",
|
|
1862
|
+
"type": "function"
|
|
1863
|
+
},
|
|
1864
|
+
{
|
|
1865
|
+
"inputs": [
|
|
1866
|
+
{
|
|
1867
|
+
"internalType": "address",
|
|
1868
|
+
"name": "newOwner",
|
|
1869
|
+
"type": "address"
|
|
1870
|
+
}
|
|
1871
|
+
],
|
|
1872
|
+
"name": "transferOwnership",
|
|
1873
|
+
"outputs": [],
|
|
1874
|
+
"stateMutability": "nonpayable",
|
|
1875
|
+
"type": "function"
|
|
1876
|
+
},
|
|
1877
|
+
{
|
|
1878
|
+
"inputs": [
|
|
1879
|
+
{
|
|
1880
|
+
"internalType": "uint256",
|
|
1881
|
+
"name": "tokenId",
|
|
1882
|
+
"type": "uint256"
|
|
1883
|
+
}
|
|
1884
|
+
],
|
|
1885
|
+
"name": "unlockAndUpgradeMNPL",
|
|
1886
|
+
"outputs": [],
|
|
1887
|
+
"stateMutability": "payable",
|
|
1888
|
+
"type": "function"
|
|
1889
|
+
},
|
|
1890
|
+
{
|
|
1891
|
+
"inputs": [
|
|
1892
|
+
{
|
|
1893
|
+
"internalType": "uint256",
|
|
1894
|
+
"name": "_id",
|
|
1895
|
+
"type": "uint256"
|
|
1896
|
+
}
|
|
1897
|
+
],
|
|
1898
|
+
"name": "unlockId",
|
|
1899
|
+
"outputs": [],
|
|
1900
|
+
"stateMutability": "nonpayable",
|
|
1901
|
+
"type": "function"
|
|
1902
|
+
},
|
|
1903
|
+
{
|
|
1904
|
+
"inputs": [],
|
|
1905
|
+
"name": "unlockPrice",
|
|
1906
|
+
"outputs": [
|
|
1907
|
+
{
|
|
1908
|
+
"internalType": "uint256",
|
|
1909
|
+
"name": "",
|
|
1910
|
+
"type": "uint256"
|
|
1911
|
+
}
|
|
1912
|
+
],
|
|
1913
|
+
"stateMutability": "view",
|
|
1914
|
+
"type": "function"
|
|
1915
|
+
},
|
|
1916
|
+
{
|
|
1917
|
+
"inputs": [
|
|
1918
|
+
{
|
|
1919
|
+
"internalType": "address[]",
|
|
1920
|
+
"name": "_contracts",
|
|
1921
|
+
"type": "address[]"
|
|
1922
|
+
},
|
|
1923
|
+
{
|
|
1924
|
+
"internalType": "bool[]",
|
|
1925
|
+
"name": "_values",
|
|
1926
|
+
"type": "bool[]"
|
|
1927
|
+
}
|
|
1928
|
+
],
|
|
1929
|
+
"name": "updateApprovedContracts",
|
|
1930
|
+
"outputs": [],
|
|
1931
|
+
"stateMutability": "nonpayable",
|
|
1932
|
+
"type": "function"
|
|
1933
|
+
},
|
|
1934
|
+
{
|
|
1935
|
+
"inputs": [],
|
|
1936
|
+
"name": "upgradePrice",
|
|
1937
|
+
"outputs": [
|
|
1938
|
+
{
|
|
1939
|
+
"internalType": "uint256",
|
|
1940
|
+
"name": "",
|
|
1941
|
+
"type": "uint256"
|
|
1942
|
+
}
|
|
1943
|
+
],
|
|
1944
|
+
"stateMutability": "view",
|
|
1945
|
+
"type": "function"
|
|
1946
|
+
},
|
|
1947
|
+
{
|
|
1948
|
+
"inputs": [
|
|
1949
|
+
{
|
|
1950
|
+
"internalType": "address[]",
|
|
1951
|
+
"name": "markets",
|
|
1952
|
+
"type": "address[]"
|
|
1953
|
+
},
|
|
1954
|
+
{
|
|
1955
|
+
"internalType": "bool",
|
|
1956
|
+
"name": "whitelisted",
|
|
1957
|
+
"type": "bool"
|
|
1958
|
+
}
|
|
1959
|
+
],
|
|
1960
|
+
"name": "whitelistMarketplaces",
|
|
1961
|
+
"outputs": [],
|
|
1962
|
+
"stateMutability": "nonpayable",
|
|
1963
|
+
"type": "function"
|
|
1964
|
+
},
|
|
1965
|
+
{
|
|
1966
|
+
"inputs": [
|
|
1967
|
+
{
|
|
1968
|
+
"internalType": "address",
|
|
1969
|
+
"name": "",
|
|
1970
|
+
"type": "address"
|
|
1971
|
+
}
|
|
1972
|
+
],
|
|
1973
|
+
"name": "whitelistedMarketplaces",
|
|
1974
|
+
"outputs": [
|
|
1975
|
+
{
|
|
1976
|
+
"internalType": "bool",
|
|
1977
|
+
"name": "",
|
|
1978
|
+
"type": "bool"
|
|
1979
|
+
}
|
|
1980
|
+
],
|
|
1981
|
+
"stateMutability": "view",
|
|
1982
|
+
"type": "function"
|
|
1983
|
+
},
|
|
1984
|
+
{
|
|
1985
|
+
"inputs": [],
|
|
1986
|
+
"name": "withdrawSales",
|
|
1987
|
+
"outputs": [],
|
|
1988
|
+
"stateMutability": "nonpayable",
|
|
1989
|
+
"type": "function"
|
|
1990
|
+
}
|
|
1991
|
+
] as const satisfies Abi;
|
|
1992
|
+
|
|
1993
|
+
/**
|
|
1994
|
+
* Type-safe ABI for Yogapetz
|
|
1995
|
+
*/
|
|
1996
|
+
export type YogapetzAbi = typeof YogapetzAbi;
|
|
1997
|
+
|
|
1998
|
+
/**
|
|
1999
|
+
* Contract instance type for Yogapetz
|
|
2000
|
+
*/
|
|
2001
|
+
// Use any for contract type to avoid complex viem type issues
|
|
2002
|
+
// The runtime behavior is type-safe through viem's ABI typing
|
|
2003
|
+
export type YogapetzContract = any;
|
|
2004
|
+
|
|
2005
|
+
/**
|
|
2006
|
+
* Yogapetz Contract Class
|
|
2007
|
+
*
|
|
2008
|
+
* Provides a class-based API similar to TypeChain for interacting with the contract.
|
|
2009
|
+
*
|
|
2010
|
+
* @example
|
|
2011
|
+
* ```typescript
|
|
2012
|
+
* import { createPublicClient, createWalletClient, http } from 'viem';
|
|
2013
|
+
* import { mainnet } from 'viem/chains';
|
|
2014
|
+
* import { Yogapetz } from 'Yogapetz';
|
|
2015
|
+
*
|
|
2016
|
+
* const publicClient = createPublicClient({ chain: mainnet, transport: http() });
|
|
2017
|
+
* const walletClient = createWalletClient({ chain: mainnet, transport: http() });
|
|
2018
|
+
*
|
|
2019
|
+
* const contract = new Yogapetz('0x...', { publicClient, walletClient });
|
|
2020
|
+
*
|
|
2021
|
+
* // Read functions
|
|
2022
|
+
* const result = await contract.balanceOf('0x...');
|
|
2023
|
+
*
|
|
2024
|
+
* // Write functions
|
|
2025
|
+
* const hash = await contract.transfer('0x...', 1000n);
|
|
2026
|
+
*
|
|
2027
|
+
* // Simulate transactions (dry-run)
|
|
2028
|
+
* const simulation = await contract.simulate.transfer('0x...', 1000n);
|
|
2029
|
+
* console.log('Gas estimate:', simulation.request.gas);
|
|
2030
|
+
*
|
|
2031
|
+
* // Watch events
|
|
2032
|
+
* const unwatch = contract.watch.Transfer((event) => {
|
|
2033
|
+
* console.log('Transfer event:', event);
|
|
2034
|
+
* });
|
|
2035
|
+
* ```
|
|
2036
|
+
*/
|
|
2037
|
+
export class Yogapetz {
|
|
2038
|
+
private contract: YogapetzContract;
|
|
2039
|
+
private contractAddress: Address;
|
|
2040
|
+
private publicClient: PublicClient;
|
|
2041
|
+
|
|
2042
|
+
constructor(
|
|
2043
|
+
address: Address,
|
|
2044
|
+
clients: {
|
|
2045
|
+
publicClient: PublicClient;
|
|
2046
|
+
walletClient?: WalletClient;
|
|
2047
|
+
}
|
|
2048
|
+
) {
|
|
2049
|
+
this.contractAddress = address;
|
|
2050
|
+
this.publicClient = clients.publicClient;
|
|
2051
|
+
this.contract = getContract({
|
|
2052
|
+
address,
|
|
2053
|
+
abi: YogapetzAbi,
|
|
2054
|
+
client: {
|
|
2055
|
+
public: clients.publicClient,
|
|
2056
|
+
wallet: clients.walletClient,
|
|
2057
|
+
},
|
|
2058
|
+
});
|
|
2059
|
+
}
|
|
2060
|
+
|
|
2061
|
+
/**
|
|
2062
|
+
* Get the contract address
|
|
2063
|
+
*/
|
|
2064
|
+
get address(): Address {
|
|
2065
|
+
return this.contractAddress;
|
|
2066
|
+
}
|
|
2067
|
+
|
|
2068
|
+
/**
|
|
2069
|
+
* Get the underlying viem contract instance.
|
|
2070
|
+
*/
|
|
2071
|
+
getContract(): YogapetzContract {
|
|
2072
|
+
return this.contract;
|
|
2073
|
+
}
|
|
2074
|
+
|
|
2075
|
+
/**
|
|
2076
|
+
* DEFAULT_OPERATOR_WHITELIST_ID
|
|
2077
|
+
* view
|
|
2078
|
+
*/
|
|
2079
|
+
async DEFAULT_OPERATOR_WHITELIST_ID(): Promise<bigint> {
|
|
2080
|
+
return this.contract.read.DEFAULT_OPERATOR_WHITELIST_ID() as Promise<bigint>;
|
|
2081
|
+
}
|
|
2082
|
+
|
|
2083
|
+
/**
|
|
2084
|
+
* DEFAULT_TRANSFER_SECURITY_LEVEL
|
|
2085
|
+
* view
|
|
2086
|
+
*/
|
|
2087
|
+
async DEFAULT_TRANSFER_SECURITY_LEVEL(): Promise<bigint> {
|
|
2088
|
+
return this.contract.read.DEFAULT_TRANSFER_SECURITY_LEVEL() as Promise<bigint>;
|
|
2089
|
+
}
|
|
2090
|
+
|
|
2091
|
+
/**
|
|
2092
|
+
* DEFAULT_TRANSFER_VALIDATOR
|
|
2093
|
+
* view
|
|
2094
|
+
*/
|
|
2095
|
+
async DEFAULT_TRANSFER_VALIDATOR(): Promise<`0x${string}`> {
|
|
2096
|
+
return this.contract.read.DEFAULT_TRANSFER_VALIDATOR() as Promise<`0x${string}`>;
|
|
2097
|
+
}
|
|
2098
|
+
|
|
2099
|
+
/**
|
|
2100
|
+
* MAX_SUPPLY
|
|
2101
|
+
* view
|
|
2102
|
+
*/
|
|
2103
|
+
async MAX_SUPPLY(): Promise<bigint> {
|
|
2104
|
+
return this.contract.read.MAX_SUPPLY() as Promise<bigint>;
|
|
2105
|
+
}
|
|
2106
|
+
|
|
2107
|
+
/**
|
|
2108
|
+
* adminLocked
|
|
2109
|
+
* view
|
|
2110
|
+
*/
|
|
2111
|
+
async adminLocked(arg0: bigint): Promise<boolean> {
|
|
2112
|
+
return this.contract.read.adminLocked([arg0] as const) as Promise<boolean>;
|
|
2113
|
+
}
|
|
2114
|
+
|
|
2115
|
+
/**
|
|
2116
|
+
* approvedContract
|
|
2117
|
+
* view
|
|
2118
|
+
*/
|
|
2119
|
+
async approvedContract(arg0: `0x${string}`): Promise<boolean> {
|
|
2120
|
+
return this.contract.read.approvedContract([arg0] as const) as Promise<boolean>;
|
|
2121
|
+
}
|
|
2122
|
+
|
|
2123
|
+
/**
|
|
2124
|
+
* balanceOf
|
|
2125
|
+
* view
|
|
2126
|
+
*/
|
|
2127
|
+
async balanceOf(owner: `0x${string}`): Promise<bigint> {
|
|
2128
|
+
return this.contract.read.balanceOf([owner] as const) as Promise<bigint>;
|
|
2129
|
+
}
|
|
2130
|
+
|
|
2131
|
+
/**
|
|
2132
|
+
* baseTokenURI
|
|
2133
|
+
* view
|
|
2134
|
+
*/
|
|
2135
|
+
async baseTokenURI(): Promise<string> {
|
|
2136
|
+
return this.contract.read.baseTokenURI() as Promise<string>;
|
|
2137
|
+
}
|
|
2138
|
+
|
|
2139
|
+
/**
|
|
2140
|
+
* bio
|
|
2141
|
+
* view
|
|
2142
|
+
*/
|
|
2143
|
+
async bio(arg0: bigint): Promise<string> {
|
|
2144
|
+
return this.contract.read.bio([arg0] as const) as Promise<string>;
|
|
2145
|
+
}
|
|
2146
|
+
|
|
2147
|
+
/**
|
|
2148
|
+
* canStake
|
|
2149
|
+
* view
|
|
2150
|
+
*/
|
|
2151
|
+
async canStake(): Promise<boolean> {
|
|
2152
|
+
return this.contract.read.canStake() as Promise<boolean>;
|
|
2153
|
+
}
|
|
2154
|
+
|
|
2155
|
+
/**
|
|
2156
|
+
* exemptedMarketplaces
|
|
2157
|
+
* view
|
|
2158
|
+
*/
|
|
2159
|
+
async exemptedMarketplaces(arg0: `0x${string}`): Promise<boolean> {
|
|
2160
|
+
return this.contract.read.exemptedMarketplaces([arg0] as const) as Promise<boolean>;
|
|
2161
|
+
}
|
|
2162
|
+
|
|
2163
|
+
/**
|
|
2164
|
+
* explicitOwnershipOf
|
|
2165
|
+
* view
|
|
2166
|
+
*/
|
|
2167
|
+
async explicitOwnershipOf(tokenId: bigint): Promise<IERC721AUpgradeable_TokenOwnership> {
|
|
2168
|
+
return this.contract.read.explicitOwnershipOf([tokenId] as const) as Promise<IERC721AUpgradeable_TokenOwnership>;
|
|
2169
|
+
}
|
|
2170
|
+
|
|
2171
|
+
/**
|
|
2172
|
+
* explicitOwnershipsOf
|
|
2173
|
+
* view
|
|
2174
|
+
*/
|
|
2175
|
+
async explicitOwnershipsOf(tokenIds: bigint[]): Promise<IERC721AUpgradeable_TokenOwnership[]> {
|
|
2176
|
+
return this.contract.read.explicitOwnershipsOf([tokenIds] as const) as Promise<IERC721AUpgradeable_TokenOwnership[]>;
|
|
2177
|
+
}
|
|
2178
|
+
|
|
2179
|
+
/**
|
|
2180
|
+
* getApproved
|
|
2181
|
+
* view
|
|
2182
|
+
*/
|
|
2183
|
+
async getApproved(tokenId: bigint): Promise<`0x${string}`> {
|
|
2184
|
+
return this.contract.read.getApproved([tokenId] as const) as Promise<`0x${string}`>;
|
|
2185
|
+
}
|
|
2186
|
+
|
|
2187
|
+
/**
|
|
2188
|
+
* getPermittedContractReceivers
|
|
2189
|
+
* view
|
|
2190
|
+
*/
|
|
2191
|
+
async getPermittedContractReceivers(): Promise<`0x${string}`[]> {
|
|
2192
|
+
return this.contract.read.getPermittedContractReceivers() as Promise<`0x${string}`[]>;
|
|
2193
|
+
}
|
|
2194
|
+
|
|
2195
|
+
/**
|
|
2196
|
+
* getSecurityPolicy
|
|
2197
|
+
* view
|
|
2198
|
+
*/
|
|
2199
|
+
async getSecurityPolicy(): Promise<CollectionSecurityPolicy> {
|
|
2200
|
+
return this.contract.read.getSecurityPolicy() as Promise<CollectionSecurityPolicy>;
|
|
2201
|
+
}
|
|
2202
|
+
|
|
2203
|
+
/**
|
|
2204
|
+
* getTier
|
|
2205
|
+
* view
|
|
2206
|
+
*/
|
|
2207
|
+
async getTier(tokenId: bigint): Promise<bigint> {
|
|
2208
|
+
return this.contract.read.getTier([tokenId] as const) as Promise<bigint>;
|
|
2209
|
+
}
|
|
2210
|
+
|
|
2211
|
+
/**
|
|
2212
|
+
* getTierMultiple
|
|
2213
|
+
* view
|
|
2214
|
+
*/
|
|
2215
|
+
async getTierMultiple(tokenIds: bigint[]): Promise<bigint[]> {
|
|
2216
|
+
return this.contract.read.getTierMultiple([tokenIds] as const) as Promise<bigint[]>;
|
|
2217
|
+
}
|
|
2218
|
+
|
|
2219
|
+
/**
|
|
2220
|
+
* getTransferValidator
|
|
2221
|
+
* view
|
|
2222
|
+
*/
|
|
2223
|
+
async getTransferValidator(): Promise<`0x${string}`> {
|
|
2224
|
+
return this.contract.read.getTransferValidator() as Promise<`0x${string}`>;
|
|
2225
|
+
}
|
|
2226
|
+
|
|
2227
|
+
/**
|
|
2228
|
+
* getWhitelistedOperators
|
|
2229
|
+
* view
|
|
2230
|
+
*/
|
|
2231
|
+
async getWhitelistedOperators(): Promise<`0x${string}`[]> {
|
|
2232
|
+
return this.contract.read.getWhitelistedOperators() as Promise<`0x${string}`[]>;
|
|
2233
|
+
}
|
|
2234
|
+
|
|
2235
|
+
/**
|
|
2236
|
+
* guardianContract
|
|
2237
|
+
* view
|
|
2238
|
+
*/
|
|
2239
|
+
async guardianContract(): Promise<`0x${string}`> {
|
|
2240
|
+
return this.contract.read.guardianContract() as Promise<`0x${string}`>;
|
|
2241
|
+
}
|
|
2242
|
+
|
|
2243
|
+
/**
|
|
2244
|
+
* isAdminLocked
|
|
2245
|
+
* view
|
|
2246
|
+
*/
|
|
2247
|
+
async isAdminLocked(tokenId: bigint): Promise<boolean> {
|
|
2248
|
+
return this.contract.read.isAdminLocked([tokenId] as const) as Promise<boolean>;
|
|
2249
|
+
}
|
|
2250
|
+
|
|
2251
|
+
/**
|
|
2252
|
+
* isApprovedForAll
|
|
2253
|
+
* view
|
|
2254
|
+
*/
|
|
2255
|
+
async isApprovedForAll(tokenOwner: `0x${string}`, operator: `0x${string}`): Promise<boolean> {
|
|
2256
|
+
return this.contract.read.isApprovedForAll([tokenOwner, operator] as const) as Promise<boolean>;
|
|
2257
|
+
}
|
|
2258
|
+
|
|
2259
|
+
/**
|
|
2260
|
+
* isContractReceiverPermitted
|
|
2261
|
+
* view
|
|
2262
|
+
*/
|
|
2263
|
+
async isContractReceiverPermitted(receiver: `0x${string}`): Promise<boolean> {
|
|
2264
|
+
return this.contract.read.isContractReceiverPermitted([receiver] as const) as Promise<boolean>;
|
|
2265
|
+
}
|
|
2266
|
+
|
|
2267
|
+
/**
|
|
2268
|
+
* isMNPLTransferLocked
|
|
2269
|
+
* view
|
|
2270
|
+
*/
|
|
2271
|
+
async isMNPLTransferLocked(tokenId: bigint): Promise<boolean> {
|
|
2272
|
+
return this.contract.read.isMNPLTransferLocked([tokenId] as const) as Promise<boolean>;
|
|
2273
|
+
}
|
|
2274
|
+
|
|
2275
|
+
/**
|
|
2276
|
+
* isOperatorWhitelisted
|
|
2277
|
+
* view
|
|
2278
|
+
*/
|
|
2279
|
+
async isOperatorWhitelisted(operator: `0x${string}`): Promise<boolean> {
|
|
2280
|
+
return this.contract.read.isOperatorWhitelisted([operator] as const) as Promise<boolean>;
|
|
2281
|
+
}
|
|
2282
|
+
|
|
2283
|
+
/**
|
|
2284
|
+
* isOriginallyMNPL
|
|
2285
|
+
* view
|
|
2286
|
+
*/
|
|
2287
|
+
async isOriginallyMNPL(tokenId: bigint): Promise<boolean> {
|
|
2288
|
+
return this.contract.read.isOriginallyMNPL([tokenId] as const) as Promise<boolean>;
|
|
2289
|
+
}
|
|
2290
|
+
|
|
2291
|
+
/**
|
|
2292
|
+
* isTransferAllowed
|
|
2293
|
+
* view
|
|
2294
|
+
*/
|
|
2295
|
+
async isTransferAllowed(caller: `0x${string}`, from: `0x${string}`, to: `0x${string}`): Promise<boolean> {
|
|
2296
|
+
return this.contract.read.isTransferAllowed([caller, from, to] as const) as Promise<boolean>;
|
|
2297
|
+
}
|
|
2298
|
+
|
|
2299
|
+
/**
|
|
2300
|
+
* isUnlocked
|
|
2301
|
+
* view
|
|
2302
|
+
*/
|
|
2303
|
+
async isUnlocked(_id: bigint): Promise<boolean> {
|
|
2304
|
+
return this.contract.read.isUnlocked([_id] as const) as Promise<boolean>;
|
|
2305
|
+
}
|
|
2306
|
+
|
|
2307
|
+
/**
|
|
2308
|
+
* isUnlockedMultiple
|
|
2309
|
+
* view
|
|
2310
|
+
*/
|
|
2311
|
+
async isUnlockedMultiple(tokenIds: bigint[]): Promise<boolean[]> {
|
|
2312
|
+
return this.contract.read.isUnlockedMultiple([tokenIds] as const) as Promise<boolean[]>;
|
|
2313
|
+
}
|
|
2314
|
+
|
|
2315
|
+
/**
|
|
2316
|
+
* lockCount
|
|
2317
|
+
* view
|
|
2318
|
+
*/
|
|
2319
|
+
async lockCount(arg0: bigint): Promise<bigint> {
|
|
2320
|
+
return this.contract.read.lockCount([arg0] as const) as Promise<bigint>;
|
|
2321
|
+
}
|
|
2322
|
+
|
|
2323
|
+
/**
|
|
2324
|
+
* lockMap
|
|
2325
|
+
* view
|
|
2326
|
+
*/
|
|
2327
|
+
async lockMap(arg0: bigint, arg1: bigint): Promise<`0x${string}`> {
|
|
2328
|
+
return this.contract.read.lockMap([arg0, arg1] as const) as Promise<`0x${string}`>;
|
|
2329
|
+
}
|
|
2330
|
+
|
|
2331
|
+
/**
|
|
2332
|
+
* lockMapIndex
|
|
2333
|
+
* view
|
|
2334
|
+
*/
|
|
2335
|
+
async lockMapIndex(arg0: bigint, arg1: `0x${string}`): Promise<bigint> {
|
|
2336
|
+
return this.contract.read.lockMapIndex([arg0, arg1] as const) as Promise<bigint>;
|
|
2337
|
+
}
|
|
2338
|
+
|
|
2339
|
+
/**
|
|
2340
|
+
* mnplUnlocked
|
|
2341
|
+
* view
|
|
2342
|
+
*/
|
|
2343
|
+
async mnplUnlocked(arg0: bigint): Promise<boolean> {
|
|
2344
|
+
return this.contract.read.mnplUnlocked([arg0] as const) as Promise<boolean>;
|
|
2345
|
+
}
|
|
2346
|
+
|
|
2347
|
+
/**
|
|
2348
|
+
* mnplUpgraded
|
|
2349
|
+
* view
|
|
2350
|
+
*/
|
|
2351
|
+
async mnplUpgraded(arg0: bigint): Promise<boolean> {
|
|
2352
|
+
return this.contract.read.mnplUpgraded([arg0] as const) as Promise<boolean>;
|
|
2353
|
+
}
|
|
2354
|
+
|
|
2355
|
+
/**
|
|
2356
|
+
* name
|
|
2357
|
+
* view
|
|
2358
|
+
*/
|
|
2359
|
+
async name(): Promise<string> {
|
|
2360
|
+
return this.contract.read.name() as Promise<string>;
|
|
2361
|
+
}
|
|
2362
|
+
|
|
2363
|
+
/**
|
|
2364
|
+
* owner
|
|
2365
|
+
* view
|
|
2366
|
+
*/
|
|
2367
|
+
async owner(): Promise<`0x${string}`> {
|
|
2368
|
+
return this.contract.read.owner() as Promise<`0x${string}`>;
|
|
2369
|
+
}
|
|
2370
|
+
|
|
2371
|
+
/**
|
|
2372
|
+
* ownerOf
|
|
2373
|
+
* view
|
|
2374
|
+
*/
|
|
2375
|
+
async ownerOf(tokenId: bigint): Promise<`0x${string}`> {
|
|
2376
|
+
return this.contract.read.ownerOf([tokenId] as const) as Promise<`0x${string}`>;
|
|
2377
|
+
}
|
|
2378
|
+
|
|
2379
|
+
/**
|
|
2380
|
+
* ownerOfMultiple
|
|
2381
|
+
* view
|
|
2382
|
+
*/
|
|
2383
|
+
async ownerOfMultiple(tokenIds: bigint[]): Promise<`0x${string}`[]> {
|
|
2384
|
+
return this.contract.read.ownerOfMultiple([tokenIds] as const) as Promise<`0x${string}`[]>;
|
|
2385
|
+
}
|
|
2386
|
+
|
|
2387
|
+
/**
|
|
2388
|
+
* stakePrice
|
|
2389
|
+
* view
|
|
2390
|
+
*/
|
|
2391
|
+
async stakePrice(): Promise<bigint> {
|
|
2392
|
+
return this.contract.read.stakePrice() as Promise<bigint>;
|
|
2393
|
+
}
|
|
2394
|
+
|
|
2395
|
+
/**
|
|
2396
|
+
* supportsInterface
|
|
2397
|
+
* view
|
|
2398
|
+
*/
|
|
2399
|
+
async supportsInterface(interfaceId: `0x${string}`): Promise<boolean> {
|
|
2400
|
+
return this.contract.read.supportsInterface([interfaceId] as const) as Promise<boolean>;
|
|
2401
|
+
}
|
|
2402
|
+
|
|
2403
|
+
/**
|
|
2404
|
+
* symbol
|
|
2405
|
+
* view
|
|
2406
|
+
*/
|
|
2407
|
+
async symbol(): Promise<string> {
|
|
2408
|
+
return this.contract.read.symbol() as Promise<string>;
|
|
2409
|
+
}
|
|
2410
|
+
|
|
2411
|
+
/**
|
|
2412
|
+
* tokenIdOrUpIsMNPL
|
|
2413
|
+
* view
|
|
2414
|
+
*/
|
|
2415
|
+
async tokenIdOrUpIsMNPL(): Promise<bigint> {
|
|
2416
|
+
return this.contract.read.tokenIdOrUpIsMNPL() as Promise<bigint>;
|
|
2417
|
+
}
|
|
2418
|
+
|
|
2419
|
+
/**
|
|
2420
|
+
* tokenURI
|
|
2421
|
+
* view
|
|
2422
|
+
*/
|
|
2423
|
+
async tokenURI(tokenId: bigint): Promise<string> {
|
|
2424
|
+
return this.contract.read.tokenURI([tokenId] as const) as Promise<string>;
|
|
2425
|
+
}
|
|
2426
|
+
|
|
2427
|
+
/**
|
|
2428
|
+
* tokensLastStakedAt
|
|
2429
|
+
* view
|
|
2430
|
+
*/
|
|
2431
|
+
async tokensLastStakedAt(arg0: bigint): Promise<bigint> {
|
|
2432
|
+
return this.contract.read.tokensLastStakedAt([arg0] as const) as Promise<bigint>;
|
|
2433
|
+
}
|
|
2434
|
+
|
|
2435
|
+
/**
|
|
2436
|
+
* tokensLastStakedAtMultiple
|
|
2437
|
+
* view
|
|
2438
|
+
*/
|
|
2439
|
+
async tokensLastStakedAtMultiple(tokenIds: bigint[]): Promise<bigint[]> {
|
|
2440
|
+
return this.contract.read.tokensLastStakedAtMultiple([tokenIds] as const) as Promise<bigint[]>;
|
|
2441
|
+
}
|
|
2442
|
+
|
|
2443
|
+
/**
|
|
2444
|
+
* tokensOfOwner
|
|
2445
|
+
* view
|
|
2446
|
+
*/
|
|
2447
|
+
async tokensOfOwner(owner: `0x${string}`): Promise<bigint[]> {
|
|
2448
|
+
return this.contract.read.tokensOfOwner([owner] as const) as Promise<bigint[]>;
|
|
2449
|
+
}
|
|
2450
|
+
|
|
2451
|
+
/**
|
|
2452
|
+
* tokensOfOwnerIn
|
|
2453
|
+
* view
|
|
2454
|
+
*/
|
|
2455
|
+
async tokensOfOwnerIn(owner: `0x${string}`, start: bigint, stop: bigint): Promise<bigint[]> {
|
|
2456
|
+
return this.contract.read.tokensOfOwnerIn([owner, start, stop] as const) as Promise<bigint[]>;
|
|
2457
|
+
}
|
|
2458
|
+
|
|
2459
|
+
/**
|
|
2460
|
+
* totalSupply
|
|
2461
|
+
* view
|
|
2462
|
+
*/
|
|
2463
|
+
async totalSupply(): Promise<bigint> {
|
|
2464
|
+
return this.contract.read.totalSupply() as Promise<bigint>;
|
|
2465
|
+
}
|
|
2466
|
+
|
|
2467
|
+
/**
|
|
2468
|
+
* unlockPrice
|
|
2469
|
+
* view
|
|
2470
|
+
*/
|
|
2471
|
+
async unlockPrice(): Promise<bigint> {
|
|
2472
|
+
return this.contract.read.unlockPrice() as Promise<bigint>;
|
|
2473
|
+
}
|
|
2474
|
+
|
|
2475
|
+
/**
|
|
2476
|
+
* upgradePrice
|
|
2477
|
+
* view
|
|
2478
|
+
*/
|
|
2479
|
+
async upgradePrice(): Promise<bigint> {
|
|
2480
|
+
return this.contract.read.upgradePrice() as Promise<bigint>;
|
|
2481
|
+
}
|
|
2482
|
+
|
|
2483
|
+
/**
|
|
2484
|
+
* whitelistedMarketplaces
|
|
2485
|
+
* view
|
|
2486
|
+
*/
|
|
2487
|
+
async whitelistedMarketplaces(arg0: `0x${string}`): Promise<boolean> {
|
|
2488
|
+
return this.contract.read.whitelistedMarketplaces([arg0] as const) as Promise<boolean>;
|
|
2489
|
+
}
|
|
2490
|
+
|
|
2491
|
+
/**
|
|
2492
|
+
* __DefaultOperatorFilterer_init
|
|
2493
|
+
* nonpayable
|
|
2494
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2495
|
+
*/
|
|
2496
|
+
async __DefaultOperatorFilterer_init(options?: {
|
|
2497
|
+
accessList?: import('viem').AccessList;
|
|
2498
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2499
|
+
chain?: import('viem').Chain | null;
|
|
2500
|
+
dataSuffix?: `0x${string}`;
|
|
2501
|
+
gas?: bigint;
|
|
2502
|
+
gasPrice?: bigint;
|
|
2503
|
+
maxFeePerGas?: bigint;
|
|
2504
|
+
maxPriorityFeePerGas?: bigint;
|
|
2505
|
+
nonce?: number;
|
|
2506
|
+
value?: bigint;
|
|
2507
|
+
}): Promise<`0x${string}`> {
|
|
2508
|
+
if (!this.contract.write) {
|
|
2509
|
+
throw new Error('Wallet client is required for write operations');
|
|
2510
|
+
}
|
|
2511
|
+
return this.contract.write.__DefaultOperatorFilterer_init(options) as Promise<`0x${string}`>;
|
|
2512
|
+
}
|
|
2513
|
+
|
|
2514
|
+
/**
|
|
2515
|
+
* __OperatorFilterer_init
|
|
2516
|
+
* nonpayable
|
|
2517
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2518
|
+
*/
|
|
2519
|
+
async __OperatorFilterer_init(subscriptionOrRegistrantToCopy: `0x${string}`, subscribe: boolean, options?: {
|
|
2520
|
+
accessList?: import('viem').AccessList;
|
|
2521
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2522
|
+
chain?: import('viem').Chain | null;
|
|
2523
|
+
dataSuffix?: `0x${string}`;
|
|
2524
|
+
gas?: bigint;
|
|
2525
|
+
gasPrice?: bigint;
|
|
2526
|
+
maxFeePerGas?: bigint;
|
|
2527
|
+
maxPriorityFeePerGas?: bigint;
|
|
2528
|
+
nonce?: number;
|
|
2529
|
+
value?: bigint;
|
|
2530
|
+
}): Promise<`0x${string}`> {
|
|
2531
|
+
if (!this.contract.write) {
|
|
2532
|
+
throw new Error('Wallet client is required for write operations');
|
|
2533
|
+
}
|
|
2534
|
+
return this.contract.write.__OperatorFilterer_init([subscriptionOrRegistrantToCopy, subscribe] as const, options) as Promise<`0x${string}`>;
|
|
2535
|
+
}
|
|
2536
|
+
|
|
2537
|
+
/**
|
|
2538
|
+
* airdropListWithAmounts
|
|
2539
|
+
* nonpayable
|
|
2540
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2541
|
+
*/
|
|
2542
|
+
async airdropListWithAmounts(receivers: `0x${string}`[], amounts: bigint[], options?: {
|
|
2543
|
+
accessList?: import('viem').AccessList;
|
|
2544
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2545
|
+
chain?: import('viem').Chain | null;
|
|
2546
|
+
dataSuffix?: `0x${string}`;
|
|
2547
|
+
gas?: bigint;
|
|
2548
|
+
gasPrice?: bigint;
|
|
2549
|
+
maxFeePerGas?: bigint;
|
|
2550
|
+
maxPriorityFeePerGas?: bigint;
|
|
2551
|
+
nonce?: number;
|
|
2552
|
+
value?: bigint;
|
|
2553
|
+
}): Promise<`0x${string}`> {
|
|
2554
|
+
if (!this.contract.write) {
|
|
2555
|
+
throw new Error('Wallet client is required for write operations');
|
|
2556
|
+
}
|
|
2557
|
+
return this.contract.write.airdropListWithAmounts([receivers, amounts] as const, options) as Promise<`0x${string}`>;
|
|
2558
|
+
}
|
|
2559
|
+
|
|
2560
|
+
/**
|
|
2561
|
+
* approve
|
|
2562
|
+
* nonpayable
|
|
2563
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2564
|
+
*/
|
|
2565
|
+
async approve(to: `0x${string}`, tokenId: bigint, options?: {
|
|
2566
|
+
accessList?: import('viem').AccessList;
|
|
2567
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2568
|
+
chain?: import('viem').Chain | null;
|
|
2569
|
+
dataSuffix?: `0x${string}`;
|
|
2570
|
+
gas?: bigint;
|
|
2571
|
+
gasPrice?: bigint;
|
|
2572
|
+
maxFeePerGas?: bigint;
|
|
2573
|
+
maxPriorityFeePerGas?: bigint;
|
|
2574
|
+
nonce?: number;
|
|
2575
|
+
value?: bigint;
|
|
2576
|
+
}): Promise<`0x${string}`> {
|
|
2577
|
+
if (!this.contract.write) {
|
|
2578
|
+
throw new Error('Wallet client is required for write operations');
|
|
2579
|
+
}
|
|
2580
|
+
return this.contract.write.approve([to, tokenId] as const, options) as Promise<`0x${string}`>;
|
|
2581
|
+
}
|
|
2582
|
+
|
|
2583
|
+
/**
|
|
2584
|
+
* confiscateT2
|
|
2585
|
+
* nonpayable
|
|
2586
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2587
|
+
*/
|
|
2588
|
+
async confiscateT2(t2TokenIds: bigint[], options?: {
|
|
2589
|
+
accessList?: import('viem').AccessList;
|
|
2590
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2591
|
+
chain?: import('viem').Chain | null;
|
|
2592
|
+
dataSuffix?: `0x${string}`;
|
|
2593
|
+
gas?: bigint;
|
|
2594
|
+
gasPrice?: bigint;
|
|
2595
|
+
maxFeePerGas?: bigint;
|
|
2596
|
+
maxPriorityFeePerGas?: bigint;
|
|
2597
|
+
nonce?: number;
|
|
2598
|
+
value?: bigint;
|
|
2599
|
+
}): Promise<`0x${string}`> {
|
|
2600
|
+
if (!this.contract.write) {
|
|
2601
|
+
throw new Error('Wallet client is required for write operations');
|
|
2602
|
+
}
|
|
2603
|
+
return this.contract.write.confiscateT2([t2TokenIds] as const, options) as Promise<`0x${string}`>;
|
|
2604
|
+
}
|
|
2605
|
+
|
|
2606
|
+
/**
|
|
2607
|
+
* exemptMarketplaces
|
|
2608
|
+
* nonpayable
|
|
2609
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2610
|
+
*/
|
|
2611
|
+
async exemptMarketplaces(markets: `0x${string}`[], exempted: boolean, options?: {
|
|
2612
|
+
accessList?: import('viem').AccessList;
|
|
2613
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2614
|
+
chain?: import('viem').Chain | null;
|
|
2615
|
+
dataSuffix?: `0x${string}`;
|
|
2616
|
+
gas?: bigint;
|
|
2617
|
+
gasPrice?: bigint;
|
|
2618
|
+
maxFeePerGas?: bigint;
|
|
2619
|
+
maxPriorityFeePerGas?: bigint;
|
|
2620
|
+
nonce?: number;
|
|
2621
|
+
value?: bigint;
|
|
2622
|
+
}): Promise<`0x${string}`> {
|
|
2623
|
+
if (!this.contract.write) {
|
|
2624
|
+
throw new Error('Wallet client is required for write operations');
|
|
2625
|
+
}
|
|
2626
|
+
return this.contract.write.exemptMarketplaces([markets, exempted] as const, options) as Promise<`0x${string}`>;
|
|
2627
|
+
}
|
|
2628
|
+
|
|
2629
|
+
/**
|
|
2630
|
+
* freeId
|
|
2631
|
+
* nonpayable
|
|
2632
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2633
|
+
*/
|
|
2634
|
+
async freeId(_id: bigint, _contract: `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<`0x${string}`> {
|
|
2646
|
+
if (!this.contract.write) {
|
|
2647
|
+
throw new Error('Wallet client is required for write operations');
|
|
2648
|
+
}
|
|
2649
|
+
return this.contract.write.freeId([_id, _contract] as const, options) as Promise<`0x${string}`>;
|
|
2650
|
+
}
|
|
2651
|
+
|
|
2652
|
+
/**
|
|
2653
|
+
* initialize
|
|
2654
|
+
* nonpayable
|
|
2655
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2656
|
+
*/
|
|
2657
|
+
async initialize(baseURI: string, options?: {
|
|
2658
|
+
accessList?: import('viem').AccessList;
|
|
2659
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2660
|
+
chain?: import('viem').Chain | null;
|
|
2661
|
+
dataSuffix?: `0x${string}`;
|
|
2662
|
+
gas?: bigint;
|
|
2663
|
+
gasPrice?: bigint;
|
|
2664
|
+
maxFeePerGas?: bigint;
|
|
2665
|
+
maxPriorityFeePerGas?: bigint;
|
|
2666
|
+
nonce?: number;
|
|
2667
|
+
value?: bigint;
|
|
2668
|
+
}): Promise<`0x${string}`> {
|
|
2669
|
+
if (!this.contract.write) {
|
|
2670
|
+
throw new Error('Wallet client is required for write operations');
|
|
2671
|
+
}
|
|
2672
|
+
return this.contract.write.initialize([baseURI] as const, options) as Promise<`0x${string}`>;
|
|
2673
|
+
}
|
|
2674
|
+
|
|
2675
|
+
/**
|
|
2676
|
+
* initializeV3
|
|
2677
|
+
* nonpayable
|
|
2678
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2679
|
+
*/
|
|
2680
|
+
async initializeV3(options?: {
|
|
2681
|
+
accessList?: import('viem').AccessList;
|
|
2682
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2683
|
+
chain?: import('viem').Chain | null;
|
|
2684
|
+
dataSuffix?: `0x${string}`;
|
|
2685
|
+
gas?: bigint;
|
|
2686
|
+
gasPrice?: bigint;
|
|
2687
|
+
maxFeePerGas?: bigint;
|
|
2688
|
+
maxPriorityFeePerGas?: bigint;
|
|
2689
|
+
nonce?: number;
|
|
2690
|
+
value?: bigint;
|
|
2691
|
+
}): Promise<`0x${string}`> {
|
|
2692
|
+
if (!this.contract.write) {
|
|
2693
|
+
throw new Error('Wallet client is required for write operations');
|
|
2694
|
+
}
|
|
2695
|
+
return this.contract.write.initializeV3(options) as Promise<`0x${string}`>;
|
|
2696
|
+
}
|
|
2697
|
+
|
|
2698
|
+
/**
|
|
2699
|
+
* keepTOLTransferFrom
|
|
2700
|
+
* nonpayable
|
|
2701
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2702
|
+
*/
|
|
2703
|
+
async keepTOLTransferFrom(from: `0x${string}`, to: `0x${string}`, tokenId: bigint, options?: {
|
|
2704
|
+
accessList?: import('viem').AccessList;
|
|
2705
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2706
|
+
chain?: import('viem').Chain | null;
|
|
2707
|
+
dataSuffix?: `0x${string}`;
|
|
2708
|
+
gas?: bigint;
|
|
2709
|
+
gasPrice?: bigint;
|
|
2710
|
+
maxFeePerGas?: bigint;
|
|
2711
|
+
maxPriorityFeePerGas?: bigint;
|
|
2712
|
+
nonce?: number;
|
|
2713
|
+
value?: bigint;
|
|
2714
|
+
}): Promise<`0x${string}`> {
|
|
2715
|
+
if (!this.contract.write) {
|
|
2716
|
+
throw new Error('Wallet client is required for write operations');
|
|
2717
|
+
}
|
|
2718
|
+
return this.contract.write.keepTOLTransferFrom([from, to, tokenId] as const, options) as Promise<`0x${string}`>;
|
|
2719
|
+
}
|
|
2720
|
+
|
|
2721
|
+
/**
|
|
2722
|
+
* lockId
|
|
2723
|
+
* nonpayable
|
|
2724
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2725
|
+
*/
|
|
2726
|
+
async lockId(_id: bigint, options?: {
|
|
2727
|
+
accessList?: import('viem').AccessList;
|
|
2728
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2729
|
+
chain?: import('viem').Chain | null;
|
|
2730
|
+
dataSuffix?: `0x${string}`;
|
|
2731
|
+
gas?: bigint;
|
|
2732
|
+
gasPrice?: bigint;
|
|
2733
|
+
maxFeePerGas?: bigint;
|
|
2734
|
+
maxPriorityFeePerGas?: bigint;
|
|
2735
|
+
nonce?: number;
|
|
2736
|
+
value?: bigint;
|
|
2737
|
+
}): Promise<`0x${string}`> {
|
|
2738
|
+
if (!this.contract.write) {
|
|
2739
|
+
throw new Error('Wallet client is required for write operations');
|
|
2740
|
+
}
|
|
2741
|
+
return this.contract.write.lockId([_id] as const, options) as Promise<`0x${string}`>;
|
|
2742
|
+
}
|
|
2743
|
+
|
|
2744
|
+
/**
|
|
2745
|
+
* payRoyalty
|
|
2746
|
+
* payable
|
|
2747
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2748
|
+
*/
|
|
2749
|
+
async payRoyalty(tokenId: bigint, options?: {
|
|
2750
|
+
accessList?: import('viem').AccessList;
|
|
2751
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2752
|
+
chain?: import('viem').Chain | null;
|
|
2753
|
+
dataSuffix?: `0x${string}`;
|
|
2754
|
+
gas?: bigint;
|
|
2755
|
+
gasPrice?: bigint;
|
|
2756
|
+
maxFeePerGas?: bigint;
|
|
2757
|
+
maxPriorityFeePerGas?: bigint;
|
|
2758
|
+
nonce?: number;
|
|
2759
|
+
value?: bigint;
|
|
2760
|
+
}): Promise<`0x${string}`> {
|
|
2761
|
+
if (!this.contract.write) {
|
|
2762
|
+
throw new Error('Wallet client is required for write operations');
|
|
2763
|
+
}
|
|
2764
|
+
return this.contract.write.payRoyalty([tokenId] as const, options) as Promise<`0x${string}`>;
|
|
2765
|
+
}
|
|
2766
|
+
|
|
2767
|
+
/**
|
|
2768
|
+
* renounceOwnership
|
|
2769
|
+
* nonpayable
|
|
2770
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2771
|
+
*/
|
|
2772
|
+
async renounceOwnership(options?: {
|
|
2773
|
+
accessList?: import('viem').AccessList;
|
|
2774
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2775
|
+
chain?: import('viem').Chain | null;
|
|
2776
|
+
dataSuffix?: `0x${string}`;
|
|
2777
|
+
gas?: bigint;
|
|
2778
|
+
gasPrice?: bigint;
|
|
2779
|
+
maxFeePerGas?: bigint;
|
|
2780
|
+
maxPriorityFeePerGas?: bigint;
|
|
2781
|
+
nonce?: number;
|
|
2782
|
+
value?: bigint;
|
|
2783
|
+
}): Promise<`0x${string}`> {
|
|
2784
|
+
if (!this.contract.write) {
|
|
2785
|
+
throw new Error('Wallet client is required for write operations');
|
|
2786
|
+
}
|
|
2787
|
+
return this.contract.write.renounceOwnership(options) as Promise<`0x${string}`>;
|
|
2788
|
+
}
|
|
2789
|
+
|
|
2790
|
+
async safeTransferFrom(from: `0x${string}`, to: `0x${string}`, tokenId: bigint, options?: {
|
|
2791
|
+
accessList?: import('viem').AccessList;
|
|
2792
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2793
|
+
chain?: import('viem').Chain | null;
|
|
2794
|
+
dataSuffix?: `0x${string}`;
|
|
2795
|
+
gas?: bigint;
|
|
2796
|
+
gasPrice?: bigint;
|
|
2797
|
+
maxFeePerGas?: bigint;
|
|
2798
|
+
maxPriorityFeePerGas?: bigint;
|
|
2799
|
+
nonce?: number;
|
|
2800
|
+
value?: bigint;
|
|
2801
|
+
}): Promise<`0x${string}`>;
|
|
2802
|
+
async safeTransferFrom(_from: `0x${string}`, _to: `0x${string}`, _tokenId: bigint, data: `0x${string}`, options?: {
|
|
2803
|
+
accessList?: import('viem').AccessList;
|
|
2804
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2805
|
+
chain?: import('viem').Chain | null;
|
|
2806
|
+
dataSuffix?: `0x${string}`;
|
|
2807
|
+
gas?: bigint;
|
|
2808
|
+
gasPrice?: bigint;
|
|
2809
|
+
maxFeePerGas?: bigint;
|
|
2810
|
+
maxPriorityFeePerGas?: bigint;
|
|
2811
|
+
nonce?: number;
|
|
2812
|
+
value?: bigint;
|
|
2813
|
+
}): Promise<`0x${string}`>;
|
|
2814
|
+
async safeTransferFrom(...args: any[]): Promise<`0x${string}`> {
|
|
2815
|
+
if (!this.contract.write) {
|
|
2816
|
+
throw new Error('Wallet client is required for write operations');
|
|
2817
|
+
}
|
|
2818
|
+
return this.contract.write.safeTransferFrom(args as any) as Promise<`0x${string}`>;
|
|
2819
|
+
}
|
|
2820
|
+
|
|
2821
|
+
/**
|
|
2822
|
+
* setAdminLocked
|
|
2823
|
+
* nonpayable
|
|
2824
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2825
|
+
*/
|
|
2826
|
+
async setAdminLocked(tokenId: bigint, isLocked: boolean, options?: {
|
|
2827
|
+
accessList?: import('viem').AccessList;
|
|
2828
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2829
|
+
chain?: import('viem').Chain | null;
|
|
2830
|
+
dataSuffix?: `0x${string}`;
|
|
2831
|
+
gas?: bigint;
|
|
2832
|
+
gasPrice?: bigint;
|
|
2833
|
+
maxFeePerGas?: bigint;
|
|
2834
|
+
maxPriorityFeePerGas?: bigint;
|
|
2835
|
+
nonce?: number;
|
|
2836
|
+
value?: bigint;
|
|
2837
|
+
}): Promise<`0x${string}`> {
|
|
2838
|
+
if (!this.contract.write) {
|
|
2839
|
+
throw new Error('Wallet client is required for write operations');
|
|
2840
|
+
}
|
|
2841
|
+
return this.contract.write.setAdminLocked([tokenId, isLocked] as const, options) as Promise<`0x${string}`>;
|
|
2842
|
+
}
|
|
2843
|
+
|
|
2844
|
+
/**
|
|
2845
|
+
* setAdminLockedMultiple
|
|
2846
|
+
* nonpayable
|
|
2847
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2848
|
+
*/
|
|
2849
|
+
async setAdminLockedMultiple(tokenIds: bigint[], isLockeds: boolean[], options?: {
|
|
2850
|
+
accessList?: import('viem').AccessList;
|
|
2851
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2852
|
+
chain?: import('viem').Chain | null;
|
|
2853
|
+
dataSuffix?: `0x${string}`;
|
|
2854
|
+
gas?: bigint;
|
|
2855
|
+
gasPrice?: bigint;
|
|
2856
|
+
maxFeePerGas?: bigint;
|
|
2857
|
+
maxPriorityFeePerGas?: bigint;
|
|
2858
|
+
nonce?: number;
|
|
2859
|
+
value?: bigint;
|
|
2860
|
+
}): Promise<`0x${string}`> {
|
|
2861
|
+
if (!this.contract.write) {
|
|
2862
|
+
throw new Error('Wallet client is required for write operations');
|
|
2863
|
+
}
|
|
2864
|
+
return this.contract.write.setAdminLockedMultiple([tokenIds, isLockeds] as const, options) as Promise<`0x${string}`>;
|
|
2865
|
+
}
|
|
2866
|
+
|
|
2867
|
+
/**
|
|
2868
|
+
* setApprovalForAll
|
|
2869
|
+
* nonpayable
|
|
2870
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2871
|
+
*/
|
|
2872
|
+
async setApprovalForAll(operator: `0x${string}`, approved: boolean, options?: {
|
|
2873
|
+
accessList?: import('viem').AccessList;
|
|
2874
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2875
|
+
chain?: import('viem').Chain | null;
|
|
2876
|
+
dataSuffix?: `0x${string}`;
|
|
2877
|
+
gas?: bigint;
|
|
2878
|
+
gasPrice?: bigint;
|
|
2879
|
+
maxFeePerGas?: bigint;
|
|
2880
|
+
maxPriorityFeePerGas?: bigint;
|
|
2881
|
+
nonce?: number;
|
|
2882
|
+
value?: bigint;
|
|
2883
|
+
}): Promise<`0x${string}`> {
|
|
2884
|
+
if (!this.contract.write) {
|
|
2885
|
+
throw new Error('Wallet client is required for write operations');
|
|
2886
|
+
}
|
|
2887
|
+
return this.contract.write.setApprovalForAll([operator, approved] as const, options) as Promise<`0x${string}`>;
|
|
2888
|
+
}
|
|
2889
|
+
|
|
2890
|
+
/**
|
|
2891
|
+
* setBaseURI
|
|
2892
|
+
* nonpayable
|
|
2893
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2894
|
+
*/
|
|
2895
|
+
async setBaseURI(baseURI: string, options?: {
|
|
2896
|
+
accessList?: import('viem').AccessList;
|
|
2897
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2898
|
+
chain?: import('viem').Chain | null;
|
|
2899
|
+
dataSuffix?: `0x${string}`;
|
|
2900
|
+
gas?: bigint;
|
|
2901
|
+
gasPrice?: bigint;
|
|
2902
|
+
maxFeePerGas?: bigint;
|
|
2903
|
+
maxPriorityFeePerGas?: bigint;
|
|
2904
|
+
nonce?: number;
|
|
2905
|
+
value?: bigint;
|
|
2906
|
+
}): Promise<`0x${string}`> {
|
|
2907
|
+
if (!this.contract.write) {
|
|
2908
|
+
throw new Error('Wallet client is required for write operations');
|
|
2909
|
+
}
|
|
2910
|
+
return this.contract.write.setBaseURI([baseURI] as const, options) as Promise<`0x${string}`>;
|
|
2911
|
+
}
|
|
2912
|
+
|
|
2913
|
+
/**
|
|
2914
|
+
* setToCustomSecurityPolicy
|
|
2915
|
+
* nonpayable
|
|
2916
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2917
|
+
*/
|
|
2918
|
+
async setToCustomSecurityPolicy(level: bigint, operatorWhitelistId: bigint, permittedContractReceiversAllowlistId: bigint, options?: {
|
|
2919
|
+
accessList?: import('viem').AccessList;
|
|
2920
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2921
|
+
chain?: import('viem').Chain | null;
|
|
2922
|
+
dataSuffix?: `0x${string}`;
|
|
2923
|
+
gas?: bigint;
|
|
2924
|
+
gasPrice?: bigint;
|
|
2925
|
+
maxFeePerGas?: bigint;
|
|
2926
|
+
maxPriorityFeePerGas?: bigint;
|
|
2927
|
+
nonce?: number;
|
|
2928
|
+
value?: bigint;
|
|
2929
|
+
}): Promise<`0x${string}`> {
|
|
2930
|
+
if (!this.contract.write) {
|
|
2931
|
+
throw new Error('Wallet client is required for write operations');
|
|
2932
|
+
}
|
|
2933
|
+
return this.contract.write.setToCustomSecurityPolicy([level, operatorWhitelistId, permittedContractReceiversAllowlistId] as const, options) as Promise<`0x${string}`>;
|
|
2934
|
+
}
|
|
2935
|
+
|
|
2936
|
+
/**
|
|
2937
|
+
* setToCustomValidatorAndSecurityPolicy
|
|
2938
|
+
* nonpayable
|
|
2939
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2940
|
+
*/
|
|
2941
|
+
async setToCustomValidatorAndSecurityPolicy(validator: `0x${string}`, level: bigint, operatorWhitelistId: bigint, permittedContractReceiversAllowlistId: bigint, options?: {
|
|
2942
|
+
accessList?: import('viem').AccessList;
|
|
2943
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2944
|
+
chain?: import('viem').Chain | null;
|
|
2945
|
+
dataSuffix?: `0x${string}`;
|
|
2946
|
+
gas?: bigint;
|
|
2947
|
+
gasPrice?: bigint;
|
|
2948
|
+
maxFeePerGas?: bigint;
|
|
2949
|
+
maxPriorityFeePerGas?: bigint;
|
|
2950
|
+
nonce?: number;
|
|
2951
|
+
value?: bigint;
|
|
2952
|
+
}): Promise<`0x${string}`> {
|
|
2953
|
+
if (!this.contract.write) {
|
|
2954
|
+
throw new Error('Wallet client is required for write operations');
|
|
2955
|
+
}
|
|
2956
|
+
return this.contract.write.setToCustomValidatorAndSecurityPolicy([validator, level, operatorWhitelistId, permittedContractReceiversAllowlistId] as const, options) as Promise<`0x${string}`>;
|
|
2957
|
+
}
|
|
2958
|
+
|
|
2959
|
+
/**
|
|
2960
|
+
* setToDefaultSecurityPolicy
|
|
2961
|
+
* nonpayable
|
|
2962
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2963
|
+
*/
|
|
2964
|
+
async setToDefaultSecurityPolicy(options?: {
|
|
2965
|
+
accessList?: import('viem').AccessList;
|
|
2966
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2967
|
+
chain?: import('viem').Chain | null;
|
|
2968
|
+
dataSuffix?: `0x${string}`;
|
|
2969
|
+
gas?: bigint;
|
|
2970
|
+
gasPrice?: bigint;
|
|
2971
|
+
maxFeePerGas?: bigint;
|
|
2972
|
+
maxPriorityFeePerGas?: bigint;
|
|
2973
|
+
nonce?: number;
|
|
2974
|
+
value?: bigint;
|
|
2975
|
+
}): Promise<`0x${string}`> {
|
|
2976
|
+
if (!this.contract.write) {
|
|
2977
|
+
throw new Error('Wallet client is required for write operations');
|
|
2978
|
+
}
|
|
2979
|
+
return this.contract.write.setToDefaultSecurityPolicy(options) as Promise<`0x${string}`>;
|
|
2980
|
+
}
|
|
2981
|
+
|
|
2982
|
+
/**
|
|
2983
|
+
* setTokensStakeStatus
|
|
2984
|
+
* payable
|
|
2985
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
2986
|
+
*/
|
|
2987
|
+
async setTokensStakeStatus(tokenIds: bigint[], setStake: boolean, options?: {
|
|
2988
|
+
accessList?: import('viem').AccessList;
|
|
2989
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
2990
|
+
chain?: import('viem').Chain | null;
|
|
2991
|
+
dataSuffix?: `0x${string}`;
|
|
2992
|
+
gas?: bigint;
|
|
2993
|
+
gasPrice?: bigint;
|
|
2994
|
+
maxFeePerGas?: bigint;
|
|
2995
|
+
maxPriorityFeePerGas?: bigint;
|
|
2996
|
+
nonce?: number;
|
|
2997
|
+
value?: bigint;
|
|
2998
|
+
}): Promise<`0x${string}`> {
|
|
2999
|
+
if (!this.contract.write) {
|
|
3000
|
+
throw new Error('Wallet client is required for write operations');
|
|
3001
|
+
}
|
|
3002
|
+
return this.contract.write.setTokensStakeStatus([tokenIds, setStake] as const, options) as Promise<`0x${string}`>;
|
|
3003
|
+
}
|
|
3004
|
+
|
|
3005
|
+
/**
|
|
3006
|
+
* setTransferValidator
|
|
3007
|
+
* nonpayable
|
|
3008
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3009
|
+
*/
|
|
3010
|
+
async setTransferValidator(transferValidator_: `0x${string}`, options?: {
|
|
3011
|
+
accessList?: import('viem').AccessList;
|
|
3012
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3013
|
+
chain?: import('viem').Chain | null;
|
|
3014
|
+
dataSuffix?: `0x${string}`;
|
|
3015
|
+
gas?: bigint;
|
|
3016
|
+
gasPrice?: bigint;
|
|
3017
|
+
maxFeePerGas?: bigint;
|
|
3018
|
+
maxPriorityFeePerGas?: bigint;
|
|
3019
|
+
nonce?: number;
|
|
3020
|
+
value?: bigint;
|
|
3021
|
+
}): Promise<`0x${string}`> {
|
|
3022
|
+
if (!this.contract.write) {
|
|
3023
|
+
throw new Error('Wallet client is required for write operations');
|
|
3024
|
+
}
|
|
3025
|
+
return this.contract.write.setTransferValidator([transferValidator_] as const, options) as Promise<`0x${string}`>;
|
|
3026
|
+
}
|
|
3027
|
+
|
|
3028
|
+
/**
|
|
3029
|
+
* setupGuardianAndMNPL
|
|
3030
|
+
* nonpayable
|
|
3031
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3032
|
+
*/
|
|
3033
|
+
async setupGuardianAndMNPL(guardianAddress: `0x${string}`, _tokenIdOrUpIsMNPL: bigint, _unlockPrice: bigint, options?: {
|
|
3034
|
+
accessList?: import('viem').AccessList;
|
|
3035
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3036
|
+
chain?: import('viem').Chain | null;
|
|
3037
|
+
dataSuffix?: `0x${string}`;
|
|
3038
|
+
gas?: bigint;
|
|
3039
|
+
gasPrice?: bigint;
|
|
3040
|
+
maxFeePerGas?: bigint;
|
|
3041
|
+
maxPriorityFeePerGas?: bigint;
|
|
3042
|
+
nonce?: number;
|
|
3043
|
+
value?: bigint;
|
|
3044
|
+
}): Promise<`0x${string}`> {
|
|
3045
|
+
if (!this.contract.write) {
|
|
3046
|
+
throw new Error('Wallet client is required for write operations');
|
|
3047
|
+
}
|
|
3048
|
+
return this.contract.write.setupGuardianAndMNPL([guardianAddress, _tokenIdOrUpIsMNPL, _unlockPrice] as const, options) as Promise<`0x${string}`>;
|
|
3049
|
+
}
|
|
3050
|
+
|
|
3051
|
+
/**
|
|
3052
|
+
* setupStaking
|
|
3053
|
+
* nonpayable
|
|
3054
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3055
|
+
*/
|
|
3056
|
+
async setupStaking(b: boolean, price: bigint, options?: {
|
|
3057
|
+
accessList?: import('viem').AccessList;
|
|
3058
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3059
|
+
chain?: import('viem').Chain | null;
|
|
3060
|
+
dataSuffix?: `0x${string}`;
|
|
3061
|
+
gas?: bigint;
|
|
3062
|
+
gasPrice?: bigint;
|
|
3063
|
+
maxFeePerGas?: bigint;
|
|
3064
|
+
maxPriorityFeePerGas?: bigint;
|
|
3065
|
+
nonce?: number;
|
|
3066
|
+
value?: bigint;
|
|
3067
|
+
}): Promise<`0x${string}`> {
|
|
3068
|
+
if (!this.contract.write) {
|
|
3069
|
+
throw new Error('Wallet client is required for write operations');
|
|
3070
|
+
}
|
|
3071
|
+
return this.contract.write.setupStaking([b, price] as const, options) as Promise<`0x${string}`>;
|
|
3072
|
+
}
|
|
3073
|
+
|
|
3074
|
+
/**
|
|
3075
|
+
* transferFrom
|
|
3076
|
+
* nonpayable
|
|
3077
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3078
|
+
*/
|
|
3079
|
+
async transferFrom(_from: `0x${string}`, _to: `0x${string}`, _tokenId: bigint, options?: {
|
|
3080
|
+
accessList?: import('viem').AccessList;
|
|
3081
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3082
|
+
chain?: import('viem').Chain | null;
|
|
3083
|
+
dataSuffix?: `0x${string}`;
|
|
3084
|
+
gas?: bigint;
|
|
3085
|
+
gasPrice?: bigint;
|
|
3086
|
+
maxFeePerGas?: bigint;
|
|
3087
|
+
maxPriorityFeePerGas?: bigint;
|
|
3088
|
+
nonce?: number;
|
|
3089
|
+
value?: bigint;
|
|
3090
|
+
}): Promise<`0x${string}`> {
|
|
3091
|
+
if (!this.contract.write) {
|
|
3092
|
+
throw new Error('Wallet client is required for write operations');
|
|
3093
|
+
}
|
|
3094
|
+
return this.contract.write.transferFrom([_from, _to, _tokenId] as const, options) as Promise<`0x${string}`>;
|
|
3095
|
+
}
|
|
3096
|
+
|
|
3097
|
+
/**
|
|
3098
|
+
* transferOwnership
|
|
3099
|
+
* nonpayable
|
|
3100
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3101
|
+
*/
|
|
3102
|
+
async transferOwnership(newOwner: `0x${string}`, options?: {
|
|
3103
|
+
accessList?: import('viem').AccessList;
|
|
3104
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3105
|
+
chain?: import('viem').Chain | null;
|
|
3106
|
+
dataSuffix?: `0x${string}`;
|
|
3107
|
+
gas?: bigint;
|
|
3108
|
+
gasPrice?: bigint;
|
|
3109
|
+
maxFeePerGas?: bigint;
|
|
3110
|
+
maxPriorityFeePerGas?: bigint;
|
|
3111
|
+
nonce?: number;
|
|
3112
|
+
value?: bigint;
|
|
3113
|
+
}): Promise<`0x${string}`> {
|
|
3114
|
+
if (!this.contract.write) {
|
|
3115
|
+
throw new Error('Wallet client is required for write operations');
|
|
3116
|
+
}
|
|
3117
|
+
return this.contract.write.transferOwnership([newOwner] as const, options) as Promise<`0x${string}`>;
|
|
3118
|
+
}
|
|
3119
|
+
|
|
3120
|
+
/**
|
|
3121
|
+
* unlockAndUpgradeMNPL
|
|
3122
|
+
* payable
|
|
3123
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3124
|
+
*/
|
|
3125
|
+
async unlockAndUpgradeMNPL(tokenId: bigint, options?: {
|
|
3126
|
+
accessList?: import('viem').AccessList;
|
|
3127
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3128
|
+
chain?: import('viem').Chain | null;
|
|
3129
|
+
dataSuffix?: `0x${string}`;
|
|
3130
|
+
gas?: bigint;
|
|
3131
|
+
gasPrice?: bigint;
|
|
3132
|
+
maxFeePerGas?: bigint;
|
|
3133
|
+
maxPriorityFeePerGas?: bigint;
|
|
3134
|
+
nonce?: number;
|
|
3135
|
+
value?: bigint;
|
|
3136
|
+
}): Promise<`0x${string}`> {
|
|
3137
|
+
if (!this.contract.write) {
|
|
3138
|
+
throw new Error('Wallet client is required for write operations');
|
|
3139
|
+
}
|
|
3140
|
+
return this.contract.write.unlockAndUpgradeMNPL([tokenId] as const, options) as Promise<`0x${string}`>;
|
|
3141
|
+
}
|
|
3142
|
+
|
|
3143
|
+
/**
|
|
3144
|
+
* unlockId
|
|
3145
|
+
* nonpayable
|
|
3146
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3147
|
+
*/
|
|
3148
|
+
async unlockId(_id: bigint, options?: {
|
|
3149
|
+
accessList?: import('viem').AccessList;
|
|
3150
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3151
|
+
chain?: import('viem').Chain | null;
|
|
3152
|
+
dataSuffix?: `0x${string}`;
|
|
3153
|
+
gas?: bigint;
|
|
3154
|
+
gasPrice?: bigint;
|
|
3155
|
+
maxFeePerGas?: bigint;
|
|
3156
|
+
maxPriorityFeePerGas?: bigint;
|
|
3157
|
+
nonce?: number;
|
|
3158
|
+
value?: bigint;
|
|
3159
|
+
}): Promise<`0x${string}`> {
|
|
3160
|
+
if (!this.contract.write) {
|
|
3161
|
+
throw new Error('Wallet client is required for write operations');
|
|
3162
|
+
}
|
|
3163
|
+
return this.contract.write.unlockId([_id] as const, options) as Promise<`0x${string}`>;
|
|
3164
|
+
}
|
|
3165
|
+
|
|
3166
|
+
/**
|
|
3167
|
+
* updateApprovedContracts
|
|
3168
|
+
* nonpayable
|
|
3169
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3170
|
+
*/
|
|
3171
|
+
async updateApprovedContracts(_contracts: `0x${string}`[], _values: boolean[], options?: {
|
|
3172
|
+
accessList?: import('viem').AccessList;
|
|
3173
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3174
|
+
chain?: import('viem').Chain | null;
|
|
3175
|
+
dataSuffix?: `0x${string}`;
|
|
3176
|
+
gas?: bigint;
|
|
3177
|
+
gasPrice?: bigint;
|
|
3178
|
+
maxFeePerGas?: bigint;
|
|
3179
|
+
maxPriorityFeePerGas?: bigint;
|
|
3180
|
+
nonce?: number;
|
|
3181
|
+
value?: bigint;
|
|
3182
|
+
}): Promise<`0x${string}`> {
|
|
3183
|
+
if (!this.contract.write) {
|
|
3184
|
+
throw new Error('Wallet client is required for write operations');
|
|
3185
|
+
}
|
|
3186
|
+
return this.contract.write.updateApprovedContracts([_contracts, _values] as const, options) as Promise<`0x${string}`>;
|
|
3187
|
+
}
|
|
3188
|
+
|
|
3189
|
+
/**
|
|
3190
|
+
* whitelistMarketplaces
|
|
3191
|
+
* nonpayable
|
|
3192
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3193
|
+
*/
|
|
3194
|
+
async whitelistMarketplaces(markets: `0x${string}`[], whitelisted: boolean, options?: {
|
|
3195
|
+
accessList?: import('viem').AccessList;
|
|
3196
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3197
|
+
chain?: import('viem').Chain | null;
|
|
3198
|
+
dataSuffix?: `0x${string}`;
|
|
3199
|
+
gas?: bigint;
|
|
3200
|
+
gasPrice?: bigint;
|
|
3201
|
+
maxFeePerGas?: bigint;
|
|
3202
|
+
maxPriorityFeePerGas?: bigint;
|
|
3203
|
+
nonce?: number;
|
|
3204
|
+
value?: bigint;
|
|
3205
|
+
}): Promise<`0x${string}`> {
|
|
3206
|
+
if (!this.contract.write) {
|
|
3207
|
+
throw new Error('Wallet client is required for write operations');
|
|
3208
|
+
}
|
|
3209
|
+
return this.contract.write.whitelistMarketplaces([markets, whitelisted] as const, options) as Promise<`0x${string}`>;
|
|
3210
|
+
}
|
|
3211
|
+
|
|
3212
|
+
/**
|
|
3213
|
+
* withdrawSales
|
|
3214
|
+
* nonpayable
|
|
3215
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3216
|
+
*/
|
|
3217
|
+
async withdrawSales(options?: {
|
|
3218
|
+
accessList?: import('viem').AccessList;
|
|
3219
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3220
|
+
chain?: import('viem').Chain | null;
|
|
3221
|
+
dataSuffix?: `0x${string}`;
|
|
3222
|
+
gas?: bigint;
|
|
3223
|
+
gasPrice?: bigint;
|
|
3224
|
+
maxFeePerGas?: bigint;
|
|
3225
|
+
maxPriorityFeePerGas?: bigint;
|
|
3226
|
+
nonce?: number;
|
|
3227
|
+
value?: bigint;
|
|
3228
|
+
}): Promise<`0x${string}`> {
|
|
3229
|
+
if (!this.contract.write) {
|
|
3230
|
+
throw new Error('Wallet client is required for write operations');
|
|
3231
|
+
}
|
|
3232
|
+
return this.contract.write.withdrawSales(options) as Promise<`0x${string}`>;
|
|
3233
|
+
}
|
|
3234
|
+
|
|
3235
|
+
|
|
3236
|
+
|
|
3237
|
+
/**
|
|
3238
|
+
* Simulate contract write operations (dry-run without sending transaction)
|
|
3239
|
+
*
|
|
3240
|
+
* @example
|
|
3241
|
+
* const result = await contract.simulate.transfer('0x...', 1000n);
|
|
3242
|
+
* console.log('Gas estimate:', result.request.gas);
|
|
3243
|
+
* console.log('Would succeed:', result.result);
|
|
3244
|
+
*/
|
|
3245
|
+
get simulate() {
|
|
3246
|
+
const contract = this.contract;
|
|
3247
|
+
if (!contract.simulate) {
|
|
3248
|
+
throw new Error('Public client is required for simulation');
|
|
3249
|
+
}
|
|
3250
|
+
return {
|
|
3251
|
+
/**
|
|
3252
|
+
* Simulate __DefaultOperatorFilterer_init
|
|
3253
|
+
* Returns gas estimate and result without sending transaction
|
|
3254
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3255
|
+
*/
|
|
3256
|
+
async __DefaultOperatorFilterer_init(options?: {
|
|
3257
|
+
accessList?: import('viem').AccessList;
|
|
3258
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3259
|
+
chain?: import('viem').Chain | null;
|
|
3260
|
+
dataSuffix?: `0x${string}`;
|
|
3261
|
+
gas?: bigint;
|
|
3262
|
+
gasPrice?: bigint;
|
|
3263
|
+
maxFeePerGas?: bigint;
|
|
3264
|
+
maxPriorityFeePerGas?: bigint;
|
|
3265
|
+
nonce?: number;
|
|
3266
|
+
value?: bigint;
|
|
3267
|
+
}): Promise<void> {
|
|
3268
|
+
return contract.simulate.__DefaultOperatorFilterer_init(options) as Promise<void>;
|
|
3269
|
+
},
|
|
3270
|
+
/**
|
|
3271
|
+
* Simulate __OperatorFilterer_init
|
|
3272
|
+
* Returns gas estimate and result without sending transaction
|
|
3273
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3274
|
+
*/
|
|
3275
|
+
async __OperatorFilterer_init(subscriptionOrRegistrantToCopy: `0x${string}`, subscribe: boolean, options?: {
|
|
3276
|
+
accessList?: import('viem').AccessList;
|
|
3277
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3278
|
+
chain?: import('viem').Chain | null;
|
|
3279
|
+
dataSuffix?: `0x${string}`;
|
|
3280
|
+
gas?: bigint;
|
|
3281
|
+
gasPrice?: bigint;
|
|
3282
|
+
maxFeePerGas?: bigint;
|
|
3283
|
+
maxPriorityFeePerGas?: bigint;
|
|
3284
|
+
nonce?: number;
|
|
3285
|
+
value?: bigint;
|
|
3286
|
+
}): Promise<void> {
|
|
3287
|
+
return contract.simulate.__OperatorFilterer_init([subscriptionOrRegistrantToCopy, subscribe] as const, options) as Promise<void>;
|
|
3288
|
+
},
|
|
3289
|
+
/**
|
|
3290
|
+
* Simulate airdropListWithAmounts
|
|
3291
|
+
* Returns gas estimate and result without sending transaction
|
|
3292
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3293
|
+
*/
|
|
3294
|
+
async airdropListWithAmounts(receivers: `0x${string}`[], amounts: bigint[], options?: {
|
|
3295
|
+
accessList?: import('viem').AccessList;
|
|
3296
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3297
|
+
chain?: import('viem').Chain | null;
|
|
3298
|
+
dataSuffix?: `0x${string}`;
|
|
3299
|
+
gas?: bigint;
|
|
3300
|
+
gasPrice?: bigint;
|
|
3301
|
+
maxFeePerGas?: bigint;
|
|
3302
|
+
maxPriorityFeePerGas?: bigint;
|
|
3303
|
+
nonce?: number;
|
|
3304
|
+
value?: bigint;
|
|
3305
|
+
}): Promise<void> {
|
|
3306
|
+
return contract.simulate.airdropListWithAmounts([receivers, amounts] as const, options) as Promise<void>;
|
|
3307
|
+
},
|
|
3308
|
+
/**
|
|
3309
|
+
* Simulate approve
|
|
3310
|
+
* Returns gas estimate and result without sending transaction
|
|
3311
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3312
|
+
*/
|
|
3313
|
+
async approve(to: `0x${string}`, tokenId: bigint, options?: {
|
|
3314
|
+
accessList?: import('viem').AccessList;
|
|
3315
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3316
|
+
chain?: import('viem').Chain | null;
|
|
3317
|
+
dataSuffix?: `0x${string}`;
|
|
3318
|
+
gas?: bigint;
|
|
3319
|
+
gasPrice?: bigint;
|
|
3320
|
+
maxFeePerGas?: bigint;
|
|
3321
|
+
maxPriorityFeePerGas?: bigint;
|
|
3322
|
+
nonce?: number;
|
|
3323
|
+
value?: bigint;
|
|
3324
|
+
}): Promise<void> {
|
|
3325
|
+
return contract.simulate.approve([to, tokenId] as const, options) as Promise<void>;
|
|
3326
|
+
},
|
|
3327
|
+
/**
|
|
3328
|
+
* Simulate confiscateT2
|
|
3329
|
+
* Returns gas estimate and result without sending transaction
|
|
3330
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3331
|
+
*/
|
|
3332
|
+
async confiscateT2(t2TokenIds: bigint[], options?: {
|
|
3333
|
+
accessList?: import('viem').AccessList;
|
|
3334
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3335
|
+
chain?: import('viem').Chain | null;
|
|
3336
|
+
dataSuffix?: `0x${string}`;
|
|
3337
|
+
gas?: bigint;
|
|
3338
|
+
gasPrice?: bigint;
|
|
3339
|
+
maxFeePerGas?: bigint;
|
|
3340
|
+
maxPriorityFeePerGas?: bigint;
|
|
3341
|
+
nonce?: number;
|
|
3342
|
+
value?: bigint;
|
|
3343
|
+
}): Promise<void> {
|
|
3344
|
+
return contract.simulate.confiscateT2([t2TokenIds] as const, options) as Promise<void>;
|
|
3345
|
+
},
|
|
3346
|
+
/**
|
|
3347
|
+
* Simulate exemptMarketplaces
|
|
3348
|
+
* Returns gas estimate and result without sending transaction
|
|
3349
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3350
|
+
*/
|
|
3351
|
+
async exemptMarketplaces(markets: `0x${string}`[], exempted: boolean, options?: {
|
|
3352
|
+
accessList?: import('viem').AccessList;
|
|
3353
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3354
|
+
chain?: import('viem').Chain | null;
|
|
3355
|
+
dataSuffix?: `0x${string}`;
|
|
3356
|
+
gas?: bigint;
|
|
3357
|
+
gasPrice?: bigint;
|
|
3358
|
+
maxFeePerGas?: bigint;
|
|
3359
|
+
maxPriorityFeePerGas?: bigint;
|
|
3360
|
+
nonce?: number;
|
|
3361
|
+
value?: bigint;
|
|
3362
|
+
}): Promise<void> {
|
|
3363
|
+
return contract.simulate.exemptMarketplaces([markets, exempted] as const, options) as Promise<void>;
|
|
3364
|
+
},
|
|
3365
|
+
/**
|
|
3366
|
+
* Simulate freeId
|
|
3367
|
+
* Returns gas estimate and result without sending transaction
|
|
3368
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3369
|
+
*/
|
|
3370
|
+
async freeId(_id: bigint, _contract: `0x${string}`, options?: {
|
|
3371
|
+
accessList?: import('viem').AccessList;
|
|
3372
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3373
|
+
chain?: import('viem').Chain | null;
|
|
3374
|
+
dataSuffix?: `0x${string}`;
|
|
3375
|
+
gas?: bigint;
|
|
3376
|
+
gasPrice?: bigint;
|
|
3377
|
+
maxFeePerGas?: bigint;
|
|
3378
|
+
maxPriorityFeePerGas?: bigint;
|
|
3379
|
+
nonce?: number;
|
|
3380
|
+
value?: bigint;
|
|
3381
|
+
}): Promise<void> {
|
|
3382
|
+
return contract.simulate.freeId([_id, _contract] as const, options) as Promise<void>;
|
|
3383
|
+
},
|
|
3384
|
+
/**
|
|
3385
|
+
* Simulate initialize
|
|
3386
|
+
* Returns gas estimate and result without sending transaction
|
|
3387
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3388
|
+
*/
|
|
3389
|
+
async initialize(baseURI: string, options?: {
|
|
3390
|
+
accessList?: import('viem').AccessList;
|
|
3391
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3392
|
+
chain?: import('viem').Chain | null;
|
|
3393
|
+
dataSuffix?: `0x${string}`;
|
|
3394
|
+
gas?: bigint;
|
|
3395
|
+
gasPrice?: bigint;
|
|
3396
|
+
maxFeePerGas?: bigint;
|
|
3397
|
+
maxPriorityFeePerGas?: bigint;
|
|
3398
|
+
nonce?: number;
|
|
3399
|
+
value?: bigint;
|
|
3400
|
+
}): Promise<void> {
|
|
3401
|
+
return contract.simulate.initialize([baseURI] as const, options) as Promise<void>;
|
|
3402
|
+
},
|
|
3403
|
+
/**
|
|
3404
|
+
* Simulate initializeV3
|
|
3405
|
+
* Returns gas estimate and result without sending transaction
|
|
3406
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3407
|
+
*/
|
|
3408
|
+
async initializeV3(options?: {
|
|
3409
|
+
accessList?: import('viem').AccessList;
|
|
3410
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3411
|
+
chain?: import('viem').Chain | null;
|
|
3412
|
+
dataSuffix?: `0x${string}`;
|
|
3413
|
+
gas?: bigint;
|
|
3414
|
+
gasPrice?: bigint;
|
|
3415
|
+
maxFeePerGas?: bigint;
|
|
3416
|
+
maxPriorityFeePerGas?: bigint;
|
|
3417
|
+
nonce?: number;
|
|
3418
|
+
value?: bigint;
|
|
3419
|
+
}): Promise<void> {
|
|
3420
|
+
return contract.simulate.initializeV3(options) as Promise<void>;
|
|
3421
|
+
},
|
|
3422
|
+
/**
|
|
3423
|
+
* Simulate keepTOLTransferFrom
|
|
3424
|
+
* Returns gas estimate and result without sending transaction
|
|
3425
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3426
|
+
*/
|
|
3427
|
+
async keepTOLTransferFrom(from: `0x${string}`, to: `0x${string}`, tokenId: bigint, options?: {
|
|
3428
|
+
accessList?: import('viem').AccessList;
|
|
3429
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3430
|
+
chain?: import('viem').Chain | null;
|
|
3431
|
+
dataSuffix?: `0x${string}`;
|
|
3432
|
+
gas?: bigint;
|
|
3433
|
+
gasPrice?: bigint;
|
|
3434
|
+
maxFeePerGas?: bigint;
|
|
3435
|
+
maxPriorityFeePerGas?: bigint;
|
|
3436
|
+
nonce?: number;
|
|
3437
|
+
value?: bigint;
|
|
3438
|
+
}): Promise<void> {
|
|
3439
|
+
return contract.simulate.keepTOLTransferFrom([from, to, tokenId] as const, options) as Promise<void>;
|
|
3440
|
+
},
|
|
3441
|
+
/**
|
|
3442
|
+
* Simulate lockId
|
|
3443
|
+
* Returns gas estimate and result without sending transaction
|
|
3444
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3445
|
+
*/
|
|
3446
|
+
async lockId(_id: bigint, options?: {
|
|
3447
|
+
accessList?: import('viem').AccessList;
|
|
3448
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3449
|
+
chain?: import('viem').Chain | null;
|
|
3450
|
+
dataSuffix?: `0x${string}`;
|
|
3451
|
+
gas?: bigint;
|
|
3452
|
+
gasPrice?: bigint;
|
|
3453
|
+
maxFeePerGas?: bigint;
|
|
3454
|
+
maxPriorityFeePerGas?: bigint;
|
|
3455
|
+
nonce?: number;
|
|
3456
|
+
value?: bigint;
|
|
3457
|
+
}): Promise<void> {
|
|
3458
|
+
return contract.simulate.lockId([_id] as const, options) as Promise<void>;
|
|
3459
|
+
},
|
|
3460
|
+
/**
|
|
3461
|
+
* Simulate payRoyalty
|
|
3462
|
+
* Returns gas estimate and result without sending transaction
|
|
3463
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3464
|
+
*/
|
|
3465
|
+
async payRoyalty(tokenId: bigint, options?: {
|
|
3466
|
+
accessList?: import('viem').AccessList;
|
|
3467
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3468
|
+
chain?: import('viem').Chain | null;
|
|
3469
|
+
dataSuffix?: `0x${string}`;
|
|
3470
|
+
gas?: bigint;
|
|
3471
|
+
gasPrice?: bigint;
|
|
3472
|
+
maxFeePerGas?: bigint;
|
|
3473
|
+
maxPriorityFeePerGas?: bigint;
|
|
3474
|
+
nonce?: number;
|
|
3475
|
+
value?: bigint;
|
|
3476
|
+
}): Promise<void> {
|
|
3477
|
+
return contract.simulate.payRoyalty([tokenId] as const, options) as Promise<void>;
|
|
3478
|
+
},
|
|
3479
|
+
/**
|
|
3480
|
+
* Simulate renounceOwnership
|
|
3481
|
+
* Returns gas estimate and result without sending transaction
|
|
3482
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3483
|
+
*/
|
|
3484
|
+
async renounceOwnership(options?: {
|
|
3485
|
+
accessList?: import('viem').AccessList;
|
|
3486
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3487
|
+
chain?: import('viem').Chain | null;
|
|
3488
|
+
dataSuffix?: `0x${string}`;
|
|
3489
|
+
gas?: bigint;
|
|
3490
|
+
gasPrice?: bigint;
|
|
3491
|
+
maxFeePerGas?: bigint;
|
|
3492
|
+
maxPriorityFeePerGas?: bigint;
|
|
3493
|
+
nonce?: number;
|
|
3494
|
+
value?: bigint;
|
|
3495
|
+
}): Promise<void> {
|
|
3496
|
+
return contract.simulate.renounceOwnership(options) as Promise<void>;
|
|
3497
|
+
},
|
|
3498
|
+
/**
|
|
3499
|
+
* Simulate safeTransferFrom
|
|
3500
|
+
* Returns gas estimate and result without sending transaction
|
|
3501
|
+
* Supports multiple overloads: (address, address, uint256), (address, address, uint256, bytes)
|
|
3502
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3503
|
+
*/
|
|
3504
|
+
async safeTransferFrom(...args: any[]): Promise<any> {
|
|
3505
|
+
return contract.simulate.safeTransferFrom(args as any) as Promise<any>;
|
|
3506
|
+
},
|
|
3507
|
+
/**
|
|
3508
|
+
* Simulate setAdminLocked
|
|
3509
|
+
* Returns gas estimate and result without sending transaction
|
|
3510
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3511
|
+
*/
|
|
3512
|
+
async setAdminLocked(tokenId: bigint, isLocked: boolean, options?: {
|
|
3513
|
+
accessList?: import('viem').AccessList;
|
|
3514
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3515
|
+
chain?: import('viem').Chain | null;
|
|
3516
|
+
dataSuffix?: `0x${string}`;
|
|
3517
|
+
gas?: bigint;
|
|
3518
|
+
gasPrice?: bigint;
|
|
3519
|
+
maxFeePerGas?: bigint;
|
|
3520
|
+
maxPriorityFeePerGas?: bigint;
|
|
3521
|
+
nonce?: number;
|
|
3522
|
+
value?: bigint;
|
|
3523
|
+
}): Promise<void> {
|
|
3524
|
+
return contract.simulate.setAdminLocked([tokenId, isLocked] as const, options) as Promise<void>;
|
|
3525
|
+
},
|
|
3526
|
+
/**
|
|
3527
|
+
* Simulate setAdminLockedMultiple
|
|
3528
|
+
* Returns gas estimate and result without sending transaction
|
|
3529
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3530
|
+
*/
|
|
3531
|
+
async setAdminLockedMultiple(tokenIds: bigint[], isLockeds: boolean[], options?: {
|
|
3532
|
+
accessList?: import('viem').AccessList;
|
|
3533
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3534
|
+
chain?: import('viem').Chain | null;
|
|
3535
|
+
dataSuffix?: `0x${string}`;
|
|
3536
|
+
gas?: bigint;
|
|
3537
|
+
gasPrice?: bigint;
|
|
3538
|
+
maxFeePerGas?: bigint;
|
|
3539
|
+
maxPriorityFeePerGas?: bigint;
|
|
3540
|
+
nonce?: number;
|
|
3541
|
+
value?: bigint;
|
|
3542
|
+
}): Promise<void> {
|
|
3543
|
+
return contract.simulate.setAdminLockedMultiple([tokenIds, isLockeds] as const, options) as Promise<void>;
|
|
3544
|
+
},
|
|
3545
|
+
/**
|
|
3546
|
+
* Simulate setApprovalForAll
|
|
3547
|
+
* Returns gas estimate and result without sending transaction
|
|
3548
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3549
|
+
*/
|
|
3550
|
+
async setApprovalForAll(operator: `0x${string}`, approved: boolean, options?: {
|
|
3551
|
+
accessList?: import('viem').AccessList;
|
|
3552
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3553
|
+
chain?: import('viem').Chain | null;
|
|
3554
|
+
dataSuffix?: `0x${string}`;
|
|
3555
|
+
gas?: bigint;
|
|
3556
|
+
gasPrice?: bigint;
|
|
3557
|
+
maxFeePerGas?: bigint;
|
|
3558
|
+
maxPriorityFeePerGas?: bigint;
|
|
3559
|
+
nonce?: number;
|
|
3560
|
+
value?: bigint;
|
|
3561
|
+
}): Promise<void> {
|
|
3562
|
+
return contract.simulate.setApprovalForAll([operator, approved] as const, options) as Promise<void>;
|
|
3563
|
+
},
|
|
3564
|
+
/**
|
|
3565
|
+
* Simulate setBaseURI
|
|
3566
|
+
* Returns gas estimate and result without sending transaction
|
|
3567
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3568
|
+
*/
|
|
3569
|
+
async setBaseURI(baseURI: string, options?: {
|
|
3570
|
+
accessList?: import('viem').AccessList;
|
|
3571
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3572
|
+
chain?: import('viem').Chain | null;
|
|
3573
|
+
dataSuffix?: `0x${string}`;
|
|
3574
|
+
gas?: bigint;
|
|
3575
|
+
gasPrice?: bigint;
|
|
3576
|
+
maxFeePerGas?: bigint;
|
|
3577
|
+
maxPriorityFeePerGas?: bigint;
|
|
3578
|
+
nonce?: number;
|
|
3579
|
+
value?: bigint;
|
|
3580
|
+
}): Promise<void> {
|
|
3581
|
+
return contract.simulate.setBaseURI([baseURI] as const, options) as Promise<void>;
|
|
3582
|
+
},
|
|
3583
|
+
/**
|
|
3584
|
+
* Simulate setToCustomSecurityPolicy
|
|
3585
|
+
* Returns gas estimate and result without sending transaction
|
|
3586
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3587
|
+
*/
|
|
3588
|
+
async setToCustomSecurityPolicy(level: bigint, operatorWhitelistId: bigint, permittedContractReceiversAllowlistId: bigint, options?: {
|
|
3589
|
+
accessList?: import('viem').AccessList;
|
|
3590
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3591
|
+
chain?: import('viem').Chain | null;
|
|
3592
|
+
dataSuffix?: `0x${string}`;
|
|
3593
|
+
gas?: bigint;
|
|
3594
|
+
gasPrice?: bigint;
|
|
3595
|
+
maxFeePerGas?: bigint;
|
|
3596
|
+
maxPriorityFeePerGas?: bigint;
|
|
3597
|
+
nonce?: number;
|
|
3598
|
+
value?: bigint;
|
|
3599
|
+
}): Promise<void> {
|
|
3600
|
+
return contract.simulate.setToCustomSecurityPolicy([level, operatorWhitelistId, permittedContractReceiversAllowlistId] as const, options) as Promise<void>;
|
|
3601
|
+
},
|
|
3602
|
+
/**
|
|
3603
|
+
* Simulate setToCustomValidatorAndSecurityPolicy
|
|
3604
|
+
* Returns gas estimate and result without sending transaction
|
|
3605
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3606
|
+
*/
|
|
3607
|
+
async setToCustomValidatorAndSecurityPolicy(validator: `0x${string}`, level: bigint, operatorWhitelistId: bigint, permittedContractReceiversAllowlistId: bigint, options?: {
|
|
3608
|
+
accessList?: import('viem').AccessList;
|
|
3609
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3610
|
+
chain?: import('viem').Chain | null;
|
|
3611
|
+
dataSuffix?: `0x${string}`;
|
|
3612
|
+
gas?: bigint;
|
|
3613
|
+
gasPrice?: bigint;
|
|
3614
|
+
maxFeePerGas?: bigint;
|
|
3615
|
+
maxPriorityFeePerGas?: bigint;
|
|
3616
|
+
nonce?: number;
|
|
3617
|
+
value?: bigint;
|
|
3618
|
+
}): Promise<void> {
|
|
3619
|
+
return contract.simulate.setToCustomValidatorAndSecurityPolicy([validator, level, operatorWhitelistId, permittedContractReceiversAllowlistId] as const, options) as Promise<void>;
|
|
3620
|
+
},
|
|
3621
|
+
/**
|
|
3622
|
+
* Simulate setToDefaultSecurityPolicy
|
|
3623
|
+
* Returns gas estimate and result without sending transaction
|
|
3624
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3625
|
+
*/
|
|
3626
|
+
async setToDefaultSecurityPolicy(options?: {
|
|
3627
|
+
accessList?: import('viem').AccessList;
|
|
3628
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3629
|
+
chain?: import('viem').Chain | null;
|
|
3630
|
+
dataSuffix?: `0x${string}`;
|
|
3631
|
+
gas?: bigint;
|
|
3632
|
+
gasPrice?: bigint;
|
|
3633
|
+
maxFeePerGas?: bigint;
|
|
3634
|
+
maxPriorityFeePerGas?: bigint;
|
|
3635
|
+
nonce?: number;
|
|
3636
|
+
value?: bigint;
|
|
3637
|
+
}): Promise<void> {
|
|
3638
|
+
return contract.simulate.setToDefaultSecurityPolicy(options) as Promise<void>;
|
|
3639
|
+
},
|
|
3640
|
+
/**
|
|
3641
|
+
* Simulate setTokensStakeStatus
|
|
3642
|
+
* Returns gas estimate and result without sending transaction
|
|
3643
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3644
|
+
*/
|
|
3645
|
+
async setTokensStakeStatus(tokenIds: bigint[], setStake: boolean, options?: {
|
|
3646
|
+
accessList?: import('viem').AccessList;
|
|
3647
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3648
|
+
chain?: import('viem').Chain | null;
|
|
3649
|
+
dataSuffix?: `0x${string}`;
|
|
3650
|
+
gas?: bigint;
|
|
3651
|
+
gasPrice?: bigint;
|
|
3652
|
+
maxFeePerGas?: bigint;
|
|
3653
|
+
maxPriorityFeePerGas?: bigint;
|
|
3654
|
+
nonce?: number;
|
|
3655
|
+
value?: bigint;
|
|
3656
|
+
}): Promise<void> {
|
|
3657
|
+
return contract.simulate.setTokensStakeStatus([tokenIds, setStake] as const, options) as Promise<void>;
|
|
3658
|
+
},
|
|
3659
|
+
/**
|
|
3660
|
+
* Simulate setTransferValidator
|
|
3661
|
+
* Returns gas estimate and result without sending transaction
|
|
3662
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3663
|
+
*/
|
|
3664
|
+
async setTransferValidator(transferValidator_: `0x${string}`, options?: {
|
|
3665
|
+
accessList?: import('viem').AccessList;
|
|
3666
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3667
|
+
chain?: import('viem').Chain | null;
|
|
3668
|
+
dataSuffix?: `0x${string}`;
|
|
3669
|
+
gas?: bigint;
|
|
3670
|
+
gasPrice?: bigint;
|
|
3671
|
+
maxFeePerGas?: bigint;
|
|
3672
|
+
maxPriorityFeePerGas?: bigint;
|
|
3673
|
+
nonce?: number;
|
|
3674
|
+
value?: bigint;
|
|
3675
|
+
}): Promise<void> {
|
|
3676
|
+
return contract.simulate.setTransferValidator([transferValidator_] as const, options) as Promise<void>;
|
|
3677
|
+
},
|
|
3678
|
+
/**
|
|
3679
|
+
* Simulate setupGuardianAndMNPL
|
|
3680
|
+
* Returns gas estimate and result without sending transaction
|
|
3681
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3682
|
+
*/
|
|
3683
|
+
async setupGuardianAndMNPL(guardianAddress: `0x${string}`, _tokenIdOrUpIsMNPL: bigint, _unlockPrice: bigint, options?: {
|
|
3684
|
+
accessList?: import('viem').AccessList;
|
|
3685
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3686
|
+
chain?: import('viem').Chain | null;
|
|
3687
|
+
dataSuffix?: `0x${string}`;
|
|
3688
|
+
gas?: bigint;
|
|
3689
|
+
gasPrice?: bigint;
|
|
3690
|
+
maxFeePerGas?: bigint;
|
|
3691
|
+
maxPriorityFeePerGas?: bigint;
|
|
3692
|
+
nonce?: number;
|
|
3693
|
+
value?: bigint;
|
|
3694
|
+
}): Promise<void> {
|
|
3695
|
+
return contract.simulate.setupGuardianAndMNPL([guardianAddress, _tokenIdOrUpIsMNPL, _unlockPrice] as const, options) as Promise<void>;
|
|
3696
|
+
},
|
|
3697
|
+
/**
|
|
3698
|
+
* Simulate setupStaking
|
|
3699
|
+
* Returns gas estimate and result without sending transaction
|
|
3700
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3701
|
+
*/
|
|
3702
|
+
async setupStaking(b: boolean, price: bigint, options?: {
|
|
3703
|
+
accessList?: import('viem').AccessList;
|
|
3704
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3705
|
+
chain?: import('viem').Chain | null;
|
|
3706
|
+
dataSuffix?: `0x${string}`;
|
|
3707
|
+
gas?: bigint;
|
|
3708
|
+
gasPrice?: bigint;
|
|
3709
|
+
maxFeePerGas?: bigint;
|
|
3710
|
+
maxPriorityFeePerGas?: bigint;
|
|
3711
|
+
nonce?: number;
|
|
3712
|
+
value?: bigint;
|
|
3713
|
+
}): Promise<void> {
|
|
3714
|
+
return contract.simulate.setupStaking([b, price] as const, options) as Promise<void>;
|
|
3715
|
+
},
|
|
3716
|
+
/**
|
|
3717
|
+
* Simulate transferFrom
|
|
3718
|
+
* Returns gas estimate and result without sending transaction
|
|
3719
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3720
|
+
*/
|
|
3721
|
+
async transferFrom(_from: `0x${string}`, _to: `0x${string}`, _tokenId: bigint, options?: {
|
|
3722
|
+
accessList?: import('viem').AccessList;
|
|
3723
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3724
|
+
chain?: import('viem').Chain | null;
|
|
3725
|
+
dataSuffix?: `0x${string}`;
|
|
3726
|
+
gas?: bigint;
|
|
3727
|
+
gasPrice?: bigint;
|
|
3728
|
+
maxFeePerGas?: bigint;
|
|
3729
|
+
maxPriorityFeePerGas?: bigint;
|
|
3730
|
+
nonce?: number;
|
|
3731
|
+
value?: bigint;
|
|
3732
|
+
}): Promise<void> {
|
|
3733
|
+
return contract.simulate.transferFrom([_from, _to, _tokenId] as const, options) as Promise<void>;
|
|
3734
|
+
},
|
|
3735
|
+
/**
|
|
3736
|
+
* Simulate transferOwnership
|
|
3737
|
+
* Returns gas estimate and result without sending transaction
|
|
3738
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3739
|
+
*/
|
|
3740
|
+
async transferOwnership(newOwner: `0x${string}`, options?: {
|
|
3741
|
+
accessList?: import('viem').AccessList;
|
|
3742
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3743
|
+
chain?: import('viem').Chain | null;
|
|
3744
|
+
dataSuffix?: `0x${string}`;
|
|
3745
|
+
gas?: bigint;
|
|
3746
|
+
gasPrice?: bigint;
|
|
3747
|
+
maxFeePerGas?: bigint;
|
|
3748
|
+
maxPriorityFeePerGas?: bigint;
|
|
3749
|
+
nonce?: number;
|
|
3750
|
+
value?: bigint;
|
|
3751
|
+
}): Promise<void> {
|
|
3752
|
+
return contract.simulate.transferOwnership([newOwner] as const, options) as Promise<void>;
|
|
3753
|
+
},
|
|
3754
|
+
/**
|
|
3755
|
+
* Simulate unlockAndUpgradeMNPL
|
|
3756
|
+
* Returns gas estimate and result without sending transaction
|
|
3757
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3758
|
+
*/
|
|
3759
|
+
async unlockAndUpgradeMNPL(tokenId: bigint, options?: {
|
|
3760
|
+
accessList?: import('viem').AccessList;
|
|
3761
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3762
|
+
chain?: import('viem').Chain | null;
|
|
3763
|
+
dataSuffix?: `0x${string}`;
|
|
3764
|
+
gas?: bigint;
|
|
3765
|
+
gasPrice?: bigint;
|
|
3766
|
+
maxFeePerGas?: bigint;
|
|
3767
|
+
maxPriorityFeePerGas?: bigint;
|
|
3768
|
+
nonce?: number;
|
|
3769
|
+
value?: bigint;
|
|
3770
|
+
}): Promise<void> {
|
|
3771
|
+
return contract.simulate.unlockAndUpgradeMNPL([tokenId] as const, options) as Promise<void>;
|
|
3772
|
+
},
|
|
3773
|
+
/**
|
|
3774
|
+
* Simulate unlockId
|
|
3775
|
+
* Returns gas estimate and result without sending transaction
|
|
3776
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3777
|
+
*/
|
|
3778
|
+
async unlockId(_id: bigint, options?: {
|
|
3779
|
+
accessList?: import('viem').AccessList;
|
|
3780
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3781
|
+
chain?: import('viem').Chain | null;
|
|
3782
|
+
dataSuffix?: `0x${string}`;
|
|
3783
|
+
gas?: bigint;
|
|
3784
|
+
gasPrice?: bigint;
|
|
3785
|
+
maxFeePerGas?: bigint;
|
|
3786
|
+
maxPriorityFeePerGas?: bigint;
|
|
3787
|
+
nonce?: number;
|
|
3788
|
+
value?: bigint;
|
|
3789
|
+
}): Promise<void> {
|
|
3790
|
+
return contract.simulate.unlockId([_id] as const, options) as Promise<void>;
|
|
3791
|
+
},
|
|
3792
|
+
/**
|
|
3793
|
+
* Simulate updateApprovedContracts
|
|
3794
|
+
* Returns gas estimate and result without sending transaction
|
|
3795
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3796
|
+
*/
|
|
3797
|
+
async updateApprovedContracts(_contracts: `0x${string}`[], _values: boolean[], options?: {
|
|
3798
|
+
accessList?: import('viem').AccessList;
|
|
3799
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3800
|
+
chain?: import('viem').Chain | null;
|
|
3801
|
+
dataSuffix?: `0x${string}`;
|
|
3802
|
+
gas?: bigint;
|
|
3803
|
+
gasPrice?: bigint;
|
|
3804
|
+
maxFeePerGas?: bigint;
|
|
3805
|
+
maxPriorityFeePerGas?: bigint;
|
|
3806
|
+
nonce?: number;
|
|
3807
|
+
value?: bigint;
|
|
3808
|
+
}): Promise<void> {
|
|
3809
|
+
return contract.simulate.updateApprovedContracts([_contracts, _values] as const, options) as Promise<void>;
|
|
3810
|
+
},
|
|
3811
|
+
/**
|
|
3812
|
+
* Simulate whitelistMarketplaces
|
|
3813
|
+
* Returns gas estimate and result without sending transaction
|
|
3814
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3815
|
+
*/
|
|
3816
|
+
async whitelistMarketplaces(markets: `0x${string}`[], whitelisted: boolean, options?: {
|
|
3817
|
+
accessList?: import('viem').AccessList;
|
|
3818
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3819
|
+
chain?: import('viem').Chain | null;
|
|
3820
|
+
dataSuffix?: `0x${string}`;
|
|
3821
|
+
gas?: bigint;
|
|
3822
|
+
gasPrice?: bigint;
|
|
3823
|
+
maxFeePerGas?: bigint;
|
|
3824
|
+
maxPriorityFeePerGas?: bigint;
|
|
3825
|
+
nonce?: number;
|
|
3826
|
+
value?: bigint;
|
|
3827
|
+
}): Promise<void> {
|
|
3828
|
+
return contract.simulate.whitelistMarketplaces([markets, whitelisted] as const, options) as Promise<void>;
|
|
3829
|
+
},
|
|
3830
|
+
/**
|
|
3831
|
+
* Simulate withdrawSales
|
|
3832
|
+
* Returns gas estimate and result without sending transaction
|
|
3833
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
3834
|
+
*/
|
|
3835
|
+
async withdrawSales(options?: {
|
|
3836
|
+
accessList?: import('viem').AccessList;
|
|
3837
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
3838
|
+
chain?: import('viem').Chain | null;
|
|
3839
|
+
dataSuffix?: `0x${string}`;
|
|
3840
|
+
gas?: bigint;
|
|
3841
|
+
gasPrice?: bigint;
|
|
3842
|
+
maxFeePerGas?: bigint;
|
|
3843
|
+
maxPriorityFeePerGas?: bigint;
|
|
3844
|
+
nonce?: number;
|
|
3845
|
+
value?: bigint;
|
|
3846
|
+
}): Promise<void> {
|
|
3847
|
+
return contract.simulate.withdrawSales(options) as Promise<void>;
|
|
3848
|
+
}
|
|
3849
|
+
};
|
|
3850
|
+
}
|
|
3851
|
+
|
|
3852
|
+
/**
|
|
3853
|
+
* Watch contract events
|
|
3854
|
+
*
|
|
3855
|
+
* @example
|
|
3856
|
+
* // Watch all Transfer events
|
|
3857
|
+
* const unwatch = contract.watch.Transfer((event) => {
|
|
3858
|
+
* console.log('Transfer:', event);
|
|
3859
|
+
* });
|
|
3860
|
+
*
|
|
3861
|
+
* // Stop watching
|
|
3862
|
+
* unwatch();
|
|
3863
|
+
*/
|
|
3864
|
+
get watch() {
|
|
3865
|
+
return {
|
|
3866
|
+
/**
|
|
3867
|
+
* Watch Approval events
|
|
3868
|
+
* @param callback Function to call when event is emitted
|
|
3869
|
+
* @param filter Optional filter for indexed parameters
|
|
3870
|
+
* @returns Unwatch function to stop listening
|
|
3871
|
+
*/
|
|
3872
|
+
Approval: (callback: (event: { owner: `0x${string}`; approved: `0x${string}`; tokenId: bigint }) => void, filter?: { owner?: `0x${string}` | `0x${string}`[] | null; approved?: `0x${string}` | `0x${string}`[] | null; tokenId?: bigint | bigint[] | null }) => {
|
|
3873
|
+
return this.publicClient.watchContractEvent({
|
|
3874
|
+
address: this.contractAddress,
|
|
3875
|
+
abi: YogapetzAbi,
|
|
3876
|
+
eventName: 'Approval',
|
|
3877
|
+
args: filter as any,
|
|
3878
|
+
onLogs: (logs: any[]) => {
|
|
3879
|
+
logs.forEach((log: any) => {
|
|
3880
|
+
callback(log.args as any);
|
|
3881
|
+
});
|
|
3882
|
+
},
|
|
3883
|
+
}) as () => void;
|
|
3884
|
+
},
|
|
3885
|
+
/**
|
|
3886
|
+
* Watch ApprovalForAll events
|
|
3887
|
+
* @param callback Function to call when event is emitted
|
|
3888
|
+
* @param filter Optional filter for indexed parameters
|
|
3889
|
+
* @returns Unwatch function to stop listening
|
|
3890
|
+
*/
|
|
3891
|
+
ApprovalForAll: (callback: (event: { owner: `0x${string}`; operator: `0x${string}`; approved: boolean }) => void, filter?: { owner?: `0x${string}` | `0x${string}`[] | null; operator?: `0x${string}` | `0x${string}`[] | null }) => {
|
|
3892
|
+
return this.publicClient.watchContractEvent({
|
|
3893
|
+
address: this.contractAddress,
|
|
3894
|
+
abi: YogapetzAbi,
|
|
3895
|
+
eventName: 'ApprovalForAll',
|
|
3896
|
+
args: filter as any,
|
|
3897
|
+
onLogs: (logs: any[]) => {
|
|
3898
|
+
logs.forEach((log: any) => {
|
|
3899
|
+
callback(log.args as any);
|
|
3900
|
+
});
|
|
3901
|
+
},
|
|
3902
|
+
}) as () => void;
|
|
3903
|
+
},
|
|
3904
|
+
/**
|
|
3905
|
+
* Watch BioChange events
|
|
3906
|
+
* @param callback Function to call when event is emitted
|
|
3907
|
+
* @param filter Optional filter for indexed parameters
|
|
3908
|
+
* @returns Unwatch function to stop listening
|
|
3909
|
+
*/
|
|
3910
|
+
BioChange: (callback: (event: { tokenId: bigint; bio: string }) => void, filter?: { tokenId?: bigint | bigint[] | null }) => {
|
|
3911
|
+
return this.publicClient.watchContractEvent({
|
|
3912
|
+
address: this.contractAddress,
|
|
3913
|
+
abi: YogapetzAbi,
|
|
3914
|
+
eventName: 'BioChange',
|
|
3915
|
+
args: filter as any,
|
|
3916
|
+
onLogs: (logs: any[]) => {
|
|
3917
|
+
logs.forEach((log: any) => {
|
|
3918
|
+
callback(log.args as any);
|
|
3919
|
+
});
|
|
3920
|
+
},
|
|
3921
|
+
}) as () => void;
|
|
3922
|
+
},
|
|
3923
|
+
/**
|
|
3924
|
+
* Watch ConsecutiveTransfer events
|
|
3925
|
+
* @param callback Function to call when event is emitted
|
|
3926
|
+
* @param filter Optional filter for indexed parameters
|
|
3927
|
+
* @returns Unwatch function to stop listening
|
|
3928
|
+
*/
|
|
3929
|
+
ConsecutiveTransfer: (callback: (event: { fromTokenId: bigint; toTokenId: bigint; from: `0x${string}`; to: `0x${string}` }) => void, filter?: { fromTokenId?: bigint | bigint[] | null; from?: `0x${string}` | `0x${string}`[] | null; to?: `0x${string}` | `0x${string}`[] | null }) => {
|
|
3930
|
+
return this.publicClient.watchContractEvent({
|
|
3931
|
+
address: this.contractAddress,
|
|
3932
|
+
abi: YogapetzAbi,
|
|
3933
|
+
eventName: 'ConsecutiveTransfer',
|
|
3934
|
+
args: filter as any,
|
|
3935
|
+
onLogs: (logs: any[]) => {
|
|
3936
|
+
logs.forEach((log: any) => {
|
|
3937
|
+
callback(log.args as any);
|
|
3938
|
+
});
|
|
3939
|
+
},
|
|
3940
|
+
}) as () => void;
|
|
3941
|
+
},
|
|
3942
|
+
/**
|
|
3943
|
+
* Watch Initialized events
|
|
3944
|
+
* @param callback Function to call when event is emitted
|
|
3945
|
+
* @param filter Optional filter for indexed parameters
|
|
3946
|
+
* @returns Unwatch function to stop listening
|
|
3947
|
+
*/
|
|
3948
|
+
Initialized: (callback: (event: { version: bigint }) => void) => {
|
|
3949
|
+
return this.publicClient.watchContractEvent({
|
|
3950
|
+
address: this.contractAddress,
|
|
3951
|
+
abi: YogapetzAbi,
|
|
3952
|
+
eventName: 'Initialized',
|
|
3953
|
+
|
|
3954
|
+
onLogs: (logs: any[]) => {
|
|
3955
|
+
logs.forEach((log: any) => {
|
|
3956
|
+
callback(log.args as any);
|
|
3957
|
+
});
|
|
3958
|
+
},
|
|
3959
|
+
}) as () => void;
|
|
3960
|
+
},
|
|
3961
|
+
/**
|
|
3962
|
+
* Watch KeepTOLTransfer events
|
|
3963
|
+
* @param callback Function to call when event is emitted
|
|
3964
|
+
* @param filter Optional filter for indexed parameters
|
|
3965
|
+
* @returns Unwatch function to stop listening
|
|
3966
|
+
*/
|
|
3967
|
+
KeepTOLTransfer: (callback: (event: { from: `0x${string}`; to: `0x${string}`; tokenId: bigint }) => void) => {
|
|
3968
|
+
return this.publicClient.watchContractEvent({
|
|
3969
|
+
address: this.contractAddress,
|
|
3970
|
+
abi: YogapetzAbi,
|
|
3971
|
+
eventName: 'KeepTOLTransfer',
|
|
3972
|
+
|
|
3973
|
+
onLogs: (logs: any[]) => {
|
|
3974
|
+
logs.forEach((log: any) => {
|
|
3975
|
+
callback(log.args as any);
|
|
3976
|
+
});
|
|
3977
|
+
},
|
|
3978
|
+
}) as () => void;
|
|
3979
|
+
},
|
|
3980
|
+
/**
|
|
3981
|
+
* Watch MNPLUnlockedUpgraded events
|
|
3982
|
+
* @param callback Function to call when event is emitted
|
|
3983
|
+
* @param filter Optional filter for indexed parameters
|
|
3984
|
+
* @returns Unwatch function to stop listening
|
|
3985
|
+
*/
|
|
3986
|
+
MNPLUnlockedUpgraded: (callback: (event: { tokenId: bigint }) => void) => {
|
|
3987
|
+
return this.publicClient.watchContractEvent({
|
|
3988
|
+
address: this.contractAddress,
|
|
3989
|
+
abi: YogapetzAbi,
|
|
3990
|
+
eventName: 'MNPLUnlockedUpgraded',
|
|
3991
|
+
|
|
3992
|
+
onLogs: (logs: any[]) => {
|
|
3993
|
+
logs.forEach((log: any) => {
|
|
3994
|
+
callback(log.args as any);
|
|
3995
|
+
});
|
|
3996
|
+
},
|
|
3997
|
+
}) as () => void;
|
|
3998
|
+
},
|
|
3999
|
+
/**
|
|
4000
|
+
* Watch NameChange events
|
|
4001
|
+
* @param callback Function to call when event is emitted
|
|
4002
|
+
* @param filter Optional filter for indexed parameters
|
|
4003
|
+
* @returns Unwatch function to stop listening
|
|
4004
|
+
*/
|
|
4005
|
+
NameChange: (callback: (event: { tokenId: bigint; newName: string }) => void, filter?: { tokenId?: bigint | bigint[] | null }) => {
|
|
4006
|
+
return this.publicClient.watchContractEvent({
|
|
4007
|
+
address: this.contractAddress,
|
|
4008
|
+
abi: YogapetzAbi,
|
|
4009
|
+
eventName: 'NameChange',
|
|
4010
|
+
args: filter as any,
|
|
4011
|
+
onLogs: (logs: any[]) => {
|
|
4012
|
+
logs.forEach((log: any) => {
|
|
4013
|
+
callback(log.args as any);
|
|
4014
|
+
});
|
|
4015
|
+
},
|
|
4016
|
+
}) as () => void;
|
|
4017
|
+
},
|
|
4018
|
+
/**
|
|
4019
|
+
* Watch OwnershipTransferred events
|
|
4020
|
+
* @param callback Function to call when event is emitted
|
|
4021
|
+
* @param filter Optional filter for indexed parameters
|
|
4022
|
+
* @returns Unwatch function to stop listening
|
|
4023
|
+
*/
|
|
4024
|
+
OwnershipTransferred: (callback: (event: { previousOwner: `0x${string}`; newOwner: `0x${string}` }) => void, filter?: { previousOwner?: `0x${string}` | `0x${string}`[] | null; newOwner?: `0x${string}` | `0x${string}`[] | null }) => {
|
|
4025
|
+
return this.publicClient.watchContractEvent({
|
|
4026
|
+
address: this.contractAddress,
|
|
4027
|
+
abi: YogapetzAbi,
|
|
4028
|
+
eventName: 'OwnershipTransferred',
|
|
4029
|
+
args: filter as any,
|
|
4030
|
+
onLogs: (logs: any[]) => {
|
|
4031
|
+
logs.forEach((log: any) => {
|
|
4032
|
+
callback(log.args as any);
|
|
4033
|
+
});
|
|
4034
|
+
},
|
|
4035
|
+
}) as () => void;
|
|
4036
|
+
},
|
|
4037
|
+
/**
|
|
4038
|
+
* Watch RoyaltyPaid events
|
|
4039
|
+
* @param callback Function to call when event is emitted
|
|
4040
|
+
* @param filter Optional filter for indexed parameters
|
|
4041
|
+
* @returns Unwatch function to stop listening
|
|
4042
|
+
*/
|
|
4043
|
+
RoyaltyPaid: (callback: (event: { tokenId: bigint; amount: bigint }) => void) => {
|
|
4044
|
+
return this.publicClient.watchContractEvent({
|
|
4045
|
+
address: this.contractAddress,
|
|
4046
|
+
abi: YogapetzAbi,
|
|
4047
|
+
eventName: 'RoyaltyPaid',
|
|
4048
|
+
|
|
4049
|
+
onLogs: (logs: any[]) => {
|
|
4050
|
+
logs.forEach((log: any) => {
|
|
4051
|
+
callback(log.args as any);
|
|
4052
|
+
});
|
|
4053
|
+
},
|
|
4054
|
+
}) as () => void;
|
|
4055
|
+
},
|
|
4056
|
+
/**
|
|
4057
|
+
* Watch Stake events
|
|
4058
|
+
* @param callback Function to call when event is emitted
|
|
4059
|
+
* @param filter Optional filter for indexed parameters
|
|
4060
|
+
* @returns Unwatch function to stop listening
|
|
4061
|
+
*/
|
|
4062
|
+
Stake: (callback: (event: { tokenId: bigint }) => void, filter?: { tokenId?: bigint | bigint[] | null }) => {
|
|
4063
|
+
return this.publicClient.watchContractEvent({
|
|
4064
|
+
address: this.contractAddress,
|
|
4065
|
+
abi: YogapetzAbi,
|
|
4066
|
+
eventName: 'Stake',
|
|
4067
|
+
args: filter as any,
|
|
4068
|
+
onLogs: (logs: any[]) => {
|
|
4069
|
+
logs.forEach((log: any) => {
|
|
4070
|
+
callback(log.args as any);
|
|
4071
|
+
});
|
|
4072
|
+
},
|
|
4073
|
+
}) as () => void;
|
|
4074
|
+
},
|
|
4075
|
+
/**
|
|
4076
|
+
* Watch TokenAdminLockedChanged events
|
|
4077
|
+
* @param callback Function to call when event is emitted
|
|
4078
|
+
* @param filter Optional filter for indexed parameters
|
|
4079
|
+
* @returns Unwatch function to stop listening
|
|
4080
|
+
*/
|
|
4081
|
+
TokenAdminLockedChanged: (callback: (event: { tokenId: bigint; isAdminLocked: boolean }) => void) => {
|
|
4082
|
+
return this.publicClient.watchContractEvent({
|
|
4083
|
+
address: this.contractAddress,
|
|
4084
|
+
abi: YogapetzAbi,
|
|
4085
|
+
eventName: 'TokenAdminLockedChanged',
|
|
4086
|
+
|
|
4087
|
+
onLogs: (logs: any[]) => {
|
|
4088
|
+
logs.forEach((log: any) => {
|
|
4089
|
+
callback(log.args as any);
|
|
4090
|
+
});
|
|
4091
|
+
},
|
|
4092
|
+
}) as () => void;
|
|
4093
|
+
},
|
|
4094
|
+
/**
|
|
4095
|
+
* Watch TokenLocked events
|
|
4096
|
+
* @param callback Function to call when event is emitted
|
|
4097
|
+
* @param filter Optional filter for indexed parameters
|
|
4098
|
+
* @returns Unwatch function to stop listening
|
|
4099
|
+
*/
|
|
4100
|
+
TokenLocked: (callback: (event: { tokenId: bigint; approvedContract: `0x${string}` }) => void, filter?: { tokenId?: bigint | bigint[] | null; approvedContract?: `0x${string}` | `0x${string}`[] | null }) => {
|
|
4101
|
+
return this.publicClient.watchContractEvent({
|
|
4102
|
+
address: this.contractAddress,
|
|
4103
|
+
abi: YogapetzAbi,
|
|
4104
|
+
eventName: 'TokenLocked',
|
|
4105
|
+
args: filter as any,
|
|
4106
|
+
onLogs: (logs: any[]) => {
|
|
4107
|
+
logs.forEach((log: any) => {
|
|
4108
|
+
callback(log.args as any);
|
|
4109
|
+
});
|
|
4110
|
+
},
|
|
4111
|
+
}) as () => void;
|
|
4112
|
+
},
|
|
4113
|
+
/**
|
|
4114
|
+
* Watch TokenUnlocked events
|
|
4115
|
+
* @param callback Function to call when event is emitted
|
|
4116
|
+
* @param filter Optional filter for indexed parameters
|
|
4117
|
+
* @returns Unwatch function to stop listening
|
|
4118
|
+
*/
|
|
4119
|
+
TokenUnlocked: (callback: (event: { tokenId: bigint; approvedContract: `0x${string}` }) => void, filter?: { tokenId?: bigint | bigint[] | null; approvedContract?: `0x${string}` | `0x${string}`[] | null }) => {
|
|
4120
|
+
return this.publicClient.watchContractEvent({
|
|
4121
|
+
address: this.contractAddress,
|
|
4122
|
+
abi: YogapetzAbi,
|
|
4123
|
+
eventName: 'TokenUnlocked',
|
|
4124
|
+
args: filter as any,
|
|
4125
|
+
onLogs: (logs: any[]) => {
|
|
4126
|
+
logs.forEach((log: any) => {
|
|
4127
|
+
callback(log.args as any);
|
|
4128
|
+
});
|
|
4129
|
+
},
|
|
4130
|
+
}) as () => void;
|
|
4131
|
+
},
|
|
4132
|
+
/**
|
|
4133
|
+
* Watch Transfer events
|
|
4134
|
+
* @param callback Function to call when event is emitted
|
|
4135
|
+
* @param filter Optional filter for indexed parameters
|
|
4136
|
+
* @returns Unwatch function to stop listening
|
|
4137
|
+
*/
|
|
4138
|
+
Transfer: (callback: (event: { from: `0x${string}`; to: `0x${string}`; tokenId: bigint }) => void, filter?: { from?: `0x${string}` | `0x${string}`[] | null; to?: `0x${string}` | `0x${string}`[] | null; tokenId?: bigint | bigint[] | null }) => {
|
|
4139
|
+
return this.publicClient.watchContractEvent({
|
|
4140
|
+
address: this.contractAddress,
|
|
4141
|
+
abi: YogapetzAbi,
|
|
4142
|
+
eventName: 'Transfer',
|
|
4143
|
+
args: filter as any,
|
|
4144
|
+
onLogs: (logs: any[]) => {
|
|
4145
|
+
logs.forEach((log: any) => {
|
|
4146
|
+
callback(log.args as any);
|
|
4147
|
+
});
|
|
4148
|
+
},
|
|
4149
|
+
}) as () => void;
|
|
4150
|
+
},
|
|
4151
|
+
/**
|
|
4152
|
+
* Watch TransferValidatorUpdated events
|
|
4153
|
+
* @param callback Function to call when event is emitted
|
|
4154
|
+
* @param filter Optional filter for indexed parameters
|
|
4155
|
+
* @returns Unwatch function to stop listening
|
|
4156
|
+
*/
|
|
4157
|
+
TransferValidatorUpdated: (callback: (event: { oldValidator: `0x${string}`; newValidator: `0x${string}` }) => void) => {
|
|
4158
|
+
return this.publicClient.watchContractEvent({
|
|
4159
|
+
address: this.contractAddress,
|
|
4160
|
+
abi: YogapetzAbi,
|
|
4161
|
+
eventName: 'TransferValidatorUpdated',
|
|
4162
|
+
|
|
4163
|
+
onLogs: (logs: any[]) => {
|
|
4164
|
+
logs.forEach((log: any) => {
|
|
4165
|
+
callback(log.args as any);
|
|
4166
|
+
});
|
|
4167
|
+
},
|
|
4168
|
+
}) as () => void;
|
|
4169
|
+
},
|
|
4170
|
+
/**
|
|
4171
|
+
* Watch Unstake events
|
|
4172
|
+
* @param callback Function to call when event is emitted
|
|
4173
|
+
* @param filter Optional filter for indexed parameters
|
|
4174
|
+
* @returns Unwatch function to stop listening
|
|
4175
|
+
*/
|
|
4176
|
+
Unstake: (callback: (event: { tokenId: bigint; stakedAtTimestamp: bigint; removedFromStakeAtTimestamp: bigint }) => void, filter?: { tokenId?: bigint | bigint[] | null }) => {
|
|
4177
|
+
return this.publicClient.watchContractEvent({
|
|
4178
|
+
address: this.contractAddress,
|
|
4179
|
+
abi: YogapetzAbi,
|
|
4180
|
+
eventName: 'Unstake',
|
|
4181
|
+
args: filter as any,
|
|
4182
|
+
onLogs: (logs: any[]) => {
|
|
4183
|
+
logs.forEach((log: any) => {
|
|
4184
|
+
callback(log.args as any);
|
|
4185
|
+
});
|
|
4186
|
+
},
|
|
4187
|
+
}) as () => void;
|
|
4188
|
+
}
|
|
4189
|
+
};
|
|
4190
|
+
}
|
|
4191
|
+
}
|