@gitmyabi/land 1.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +108 -0
- package/contracts/Land_json.d.ts +2110 -0
- package/contracts/Land_json.js +2249 -0
- package/contracts/Land_json.ts +2787 -0
- package/contracts/TransparentUpgradeableProxy_json.d.ts +380 -0
- package/contracts/TransparentUpgradeableProxy_json.js +366 -0
- package/contracts/TransparentUpgradeableProxy_json.ts +510 -0
- package/contracts/index.d.ts +4 -0
- package/contracts/index.js +10 -0
- package/contracts/index.ts +5 -0
- package/index.d.ts +1 -0
- package/index.js +19 -0
- package/package.json +43 -0
|
@@ -0,0 +1,2249 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.Land_json = exports.Land_jsonAbi = void 0;
|
|
4
|
+
const viem_1 = require("viem");
|
|
5
|
+
/**
|
|
6
|
+
* Land_json ABI
|
|
7
|
+
*
|
|
8
|
+
* This ABI is typed using viem's type system for full type safety.
|
|
9
|
+
*/
|
|
10
|
+
exports.Land_jsonAbi = [
|
|
11
|
+
{
|
|
12
|
+
"inputs": [
|
|
13
|
+
{
|
|
14
|
+
"internalType": "uint256",
|
|
15
|
+
"name": "tokenId",
|
|
16
|
+
"type": "uint256"
|
|
17
|
+
}
|
|
18
|
+
],
|
|
19
|
+
"name": "AlreadyMinted",
|
|
20
|
+
"type": "error"
|
|
21
|
+
},
|
|
22
|
+
{
|
|
23
|
+
"inputs": [
|
|
24
|
+
{
|
|
25
|
+
"internalType": "address",
|
|
26
|
+
"name": "sender",
|
|
27
|
+
"type": "address"
|
|
28
|
+
},
|
|
29
|
+
{
|
|
30
|
+
"internalType": "uint256",
|
|
31
|
+
"name": "tokenId",
|
|
32
|
+
"type": "uint256"
|
|
33
|
+
},
|
|
34
|
+
{
|
|
35
|
+
"internalType": "address",
|
|
36
|
+
"name": "owner",
|
|
37
|
+
"type": "address"
|
|
38
|
+
}
|
|
39
|
+
],
|
|
40
|
+
"name": "ERC721IncorrectOwner",
|
|
41
|
+
"type": "error"
|
|
42
|
+
},
|
|
43
|
+
{
|
|
44
|
+
"inputs": [
|
|
45
|
+
{
|
|
46
|
+
"internalType": "address",
|
|
47
|
+
"name": "operator",
|
|
48
|
+
"type": "address"
|
|
49
|
+
},
|
|
50
|
+
{
|
|
51
|
+
"internalType": "uint256",
|
|
52
|
+
"name": "tokenId",
|
|
53
|
+
"type": "uint256"
|
|
54
|
+
}
|
|
55
|
+
],
|
|
56
|
+
"name": "ERC721InsufficientApproval",
|
|
57
|
+
"type": "error"
|
|
58
|
+
},
|
|
59
|
+
{
|
|
60
|
+
"inputs": [
|
|
61
|
+
{
|
|
62
|
+
"internalType": "address",
|
|
63
|
+
"name": "approver",
|
|
64
|
+
"type": "address"
|
|
65
|
+
}
|
|
66
|
+
],
|
|
67
|
+
"name": "ERC721InvalidApprover",
|
|
68
|
+
"type": "error"
|
|
69
|
+
},
|
|
70
|
+
{
|
|
71
|
+
"inputs": [
|
|
72
|
+
{
|
|
73
|
+
"internalType": "address",
|
|
74
|
+
"name": "operator",
|
|
75
|
+
"type": "address"
|
|
76
|
+
}
|
|
77
|
+
],
|
|
78
|
+
"name": "ERC721InvalidOperator",
|
|
79
|
+
"type": "error"
|
|
80
|
+
},
|
|
81
|
+
{
|
|
82
|
+
"inputs": [
|
|
83
|
+
{
|
|
84
|
+
"internalType": "address",
|
|
85
|
+
"name": "owner",
|
|
86
|
+
"type": "address"
|
|
87
|
+
}
|
|
88
|
+
],
|
|
89
|
+
"name": "ERC721InvalidOwner",
|
|
90
|
+
"type": "error"
|
|
91
|
+
},
|
|
92
|
+
{
|
|
93
|
+
"inputs": [
|
|
94
|
+
{
|
|
95
|
+
"internalType": "address",
|
|
96
|
+
"name": "receiver",
|
|
97
|
+
"type": "address"
|
|
98
|
+
}
|
|
99
|
+
],
|
|
100
|
+
"name": "ERC721InvalidReceiver",
|
|
101
|
+
"type": "error"
|
|
102
|
+
},
|
|
103
|
+
{
|
|
104
|
+
"inputs": [
|
|
105
|
+
{
|
|
106
|
+
"internalType": "address",
|
|
107
|
+
"name": "sender",
|
|
108
|
+
"type": "address"
|
|
109
|
+
}
|
|
110
|
+
],
|
|
111
|
+
"name": "ERC721InvalidSender",
|
|
112
|
+
"type": "error"
|
|
113
|
+
},
|
|
114
|
+
{
|
|
115
|
+
"inputs": [
|
|
116
|
+
{
|
|
117
|
+
"internalType": "uint256",
|
|
118
|
+
"name": "tokenId",
|
|
119
|
+
"type": "uint256"
|
|
120
|
+
}
|
|
121
|
+
],
|
|
122
|
+
"name": "ERC721NonexistentToken",
|
|
123
|
+
"type": "error"
|
|
124
|
+
},
|
|
125
|
+
{
|
|
126
|
+
"inputs": [],
|
|
127
|
+
"name": "InvalidAddress",
|
|
128
|
+
"type": "error"
|
|
129
|
+
},
|
|
130
|
+
{
|
|
131
|
+
"inputs": [],
|
|
132
|
+
"name": "InvalidArgument",
|
|
133
|
+
"type": "error"
|
|
134
|
+
},
|
|
135
|
+
{
|
|
136
|
+
"inputs": [
|
|
137
|
+
{
|
|
138
|
+
"internalType": "uint256",
|
|
139
|
+
"name": "size",
|
|
140
|
+
"type": "uint256"
|
|
141
|
+
},
|
|
142
|
+
{
|
|
143
|
+
"internalType": "uint256",
|
|
144
|
+
"name": "x",
|
|
145
|
+
"type": "uint256"
|
|
146
|
+
},
|
|
147
|
+
{
|
|
148
|
+
"internalType": "uint256",
|
|
149
|
+
"name": "y",
|
|
150
|
+
"type": "uint256"
|
|
151
|
+
}
|
|
152
|
+
],
|
|
153
|
+
"name": "InvalidCoordinates",
|
|
154
|
+
"type": "error"
|
|
155
|
+
},
|
|
156
|
+
{
|
|
157
|
+
"inputs": [],
|
|
158
|
+
"name": "InvalidInitialization",
|
|
159
|
+
"type": "error"
|
|
160
|
+
},
|
|
161
|
+
{
|
|
162
|
+
"inputs": [],
|
|
163
|
+
"name": "InvalidLength",
|
|
164
|
+
"type": "error"
|
|
165
|
+
},
|
|
166
|
+
{
|
|
167
|
+
"inputs": [],
|
|
168
|
+
"name": "NotInitializing",
|
|
169
|
+
"type": "error"
|
|
170
|
+
},
|
|
171
|
+
{
|
|
172
|
+
"inputs": [
|
|
173
|
+
{
|
|
174
|
+
"internalType": "uint256",
|
|
175
|
+
"name": "x",
|
|
176
|
+
"type": "uint256"
|
|
177
|
+
},
|
|
178
|
+
{
|
|
179
|
+
"internalType": "uint256",
|
|
180
|
+
"name": "y",
|
|
181
|
+
"type": "uint256"
|
|
182
|
+
}
|
|
183
|
+
],
|
|
184
|
+
"name": "NotOwner",
|
|
185
|
+
"type": "error"
|
|
186
|
+
},
|
|
187
|
+
{
|
|
188
|
+
"inputs": [],
|
|
189
|
+
"name": "OnlyAdmin",
|
|
190
|
+
"type": "error"
|
|
191
|
+
},
|
|
192
|
+
{
|
|
193
|
+
"inputs": [],
|
|
194
|
+
"name": "OperatorNotAllowed",
|
|
195
|
+
"type": "error"
|
|
196
|
+
},
|
|
197
|
+
{
|
|
198
|
+
"anonymous": false,
|
|
199
|
+
"inputs": [
|
|
200
|
+
{
|
|
201
|
+
"indexed": true,
|
|
202
|
+
"internalType": "address",
|
|
203
|
+
"name": "oldAdmin",
|
|
204
|
+
"type": "address"
|
|
205
|
+
},
|
|
206
|
+
{
|
|
207
|
+
"indexed": true,
|
|
208
|
+
"internalType": "address",
|
|
209
|
+
"name": "newAdmin",
|
|
210
|
+
"type": "address"
|
|
211
|
+
}
|
|
212
|
+
],
|
|
213
|
+
"name": "AdminChanged",
|
|
214
|
+
"type": "event"
|
|
215
|
+
},
|
|
216
|
+
{
|
|
217
|
+
"anonymous": false,
|
|
218
|
+
"inputs": [
|
|
219
|
+
{
|
|
220
|
+
"indexed": true,
|
|
221
|
+
"internalType": "address",
|
|
222
|
+
"name": "owner",
|
|
223
|
+
"type": "address"
|
|
224
|
+
},
|
|
225
|
+
{
|
|
226
|
+
"indexed": true,
|
|
227
|
+
"internalType": "address",
|
|
228
|
+
"name": "approved",
|
|
229
|
+
"type": "address"
|
|
230
|
+
},
|
|
231
|
+
{
|
|
232
|
+
"indexed": true,
|
|
233
|
+
"internalType": "uint256",
|
|
234
|
+
"name": "tokenId",
|
|
235
|
+
"type": "uint256"
|
|
236
|
+
}
|
|
237
|
+
],
|
|
238
|
+
"name": "Approval",
|
|
239
|
+
"type": "event"
|
|
240
|
+
},
|
|
241
|
+
{
|
|
242
|
+
"anonymous": false,
|
|
243
|
+
"inputs": [
|
|
244
|
+
{
|
|
245
|
+
"indexed": true,
|
|
246
|
+
"internalType": "address",
|
|
247
|
+
"name": "owner",
|
|
248
|
+
"type": "address"
|
|
249
|
+
},
|
|
250
|
+
{
|
|
251
|
+
"indexed": true,
|
|
252
|
+
"internalType": "address",
|
|
253
|
+
"name": "operator",
|
|
254
|
+
"type": "address"
|
|
255
|
+
},
|
|
256
|
+
{
|
|
257
|
+
"indexed": false,
|
|
258
|
+
"internalType": "bool",
|
|
259
|
+
"name": "approved",
|
|
260
|
+
"type": "bool"
|
|
261
|
+
}
|
|
262
|
+
],
|
|
263
|
+
"name": "ApprovalForAll",
|
|
264
|
+
"type": "event"
|
|
265
|
+
},
|
|
266
|
+
{
|
|
267
|
+
"anonymous": false,
|
|
268
|
+
"inputs": [
|
|
269
|
+
{
|
|
270
|
+
"indexed": true,
|
|
271
|
+
"internalType": "address",
|
|
272
|
+
"name": "subscriptionOrRegistrant",
|
|
273
|
+
"type": "address"
|
|
274
|
+
},
|
|
275
|
+
{
|
|
276
|
+
"indexed": false,
|
|
277
|
+
"internalType": "bool",
|
|
278
|
+
"name": "subscribe",
|
|
279
|
+
"type": "bool"
|
|
280
|
+
}
|
|
281
|
+
],
|
|
282
|
+
"name": "ContractRegistered",
|
|
283
|
+
"type": "event"
|
|
284
|
+
},
|
|
285
|
+
{
|
|
286
|
+
"anonymous": false,
|
|
287
|
+
"inputs": [
|
|
288
|
+
{
|
|
289
|
+
"indexed": false,
|
|
290
|
+
"internalType": "uint64",
|
|
291
|
+
"name": "version",
|
|
292
|
+
"type": "uint64"
|
|
293
|
+
}
|
|
294
|
+
],
|
|
295
|
+
"name": "Initialized",
|
|
296
|
+
"type": "event"
|
|
297
|
+
},
|
|
298
|
+
{
|
|
299
|
+
"anonymous": false,
|
|
300
|
+
"inputs": [
|
|
301
|
+
{
|
|
302
|
+
"indexed": true,
|
|
303
|
+
"internalType": "address",
|
|
304
|
+
"name": "metadataRegistry",
|
|
305
|
+
"type": "address"
|
|
306
|
+
}
|
|
307
|
+
],
|
|
308
|
+
"name": "MetadataRegistrySet",
|
|
309
|
+
"type": "event"
|
|
310
|
+
},
|
|
311
|
+
{
|
|
312
|
+
"anonymous": false,
|
|
313
|
+
"inputs": [
|
|
314
|
+
{
|
|
315
|
+
"indexed": true,
|
|
316
|
+
"internalType": "address",
|
|
317
|
+
"name": "minter",
|
|
318
|
+
"type": "address"
|
|
319
|
+
},
|
|
320
|
+
{
|
|
321
|
+
"indexed": false,
|
|
322
|
+
"internalType": "bool",
|
|
323
|
+
"name": "enabled",
|
|
324
|
+
"type": "bool"
|
|
325
|
+
}
|
|
326
|
+
],
|
|
327
|
+
"name": "Minter",
|
|
328
|
+
"type": "event"
|
|
329
|
+
},
|
|
330
|
+
{
|
|
331
|
+
"anonymous": false,
|
|
332
|
+
"inputs": [
|
|
333
|
+
{
|
|
334
|
+
"indexed": true,
|
|
335
|
+
"internalType": "contract IOperatorFilterRegistry",
|
|
336
|
+
"name": "registry",
|
|
337
|
+
"type": "address"
|
|
338
|
+
}
|
|
339
|
+
],
|
|
340
|
+
"name": "OperatorRegistrySet",
|
|
341
|
+
"type": "event"
|
|
342
|
+
},
|
|
343
|
+
{
|
|
344
|
+
"anonymous": false,
|
|
345
|
+
"inputs": [
|
|
346
|
+
{
|
|
347
|
+
"indexed": true,
|
|
348
|
+
"internalType": "address",
|
|
349
|
+
"name": "previousOwner",
|
|
350
|
+
"type": "address"
|
|
351
|
+
},
|
|
352
|
+
{
|
|
353
|
+
"indexed": true,
|
|
354
|
+
"internalType": "address",
|
|
355
|
+
"name": "newOwner",
|
|
356
|
+
"type": "address"
|
|
357
|
+
}
|
|
358
|
+
],
|
|
359
|
+
"name": "OwnershipTransferred",
|
|
360
|
+
"type": "event"
|
|
361
|
+
},
|
|
362
|
+
{
|
|
363
|
+
"anonymous": false,
|
|
364
|
+
"inputs": [
|
|
365
|
+
{
|
|
366
|
+
"indexed": true,
|
|
367
|
+
"internalType": "address",
|
|
368
|
+
"name": "royaltyManager",
|
|
369
|
+
"type": "address"
|
|
370
|
+
}
|
|
371
|
+
],
|
|
372
|
+
"name": "RoyaltyManagerSet",
|
|
373
|
+
"type": "event"
|
|
374
|
+
},
|
|
375
|
+
{
|
|
376
|
+
"anonymous": false,
|
|
377
|
+
"inputs": [
|
|
378
|
+
{
|
|
379
|
+
"indexed": true,
|
|
380
|
+
"internalType": "address",
|
|
381
|
+
"name": "superOperator",
|
|
382
|
+
"type": "address"
|
|
383
|
+
},
|
|
384
|
+
{
|
|
385
|
+
"indexed": true,
|
|
386
|
+
"internalType": "bool",
|
|
387
|
+
"name": "enabled",
|
|
388
|
+
"type": "bool"
|
|
389
|
+
}
|
|
390
|
+
],
|
|
391
|
+
"name": "SuperOperator",
|
|
392
|
+
"type": "event"
|
|
393
|
+
},
|
|
394
|
+
{
|
|
395
|
+
"anonymous": false,
|
|
396
|
+
"inputs": [
|
|
397
|
+
{
|
|
398
|
+
"indexed": true,
|
|
399
|
+
"internalType": "address",
|
|
400
|
+
"name": "from",
|
|
401
|
+
"type": "address"
|
|
402
|
+
},
|
|
403
|
+
{
|
|
404
|
+
"indexed": true,
|
|
405
|
+
"internalType": "address",
|
|
406
|
+
"name": "to",
|
|
407
|
+
"type": "address"
|
|
408
|
+
},
|
|
409
|
+
{
|
|
410
|
+
"indexed": true,
|
|
411
|
+
"internalType": "uint256",
|
|
412
|
+
"name": "tokenId",
|
|
413
|
+
"type": "uint256"
|
|
414
|
+
}
|
|
415
|
+
],
|
|
416
|
+
"name": "Transfer",
|
|
417
|
+
"type": "event"
|
|
418
|
+
},
|
|
419
|
+
{
|
|
420
|
+
"inputs": [
|
|
421
|
+
{
|
|
422
|
+
"internalType": "address",
|
|
423
|
+
"name": "operator",
|
|
424
|
+
"type": "address"
|
|
425
|
+
},
|
|
426
|
+
{
|
|
427
|
+
"internalType": "uint256",
|
|
428
|
+
"name": "tokenId",
|
|
429
|
+
"type": "uint256"
|
|
430
|
+
}
|
|
431
|
+
],
|
|
432
|
+
"name": "approve",
|
|
433
|
+
"outputs": [],
|
|
434
|
+
"stateMutability": "nonpayable",
|
|
435
|
+
"type": "function"
|
|
436
|
+
},
|
|
437
|
+
{
|
|
438
|
+
"inputs": [
|
|
439
|
+
{
|
|
440
|
+
"internalType": "address",
|
|
441
|
+
"name": "sender",
|
|
442
|
+
"type": "address"
|
|
443
|
+
},
|
|
444
|
+
{
|
|
445
|
+
"internalType": "address",
|
|
446
|
+
"name": "operator",
|
|
447
|
+
"type": "address"
|
|
448
|
+
},
|
|
449
|
+
{
|
|
450
|
+
"internalType": "uint256",
|
|
451
|
+
"name": "tokenId",
|
|
452
|
+
"type": "uint256"
|
|
453
|
+
}
|
|
454
|
+
],
|
|
455
|
+
"name": "approveFor",
|
|
456
|
+
"outputs": [],
|
|
457
|
+
"stateMutability": "nonpayable",
|
|
458
|
+
"type": "function"
|
|
459
|
+
},
|
|
460
|
+
{
|
|
461
|
+
"inputs": [
|
|
462
|
+
{
|
|
463
|
+
"internalType": "address",
|
|
464
|
+
"name": "owner",
|
|
465
|
+
"type": "address"
|
|
466
|
+
}
|
|
467
|
+
],
|
|
468
|
+
"name": "balanceOf",
|
|
469
|
+
"outputs": [
|
|
470
|
+
{
|
|
471
|
+
"internalType": "uint256",
|
|
472
|
+
"name": "",
|
|
473
|
+
"type": "uint256"
|
|
474
|
+
}
|
|
475
|
+
],
|
|
476
|
+
"stateMutability": "view",
|
|
477
|
+
"type": "function"
|
|
478
|
+
},
|
|
479
|
+
{
|
|
480
|
+
"inputs": [
|
|
481
|
+
{
|
|
482
|
+
"internalType": "address",
|
|
483
|
+
"name": "from",
|
|
484
|
+
"type": "address"
|
|
485
|
+
},
|
|
486
|
+
{
|
|
487
|
+
"internalType": "address",
|
|
488
|
+
"name": "to",
|
|
489
|
+
"type": "address"
|
|
490
|
+
},
|
|
491
|
+
{
|
|
492
|
+
"internalType": "uint256[]",
|
|
493
|
+
"name": "ids",
|
|
494
|
+
"type": "uint256[]"
|
|
495
|
+
},
|
|
496
|
+
{
|
|
497
|
+
"internalType": "bytes",
|
|
498
|
+
"name": "data",
|
|
499
|
+
"type": "bytes"
|
|
500
|
+
}
|
|
501
|
+
],
|
|
502
|
+
"name": "batchTransferFrom",
|
|
503
|
+
"outputs": [],
|
|
504
|
+
"stateMutability": "nonpayable",
|
|
505
|
+
"type": "function"
|
|
506
|
+
},
|
|
507
|
+
{
|
|
508
|
+
"inputs": [
|
|
509
|
+
{
|
|
510
|
+
"internalType": "address",
|
|
511
|
+
"name": "from",
|
|
512
|
+
"type": "address"
|
|
513
|
+
},
|
|
514
|
+
{
|
|
515
|
+
"internalType": "address",
|
|
516
|
+
"name": "to",
|
|
517
|
+
"type": "address"
|
|
518
|
+
},
|
|
519
|
+
{
|
|
520
|
+
"internalType": "uint256[]",
|
|
521
|
+
"name": "sizes",
|
|
522
|
+
"type": "uint256[]"
|
|
523
|
+
},
|
|
524
|
+
{
|
|
525
|
+
"internalType": "uint256[]",
|
|
526
|
+
"name": "xs",
|
|
527
|
+
"type": "uint256[]"
|
|
528
|
+
},
|
|
529
|
+
{
|
|
530
|
+
"internalType": "uint256[]",
|
|
531
|
+
"name": "ys",
|
|
532
|
+
"type": "uint256[]"
|
|
533
|
+
},
|
|
534
|
+
{
|
|
535
|
+
"internalType": "bytes",
|
|
536
|
+
"name": "data",
|
|
537
|
+
"type": "bytes"
|
|
538
|
+
}
|
|
539
|
+
],
|
|
540
|
+
"name": "batchTransferQuad",
|
|
541
|
+
"outputs": [],
|
|
542
|
+
"stateMutability": "nonpayable",
|
|
543
|
+
"type": "function"
|
|
544
|
+
},
|
|
545
|
+
{
|
|
546
|
+
"inputs": [
|
|
547
|
+
{
|
|
548
|
+
"internalType": "address",
|
|
549
|
+
"name": "newAdmin",
|
|
550
|
+
"type": "address"
|
|
551
|
+
}
|
|
552
|
+
],
|
|
553
|
+
"name": "changeAdmin",
|
|
554
|
+
"outputs": [],
|
|
555
|
+
"stateMutability": "nonpayable",
|
|
556
|
+
"type": "function"
|
|
557
|
+
},
|
|
558
|
+
{
|
|
559
|
+
"inputs": [
|
|
560
|
+
{
|
|
561
|
+
"internalType": "uint256",
|
|
562
|
+
"name": "size",
|
|
563
|
+
"type": "uint256"
|
|
564
|
+
},
|
|
565
|
+
{
|
|
566
|
+
"internalType": "uint256",
|
|
567
|
+
"name": "x",
|
|
568
|
+
"type": "uint256"
|
|
569
|
+
},
|
|
570
|
+
{
|
|
571
|
+
"internalType": "uint256",
|
|
572
|
+
"name": "y",
|
|
573
|
+
"type": "uint256"
|
|
574
|
+
}
|
|
575
|
+
],
|
|
576
|
+
"name": "exists",
|
|
577
|
+
"outputs": [
|
|
578
|
+
{
|
|
579
|
+
"internalType": "bool",
|
|
580
|
+
"name": "",
|
|
581
|
+
"type": "bool"
|
|
582
|
+
}
|
|
583
|
+
],
|
|
584
|
+
"stateMutability": "view",
|
|
585
|
+
"type": "function"
|
|
586
|
+
},
|
|
587
|
+
{
|
|
588
|
+
"inputs": [],
|
|
589
|
+
"name": "getAdmin",
|
|
590
|
+
"outputs": [
|
|
591
|
+
{
|
|
592
|
+
"internalType": "address",
|
|
593
|
+
"name": "",
|
|
594
|
+
"type": "address"
|
|
595
|
+
}
|
|
596
|
+
],
|
|
597
|
+
"stateMutability": "view",
|
|
598
|
+
"type": "function"
|
|
599
|
+
},
|
|
600
|
+
{
|
|
601
|
+
"inputs": [
|
|
602
|
+
{
|
|
603
|
+
"internalType": "uint256",
|
|
604
|
+
"name": "tokenId",
|
|
605
|
+
"type": "uint256"
|
|
606
|
+
}
|
|
607
|
+
],
|
|
608
|
+
"name": "getApproved",
|
|
609
|
+
"outputs": [
|
|
610
|
+
{
|
|
611
|
+
"internalType": "address",
|
|
612
|
+
"name": "",
|
|
613
|
+
"type": "address"
|
|
614
|
+
}
|
|
615
|
+
],
|
|
616
|
+
"stateMutability": "view",
|
|
617
|
+
"type": "function"
|
|
618
|
+
},
|
|
619
|
+
{
|
|
620
|
+
"inputs": [
|
|
621
|
+
{
|
|
622
|
+
"internalType": "uint256",
|
|
623
|
+
"name": "tokenId",
|
|
624
|
+
"type": "uint256"
|
|
625
|
+
}
|
|
626
|
+
],
|
|
627
|
+
"name": "getMetadata",
|
|
628
|
+
"outputs": [
|
|
629
|
+
{
|
|
630
|
+
"internalType": "bool",
|
|
631
|
+
"name": "",
|
|
632
|
+
"type": "bool"
|
|
633
|
+
},
|
|
634
|
+
{
|
|
635
|
+
"internalType": "uint256",
|
|
636
|
+
"name": "",
|
|
637
|
+
"type": "uint256"
|
|
638
|
+
},
|
|
639
|
+
{
|
|
640
|
+
"internalType": "string",
|
|
641
|
+
"name": "",
|
|
642
|
+
"type": "string"
|
|
643
|
+
}
|
|
644
|
+
],
|
|
645
|
+
"stateMutability": "view",
|
|
646
|
+
"type": "function"
|
|
647
|
+
},
|
|
648
|
+
{
|
|
649
|
+
"inputs": [],
|
|
650
|
+
"name": "getMetadataRegistry",
|
|
651
|
+
"outputs": [
|
|
652
|
+
{
|
|
653
|
+
"internalType": "contract ILandMetadataRegistry",
|
|
654
|
+
"name": "",
|
|
655
|
+
"type": "address"
|
|
656
|
+
}
|
|
657
|
+
],
|
|
658
|
+
"stateMutability": "view",
|
|
659
|
+
"type": "function"
|
|
660
|
+
},
|
|
661
|
+
{
|
|
662
|
+
"inputs": [
|
|
663
|
+
{
|
|
664
|
+
"internalType": "uint256",
|
|
665
|
+
"name": "tokenId",
|
|
666
|
+
"type": "uint256"
|
|
667
|
+
}
|
|
668
|
+
],
|
|
669
|
+
"name": "getNeighborhoodId",
|
|
670
|
+
"outputs": [
|
|
671
|
+
{
|
|
672
|
+
"internalType": "uint256",
|
|
673
|
+
"name": "",
|
|
674
|
+
"type": "uint256"
|
|
675
|
+
}
|
|
676
|
+
],
|
|
677
|
+
"stateMutability": "view",
|
|
678
|
+
"type": "function"
|
|
679
|
+
},
|
|
680
|
+
{
|
|
681
|
+
"inputs": [
|
|
682
|
+
{
|
|
683
|
+
"internalType": "uint256",
|
|
684
|
+
"name": "tokenId",
|
|
685
|
+
"type": "uint256"
|
|
686
|
+
}
|
|
687
|
+
],
|
|
688
|
+
"name": "getOwnerData",
|
|
689
|
+
"outputs": [
|
|
690
|
+
{
|
|
691
|
+
"internalType": "uint256",
|
|
692
|
+
"name": "",
|
|
693
|
+
"type": "uint256"
|
|
694
|
+
}
|
|
695
|
+
],
|
|
696
|
+
"stateMutability": "view",
|
|
697
|
+
"type": "function"
|
|
698
|
+
},
|
|
699
|
+
{
|
|
700
|
+
"inputs": [],
|
|
701
|
+
"name": "getRoyaltyManager",
|
|
702
|
+
"outputs": [
|
|
703
|
+
{
|
|
704
|
+
"internalType": "contract IRoyaltyManager",
|
|
705
|
+
"name": "",
|
|
706
|
+
"type": "address"
|
|
707
|
+
}
|
|
708
|
+
],
|
|
709
|
+
"stateMutability": "view",
|
|
710
|
+
"type": "function"
|
|
711
|
+
},
|
|
712
|
+
{
|
|
713
|
+
"inputs": [
|
|
714
|
+
{
|
|
715
|
+
"internalType": "uint256",
|
|
716
|
+
"name": "tokenId",
|
|
717
|
+
"type": "uint256"
|
|
718
|
+
}
|
|
719
|
+
],
|
|
720
|
+
"name": "getX",
|
|
721
|
+
"outputs": [
|
|
722
|
+
{
|
|
723
|
+
"internalType": "uint256",
|
|
724
|
+
"name": "",
|
|
725
|
+
"type": "uint256"
|
|
726
|
+
}
|
|
727
|
+
],
|
|
728
|
+
"stateMutability": "pure",
|
|
729
|
+
"type": "function"
|
|
730
|
+
},
|
|
731
|
+
{
|
|
732
|
+
"inputs": [
|
|
733
|
+
{
|
|
734
|
+
"internalType": "uint256",
|
|
735
|
+
"name": "tokenId",
|
|
736
|
+
"type": "uint256"
|
|
737
|
+
}
|
|
738
|
+
],
|
|
739
|
+
"name": "getY",
|
|
740
|
+
"outputs": [
|
|
741
|
+
{
|
|
742
|
+
"internalType": "uint256",
|
|
743
|
+
"name": "",
|
|
744
|
+
"type": "uint256"
|
|
745
|
+
}
|
|
746
|
+
],
|
|
747
|
+
"stateMutability": "pure",
|
|
748
|
+
"type": "function"
|
|
749
|
+
},
|
|
750
|
+
{
|
|
751
|
+
"inputs": [],
|
|
752
|
+
"name": "height",
|
|
753
|
+
"outputs": [
|
|
754
|
+
{
|
|
755
|
+
"internalType": "uint256",
|
|
756
|
+
"name": "",
|
|
757
|
+
"type": "uint256"
|
|
758
|
+
}
|
|
759
|
+
],
|
|
760
|
+
"stateMutability": "pure",
|
|
761
|
+
"type": "function"
|
|
762
|
+
},
|
|
763
|
+
{
|
|
764
|
+
"inputs": [
|
|
765
|
+
{
|
|
766
|
+
"internalType": "address",
|
|
767
|
+
"name": "admin",
|
|
768
|
+
"type": "address"
|
|
769
|
+
}
|
|
770
|
+
],
|
|
771
|
+
"name": "initialize",
|
|
772
|
+
"outputs": [],
|
|
773
|
+
"stateMutability": "nonpayable",
|
|
774
|
+
"type": "function"
|
|
775
|
+
},
|
|
776
|
+
{
|
|
777
|
+
"inputs": [
|
|
778
|
+
{
|
|
779
|
+
"internalType": "address",
|
|
780
|
+
"name": "owner",
|
|
781
|
+
"type": "address"
|
|
782
|
+
},
|
|
783
|
+
{
|
|
784
|
+
"internalType": "address",
|
|
785
|
+
"name": "operator",
|
|
786
|
+
"type": "address"
|
|
787
|
+
}
|
|
788
|
+
],
|
|
789
|
+
"name": "isApprovedForAll",
|
|
790
|
+
"outputs": [
|
|
791
|
+
{
|
|
792
|
+
"internalType": "bool",
|
|
793
|
+
"name": "",
|
|
794
|
+
"type": "bool"
|
|
795
|
+
}
|
|
796
|
+
],
|
|
797
|
+
"stateMutability": "view",
|
|
798
|
+
"type": "function"
|
|
799
|
+
},
|
|
800
|
+
{
|
|
801
|
+
"inputs": [
|
|
802
|
+
{
|
|
803
|
+
"internalType": "address",
|
|
804
|
+
"name": "who",
|
|
805
|
+
"type": "address"
|
|
806
|
+
}
|
|
807
|
+
],
|
|
808
|
+
"name": "isMinter",
|
|
809
|
+
"outputs": [
|
|
810
|
+
{
|
|
811
|
+
"internalType": "bool",
|
|
812
|
+
"name": "",
|
|
813
|
+
"type": "bool"
|
|
814
|
+
}
|
|
815
|
+
],
|
|
816
|
+
"stateMutability": "view",
|
|
817
|
+
"type": "function"
|
|
818
|
+
},
|
|
819
|
+
{
|
|
820
|
+
"inputs": [
|
|
821
|
+
{
|
|
822
|
+
"internalType": "uint256",
|
|
823
|
+
"name": "tokenId",
|
|
824
|
+
"type": "uint256"
|
|
825
|
+
}
|
|
826
|
+
],
|
|
827
|
+
"name": "isPremium",
|
|
828
|
+
"outputs": [
|
|
829
|
+
{
|
|
830
|
+
"internalType": "bool",
|
|
831
|
+
"name": "",
|
|
832
|
+
"type": "bool"
|
|
833
|
+
}
|
|
834
|
+
],
|
|
835
|
+
"stateMutability": "view",
|
|
836
|
+
"type": "function"
|
|
837
|
+
},
|
|
838
|
+
{
|
|
839
|
+
"inputs": [
|
|
840
|
+
{
|
|
841
|
+
"internalType": "address",
|
|
842
|
+
"name": "superOperator",
|
|
843
|
+
"type": "address"
|
|
844
|
+
}
|
|
845
|
+
],
|
|
846
|
+
"name": "isSuperOperator",
|
|
847
|
+
"outputs": [
|
|
848
|
+
{
|
|
849
|
+
"internalType": "bool",
|
|
850
|
+
"name": "",
|
|
851
|
+
"type": "bool"
|
|
852
|
+
}
|
|
853
|
+
],
|
|
854
|
+
"stateMutability": "view",
|
|
855
|
+
"type": "function"
|
|
856
|
+
},
|
|
857
|
+
{
|
|
858
|
+
"inputs": [
|
|
859
|
+
{
|
|
860
|
+
"internalType": "address",
|
|
861
|
+
"name": "to",
|
|
862
|
+
"type": "address"
|
|
863
|
+
},
|
|
864
|
+
{
|
|
865
|
+
"internalType": "uint256",
|
|
866
|
+
"name": "size",
|
|
867
|
+
"type": "uint256"
|
|
868
|
+
},
|
|
869
|
+
{
|
|
870
|
+
"internalType": "uint256",
|
|
871
|
+
"name": "x",
|
|
872
|
+
"type": "uint256"
|
|
873
|
+
},
|
|
874
|
+
{
|
|
875
|
+
"internalType": "uint256",
|
|
876
|
+
"name": "y",
|
|
877
|
+
"type": "uint256"
|
|
878
|
+
},
|
|
879
|
+
{
|
|
880
|
+
"internalType": "bytes",
|
|
881
|
+
"name": "data",
|
|
882
|
+
"type": "bytes"
|
|
883
|
+
}
|
|
884
|
+
],
|
|
885
|
+
"name": "mintAndTransferQuad",
|
|
886
|
+
"outputs": [],
|
|
887
|
+
"stateMutability": "nonpayable",
|
|
888
|
+
"type": "function"
|
|
889
|
+
},
|
|
890
|
+
{
|
|
891
|
+
"inputs": [
|
|
892
|
+
{
|
|
893
|
+
"internalType": "address",
|
|
894
|
+
"name": "to",
|
|
895
|
+
"type": "address"
|
|
896
|
+
},
|
|
897
|
+
{
|
|
898
|
+
"internalType": "uint256",
|
|
899
|
+
"name": "size",
|
|
900
|
+
"type": "uint256"
|
|
901
|
+
},
|
|
902
|
+
{
|
|
903
|
+
"internalType": "uint256",
|
|
904
|
+
"name": "x",
|
|
905
|
+
"type": "uint256"
|
|
906
|
+
},
|
|
907
|
+
{
|
|
908
|
+
"internalType": "uint256",
|
|
909
|
+
"name": "y",
|
|
910
|
+
"type": "uint256"
|
|
911
|
+
},
|
|
912
|
+
{
|
|
913
|
+
"internalType": "bytes",
|
|
914
|
+
"name": "data",
|
|
915
|
+
"type": "bytes"
|
|
916
|
+
}
|
|
917
|
+
],
|
|
918
|
+
"name": "mintQuad",
|
|
919
|
+
"outputs": [],
|
|
920
|
+
"stateMutability": "nonpayable",
|
|
921
|
+
"type": "function"
|
|
922
|
+
},
|
|
923
|
+
{
|
|
924
|
+
"inputs": [],
|
|
925
|
+
"name": "name",
|
|
926
|
+
"outputs": [
|
|
927
|
+
{
|
|
928
|
+
"internalType": "string",
|
|
929
|
+
"name": "",
|
|
930
|
+
"type": "string"
|
|
931
|
+
}
|
|
932
|
+
],
|
|
933
|
+
"stateMutability": "pure",
|
|
934
|
+
"type": "function"
|
|
935
|
+
},
|
|
936
|
+
{
|
|
937
|
+
"inputs": [],
|
|
938
|
+
"name": "operatorFilterRegistry",
|
|
939
|
+
"outputs": [
|
|
940
|
+
{
|
|
941
|
+
"internalType": "contract IOperatorFilterRegistry",
|
|
942
|
+
"name": "",
|
|
943
|
+
"type": "address"
|
|
944
|
+
}
|
|
945
|
+
],
|
|
946
|
+
"stateMutability": "view",
|
|
947
|
+
"type": "function"
|
|
948
|
+
},
|
|
949
|
+
{
|
|
950
|
+
"inputs": [],
|
|
951
|
+
"name": "owner",
|
|
952
|
+
"outputs": [
|
|
953
|
+
{
|
|
954
|
+
"internalType": "address",
|
|
955
|
+
"name": "",
|
|
956
|
+
"type": "address"
|
|
957
|
+
}
|
|
958
|
+
],
|
|
959
|
+
"stateMutability": "view",
|
|
960
|
+
"type": "function"
|
|
961
|
+
},
|
|
962
|
+
{
|
|
963
|
+
"inputs": [
|
|
964
|
+
{
|
|
965
|
+
"internalType": "uint256",
|
|
966
|
+
"name": "tokenId",
|
|
967
|
+
"type": "uint256"
|
|
968
|
+
}
|
|
969
|
+
],
|
|
970
|
+
"name": "ownerOf",
|
|
971
|
+
"outputs": [
|
|
972
|
+
{
|
|
973
|
+
"internalType": "address",
|
|
974
|
+
"name": "owner",
|
|
975
|
+
"type": "address"
|
|
976
|
+
}
|
|
977
|
+
],
|
|
978
|
+
"stateMutability": "view",
|
|
979
|
+
"type": "function"
|
|
980
|
+
},
|
|
981
|
+
{
|
|
982
|
+
"inputs": [
|
|
983
|
+
{
|
|
984
|
+
"internalType": "address",
|
|
985
|
+
"name": "subscriptionOrRegistrantToCopy",
|
|
986
|
+
"type": "address"
|
|
987
|
+
},
|
|
988
|
+
{
|
|
989
|
+
"internalType": "bool",
|
|
990
|
+
"name": "subscribe",
|
|
991
|
+
"type": "bool"
|
|
992
|
+
}
|
|
993
|
+
],
|
|
994
|
+
"name": "register",
|
|
995
|
+
"outputs": [],
|
|
996
|
+
"stateMutability": "nonpayable",
|
|
997
|
+
"type": "function"
|
|
998
|
+
},
|
|
999
|
+
{
|
|
1000
|
+
"inputs": [
|
|
1001
|
+
{
|
|
1002
|
+
"internalType": "uint256",
|
|
1003
|
+
"name": "",
|
|
1004
|
+
"type": "uint256"
|
|
1005
|
+
},
|
|
1006
|
+
{
|
|
1007
|
+
"internalType": "uint256",
|
|
1008
|
+
"name": "salePrice",
|
|
1009
|
+
"type": "uint256"
|
|
1010
|
+
}
|
|
1011
|
+
],
|
|
1012
|
+
"name": "royaltyInfo",
|
|
1013
|
+
"outputs": [
|
|
1014
|
+
{
|
|
1015
|
+
"internalType": "address",
|
|
1016
|
+
"name": "receiver",
|
|
1017
|
+
"type": "address"
|
|
1018
|
+
},
|
|
1019
|
+
{
|
|
1020
|
+
"internalType": "uint256",
|
|
1021
|
+
"name": "royaltyAmount",
|
|
1022
|
+
"type": "uint256"
|
|
1023
|
+
}
|
|
1024
|
+
],
|
|
1025
|
+
"stateMutability": "view",
|
|
1026
|
+
"type": "function"
|
|
1027
|
+
},
|
|
1028
|
+
{
|
|
1029
|
+
"inputs": [
|
|
1030
|
+
{
|
|
1031
|
+
"internalType": "address",
|
|
1032
|
+
"name": "from",
|
|
1033
|
+
"type": "address"
|
|
1034
|
+
},
|
|
1035
|
+
{
|
|
1036
|
+
"internalType": "address",
|
|
1037
|
+
"name": "to",
|
|
1038
|
+
"type": "address"
|
|
1039
|
+
},
|
|
1040
|
+
{
|
|
1041
|
+
"internalType": "uint256[]",
|
|
1042
|
+
"name": "ids",
|
|
1043
|
+
"type": "uint256[]"
|
|
1044
|
+
},
|
|
1045
|
+
{
|
|
1046
|
+
"internalType": "bytes",
|
|
1047
|
+
"name": "data",
|
|
1048
|
+
"type": "bytes"
|
|
1049
|
+
}
|
|
1050
|
+
],
|
|
1051
|
+
"name": "safeBatchTransferFrom",
|
|
1052
|
+
"outputs": [],
|
|
1053
|
+
"stateMutability": "nonpayable",
|
|
1054
|
+
"type": "function"
|
|
1055
|
+
},
|
|
1056
|
+
{
|
|
1057
|
+
"inputs": [
|
|
1058
|
+
{
|
|
1059
|
+
"internalType": "address",
|
|
1060
|
+
"name": "from",
|
|
1061
|
+
"type": "address"
|
|
1062
|
+
},
|
|
1063
|
+
{
|
|
1064
|
+
"internalType": "address",
|
|
1065
|
+
"name": "to",
|
|
1066
|
+
"type": "address"
|
|
1067
|
+
},
|
|
1068
|
+
{
|
|
1069
|
+
"internalType": "uint256",
|
|
1070
|
+
"name": "tokenId",
|
|
1071
|
+
"type": "uint256"
|
|
1072
|
+
}
|
|
1073
|
+
],
|
|
1074
|
+
"name": "safeTransferFrom",
|
|
1075
|
+
"outputs": [],
|
|
1076
|
+
"stateMutability": "nonpayable",
|
|
1077
|
+
"type": "function"
|
|
1078
|
+
},
|
|
1079
|
+
{
|
|
1080
|
+
"inputs": [
|
|
1081
|
+
{
|
|
1082
|
+
"internalType": "address",
|
|
1083
|
+
"name": "from",
|
|
1084
|
+
"type": "address"
|
|
1085
|
+
},
|
|
1086
|
+
{
|
|
1087
|
+
"internalType": "address",
|
|
1088
|
+
"name": "to",
|
|
1089
|
+
"type": "address"
|
|
1090
|
+
},
|
|
1091
|
+
{
|
|
1092
|
+
"internalType": "uint256",
|
|
1093
|
+
"name": "tokenId",
|
|
1094
|
+
"type": "uint256"
|
|
1095
|
+
},
|
|
1096
|
+
{
|
|
1097
|
+
"internalType": "bytes",
|
|
1098
|
+
"name": "data",
|
|
1099
|
+
"type": "bytes"
|
|
1100
|
+
}
|
|
1101
|
+
],
|
|
1102
|
+
"name": "safeTransferFrom",
|
|
1103
|
+
"outputs": [],
|
|
1104
|
+
"stateMutability": "nonpayable",
|
|
1105
|
+
"type": "function"
|
|
1106
|
+
},
|
|
1107
|
+
{
|
|
1108
|
+
"inputs": [
|
|
1109
|
+
{
|
|
1110
|
+
"internalType": "address",
|
|
1111
|
+
"name": "operator",
|
|
1112
|
+
"type": "address"
|
|
1113
|
+
},
|
|
1114
|
+
{
|
|
1115
|
+
"internalType": "bool",
|
|
1116
|
+
"name": "approved",
|
|
1117
|
+
"type": "bool"
|
|
1118
|
+
}
|
|
1119
|
+
],
|
|
1120
|
+
"name": "setApprovalForAll",
|
|
1121
|
+
"outputs": [],
|
|
1122
|
+
"stateMutability": "nonpayable",
|
|
1123
|
+
"type": "function"
|
|
1124
|
+
},
|
|
1125
|
+
{
|
|
1126
|
+
"inputs": [
|
|
1127
|
+
{
|
|
1128
|
+
"internalType": "address",
|
|
1129
|
+
"name": "sender",
|
|
1130
|
+
"type": "address"
|
|
1131
|
+
},
|
|
1132
|
+
{
|
|
1133
|
+
"internalType": "address",
|
|
1134
|
+
"name": "operator",
|
|
1135
|
+
"type": "address"
|
|
1136
|
+
},
|
|
1137
|
+
{
|
|
1138
|
+
"internalType": "bool",
|
|
1139
|
+
"name": "approved",
|
|
1140
|
+
"type": "bool"
|
|
1141
|
+
}
|
|
1142
|
+
],
|
|
1143
|
+
"name": "setApprovalForAllFor",
|
|
1144
|
+
"outputs": [],
|
|
1145
|
+
"stateMutability": "nonpayable",
|
|
1146
|
+
"type": "function"
|
|
1147
|
+
},
|
|
1148
|
+
{
|
|
1149
|
+
"inputs": [
|
|
1150
|
+
{
|
|
1151
|
+
"internalType": "address",
|
|
1152
|
+
"name": "metadataRegistry",
|
|
1153
|
+
"type": "address"
|
|
1154
|
+
}
|
|
1155
|
+
],
|
|
1156
|
+
"name": "setMetadataRegistry",
|
|
1157
|
+
"outputs": [],
|
|
1158
|
+
"stateMutability": "nonpayable",
|
|
1159
|
+
"type": "function"
|
|
1160
|
+
},
|
|
1161
|
+
{
|
|
1162
|
+
"inputs": [
|
|
1163
|
+
{
|
|
1164
|
+
"internalType": "address",
|
|
1165
|
+
"name": "minter",
|
|
1166
|
+
"type": "address"
|
|
1167
|
+
},
|
|
1168
|
+
{
|
|
1169
|
+
"internalType": "bool",
|
|
1170
|
+
"name": "enabled",
|
|
1171
|
+
"type": "bool"
|
|
1172
|
+
}
|
|
1173
|
+
],
|
|
1174
|
+
"name": "setMinter",
|
|
1175
|
+
"outputs": [],
|
|
1176
|
+
"stateMutability": "nonpayable",
|
|
1177
|
+
"type": "function"
|
|
1178
|
+
},
|
|
1179
|
+
{
|
|
1180
|
+
"inputs": [
|
|
1181
|
+
{
|
|
1182
|
+
"internalType": "contract IOperatorFilterRegistry",
|
|
1183
|
+
"name": "registry",
|
|
1184
|
+
"type": "address"
|
|
1185
|
+
}
|
|
1186
|
+
],
|
|
1187
|
+
"name": "setOperatorRegistry",
|
|
1188
|
+
"outputs": [],
|
|
1189
|
+
"stateMutability": "nonpayable",
|
|
1190
|
+
"type": "function"
|
|
1191
|
+
},
|
|
1192
|
+
{
|
|
1193
|
+
"inputs": [
|
|
1194
|
+
{
|
|
1195
|
+
"internalType": "address",
|
|
1196
|
+
"name": "royaltyManager",
|
|
1197
|
+
"type": "address"
|
|
1198
|
+
}
|
|
1199
|
+
],
|
|
1200
|
+
"name": "setRoyaltyManager",
|
|
1201
|
+
"outputs": [],
|
|
1202
|
+
"stateMutability": "nonpayable",
|
|
1203
|
+
"type": "function"
|
|
1204
|
+
},
|
|
1205
|
+
{
|
|
1206
|
+
"inputs": [
|
|
1207
|
+
{
|
|
1208
|
+
"internalType": "address",
|
|
1209
|
+
"name": "superOperator",
|
|
1210
|
+
"type": "address"
|
|
1211
|
+
},
|
|
1212
|
+
{
|
|
1213
|
+
"internalType": "bool",
|
|
1214
|
+
"name": "enabled",
|
|
1215
|
+
"type": "bool"
|
|
1216
|
+
}
|
|
1217
|
+
],
|
|
1218
|
+
"name": "setSuperOperator",
|
|
1219
|
+
"outputs": [],
|
|
1220
|
+
"stateMutability": "nonpayable",
|
|
1221
|
+
"type": "function"
|
|
1222
|
+
},
|
|
1223
|
+
{
|
|
1224
|
+
"inputs": [
|
|
1225
|
+
{
|
|
1226
|
+
"internalType": "bytes4",
|
|
1227
|
+
"name": "interfaceId",
|
|
1228
|
+
"type": "bytes4"
|
|
1229
|
+
}
|
|
1230
|
+
],
|
|
1231
|
+
"name": "supportsInterface",
|
|
1232
|
+
"outputs": [
|
|
1233
|
+
{
|
|
1234
|
+
"internalType": "bool",
|
|
1235
|
+
"name": "",
|
|
1236
|
+
"type": "bool"
|
|
1237
|
+
}
|
|
1238
|
+
],
|
|
1239
|
+
"stateMutability": "pure",
|
|
1240
|
+
"type": "function"
|
|
1241
|
+
},
|
|
1242
|
+
{
|
|
1243
|
+
"inputs": [],
|
|
1244
|
+
"name": "symbol",
|
|
1245
|
+
"outputs": [
|
|
1246
|
+
{
|
|
1247
|
+
"internalType": "string",
|
|
1248
|
+
"name": "",
|
|
1249
|
+
"type": "string"
|
|
1250
|
+
}
|
|
1251
|
+
],
|
|
1252
|
+
"stateMutability": "pure",
|
|
1253
|
+
"type": "function"
|
|
1254
|
+
},
|
|
1255
|
+
{
|
|
1256
|
+
"inputs": [
|
|
1257
|
+
{
|
|
1258
|
+
"internalType": "uint256",
|
|
1259
|
+
"name": "tokenId",
|
|
1260
|
+
"type": "uint256"
|
|
1261
|
+
}
|
|
1262
|
+
],
|
|
1263
|
+
"name": "tokenURI",
|
|
1264
|
+
"outputs": [
|
|
1265
|
+
{
|
|
1266
|
+
"internalType": "string",
|
|
1267
|
+
"name": "",
|
|
1268
|
+
"type": "string"
|
|
1269
|
+
}
|
|
1270
|
+
],
|
|
1271
|
+
"stateMutability": "view",
|
|
1272
|
+
"type": "function"
|
|
1273
|
+
},
|
|
1274
|
+
{
|
|
1275
|
+
"inputs": [
|
|
1276
|
+
{
|
|
1277
|
+
"internalType": "address",
|
|
1278
|
+
"name": "from",
|
|
1279
|
+
"type": "address"
|
|
1280
|
+
},
|
|
1281
|
+
{
|
|
1282
|
+
"internalType": "address",
|
|
1283
|
+
"name": "to",
|
|
1284
|
+
"type": "address"
|
|
1285
|
+
},
|
|
1286
|
+
{
|
|
1287
|
+
"internalType": "uint256",
|
|
1288
|
+
"name": "tokenId",
|
|
1289
|
+
"type": "uint256"
|
|
1290
|
+
}
|
|
1291
|
+
],
|
|
1292
|
+
"name": "transferFrom",
|
|
1293
|
+
"outputs": [],
|
|
1294
|
+
"stateMutability": "nonpayable",
|
|
1295
|
+
"type": "function"
|
|
1296
|
+
},
|
|
1297
|
+
{
|
|
1298
|
+
"inputs": [
|
|
1299
|
+
{
|
|
1300
|
+
"internalType": "address",
|
|
1301
|
+
"name": "newOwner",
|
|
1302
|
+
"type": "address"
|
|
1303
|
+
}
|
|
1304
|
+
],
|
|
1305
|
+
"name": "transferOwnership",
|
|
1306
|
+
"outputs": [],
|
|
1307
|
+
"stateMutability": "nonpayable",
|
|
1308
|
+
"type": "function"
|
|
1309
|
+
},
|
|
1310
|
+
{
|
|
1311
|
+
"inputs": [
|
|
1312
|
+
{
|
|
1313
|
+
"internalType": "address",
|
|
1314
|
+
"name": "from",
|
|
1315
|
+
"type": "address"
|
|
1316
|
+
},
|
|
1317
|
+
{
|
|
1318
|
+
"internalType": "address",
|
|
1319
|
+
"name": "to",
|
|
1320
|
+
"type": "address"
|
|
1321
|
+
},
|
|
1322
|
+
{
|
|
1323
|
+
"internalType": "uint256",
|
|
1324
|
+
"name": "size",
|
|
1325
|
+
"type": "uint256"
|
|
1326
|
+
},
|
|
1327
|
+
{
|
|
1328
|
+
"internalType": "uint256",
|
|
1329
|
+
"name": "x",
|
|
1330
|
+
"type": "uint256"
|
|
1331
|
+
},
|
|
1332
|
+
{
|
|
1333
|
+
"internalType": "uint256",
|
|
1334
|
+
"name": "y",
|
|
1335
|
+
"type": "uint256"
|
|
1336
|
+
},
|
|
1337
|
+
{
|
|
1338
|
+
"internalType": "bytes",
|
|
1339
|
+
"name": "data",
|
|
1340
|
+
"type": "bytes"
|
|
1341
|
+
}
|
|
1342
|
+
],
|
|
1343
|
+
"name": "transferQuad",
|
|
1344
|
+
"outputs": [],
|
|
1345
|
+
"stateMutability": "nonpayable",
|
|
1346
|
+
"type": "function"
|
|
1347
|
+
},
|
|
1348
|
+
{
|
|
1349
|
+
"inputs": [],
|
|
1350
|
+
"name": "width",
|
|
1351
|
+
"outputs": [
|
|
1352
|
+
{
|
|
1353
|
+
"internalType": "uint256",
|
|
1354
|
+
"name": "",
|
|
1355
|
+
"type": "uint256"
|
|
1356
|
+
}
|
|
1357
|
+
],
|
|
1358
|
+
"stateMutability": "pure",
|
|
1359
|
+
"type": "function"
|
|
1360
|
+
}
|
|
1361
|
+
];
|
|
1362
|
+
/**
|
|
1363
|
+
* Land_json Contract Class
|
|
1364
|
+
*
|
|
1365
|
+
* Provides a class-based API similar to TypeChain for interacting with the contract.
|
|
1366
|
+
*
|
|
1367
|
+
* @example
|
|
1368
|
+
* ```typescript
|
|
1369
|
+
* import { createPublicClient, createWalletClient, http } from 'viem';
|
|
1370
|
+
* import { mainnet } from 'viem/chains';
|
|
1371
|
+
* import { Land_json } from 'Land_json';
|
|
1372
|
+
*
|
|
1373
|
+
* const publicClient = createPublicClient({ chain: mainnet, transport: http() });
|
|
1374
|
+
* const walletClient = createWalletClient({ chain: mainnet, transport: http() });
|
|
1375
|
+
*
|
|
1376
|
+
* const contract = new Land_json('0x...', { publicClient, walletClient });
|
|
1377
|
+
*
|
|
1378
|
+
* // Read functions
|
|
1379
|
+
* const result = await contract.balanceOf('0x...');
|
|
1380
|
+
*
|
|
1381
|
+
* // Write functions
|
|
1382
|
+
* const hash = await contract.transfer('0x...', 1000n);
|
|
1383
|
+
*
|
|
1384
|
+
* // Simulate transactions (dry-run)
|
|
1385
|
+
* const simulation = await contract.simulate.transfer('0x...', 1000n);
|
|
1386
|
+
* console.log('Gas estimate:', simulation.request.gas);
|
|
1387
|
+
*
|
|
1388
|
+
* // Watch events
|
|
1389
|
+
* const unwatch = contract.watch.Transfer((event) => {
|
|
1390
|
+
* console.log('Transfer event:', event);
|
|
1391
|
+
* });
|
|
1392
|
+
* ```
|
|
1393
|
+
*/
|
|
1394
|
+
class Land_json {
|
|
1395
|
+
constructor(address, clients) {
|
|
1396
|
+
this.contractAddress = address;
|
|
1397
|
+
this.publicClient = clients.publicClient;
|
|
1398
|
+
this.contract = (0, viem_1.getContract)({
|
|
1399
|
+
address,
|
|
1400
|
+
abi: exports.Land_jsonAbi,
|
|
1401
|
+
client: {
|
|
1402
|
+
public: clients.publicClient,
|
|
1403
|
+
wallet: clients.walletClient,
|
|
1404
|
+
},
|
|
1405
|
+
});
|
|
1406
|
+
}
|
|
1407
|
+
/**
|
|
1408
|
+
* Get the contract address
|
|
1409
|
+
*/
|
|
1410
|
+
get address() {
|
|
1411
|
+
return this.contractAddress;
|
|
1412
|
+
}
|
|
1413
|
+
/**
|
|
1414
|
+
* Get the underlying viem contract instance
|
|
1415
|
+
*/
|
|
1416
|
+
getContract() {
|
|
1417
|
+
return this.contract;
|
|
1418
|
+
}
|
|
1419
|
+
/**
|
|
1420
|
+
* balanceOf
|
|
1421
|
+
* view
|
|
1422
|
+
*/
|
|
1423
|
+
async balanceOf(owner) {
|
|
1424
|
+
return this.contract.read.balanceOf([owner]);
|
|
1425
|
+
}
|
|
1426
|
+
/**
|
|
1427
|
+
* exists
|
|
1428
|
+
* view
|
|
1429
|
+
*/
|
|
1430
|
+
async exists(size, x, y) {
|
|
1431
|
+
return this.contract.read.exists([size, x, y]);
|
|
1432
|
+
}
|
|
1433
|
+
/**
|
|
1434
|
+
* getAdmin
|
|
1435
|
+
* view
|
|
1436
|
+
*/
|
|
1437
|
+
async getAdmin() {
|
|
1438
|
+
return this.contract.read.getAdmin();
|
|
1439
|
+
}
|
|
1440
|
+
/**
|
|
1441
|
+
* getApproved
|
|
1442
|
+
* view
|
|
1443
|
+
*/
|
|
1444
|
+
async getApproved(tokenId) {
|
|
1445
|
+
return this.contract.read.getApproved([tokenId]);
|
|
1446
|
+
}
|
|
1447
|
+
/**
|
|
1448
|
+
* getMetadata
|
|
1449
|
+
* view
|
|
1450
|
+
*/
|
|
1451
|
+
async getMetadata(tokenId) {
|
|
1452
|
+
return this.contract.read.getMetadata([tokenId]);
|
|
1453
|
+
}
|
|
1454
|
+
/**
|
|
1455
|
+
* getMetadataRegistry
|
|
1456
|
+
* view
|
|
1457
|
+
*/
|
|
1458
|
+
async getMetadataRegistry() {
|
|
1459
|
+
return this.contract.read.getMetadataRegistry();
|
|
1460
|
+
}
|
|
1461
|
+
/**
|
|
1462
|
+
* getNeighborhoodId
|
|
1463
|
+
* view
|
|
1464
|
+
*/
|
|
1465
|
+
async getNeighborhoodId(tokenId) {
|
|
1466
|
+
return this.contract.read.getNeighborhoodId([tokenId]);
|
|
1467
|
+
}
|
|
1468
|
+
/**
|
|
1469
|
+
* getOwnerData
|
|
1470
|
+
* view
|
|
1471
|
+
*/
|
|
1472
|
+
async getOwnerData(tokenId) {
|
|
1473
|
+
return this.contract.read.getOwnerData([tokenId]);
|
|
1474
|
+
}
|
|
1475
|
+
/**
|
|
1476
|
+
* getRoyaltyManager
|
|
1477
|
+
* view
|
|
1478
|
+
*/
|
|
1479
|
+
async getRoyaltyManager() {
|
|
1480
|
+
return this.contract.read.getRoyaltyManager();
|
|
1481
|
+
}
|
|
1482
|
+
/**
|
|
1483
|
+
* getX
|
|
1484
|
+
* pure
|
|
1485
|
+
*/
|
|
1486
|
+
async getX(tokenId) {
|
|
1487
|
+
return this.contract.read.getX([tokenId]);
|
|
1488
|
+
}
|
|
1489
|
+
/**
|
|
1490
|
+
* getY
|
|
1491
|
+
* pure
|
|
1492
|
+
*/
|
|
1493
|
+
async getY(tokenId) {
|
|
1494
|
+
return this.contract.read.getY([tokenId]);
|
|
1495
|
+
}
|
|
1496
|
+
/**
|
|
1497
|
+
* height
|
|
1498
|
+
* pure
|
|
1499
|
+
*/
|
|
1500
|
+
async height() {
|
|
1501
|
+
return this.contract.read.height();
|
|
1502
|
+
}
|
|
1503
|
+
/**
|
|
1504
|
+
* isApprovedForAll
|
|
1505
|
+
* view
|
|
1506
|
+
*/
|
|
1507
|
+
async isApprovedForAll(owner, operator) {
|
|
1508
|
+
return this.contract.read.isApprovedForAll([owner, operator]);
|
|
1509
|
+
}
|
|
1510
|
+
/**
|
|
1511
|
+
* isMinter
|
|
1512
|
+
* view
|
|
1513
|
+
*/
|
|
1514
|
+
async isMinter(who) {
|
|
1515
|
+
return this.contract.read.isMinter([who]);
|
|
1516
|
+
}
|
|
1517
|
+
/**
|
|
1518
|
+
* isPremium
|
|
1519
|
+
* view
|
|
1520
|
+
*/
|
|
1521
|
+
async isPremium(tokenId) {
|
|
1522
|
+
return this.contract.read.isPremium([tokenId]);
|
|
1523
|
+
}
|
|
1524
|
+
/**
|
|
1525
|
+
* isSuperOperator
|
|
1526
|
+
* view
|
|
1527
|
+
*/
|
|
1528
|
+
async isSuperOperator(superOperator) {
|
|
1529
|
+
return this.contract.read.isSuperOperator([superOperator]);
|
|
1530
|
+
}
|
|
1531
|
+
/**
|
|
1532
|
+
* name
|
|
1533
|
+
* pure
|
|
1534
|
+
*/
|
|
1535
|
+
async name() {
|
|
1536
|
+
return this.contract.read.name();
|
|
1537
|
+
}
|
|
1538
|
+
/**
|
|
1539
|
+
* operatorFilterRegistry
|
|
1540
|
+
* view
|
|
1541
|
+
*/
|
|
1542
|
+
async operatorFilterRegistry() {
|
|
1543
|
+
return this.contract.read.operatorFilterRegistry();
|
|
1544
|
+
}
|
|
1545
|
+
/**
|
|
1546
|
+
* owner
|
|
1547
|
+
* view
|
|
1548
|
+
*/
|
|
1549
|
+
async owner() {
|
|
1550
|
+
return this.contract.read.owner();
|
|
1551
|
+
}
|
|
1552
|
+
/**
|
|
1553
|
+
* ownerOf
|
|
1554
|
+
* view
|
|
1555
|
+
*/
|
|
1556
|
+
async ownerOf(tokenId) {
|
|
1557
|
+
return this.contract.read.ownerOf([tokenId]);
|
|
1558
|
+
}
|
|
1559
|
+
/**
|
|
1560
|
+
* royaltyInfo
|
|
1561
|
+
* view
|
|
1562
|
+
*/
|
|
1563
|
+
async royaltyInfo(arg0, salePrice) {
|
|
1564
|
+
return this.contract.read.royaltyInfo([arg0, salePrice]);
|
|
1565
|
+
}
|
|
1566
|
+
/**
|
|
1567
|
+
* supportsInterface
|
|
1568
|
+
* pure
|
|
1569
|
+
*/
|
|
1570
|
+
async supportsInterface(interfaceId) {
|
|
1571
|
+
return this.contract.read.supportsInterface([interfaceId]);
|
|
1572
|
+
}
|
|
1573
|
+
/**
|
|
1574
|
+
* symbol
|
|
1575
|
+
* pure
|
|
1576
|
+
*/
|
|
1577
|
+
async symbol() {
|
|
1578
|
+
return this.contract.read.symbol();
|
|
1579
|
+
}
|
|
1580
|
+
/**
|
|
1581
|
+
* tokenURI
|
|
1582
|
+
* view
|
|
1583
|
+
*/
|
|
1584
|
+
async tokenURI(tokenId) {
|
|
1585
|
+
return this.contract.read.tokenURI([tokenId]);
|
|
1586
|
+
}
|
|
1587
|
+
/**
|
|
1588
|
+
* width
|
|
1589
|
+
* pure
|
|
1590
|
+
*/
|
|
1591
|
+
async width() {
|
|
1592
|
+
return this.contract.read.width();
|
|
1593
|
+
}
|
|
1594
|
+
/**
|
|
1595
|
+
* approve
|
|
1596
|
+
* nonpayable
|
|
1597
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1598
|
+
*/
|
|
1599
|
+
async approve(operator, tokenId, options) {
|
|
1600
|
+
if (!this.contract.write) {
|
|
1601
|
+
throw new Error('Wallet client is required for write operations');
|
|
1602
|
+
}
|
|
1603
|
+
return this.contract.write.approve([operator, tokenId], options);
|
|
1604
|
+
}
|
|
1605
|
+
/**
|
|
1606
|
+
* approveFor
|
|
1607
|
+
* nonpayable
|
|
1608
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1609
|
+
*/
|
|
1610
|
+
async approveFor(sender, operator, tokenId, options) {
|
|
1611
|
+
if (!this.contract.write) {
|
|
1612
|
+
throw new Error('Wallet client is required for write operations');
|
|
1613
|
+
}
|
|
1614
|
+
return this.contract.write.approveFor([sender, operator, tokenId], options);
|
|
1615
|
+
}
|
|
1616
|
+
/**
|
|
1617
|
+
* batchTransferFrom
|
|
1618
|
+
* nonpayable
|
|
1619
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1620
|
+
*/
|
|
1621
|
+
async batchTransferFrom(from, to, ids, data, options) {
|
|
1622
|
+
if (!this.contract.write) {
|
|
1623
|
+
throw new Error('Wallet client is required for write operations');
|
|
1624
|
+
}
|
|
1625
|
+
return this.contract.write.batchTransferFrom([from, to, ids, data], options);
|
|
1626
|
+
}
|
|
1627
|
+
/**
|
|
1628
|
+
* batchTransferQuad
|
|
1629
|
+
* nonpayable
|
|
1630
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1631
|
+
*/
|
|
1632
|
+
async batchTransferQuad(from, to, sizes, xs, ys, data, options) {
|
|
1633
|
+
if (!this.contract.write) {
|
|
1634
|
+
throw new Error('Wallet client is required for write operations');
|
|
1635
|
+
}
|
|
1636
|
+
return this.contract.write.batchTransferQuad([from, to, sizes, xs, ys, data], options);
|
|
1637
|
+
}
|
|
1638
|
+
/**
|
|
1639
|
+
* changeAdmin
|
|
1640
|
+
* nonpayable
|
|
1641
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1642
|
+
*/
|
|
1643
|
+
async changeAdmin(newAdmin, options) {
|
|
1644
|
+
if (!this.contract.write) {
|
|
1645
|
+
throw new Error('Wallet client is required for write operations');
|
|
1646
|
+
}
|
|
1647
|
+
return this.contract.write.changeAdmin([newAdmin], options);
|
|
1648
|
+
}
|
|
1649
|
+
/**
|
|
1650
|
+
* initialize
|
|
1651
|
+
* nonpayable
|
|
1652
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1653
|
+
*/
|
|
1654
|
+
async initialize(admin, options) {
|
|
1655
|
+
if (!this.contract.write) {
|
|
1656
|
+
throw new Error('Wallet client is required for write operations');
|
|
1657
|
+
}
|
|
1658
|
+
return this.contract.write.initialize([admin], options);
|
|
1659
|
+
}
|
|
1660
|
+
/**
|
|
1661
|
+
* mintAndTransferQuad
|
|
1662
|
+
* nonpayable
|
|
1663
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1664
|
+
*/
|
|
1665
|
+
async mintAndTransferQuad(to, size, x, y, data, options) {
|
|
1666
|
+
if (!this.contract.write) {
|
|
1667
|
+
throw new Error('Wallet client is required for write operations');
|
|
1668
|
+
}
|
|
1669
|
+
return this.contract.write.mintAndTransferQuad([to, size, x, y, data], options);
|
|
1670
|
+
}
|
|
1671
|
+
/**
|
|
1672
|
+
* mintQuad
|
|
1673
|
+
* nonpayable
|
|
1674
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1675
|
+
*/
|
|
1676
|
+
async mintQuad(to, size, x, y, data, options) {
|
|
1677
|
+
if (!this.contract.write) {
|
|
1678
|
+
throw new Error('Wallet client is required for write operations');
|
|
1679
|
+
}
|
|
1680
|
+
return this.contract.write.mintQuad([to, size, x, y, data], options);
|
|
1681
|
+
}
|
|
1682
|
+
/**
|
|
1683
|
+
* register
|
|
1684
|
+
* nonpayable
|
|
1685
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1686
|
+
*/
|
|
1687
|
+
async register(subscriptionOrRegistrantToCopy, subscribe, options) {
|
|
1688
|
+
if (!this.contract.write) {
|
|
1689
|
+
throw new Error('Wallet client is required for write operations');
|
|
1690
|
+
}
|
|
1691
|
+
return this.contract.write.register([subscriptionOrRegistrantToCopy, subscribe], options);
|
|
1692
|
+
}
|
|
1693
|
+
/**
|
|
1694
|
+
* safeBatchTransferFrom
|
|
1695
|
+
* nonpayable
|
|
1696
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1697
|
+
*/
|
|
1698
|
+
async safeBatchTransferFrom(from, to, ids, data, options) {
|
|
1699
|
+
if (!this.contract.write) {
|
|
1700
|
+
throw new Error('Wallet client is required for write operations');
|
|
1701
|
+
}
|
|
1702
|
+
return this.contract.write.safeBatchTransferFrom([from, to, ids, data], options);
|
|
1703
|
+
}
|
|
1704
|
+
async safeTransferFrom(...args) {
|
|
1705
|
+
if (!this.contract.write) {
|
|
1706
|
+
throw new Error('Wallet client is required for write operations');
|
|
1707
|
+
}
|
|
1708
|
+
return this.contract.write.safeTransferFrom(args);
|
|
1709
|
+
}
|
|
1710
|
+
/**
|
|
1711
|
+
* setApprovalForAll
|
|
1712
|
+
* nonpayable
|
|
1713
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1714
|
+
*/
|
|
1715
|
+
async setApprovalForAll(operator, approved, options) {
|
|
1716
|
+
if (!this.contract.write) {
|
|
1717
|
+
throw new Error('Wallet client is required for write operations');
|
|
1718
|
+
}
|
|
1719
|
+
return this.contract.write.setApprovalForAll([operator, approved], options);
|
|
1720
|
+
}
|
|
1721
|
+
/**
|
|
1722
|
+
* setApprovalForAllFor
|
|
1723
|
+
* nonpayable
|
|
1724
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1725
|
+
*/
|
|
1726
|
+
async setApprovalForAllFor(sender, operator, approved, options) {
|
|
1727
|
+
if (!this.contract.write) {
|
|
1728
|
+
throw new Error('Wallet client is required for write operations');
|
|
1729
|
+
}
|
|
1730
|
+
return this.contract.write.setApprovalForAllFor([sender, operator, approved], options);
|
|
1731
|
+
}
|
|
1732
|
+
/**
|
|
1733
|
+
* setMetadataRegistry
|
|
1734
|
+
* nonpayable
|
|
1735
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1736
|
+
*/
|
|
1737
|
+
async setMetadataRegistry(metadataRegistry, options) {
|
|
1738
|
+
if (!this.contract.write) {
|
|
1739
|
+
throw new Error('Wallet client is required for write operations');
|
|
1740
|
+
}
|
|
1741
|
+
return this.contract.write.setMetadataRegistry([metadataRegistry], options);
|
|
1742
|
+
}
|
|
1743
|
+
/**
|
|
1744
|
+
* setMinter
|
|
1745
|
+
* nonpayable
|
|
1746
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1747
|
+
*/
|
|
1748
|
+
async setMinter(minter, enabled, options) {
|
|
1749
|
+
if (!this.contract.write) {
|
|
1750
|
+
throw new Error('Wallet client is required for write operations');
|
|
1751
|
+
}
|
|
1752
|
+
return this.contract.write.setMinter([minter, enabled], options);
|
|
1753
|
+
}
|
|
1754
|
+
/**
|
|
1755
|
+
* setOperatorRegistry
|
|
1756
|
+
* nonpayable
|
|
1757
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1758
|
+
*/
|
|
1759
|
+
async setOperatorRegistry(registry, options) {
|
|
1760
|
+
if (!this.contract.write) {
|
|
1761
|
+
throw new Error('Wallet client is required for write operations');
|
|
1762
|
+
}
|
|
1763
|
+
return this.contract.write.setOperatorRegistry([registry], options);
|
|
1764
|
+
}
|
|
1765
|
+
/**
|
|
1766
|
+
* setRoyaltyManager
|
|
1767
|
+
* nonpayable
|
|
1768
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1769
|
+
*/
|
|
1770
|
+
async setRoyaltyManager(royaltyManager, options) {
|
|
1771
|
+
if (!this.contract.write) {
|
|
1772
|
+
throw new Error('Wallet client is required for write operations');
|
|
1773
|
+
}
|
|
1774
|
+
return this.contract.write.setRoyaltyManager([royaltyManager], options);
|
|
1775
|
+
}
|
|
1776
|
+
/**
|
|
1777
|
+
* setSuperOperator
|
|
1778
|
+
* nonpayable
|
|
1779
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1780
|
+
*/
|
|
1781
|
+
async setSuperOperator(superOperator, enabled, options) {
|
|
1782
|
+
if (!this.contract.write) {
|
|
1783
|
+
throw new Error('Wallet client is required for write operations');
|
|
1784
|
+
}
|
|
1785
|
+
return this.contract.write.setSuperOperator([superOperator, enabled], options);
|
|
1786
|
+
}
|
|
1787
|
+
/**
|
|
1788
|
+
* transferFrom
|
|
1789
|
+
* nonpayable
|
|
1790
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1791
|
+
*/
|
|
1792
|
+
async transferFrom(from, to, tokenId, options) {
|
|
1793
|
+
if (!this.contract.write) {
|
|
1794
|
+
throw new Error('Wallet client is required for write operations');
|
|
1795
|
+
}
|
|
1796
|
+
return this.contract.write.transferFrom([from, to, tokenId], options);
|
|
1797
|
+
}
|
|
1798
|
+
/**
|
|
1799
|
+
* transferOwnership
|
|
1800
|
+
* nonpayable
|
|
1801
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1802
|
+
*/
|
|
1803
|
+
async transferOwnership(newOwner, options) {
|
|
1804
|
+
if (!this.contract.write) {
|
|
1805
|
+
throw new Error('Wallet client is required for write operations');
|
|
1806
|
+
}
|
|
1807
|
+
return this.contract.write.transferOwnership([newOwner], options);
|
|
1808
|
+
}
|
|
1809
|
+
/**
|
|
1810
|
+
* transferQuad
|
|
1811
|
+
* nonpayable
|
|
1812
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1813
|
+
*/
|
|
1814
|
+
async transferQuad(from, to, size, x, y, data, options) {
|
|
1815
|
+
if (!this.contract.write) {
|
|
1816
|
+
throw new Error('Wallet client is required for write operations');
|
|
1817
|
+
}
|
|
1818
|
+
return this.contract.write.transferQuad([from, to, size, x, y, data], options);
|
|
1819
|
+
}
|
|
1820
|
+
/**
|
|
1821
|
+
* Simulate contract write operations (dry-run without sending transaction)
|
|
1822
|
+
*
|
|
1823
|
+
* @example
|
|
1824
|
+
* const result = await contract.simulate.transfer('0x...', 1000n);
|
|
1825
|
+
* console.log('Gas estimate:', result.request.gas);
|
|
1826
|
+
* console.log('Would succeed:', result.result);
|
|
1827
|
+
*/
|
|
1828
|
+
get simulate() {
|
|
1829
|
+
const contract = this.contract;
|
|
1830
|
+
if (!contract.simulate) {
|
|
1831
|
+
throw new Error('Public client is required for simulation');
|
|
1832
|
+
}
|
|
1833
|
+
return {
|
|
1834
|
+
/**
|
|
1835
|
+
* Simulate approve
|
|
1836
|
+
* Returns gas estimate and result without sending transaction
|
|
1837
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1838
|
+
*/
|
|
1839
|
+
async approve(operator, tokenId, options) {
|
|
1840
|
+
return contract.simulate.approve([operator, tokenId], options);
|
|
1841
|
+
},
|
|
1842
|
+
/**
|
|
1843
|
+
* Simulate approveFor
|
|
1844
|
+
* Returns gas estimate and result without sending transaction
|
|
1845
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1846
|
+
*/
|
|
1847
|
+
async approveFor(sender, operator, tokenId, options) {
|
|
1848
|
+
return contract.simulate.approveFor([sender, operator, tokenId], options);
|
|
1849
|
+
},
|
|
1850
|
+
/**
|
|
1851
|
+
* Simulate batchTransferFrom
|
|
1852
|
+
* Returns gas estimate and result without sending transaction
|
|
1853
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1854
|
+
*/
|
|
1855
|
+
async batchTransferFrom(from, to, ids, data, options) {
|
|
1856
|
+
return contract.simulate.batchTransferFrom([from, to, ids, data], options);
|
|
1857
|
+
},
|
|
1858
|
+
/**
|
|
1859
|
+
* Simulate batchTransferQuad
|
|
1860
|
+
* Returns gas estimate and result without sending transaction
|
|
1861
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1862
|
+
*/
|
|
1863
|
+
async batchTransferQuad(from, to, sizes, xs, ys, data, options) {
|
|
1864
|
+
return contract.simulate.batchTransferQuad([from, to, sizes, xs, ys, data], options);
|
|
1865
|
+
},
|
|
1866
|
+
/**
|
|
1867
|
+
* Simulate changeAdmin
|
|
1868
|
+
* Returns gas estimate and result without sending transaction
|
|
1869
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1870
|
+
*/
|
|
1871
|
+
async changeAdmin(newAdmin, options) {
|
|
1872
|
+
return contract.simulate.changeAdmin([newAdmin], options);
|
|
1873
|
+
},
|
|
1874
|
+
/**
|
|
1875
|
+
* Simulate initialize
|
|
1876
|
+
* Returns gas estimate and result without sending transaction
|
|
1877
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1878
|
+
*/
|
|
1879
|
+
async initialize(admin, options) {
|
|
1880
|
+
return contract.simulate.initialize([admin], options);
|
|
1881
|
+
},
|
|
1882
|
+
/**
|
|
1883
|
+
* Simulate mintAndTransferQuad
|
|
1884
|
+
* Returns gas estimate and result without sending transaction
|
|
1885
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1886
|
+
*/
|
|
1887
|
+
async mintAndTransferQuad(to, size, x, y, data, options) {
|
|
1888
|
+
return contract.simulate.mintAndTransferQuad([to, size, x, y, data], options);
|
|
1889
|
+
},
|
|
1890
|
+
/**
|
|
1891
|
+
* Simulate mintQuad
|
|
1892
|
+
* Returns gas estimate and result without sending transaction
|
|
1893
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1894
|
+
*/
|
|
1895
|
+
async mintQuad(to, size, x, y, data, options) {
|
|
1896
|
+
return contract.simulate.mintQuad([to, size, x, y, data], options);
|
|
1897
|
+
},
|
|
1898
|
+
/**
|
|
1899
|
+
* Simulate register
|
|
1900
|
+
* Returns gas estimate and result without sending transaction
|
|
1901
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1902
|
+
*/
|
|
1903
|
+
async register(subscriptionOrRegistrantToCopy, subscribe, options) {
|
|
1904
|
+
return contract.simulate.register([subscriptionOrRegistrantToCopy, subscribe], options);
|
|
1905
|
+
},
|
|
1906
|
+
/**
|
|
1907
|
+
* Simulate safeBatchTransferFrom
|
|
1908
|
+
* Returns gas estimate and result without sending transaction
|
|
1909
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1910
|
+
*/
|
|
1911
|
+
async safeBatchTransferFrom(from, to, ids, data, options) {
|
|
1912
|
+
return contract.simulate.safeBatchTransferFrom([from, to, ids, data], options);
|
|
1913
|
+
},
|
|
1914
|
+
/**
|
|
1915
|
+
* Simulate safeTransferFrom
|
|
1916
|
+
* Returns gas estimate and result without sending transaction
|
|
1917
|
+
* Supports multiple overloads: (address, address, uint256), (address, address, uint256, bytes)
|
|
1918
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1919
|
+
*/
|
|
1920
|
+
async safeTransferFrom(...args) {
|
|
1921
|
+
return contract.simulate.safeTransferFrom(args);
|
|
1922
|
+
},
|
|
1923
|
+
/**
|
|
1924
|
+
* Simulate setApprovalForAll
|
|
1925
|
+
* Returns gas estimate and result without sending transaction
|
|
1926
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1927
|
+
*/
|
|
1928
|
+
async setApprovalForAll(operator, approved, options) {
|
|
1929
|
+
return contract.simulate.setApprovalForAll([operator, approved], options);
|
|
1930
|
+
},
|
|
1931
|
+
/**
|
|
1932
|
+
* Simulate setApprovalForAllFor
|
|
1933
|
+
* Returns gas estimate and result without sending transaction
|
|
1934
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1935
|
+
*/
|
|
1936
|
+
async setApprovalForAllFor(sender, operator, approved, options) {
|
|
1937
|
+
return contract.simulate.setApprovalForAllFor([sender, operator, approved], options);
|
|
1938
|
+
},
|
|
1939
|
+
/**
|
|
1940
|
+
* Simulate setMetadataRegistry
|
|
1941
|
+
* Returns gas estimate and result without sending transaction
|
|
1942
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1943
|
+
*/
|
|
1944
|
+
async setMetadataRegistry(metadataRegistry, options) {
|
|
1945
|
+
return contract.simulate.setMetadataRegistry([metadataRegistry], options);
|
|
1946
|
+
},
|
|
1947
|
+
/**
|
|
1948
|
+
* Simulate setMinter
|
|
1949
|
+
* Returns gas estimate and result without sending transaction
|
|
1950
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1951
|
+
*/
|
|
1952
|
+
async setMinter(minter, enabled, options) {
|
|
1953
|
+
return contract.simulate.setMinter([minter, enabled], options);
|
|
1954
|
+
},
|
|
1955
|
+
/**
|
|
1956
|
+
* Simulate setOperatorRegistry
|
|
1957
|
+
* Returns gas estimate and result without sending transaction
|
|
1958
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1959
|
+
*/
|
|
1960
|
+
async setOperatorRegistry(registry, options) {
|
|
1961
|
+
return contract.simulate.setOperatorRegistry([registry], options);
|
|
1962
|
+
},
|
|
1963
|
+
/**
|
|
1964
|
+
* Simulate setRoyaltyManager
|
|
1965
|
+
* Returns gas estimate and result without sending transaction
|
|
1966
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1967
|
+
*/
|
|
1968
|
+
async setRoyaltyManager(royaltyManager, options) {
|
|
1969
|
+
return contract.simulate.setRoyaltyManager([royaltyManager], options);
|
|
1970
|
+
},
|
|
1971
|
+
/**
|
|
1972
|
+
* Simulate setSuperOperator
|
|
1973
|
+
* Returns gas estimate and result without sending transaction
|
|
1974
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1975
|
+
*/
|
|
1976
|
+
async setSuperOperator(superOperator, enabled, options) {
|
|
1977
|
+
return contract.simulate.setSuperOperator([superOperator, enabled], options);
|
|
1978
|
+
},
|
|
1979
|
+
/**
|
|
1980
|
+
* Simulate transferFrom
|
|
1981
|
+
* Returns gas estimate and result without sending transaction
|
|
1982
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1983
|
+
*/
|
|
1984
|
+
async transferFrom(from, to, tokenId, options) {
|
|
1985
|
+
return contract.simulate.transferFrom([from, to, tokenId], options);
|
|
1986
|
+
},
|
|
1987
|
+
/**
|
|
1988
|
+
* Simulate transferOwnership
|
|
1989
|
+
* Returns gas estimate and result without sending transaction
|
|
1990
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1991
|
+
*/
|
|
1992
|
+
async transferOwnership(newOwner, options) {
|
|
1993
|
+
return contract.simulate.transferOwnership([newOwner], options);
|
|
1994
|
+
},
|
|
1995
|
+
/**
|
|
1996
|
+
* Simulate transferQuad
|
|
1997
|
+
* Returns gas estimate and result without sending transaction
|
|
1998
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1999
|
+
*/
|
|
2000
|
+
async transferQuad(from, to, size, x, y, data, options) {
|
|
2001
|
+
return contract.simulate.transferQuad([from, to, size, x, y, data], options);
|
|
2002
|
+
}
|
|
2003
|
+
};
|
|
2004
|
+
}
|
|
2005
|
+
/**
|
|
2006
|
+
* Watch contract events
|
|
2007
|
+
*
|
|
2008
|
+
* @example
|
|
2009
|
+
* // Watch all Transfer events
|
|
2010
|
+
* const unwatch = contract.watch.Transfer((event) => {
|
|
2011
|
+
* console.log('Transfer:', event);
|
|
2012
|
+
* });
|
|
2013
|
+
*
|
|
2014
|
+
* // Stop watching
|
|
2015
|
+
* unwatch();
|
|
2016
|
+
*/
|
|
2017
|
+
get watch() {
|
|
2018
|
+
return {
|
|
2019
|
+
/**
|
|
2020
|
+
* Watch AdminChanged events
|
|
2021
|
+
* @param callback Function to call when event is emitted
|
|
2022
|
+
* @param filter Optional filter for indexed parameters
|
|
2023
|
+
* @returns Unwatch function to stop listening
|
|
2024
|
+
*/
|
|
2025
|
+
AdminChanged: (callback, filter) => {
|
|
2026
|
+
return this.publicClient.watchContractEvent({
|
|
2027
|
+
address: this.contractAddress,
|
|
2028
|
+
abi: exports.Land_jsonAbi,
|
|
2029
|
+
eventName: 'AdminChanged',
|
|
2030
|
+
args: filter,
|
|
2031
|
+
onLogs: (logs) => {
|
|
2032
|
+
logs.forEach((log) => {
|
|
2033
|
+
callback(log.args);
|
|
2034
|
+
});
|
|
2035
|
+
},
|
|
2036
|
+
});
|
|
2037
|
+
},
|
|
2038
|
+
/**
|
|
2039
|
+
* Watch Approval events
|
|
2040
|
+
* @param callback Function to call when event is emitted
|
|
2041
|
+
* @param filter Optional filter for indexed parameters
|
|
2042
|
+
* @returns Unwatch function to stop listening
|
|
2043
|
+
*/
|
|
2044
|
+
Approval: (callback, filter) => {
|
|
2045
|
+
return this.publicClient.watchContractEvent({
|
|
2046
|
+
address: this.contractAddress,
|
|
2047
|
+
abi: exports.Land_jsonAbi,
|
|
2048
|
+
eventName: 'Approval',
|
|
2049
|
+
args: filter,
|
|
2050
|
+
onLogs: (logs) => {
|
|
2051
|
+
logs.forEach((log) => {
|
|
2052
|
+
callback(log.args);
|
|
2053
|
+
});
|
|
2054
|
+
},
|
|
2055
|
+
});
|
|
2056
|
+
},
|
|
2057
|
+
/**
|
|
2058
|
+
* Watch ApprovalForAll events
|
|
2059
|
+
* @param callback Function to call when event is emitted
|
|
2060
|
+
* @param filter Optional filter for indexed parameters
|
|
2061
|
+
* @returns Unwatch function to stop listening
|
|
2062
|
+
*/
|
|
2063
|
+
ApprovalForAll: (callback, filter) => {
|
|
2064
|
+
return this.publicClient.watchContractEvent({
|
|
2065
|
+
address: this.contractAddress,
|
|
2066
|
+
abi: exports.Land_jsonAbi,
|
|
2067
|
+
eventName: 'ApprovalForAll',
|
|
2068
|
+
args: filter,
|
|
2069
|
+
onLogs: (logs) => {
|
|
2070
|
+
logs.forEach((log) => {
|
|
2071
|
+
callback(log.args);
|
|
2072
|
+
});
|
|
2073
|
+
},
|
|
2074
|
+
});
|
|
2075
|
+
},
|
|
2076
|
+
/**
|
|
2077
|
+
* Watch ContractRegistered events
|
|
2078
|
+
* @param callback Function to call when event is emitted
|
|
2079
|
+
* @param filter Optional filter for indexed parameters
|
|
2080
|
+
* @returns Unwatch function to stop listening
|
|
2081
|
+
*/
|
|
2082
|
+
ContractRegistered: (callback, filter) => {
|
|
2083
|
+
return this.publicClient.watchContractEvent({
|
|
2084
|
+
address: this.contractAddress,
|
|
2085
|
+
abi: exports.Land_jsonAbi,
|
|
2086
|
+
eventName: 'ContractRegistered',
|
|
2087
|
+
args: filter,
|
|
2088
|
+
onLogs: (logs) => {
|
|
2089
|
+
logs.forEach((log) => {
|
|
2090
|
+
callback(log.args);
|
|
2091
|
+
});
|
|
2092
|
+
},
|
|
2093
|
+
});
|
|
2094
|
+
},
|
|
2095
|
+
/**
|
|
2096
|
+
* Watch Initialized events
|
|
2097
|
+
* @param callback Function to call when event is emitted
|
|
2098
|
+
* @param filter Optional filter for indexed parameters
|
|
2099
|
+
* @returns Unwatch function to stop listening
|
|
2100
|
+
*/
|
|
2101
|
+
Initialized: (callback) => {
|
|
2102
|
+
return this.publicClient.watchContractEvent({
|
|
2103
|
+
address: this.contractAddress,
|
|
2104
|
+
abi: exports.Land_jsonAbi,
|
|
2105
|
+
eventName: 'Initialized',
|
|
2106
|
+
onLogs: (logs) => {
|
|
2107
|
+
logs.forEach((log) => {
|
|
2108
|
+
callback(log.args);
|
|
2109
|
+
});
|
|
2110
|
+
},
|
|
2111
|
+
});
|
|
2112
|
+
},
|
|
2113
|
+
/**
|
|
2114
|
+
* Watch MetadataRegistrySet events
|
|
2115
|
+
* @param callback Function to call when event is emitted
|
|
2116
|
+
* @param filter Optional filter for indexed parameters
|
|
2117
|
+
* @returns Unwatch function to stop listening
|
|
2118
|
+
*/
|
|
2119
|
+
MetadataRegistrySet: (callback, filter) => {
|
|
2120
|
+
return this.publicClient.watchContractEvent({
|
|
2121
|
+
address: this.contractAddress,
|
|
2122
|
+
abi: exports.Land_jsonAbi,
|
|
2123
|
+
eventName: 'MetadataRegistrySet',
|
|
2124
|
+
args: filter,
|
|
2125
|
+
onLogs: (logs) => {
|
|
2126
|
+
logs.forEach((log) => {
|
|
2127
|
+
callback(log.args);
|
|
2128
|
+
});
|
|
2129
|
+
},
|
|
2130
|
+
});
|
|
2131
|
+
},
|
|
2132
|
+
/**
|
|
2133
|
+
* Watch Minter events
|
|
2134
|
+
* @param callback Function to call when event is emitted
|
|
2135
|
+
* @param filter Optional filter for indexed parameters
|
|
2136
|
+
* @returns Unwatch function to stop listening
|
|
2137
|
+
*/
|
|
2138
|
+
Minter: (callback, filter) => {
|
|
2139
|
+
return this.publicClient.watchContractEvent({
|
|
2140
|
+
address: this.contractAddress,
|
|
2141
|
+
abi: exports.Land_jsonAbi,
|
|
2142
|
+
eventName: 'Minter',
|
|
2143
|
+
args: filter,
|
|
2144
|
+
onLogs: (logs) => {
|
|
2145
|
+
logs.forEach((log) => {
|
|
2146
|
+
callback(log.args);
|
|
2147
|
+
});
|
|
2148
|
+
},
|
|
2149
|
+
});
|
|
2150
|
+
},
|
|
2151
|
+
/**
|
|
2152
|
+
* Watch OperatorRegistrySet events
|
|
2153
|
+
* @param callback Function to call when event is emitted
|
|
2154
|
+
* @param filter Optional filter for indexed parameters
|
|
2155
|
+
* @returns Unwatch function to stop listening
|
|
2156
|
+
*/
|
|
2157
|
+
OperatorRegistrySet: (callback, filter) => {
|
|
2158
|
+
return this.publicClient.watchContractEvent({
|
|
2159
|
+
address: this.contractAddress,
|
|
2160
|
+
abi: exports.Land_jsonAbi,
|
|
2161
|
+
eventName: 'OperatorRegistrySet',
|
|
2162
|
+
args: filter,
|
|
2163
|
+
onLogs: (logs) => {
|
|
2164
|
+
logs.forEach((log) => {
|
|
2165
|
+
callback(log.args);
|
|
2166
|
+
});
|
|
2167
|
+
},
|
|
2168
|
+
});
|
|
2169
|
+
},
|
|
2170
|
+
/**
|
|
2171
|
+
* Watch OwnershipTransferred events
|
|
2172
|
+
* @param callback Function to call when event is emitted
|
|
2173
|
+
* @param filter Optional filter for indexed parameters
|
|
2174
|
+
* @returns Unwatch function to stop listening
|
|
2175
|
+
*/
|
|
2176
|
+
OwnershipTransferred: (callback, filter) => {
|
|
2177
|
+
return this.publicClient.watchContractEvent({
|
|
2178
|
+
address: this.contractAddress,
|
|
2179
|
+
abi: exports.Land_jsonAbi,
|
|
2180
|
+
eventName: 'OwnershipTransferred',
|
|
2181
|
+
args: filter,
|
|
2182
|
+
onLogs: (logs) => {
|
|
2183
|
+
logs.forEach((log) => {
|
|
2184
|
+
callback(log.args);
|
|
2185
|
+
});
|
|
2186
|
+
},
|
|
2187
|
+
});
|
|
2188
|
+
},
|
|
2189
|
+
/**
|
|
2190
|
+
* Watch RoyaltyManagerSet events
|
|
2191
|
+
* @param callback Function to call when event is emitted
|
|
2192
|
+
* @param filter Optional filter for indexed parameters
|
|
2193
|
+
* @returns Unwatch function to stop listening
|
|
2194
|
+
*/
|
|
2195
|
+
RoyaltyManagerSet: (callback, filter) => {
|
|
2196
|
+
return this.publicClient.watchContractEvent({
|
|
2197
|
+
address: this.contractAddress,
|
|
2198
|
+
abi: exports.Land_jsonAbi,
|
|
2199
|
+
eventName: 'RoyaltyManagerSet',
|
|
2200
|
+
args: filter,
|
|
2201
|
+
onLogs: (logs) => {
|
|
2202
|
+
logs.forEach((log) => {
|
|
2203
|
+
callback(log.args);
|
|
2204
|
+
});
|
|
2205
|
+
},
|
|
2206
|
+
});
|
|
2207
|
+
},
|
|
2208
|
+
/**
|
|
2209
|
+
* Watch SuperOperator events
|
|
2210
|
+
* @param callback Function to call when event is emitted
|
|
2211
|
+
* @param filter Optional filter for indexed parameters
|
|
2212
|
+
* @returns Unwatch function to stop listening
|
|
2213
|
+
*/
|
|
2214
|
+
SuperOperator: (callback, filter) => {
|
|
2215
|
+
return this.publicClient.watchContractEvent({
|
|
2216
|
+
address: this.contractAddress,
|
|
2217
|
+
abi: exports.Land_jsonAbi,
|
|
2218
|
+
eventName: 'SuperOperator',
|
|
2219
|
+
args: filter,
|
|
2220
|
+
onLogs: (logs) => {
|
|
2221
|
+
logs.forEach((log) => {
|
|
2222
|
+
callback(log.args);
|
|
2223
|
+
});
|
|
2224
|
+
},
|
|
2225
|
+
});
|
|
2226
|
+
},
|
|
2227
|
+
/**
|
|
2228
|
+
* Watch Transfer events
|
|
2229
|
+
* @param callback Function to call when event is emitted
|
|
2230
|
+
* @param filter Optional filter for indexed parameters
|
|
2231
|
+
* @returns Unwatch function to stop listening
|
|
2232
|
+
*/
|
|
2233
|
+
Transfer: (callback, filter) => {
|
|
2234
|
+
return this.publicClient.watchContractEvent({
|
|
2235
|
+
address: this.contractAddress,
|
|
2236
|
+
abi: exports.Land_jsonAbi,
|
|
2237
|
+
eventName: 'Transfer',
|
|
2238
|
+
args: filter,
|
|
2239
|
+
onLogs: (logs) => {
|
|
2240
|
+
logs.forEach((log) => {
|
|
2241
|
+
callback(log.args);
|
|
2242
|
+
});
|
|
2243
|
+
},
|
|
2244
|
+
});
|
|
2245
|
+
}
|
|
2246
|
+
};
|
|
2247
|
+
}
|
|
2248
|
+
}
|
|
2249
|
+
exports.Land_json = Land_json;
|