@gitmyabi/rari 1.0.0 → 1.0.2

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.
@@ -0,0 +1,1792 @@
1
+ import type { Address, PublicClient, WalletClient } from 'viem';
2
+ /**
3
+ * LibPart.Part struct type
4
+ */
5
+ export type LibPart_Part = {
6
+ account: `0x${string}`;
7
+ value: bigint;
8
+ };
9
+ /**
10
+ * LibERC1155LazyMint.Mint1155Data struct type
11
+ */
12
+ export type LibERC1155LazyMint_Mint1155Data = {
13
+ tokenId: bigint;
14
+ tokenURI: string;
15
+ supply: bigint;
16
+ creators: LibPart_Part[];
17
+ royalties: LibPart_Part[];
18
+ signatures: `0x${string}`[];
19
+ };
20
+ /**
21
+ * ERC1155Rarible_json ABI
22
+ *
23
+ * This ABI is typed using viem's type system for full type safety.
24
+ */
25
+ export declare const ERC1155Rarible_jsonAbi: readonly [{
26
+ readonly anonymous: false;
27
+ readonly inputs: readonly [{
28
+ readonly indexed: true;
29
+ readonly internalType: "address";
30
+ readonly name: "account";
31
+ readonly type: "address";
32
+ }, {
33
+ readonly indexed: true;
34
+ readonly internalType: "address";
35
+ readonly name: "operator";
36
+ readonly type: "address";
37
+ }, {
38
+ readonly indexed: false;
39
+ readonly internalType: "bool";
40
+ readonly name: "approved";
41
+ readonly type: "bool";
42
+ }];
43
+ readonly name: "ApprovalForAll";
44
+ readonly type: "event";
45
+ }, {
46
+ readonly anonymous: false;
47
+ readonly inputs: readonly [{
48
+ readonly indexed: false;
49
+ readonly internalType: "string";
50
+ readonly name: "newBaseURI";
51
+ readonly type: "string";
52
+ }];
53
+ readonly name: "BaseUriChanged";
54
+ readonly type: "event";
55
+ }, {
56
+ readonly anonymous: false;
57
+ readonly inputs: readonly [{
58
+ readonly indexed: true;
59
+ readonly internalType: "address";
60
+ readonly name: "operator";
61
+ readonly type: "address";
62
+ }, {
63
+ readonly indexed: true;
64
+ readonly internalType: "address";
65
+ readonly name: "account";
66
+ readonly type: "address";
67
+ }, {
68
+ readonly indexed: false;
69
+ readonly internalType: "uint256";
70
+ readonly name: "id";
71
+ readonly type: "uint256";
72
+ }, {
73
+ readonly indexed: false;
74
+ readonly internalType: "uint256";
75
+ readonly name: "amount";
76
+ readonly type: "uint256";
77
+ }];
78
+ readonly name: "BurnLazy";
79
+ readonly type: "event";
80
+ }, {
81
+ readonly anonymous: false;
82
+ readonly inputs: readonly [{
83
+ readonly indexed: true;
84
+ readonly internalType: "address";
85
+ readonly name: "operator";
86
+ readonly type: "address";
87
+ }, {
88
+ readonly indexed: true;
89
+ readonly internalType: "address";
90
+ readonly name: "account";
91
+ readonly type: "address";
92
+ }, {
93
+ readonly indexed: false;
94
+ readonly internalType: "uint256[]";
95
+ readonly name: "ids";
96
+ readonly type: "uint256[]";
97
+ }, {
98
+ readonly indexed: false;
99
+ readonly internalType: "uint256[]";
100
+ readonly name: "amounts";
101
+ readonly type: "uint256[]";
102
+ }];
103
+ readonly name: "BurnLazyBatch";
104
+ readonly type: "event";
105
+ }, {
106
+ readonly anonymous: false;
107
+ readonly inputs: readonly [{
108
+ readonly indexed: false;
109
+ readonly internalType: "address";
110
+ readonly name: "owner";
111
+ readonly type: "address";
112
+ }, {
113
+ readonly indexed: false;
114
+ readonly internalType: "string";
115
+ readonly name: "name";
116
+ readonly type: "string";
117
+ }, {
118
+ readonly indexed: false;
119
+ readonly internalType: "string";
120
+ readonly name: "symbol";
121
+ readonly type: "string";
122
+ }];
123
+ readonly name: "CreateERC1155Rarible";
124
+ readonly type: "event";
125
+ }, {
126
+ readonly anonymous: false;
127
+ readonly inputs: readonly [{
128
+ readonly indexed: false;
129
+ readonly internalType: "address";
130
+ readonly name: "owner";
131
+ readonly type: "address";
132
+ }, {
133
+ readonly indexed: false;
134
+ readonly internalType: "string";
135
+ readonly name: "name";
136
+ readonly type: "string";
137
+ }, {
138
+ readonly indexed: false;
139
+ readonly internalType: "string";
140
+ readonly name: "symbol";
141
+ readonly type: "string";
142
+ }];
143
+ readonly name: "CreateERC1155RaribleUser";
144
+ readonly type: "event";
145
+ }, {
146
+ readonly anonymous: false;
147
+ readonly inputs: readonly [{
148
+ readonly indexed: false;
149
+ readonly internalType: "uint256";
150
+ readonly name: "tokenId";
151
+ readonly type: "uint256";
152
+ }, {
153
+ readonly components: readonly [{
154
+ readonly internalType: "address payable";
155
+ readonly name: "account";
156
+ readonly type: "address";
157
+ }, {
158
+ readonly internalType: "uint96";
159
+ readonly name: "value";
160
+ readonly type: "uint96";
161
+ }];
162
+ readonly indexed: false;
163
+ readonly internalType: "struct LibPart.Part[]";
164
+ readonly name: "creators";
165
+ readonly type: "tuple[]";
166
+ }];
167
+ readonly name: "Creators";
168
+ readonly type: "event";
169
+ }, {
170
+ readonly anonymous: false;
171
+ readonly inputs: readonly [{
172
+ readonly indexed: true;
173
+ readonly internalType: "address";
174
+ readonly name: "operator";
175
+ readonly type: "address";
176
+ }, {
177
+ readonly indexed: false;
178
+ readonly internalType: "bool";
179
+ readonly name: "hasApproval";
180
+ readonly type: "bool";
181
+ }];
182
+ readonly name: "DefaultApproval";
183
+ readonly type: "event";
184
+ }, {
185
+ readonly anonymous: false;
186
+ readonly inputs: readonly [{
187
+ readonly indexed: true;
188
+ readonly internalType: "address";
189
+ readonly name: "minter";
190
+ readonly type: "address";
191
+ }, {
192
+ readonly indexed: true;
193
+ readonly internalType: "bool";
194
+ readonly name: "status";
195
+ readonly type: "bool";
196
+ }];
197
+ readonly name: "MinterStatusChanged";
198
+ readonly type: "event";
199
+ }, {
200
+ readonly anonymous: false;
201
+ readonly inputs: readonly [{
202
+ readonly indexed: true;
203
+ readonly internalType: "address";
204
+ readonly name: "previousOwner";
205
+ readonly type: "address";
206
+ }, {
207
+ readonly indexed: true;
208
+ readonly internalType: "address";
209
+ readonly name: "newOwner";
210
+ readonly type: "address";
211
+ }];
212
+ readonly name: "OwnershipTransferred";
213
+ readonly type: "event";
214
+ }, {
215
+ readonly anonymous: false;
216
+ readonly inputs: readonly [{
217
+ readonly indexed: false;
218
+ readonly internalType: "uint256";
219
+ readonly name: "tokenId";
220
+ readonly type: "uint256";
221
+ }, {
222
+ readonly components: readonly [{
223
+ readonly internalType: "address payable";
224
+ readonly name: "account";
225
+ readonly type: "address";
226
+ }, {
227
+ readonly internalType: "uint96";
228
+ readonly name: "value";
229
+ readonly type: "uint96";
230
+ }];
231
+ readonly indexed: false;
232
+ readonly internalType: "struct LibPart.Part[]";
233
+ readonly name: "royalties";
234
+ readonly type: "tuple[]";
235
+ }];
236
+ readonly name: "RoyaltiesSet";
237
+ readonly type: "event";
238
+ }, {
239
+ readonly anonymous: false;
240
+ readonly inputs: readonly [{
241
+ readonly indexed: false;
242
+ readonly internalType: "uint256";
243
+ readonly name: "tokenId";
244
+ readonly type: "uint256";
245
+ }, {
246
+ readonly indexed: false;
247
+ readonly internalType: "uint256";
248
+ readonly name: "value";
249
+ readonly type: "uint256";
250
+ }];
251
+ readonly name: "Supply";
252
+ readonly type: "event";
253
+ }, {
254
+ readonly anonymous: false;
255
+ readonly inputs: readonly [{
256
+ readonly indexed: true;
257
+ readonly internalType: "address";
258
+ readonly name: "operator";
259
+ readonly type: "address";
260
+ }, {
261
+ readonly indexed: true;
262
+ readonly internalType: "address";
263
+ readonly name: "from";
264
+ readonly type: "address";
265
+ }, {
266
+ readonly indexed: true;
267
+ readonly internalType: "address";
268
+ readonly name: "to";
269
+ readonly type: "address";
270
+ }, {
271
+ readonly indexed: false;
272
+ readonly internalType: "uint256[]";
273
+ readonly name: "ids";
274
+ readonly type: "uint256[]";
275
+ }, {
276
+ readonly indexed: false;
277
+ readonly internalType: "uint256[]";
278
+ readonly name: "values";
279
+ readonly type: "uint256[]";
280
+ }];
281
+ readonly name: "TransferBatch";
282
+ readonly type: "event";
283
+ }, {
284
+ readonly anonymous: false;
285
+ readonly inputs: readonly [{
286
+ readonly indexed: true;
287
+ readonly internalType: "address";
288
+ readonly name: "operator";
289
+ readonly type: "address";
290
+ }, {
291
+ readonly indexed: true;
292
+ readonly internalType: "address";
293
+ readonly name: "from";
294
+ readonly type: "address";
295
+ }, {
296
+ readonly indexed: true;
297
+ readonly internalType: "address";
298
+ readonly name: "to";
299
+ readonly type: "address";
300
+ }, {
301
+ readonly indexed: false;
302
+ readonly internalType: "uint256";
303
+ readonly name: "id";
304
+ readonly type: "uint256";
305
+ }, {
306
+ readonly indexed: false;
307
+ readonly internalType: "uint256";
308
+ readonly name: "value";
309
+ readonly type: "uint256";
310
+ }];
311
+ readonly name: "TransferSingle";
312
+ readonly type: "event";
313
+ }, {
314
+ readonly anonymous: false;
315
+ readonly inputs: readonly [{
316
+ readonly indexed: false;
317
+ readonly internalType: "string";
318
+ readonly name: "value";
319
+ readonly type: "string";
320
+ }, {
321
+ readonly indexed: true;
322
+ readonly internalType: "uint256";
323
+ readonly name: "id";
324
+ readonly type: "uint256";
325
+ }];
326
+ readonly name: "URI";
327
+ readonly type: "event";
328
+ }, {
329
+ readonly inputs: readonly [{
330
+ readonly internalType: "string";
331
+ readonly name: "_name";
332
+ readonly type: "string";
333
+ }, {
334
+ readonly internalType: "string";
335
+ readonly name: "_symbol";
336
+ readonly type: "string";
337
+ }, {
338
+ readonly internalType: "string";
339
+ readonly name: "baseURI";
340
+ readonly type: "string";
341
+ }, {
342
+ readonly internalType: "string";
343
+ readonly name: "contractURI";
344
+ readonly type: "string";
345
+ }, {
346
+ readonly internalType: "address[]";
347
+ readonly name: "operators";
348
+ readonly type: "address[]";
349
+ }, {
350
+ readonly internalType: "address";
351
+ readonly name: "transferProxy";
352
+ readonly type: "address";
353
+ }, {
354
+ readonly internalType: "address";
355
+ readonly name: "lazyTransferProxy";
356
+ readonly type: "address";
357
+ }];
358
+ readonly name: "__ERC1155RaribleUser_init";
359
+ readonly outputs: readonly [];
360
+ readonly stateMutability: "nonpayable";
361
+ readonly type: "function";
362
+ }, {
363
+ readonly inputs: readonly [{
364
+ readonly internalType: "string";
365
+ readonly name: "_name";
366
+ readonly type: "string";
367
+ }, {
368
+ readonly internalType: "string";
369
+ readonly name: "_symbol";
370
+ readonly type: "string";
371
+ }, {
372
+ readonly internalType: "string";
373
+ readonly name: "baseURI";
374
+ readonly type: "string";
375
+ }, {
376
+ readonly internalType: "string";
377
+ readonly name: "contractURI";
378
+ readonly type: "string";
379
+ }, {
380
+ readonly internalType: "address";
381
+ readonly name: "transferProxy";
382
+ readonly type: "address";
383
+ }, {
384
+ readonly internalType: "address";
385
+ readonly name: "lazyTransferProxy";
386
+ readonly type: "address";
387
+ }];
388
+ readonly name: "__ERC1155Rarible_init";
389
+ readonly outputs: readonly [];
390
+ readonly stateMutability: "nonpayable";
391
+ readonly type: "function";
392
+ }, {
393
+ readonly inputs: readonly [{
394
+ readonly internalType: "address";
395
+ readonly name: "minter";
396
+ readonly type: "address";
397
+ }];
398
+ readonly name: "addMinter";
399
+ readonly outputs: readonly [];
400
+ readonly stateMutability: "nonpayable";
401
+ readonly type: "function";
402
+ }, {
403
+ readonly inputs: readonly [{
404
+ readonly internalType: "address[]";
405
+ readonly name: "minters";
406
+ readonly type: "address[]";
407
+ }];
408
+ readonly name: "addMinters";
409
+ readonly outputs: readonly [];
410
+ readonly stateMutability: "nonpayable";
411
+ readonly type: "function";
412
+ }, {
413
+ readonly inputs: readonly [{
414
+ readonly internalType: "address";
415
+ readonly name: "account";
416
+ readonly type: "address";
417
+ }, {
418
+ readonly internalType: "uint256";
419
+ readonly name: "id";
420
+ readonly type: "uint256";
421
+ }];
422
+ readonly name: "balanceOf";
423
+ readonly outputs: readonly [{
424
+ readonly internalType: "uint256";
425
+ readonly name: "";
426
+ readonly type: "uint256";
427
+ }];
428
+ readonly stateMutability: "view";
429
+ readonly type: "function";
430
+ }, {
431
+ readonly inputs: readonly [{
432
+ readonly internalType: "address[]";
433
+ readonly name: "accounts";
434
+ readonly type: "address[]";
435
+ }, {
436
+ readonly internalType: "uint256[]";
437
+ readonly name: "ids";
438
+ readonly type: "uint256[]";
439
+ }];
440
+ readonly name: "balanceOfBatch";
441
+ readonly outputs: readonly [{
442
+ readonly internalType: "uint256[]";
443
+ readonly name: "";
444
+ readonly type: "uint256[]";
445
+ }];
446
+ readonly stateMutability: "view";
447
+ readonly type: "function";
448
+ }, {
449
+ readonly inputs: readonly [];
450
+ readonly name: "baseURI";
451
+ readonly outputs: readonly [{
452
+ readonly internalType: "string";
453
+ readonly name: "";
454
+ readonly type: "string";
455
+ }];
456
+ readonly stateMutability: "view";
457
+ readonly type: "function";
458
+ }, {
459
+ readonly inputs: readonly [{
460
+ readonly internalType: "address";
461
+ readonly name: "account";
462
+ readonly type: "address";
463
+ }, {
464
+ readonly internalType: "uint256";
465
+ readonly name: "id";
466
+ readonly type: "uint256";
467
+ }, {
468
+ readonly internalType: "uint256";
469
+ readonly name: "amount";
470
+ readonly type: "uint256";
471
+ }];
472
+ readonly name: "burn";
473
+ readonly outputs: readonly [];
474
+ readonly stateMutability: "nonpayable";
475
+ readonly type: "function";
476
+ }, {
477
+ readonly inputs: readonly [{
478
+ readonly internalType: "address";
479
+ readonly name: "account";
480
+ readonly type: "address";
481
+ }, {
482
+ readonly internalType: "uint256[]";
483
+ readonly name: "ids";
484
+ readonly type: "uint256[]";
485
+ }, {
486
+ readonly internalType: "uint256[]";
487
+ readonly name: "amounts";
488
+ readonly type: "uint256[]";
489
+ }];
490
+ readonly name: "burnBatch";
491
+ readonly outputs: readonly [];
492
+ readonly stateMutability: "nonpayable";
493
+ readonly type: "function";
494
+ }, {
495
+ readonly inputs: readonly [];
496
+ readonly name: "contractURI";
497
+ readonly outputs: readonly [{
498
+ readonly internalType: "string";
499
+ readonly name: "";
500
+ readonly type: "string";
501
+ }];
502
+ readonly stateMutability: "view";
503
+ readonly type: "function";
504
+ }, {
505
+ readonly inputs: readonly [{
506
+ readonly internalType: "uint256";
507
+ readonly name: "_id";
508
+ readonly type: "uint256";
509
+ }];
510
+ readonly name: "getCreators";
511
+ readonly outputs: readonly [{
512
+ readonly components: readonly [{
513
+ readonly internalType: "address payable";
514
+ readonly name: "account";
515
+ readonly type: "address";
516
+ }, {
517
+ readonly internalType: "uint96";
518
+ readonly name: "value";
519
+ readonly type: "uint96";
520
+ }];
521
+ readonly internalType: "struct LibPart.Part[]";
522
+ readonly name: "";
523
+ readonly type: "tuple[]";
524
+ }];
525
+ readonly stateMutability: "view";
526
+ readonly type: "function";
527
+ }, {
528
+ readonly inputs: readonly [{
529
+ readonly internalType: "uint256";
530
+ readonly name: "id";
531
+ readonly type: "uint256";
532
+ }];
533
+ readonly name: "getRaribleV2Royalties";
534
+ readonly outputs: readonly [{
535
+ readonly components: readonly [{
536
+ readonly internalType: "address payable";
537
+ readonly name: "account";
538
+ readonly type: "address";
539
+ }, {
540
+ readonly internalType: "uint96";
541
+ readonly name: "value";
542
+ readonly type: "uint96";
543
+ }];
544
+ readonly internalType: "struct LibPart.Part[]";
545
+ readonly name: "";
546
+ readonly type: "tuple[]";
547
+ }];
548
+ readonly stateMutability: "view";
549
+ readonly type: "function";
550
+ }, {
551
+ readonly inputs: readonly [{
552
+ readonly internalType: "address";
553
+ readonly name: "_owner";
554
+ readonly type: "address";
555
+ }, {
556
+ readonly internalType: "address";
557
+ readonly name: "_operator";
558
+ readonly type: "address";
559
+ }];
560
+ readonly name: "isApprovedForAll";
561
+ readonly outputs: readonly [{
562
+ readonly internalType: "bool";
563
+ readonly name: "";
564
+ readonly type: "bool";
565
+ }];
566
+ readonly stateMutability: "view";
567
+ readonly type: "function";
568
+ }, {
569
+ readonly inputs: readonly [{
570
+ readonly internalType: "address";
571
+ readonly name: "account";
572
+ readonly type: "address";
573
+ }];
574
+ readonly name: "isMinter";
575
+ readonly outputs: readonly [{
576
+ readonly internalType: "bool";
577
+ readonly name: "";
578
+ readonly type: "bool";
579
+ }];
580
+ readonly stateMutability: "view";
581
+ readonly type: "function";
582
+ }, {
583
+ readonly inputs: readonly [{
584
+ readonly components: readonly [{
585
+ readonly internalType: "uint256";
586
+ readonly name: "tokenId";
587
+ readonly type: "uint256";
588
+ }, {
589
+ readonly internalType: "string";
590
+ readonly name: "tokenURI";
591
+ readonly type: "string";
592
+ }, {
593
+ readonly internalType: "uint256";
594
+ readonly name: "supply";
595
+ readonly type: "uint256";
596
+ }, {
597
+ readonly components: readonly [{
598
+ readonly internalType: "address payable";
599
+ readonly name: "account";
600
+ readonly type: "address";
601
+ }, {
602
+ readonly internalType: "uint96";
603
+ readonly name: "value";
604
+ readonly type: "uint96";
605
+ }];
606
+ readonly internalType: "struct LibPart.Part[]";
607
+ readonly name: "creators";
608
+ readonly type: "tuple[]";
609
+ }, {
610
+ readonly components: readonly [{
611
+ readonly internalType: "address payable";
612
+ readonly name: "account";
613
+ readonly type: "address";
614
+ }, {
615
+ readonly internalType: "uint96";
616
+ readonly name: "value";
617
+ readonly type: "uint96";
618
+ }];
619
+ readonly internalType: "struct LibPart.Part[]";
620
+ readonly name: "royalties";
621
+ readonly type: "tuple[]";
622
+ }, {
623
+ readonly internalType: "bytes[]";
624
+ readonly name: "signatures";
625
+ readonly type: "bytes[]";
626
+ }];
627
+ readonly internalType: "struct LibERC1155LazyMint.Mint1155Data";
628
+ readonly name: "data";
629
+ readonly type: "tuple";
630
+ }, {
631
+ readonly internalType: "address";
632
+ readonly name: "to";
633
+ readonly type: "address";
634
+ }, {
635
+ readonly internalType: "uint256";
636
+ readonly name: "_amount";
637
+ readonly type: "uint256";
638
+ }];
639
+ readonly name: "mintAndTransfer";
640
+ readonly outputs: readonly [];
641
+ readonly stateMutability: "nonpayable";
642
+ readonly type: "function";
643
+ }, {
644
+ readonly inputs: readonly [];
645
+ readonly name: "name";
646
+ readonly outputs: readonly [{
647
+ readonly internalType: "string";
648
+ readonly name: "";
649
+ readonly type: "string";
650
+ }];
651
+ readonly stateMutability: "view";
652
+ readonly type: "function";
653
+ }, {
654
+ readonly inputs: readonly [];
655
+ readonly name: "owner";
656
+ readonly outputs: readonly [{
657
+ readonly internalType: "address";
658
+ readonly name: "";
659
+ readonly type: "address";
660
+ }];
661
+ readonly stateMutability: "view";
662
+ readonly type: "function";
663
+ }, {
664
+ readonly inputs: readonly [{
665
+ readonly internalType: "address";
666
+ readonly name: "_minter";
667
+ readonly type: "address";
668
+ }];
669
+ readonly name: "removeMinter";
670
+ readonly outputs: readonly [];
671
+ readonly stateMutability: "nonpayable";
672
+ readonly type: "function";
673
+ }, {
674
+ readonly inputs: readonly [];
675
+ readonly name: "renounceOwnership";
676
+ readonly outputs: readonly [];
677
+ readonly stateMutability: "nonpayable";
678
+ readonly type: "function";
679
+ }, {
680
+ readonly inputs: readonly [{
681
+ readonly internalType: "uint256";
682
+ readonly name: "id";
683
+ readonly type: "uint256";
684
+ }, {
685
+ readonly internalType: "uint256";
686
+ readonly name: "_salePrice";
687
+ readonly type: "uint256";
688
+ }];
689
+ readonly name: "royaltyInfo";
690
+ readonly outputs: readonly [{
691
+ readonly internalType: "address";
692
+ readonly name: "receiver";
693
+ readonly type: "address";
694
+ }, {
695
+ readonly internalType: "uint256";
696
+ readonly name: "royaltyAmount";
697
+ readonly type: "uint256";
698
+ }];
699
+ readonly stateMutability: "view";
700
+ readonly type: "function";
701
+ }, {
702
+ readonly inputs: readonly [{
703
+ readonly internalType: "address";
704
+ readonly name: "from";
705
+ readonly type: "address";
706
+ }, {
707
+ readonly internalType: "address";
708
+ readonly name: "to";
709
+ readonly type: "address";
710
+ }, {
711
+ readonly internalType: "uint256[]";
712
+ readonly name: "ids";
713
+ readonly type: "uint256[]";
714
+ }, {
715
+ readonly internalType: "uint256[]";
716
+ readonly name: "amounts";
717
+ readonly type: "uint256[]";
718
+ }, {
719
+ readonly internalType: "bytes";
720
+ readonly name: "data";
721
+ readonly type: "bytes";
722
+ }];
723
+ readonly name: "safeBatchTransferFrom";
724
+ readonly outputs: readonly [];
725
+ readonly stateMutability: "nonpayable";
726
+ readonly type: "function";
727
+ }, {
728
+ readonly inputs: readonly [{
729
+ readonly internalType: "address";
730
+ readonly name: "from";
731
+ readonly type: "address";
732
+ }, {
733
+ readonly internalType: "address";
734
+ readonly name: "to";
735
+ readonly type: "address";
736
+ }, {
737
+ readonly internalType: "uint256";
738
+ readonly name: "id";
739
+ readonly type: "uint256";
740
+ }, {
741
+ readonly internalType: "uint256";
742
+ readonly name: "amount";
743
+ readonly type: "uint256";
744
+ }, {
745
+ readonly internalType: "bytes";
746
+ readonly name: "data";
747
+ readonly type: "bytes";
748
+ }];
749
+ readonly name: "safeTransferFrom";
750
+ readonly outputs: readonly [];
751
+ readonly stateMutability: "nonpayable";
752
+ readonly type: "function";
753
+ }, {
754
+ readonly inputs: readonly [{
755
+ readonly internalType: "address";
756
+ readonly name: "operator";
757
+ readonly type: "address";
758
+ }, {
759
+ readonly internalType: "bool";
760
+ readonly name: "approved";
761
+ readonly type: "bool";
762
+ }];
763
+ readonly name: "setApprovalForAll";
764
+ readonly outputs: readonly [];
765
+ readonly stateMutability: "nonpayable";
766
+ readonly type: "function";
767
+ }, {
768
+ readonly inputs: readonly [{
769
+ readonly internalType: "string";
770
+ readonly name: "newBaseURI";
771
+ readonly type: "string";
772
+ }];
773
+ readonly name: "setBaseURI";
774
+ readonly outputs: readonly [];
775
+ readonly stateMutability: "nonpayable";
776
+ readonly type: "function";
777
+ }, {
778
+ readonly inputs: readonly [{
779
+ readonly internalType: "bytes4";
780
+ readonly name: "interfaceId";
781
+ readonly type: "bytes4";
782
+ }];
783
+ readonly name: "supportsInterface";
784
+ readonly outputs: readonly [{
785
+ readonly internalType: "bool";
786
+ readonly name: "";
787
+ readonly type: "bool";
788
+ }];
789
+ readonly stateMutability: "view";
790
+ readonly type: "function";
791
+ }, {
792
+ readonly inputs: readonly [];
793
+ readonly name: "symbol";
794
+ readonly outputs: readonly [{
795
+ readonly internalType: "string";
796
+ readonly name: "";
797
+ readonly type: "string";
798
+ }];
799
+ readonly stateMutability: "view";
800
+ readonly type: "function";
801
+ }, {
802
+ readonly inputs: readonly [{
803
+ readonly components: readonly [{
804
+ readonly internalType: "uint256";
805
+ readonly name: "tokenId";
806
+ readonly type: "uint256";
807
+ }, {
808
+ readonly internalType: "string";
809
+ readonly name: "tokenURI";
810
+ readonly type: "string";
811
+ }, {
812
+ readonly internalType: "uint256";
813
+ readonly name: "supply";
814
+ readonly type: "uint256";
815
+ }, {
816
+ readonly components: readonly [{
817
+ readonly internalType: "address payable";
818
+ readonly name: "account";
819
+ readonly type: "address";
820
+ }, {
821
+ readonly internalType: "uint96";
822
+ readonly name: "value";
823
+ readonly type: "uint96";
824
+ }];
825
+ readonly internalType: "struct LibPart.Part[]";
826
+ readonly name: "creators";
827
+ readonly type: "tuple[]";
828
+ }, {
829
+ readonly components: readonly [{
830
+ readonly internalType: "address payable";
831
+ readonly name: "account";
832
+ readonly type: "address";
833
+ }, {
834
+ readonly internalType: "uint96";
835
+ readonly name: "value";
836
+ readonly type: "uint96";
837
+ }];
838
+ readonly internalType: "struct LibPart.Part[]";
839
+ readonly name: "royalties";
840
+ readonly type: "tuple[]";
841
+ }, {
842
+ readonly internalType: "bytes[]";
843
+ readonly name: "signatures";
844
+ readonly type: "bytes[]";
845
+ }];
846
+ readonly internalType: "struct LibERC1155LazyMint.Mint1155Data";
847
+ readonly name: "data";
848
+ readonly type: "tuple";
849
+ }, {
850
+ readonly internalType: "address";
851
+ readonly name: "from";
852
+ readonly type: "address";
853
+ }, {
854
+ readonly internalType: "address";
855
+ readonly name: "to";
856
+ readonly type: "address";
857
+ }, {
858
+ readonly internalType: "uint256";
859
+ readonly name: "amount";
860
+ readonly type: "uint256";
861
+ }];
862
+ readonly name: "transferFromOrMint";
863
+ readonly outputs: readonly [];
864
+ readonly stateMutability: "nonpayable";
865
+ readonly type: "function";
866
+ }, {
867
+ readonly inputs: readonly [{
868
+ readonly internalType: "address";
869
+ readonly name: "newOwner";
870
+ readonly type: "address";
871
+ }];
872
+ readonly name: "transferOwnership";
873
+ readonly outputs: readonly [];
874
+ readonly stateMutability: "nonpayable";
875
+ readonly type: "function";
876
+ }, {
877
+ readonly inputs: readonly [{
878
+ readonly internalType: "uint256";
879
+ readonly name: "_id";
880
+ readonly type: "uint256";
881
+ }, {
882
+ readonly internalType: "address";
883
+ readonly name: "_from";
884
+ readonly type: "address";
885
+ }, {
886
+ readonly internalType: "address";
887
+ readonly name: "_to";
888
+ readonly type: "address";
889
+ }];
890
+ readonly name: "updateAccount";
891
+ readonly outputs: readonly [];
892
+ readonly stateMutability: "nonpayable";
893
+ readonly type: "function";
894
+ }, {
895
+ readonly inputs: readonly [{
896
+ readonly internalType: "uint256";
897
+ readonly name: "id";
898
+ readonly type: "uint256";
899
+ }];
900
+ readonly name: "uri";
901
+ readonly outputs: readonly [{
902
+ readonly internalType: "string";
903
+ readonly name: "";
904
+ readonly type: "string";
905
+ }];
906
+ readonly stateMutability: "view";
907
+ readonly type: "function";
908
+ }];
909
+ /**
910
+ * Type-safe ABI for ERC1155Rarible_json
911
+ */
912
+ export type ERC1155Rarible_jsonAbi = typeof ERC1155Rarible_jsonAbi;
913
+ /**
914
+ * Contract instance type for ERC1155Rarible_json
915
+ */
916
+ export type ERC1155Rarible_jsonContract = any;
917
+ /**
918
+ * ERC1155Rarible_json Contract Class
919
+ *
920
+ * Provides a class-based API similar to TypeChain for interacting with the contract.
921
+ *
922
+ * @example
923
+ * ```typescript
924
+ * import { createPublicClient, createWalletClient, http } from 'viem';
925
+ * import { mainnet } from 'viem/chains';
926
+ * import { ERC1155Rarible_json } from 'ERC1155Rarible_json';
927
+ *
928
+ * const publicClient = createPublicClient({ chain: mainnet, transport: http() });
929
+ * const walletClient = createWalletClient({ chain: mainnet, transport: http() });
930
+ *
931
+ * const contract = new ERC1155Rarible_json('0x...', { publicClient, walletClient });
932
+ *
933
+ * // Read functions
934
+ * const result = await contract.balanceOf('0x...');
935
+ *
936
+ * // Write functions
937
+ * const hash = await contract.transfer('0x...', 1000n);
938
+ *
939
+ * // Simulate transactions (dry-run)
940
+ * const simulation = await contract.simulate.transfer('0x...', 1000n);
941
+ * console.log('Gas estimate:', simulation.request.gas);
942
+ *
943
+ * // Watch events
944
+ * const unwatch = contract.watch.Transfer((event) => {
945
+ * console.log('Transfer event:', event);
946
+ * });
947
+ * ```
948
+ */
949
+ export declare class ERC1155Rarible_json {
950
+ private contract;
951
+ private contractAddress;
952
+ private publicClient;
953
+ constructor(address: Address, clients: {
954
+ publicClient: PublicClient;
955
+ walletClient?: WalletClient;
956
+ });
957
+ /**
958
+ * Get the contract address
959
+ */
960
+ get address(): Address;
961
+ /**
962
+ * Get the underlying viem contract instance
963
+ */
964
+ getContract(): ERC1155Rarible_jsonContract;
965
+ /**
966
+ * balanceOf
967
+ * view
968
+ */
969
+ balanceOf(account: `0x${string}`, id: bigint): Promise<bigint>;
970
+ /**
971
+ * balanceOfBatch
972
+ * view
973
+ */
974
+ balanceOfBatch(accounts: `0x${string}`[], ids: bigint[]): Promise<bigint[]>;
975
+ /**
976
+ * baseURI
977
+ * view
978
+ */
979
+ baseURI(): Promise<string>;
980
+ /**
981
+ * contractURI
982
+ * view
983
+ */
984
+ contractURI(): Promise<string>;
985
+ /**
986
+ * getCreators
987
+ * view
988
+ */
989
+ getCreators(_id: bigint): Promise<LibPart_Part[]>;
990
+ /**
991
+ * getRaribleV2Royalties
992
+ * view
993
+ */
994
+ getRaribleV2Royalties(id: bigint): Promise<LibPart_Part[]>;
995
+ /**
996
+ * isApprovedForAll
997
+ * view
998
+ */
999
+ isApprovedForAll(_owner: `0x${string}`, _operator: `0x${string}`): Promise<boolean>;
1000
+ /**
1001
+ * isMinter
1002
+ * view
1003
+ */
1004
+ isMinter(account: `0x${string}`): Promise<boolean>;
1005
+ /**
1006
+ * name
1007
+ * view
1008
+ */
1009
+ name(): Promise<string>;
1010
+ /**
1011
+ * owner
1012
+ * view
1013
+ */
1014
+ owner(): Promise<`0x${string}`>;
1015
+ /**
1016
+ * royaltyInfo
1017
+ * view
1018
+ */
1019
+ royaltyInfo(id: bigint, _salePrice: bigint): Promise<[`0x${string}`, bigint]>;
1020
+ /**
1021
+ * supportsInterface
1022
+ * view
1023
+ */
1024
+ supportsInterface(interfaceId: `0x${string}`): Promise<boolean>;
1025
+ /**
1026
+ * symbol
1027
+ * view
1028
+ */
1029
+ symbol(): Promise<string>;
1030
+ /**
1031
+ * uri
1032
+ * view
1033
+ */
1034
+ uri(id: bigint): Promise<string>;
1035
+ /**
1036
+ * __ERC1155RaribleUser_init
1037
+ * nonpayable
1038
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1039
+ */
1040
+ __ERC1155RaribleUser_init(_name: string, _symbol: string, baseURI: string, contractURI: string, operators: `0x${string}`[], transferProxy: `0x${string}`, lazyTransferProxy: `0x${string}`, options?: {
1041
+ accessList?: import('viem').AccessList;
1042
+ authorizationList?: import('viem').AuthorizationList;
1043
+ chain?: import('viem').Chain | null;
1044
+ dataSuffix?: `0x${string}`;
1045
+ gas?: bigint;
1046
+ gasPrice?: bigint;
1047
+ maxFeePerGas?: bigint;
1048
+ maxPriorityFeePerGas?: bigint;
1049
+ nonce?: number;
1050
+ value?: bigint;
1051
+ }): Promise<`0x${string}`>;
1052
+ /**
1053
+ * __ERC1155Rarible_init
1054
+ * nonpayable
1055
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1056
+ */
1057
+ __ERC1155Rarible_init(_name: string, _symbol: string, baseURI: string, contractURI: string, transferProxy: `0x${string}`, lazyTransferProxy: `0x${string}`, options?: {
1058
+ accessList?: import('viem').AccessList;
1059
+ authorizationList?: import('viem').AuthorizationList;
1060
+ chain?: import('viem').Chain | null;
1061
+ dataSuffix?: `0x${string}`;
1062
+ gas?: bigint;
1063
+ gasPrice?: bigint;
1064
+ maxFeePerGas?: bigint;
1065
+ maxPriorityFeePerGas?: bigint;
1066
+ nonce?: number;
1067
+ value?: bigint;
1068
+ }): Promise<`0x${string}`>;
1069
+ /**
1070
+ * addMinter
1071
+ * nonpayable
1072
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1073
+ */
1074
+ addMinter(minter: `0x${string}`, options?: {
1075
+ accessList?: import('viem').AccessList;
1076
+ authorizationList?: import('viem').AuthorizationList;
1077
+ chain?: import('viem').Chain | null;
1078
+ dataSuffix?: `0x${string}`;
1079
+ gas?: bigint;
1080
+ gasPrice?: bigint;
1081
+ maxFeePerGas?: bigint;
1082
+ maxPriorityFeePerGas?: bigint;
1083
+ nonce?: number;
1084
+ value?: bigint;
1085
+ }): Promise<`0x${string}`>;
1086
+ /**
1087
+ * addMinters
1088
+ * nonpayable
1089
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1090
+ */
1091
+ addMinters(minters: `0x${string}`[], options?: {
1092
+ accessList?: import('viem').AccessList;
1093
+ authorizationList?: import('viem').AuthorizationList;
1094
+ chain?: import('viem').Chain | null;
1095
+ dataSuffix?: `0x${string}`;
1096
+ gas?: bigint;
1097
+ gasPrice?: bigint;
1098
+ maxFeePerGas?: bigint;
1099
+ maxPriorityFeePerGas?: bigint;
1100
+ nonce?: number;
1101
+ value?: bigint;
1102
+ }): Promise<`0x${string}`>;
1103
+ /**
1104
+ * burn
1105
+ * nonpayable
1106
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1107
+ */
1108
+ burn(account: `0x${string}`, id: bigint, amount: bigint, options?: {
1109
+ accessList?: import('viem').AccessList;
1110
+ authorizationList?: import('viem').AuthorizationList;
1111
+ chain?: import('viem').Chain | null;
1112
+ dataSuffix?: `0x${string}`;
1113
+ gas?: bigint;
1114
+ gasPrice?: bigint;
1115
+ maxFeePerGas?: bigint;
1116
+ maxPriorityFeePerGas?: bigint;
1117
+ nonce?: number;
1118
+ value?: bigint;
1119
+ }): Promise<`0x${string}`>;
1120
+ /**
1121
+ * burnBatch
1122
+ * nonpayable
1123
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1124
+ */
1125
+ burnBatch(account: `0x${string}`, ids: bigint[], amounts: bigint[], options?: {
1126
+ accessList?: import('viem').AccessList;
1127
+ authorizationList?: import('viem').AuthorizationList;
1128
+ chain?: import('viem').Chain | null;
1129
+ dataSuffix?: `0x${string}`;
1130
+ gas?: bigint;
1131
+ gasPrice?: bigint;
1132
+ maxFeePerGas?: bigint;
1133
+ maxPriorityFeePerGas?: bigint;
1134
+ nonce?: number;
1135
+ value?: bigint;
1136
+ }): Promise<`0x${string}`>;
1137
+ /**
1138
+ * mintAndTransfer
1139
+ * nonpayable
1140
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1141
+ */
1142
+ mintAndTransfer(data: LibERC1155LazyMint_Mint1155Data, to: `0x${string}`, _amount: bigint, options?: {
1143
+ accessList?: import('viem').AccessList;
1144
+ authorizationList?: import('viem').AuthorizationList;
1145
+ chain?: import('viem').Chain | null;
1146
+ dataSuffix?: `0x${string}`;
1147
+ gas?: bigint;
1148
+ gasPrice?: bigint;
1149
+ maxFeePerGas?: bigint;
1150
+ maxPriorityFeePerGas?: bigint;
1151
+ nonce?: number;
1152
+ value?: bigint;
1153
+ }): Promise<`0x${string}`>;
1154
+ /**
1155
+ * removeMinter
1156
+ * nonpayable
1157
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1158
+ */
1159
+ removeMinter(_minter: `0x${string}`, options?: {
1160
+ accessList?: import('viem').AccessList;
1161
+ authorizationList?: import('viem').AuthorizationList;
1162
+ chain?: import('viem').Chain | null;
1163
+ dataSuffix?: `0x${string}`;
1164
+ gas?: bigint;
1165
+ gasPrice?: bigint;
1166
+ maxFeePerGas?: bigint;
1167
+ maxPriorityFeePerGas?: bigint;
1168
+ nonce?: number;
1169
+ value?: bigint;
1170
+ }): Promise<`0x${string}`>;
1171
+ /**
1172
+ * renounceOwnership
1173
+ * nonpayable
1174
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1175
+ */
1176
+ renounceOwnership(options?: {
1177
+ accessList?: import('viem').AccessList;
1178
+ authorizationList?: import('viem').AuthorizationList;
1179
+ chain?: import('viem').Chain | null;
1180
+ dataSuffix?: `0x${string}`;
1181
+ gas?: bigint;
1182
+ gasPrice?: bigint;
1183
+ maxFeePerGas?: bigint;
1184
+ maxPriorityFeePerGas?: bigint;
1185
+ nonce?: number;
1186
+ value?: bigint;
1187
+ }): Promise<`0x${string}`>;
1188
+ /**
1189
+ * safeBatchTransferFrom
1190
+ * nonpayable
1191
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1192
+ */
1193
+ safeBatchTransferFrom(from: `0x${string}`, to: `0x${string}`, ids: bigint[], amounts: bigint[], data: `0x${string}`, options?: {
1194
+ accessList?: import('viem').AccessList;
1195
+ authorizationList?: import('viem').AuthorizationList;
1196
+ chain?: import('viem').Chain | null;
1197
+ dataSuffix?: `0x${string}`;
1198
+ gas?: bigint;
1199
+ gasPrice?: bigint;
1200
+ maxFeePerGas?: bigint;
1201
+ maxPriorityFeePerGas?: bigint;
1202
+ nonce?: number;
1203
+ value?: bigint;
1204
+ }): Promise<`0x${string}`>;
1205
+ /**
1206
+ * safeTransferFrom
1207
+ * nonpayable
1208
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1209
+ */
1210
+ safeTransferFrom(from: `0x${string}`, to: `0x${string}`, id: bigint, amount: bigint, data: `0x${string}`, options?: {
1211
+ accessList?: import('viem').AccessList;
1212
+ authorizationList?: import('viem').AuthorizationList;
1213
+ chain?: import('viem').Chain | null;
1214
+ dataSuffix?: `0x${string}`;
1215
+ gas?: bigint;
1216
+ gasPrice?: bigint;
1217
+ maxFeePerGas?: bigint;
1218
+ maxPriorityFeePerGas?: bigint;
1219
+ nonce?: number;
1220
+ value?: bigint;
1221
+ }): Promise<`0x${string}`>;
1222
+ /**
1223
+ * setApprovalForAll
1224
+ * nonpayable
1225
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1226
+ */
1227
+ setApprovalForAll(operator: `0x${string}`, approved: boolean, options?: {
1228
+ accessList?: import('viem').AccessList;
1229
+ authorizationList?: import('viem').AuthorizationList;
1230
+ chain?: import('viem').Chain | null;
1231
+ dataSuffix?: `0x${string}`;
1232
+ gas?: bigint;
1233
+ gasPrice?: bigint;
1234
+ maxFeePerGas?: bigint;
1235
+ maxPriorityFeePerGas?: bigint;
1236
+ nonce?: number;
1237
+ value?: bigint;
1238
+ }): Promise<`0x${string}`>;
1239
+ /**
1240
+ * setBaseURI
1241
+ * nonpayable
1242
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1243
+ */
1244
+ setBaseURI(newBaseURI: string, options?: {
1245
+ accessList?: import('viem').AccessList;
1246
+ authorizationList?: import('viem').AuthorizationList;
1247
+ chain?: import('viem').Chain | null;
1248
+ dataSuffix?: `0x${string}`;
1249
+ gas?: bigint;
1250
+ gasPrice?: bigint;
1251
+ maxFeePerGas?: bigint;
1252
+ maxPriorityFeePerGas?: bigint;
1253
+ nonce?: number;
1254
+ value?: bigint;
1255
+ }): Promise<`0x${string}`>;
1256
+ /**
1257
+ * transferFromOrMint
1258
+ * nonpayable
1259
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1260
+ */
1261
+ transferFromOrMint(data: LibERC1155LazyMint_Mint1155Data, from: `0x${string}`, to: `0x${string}`, amount: bigint, options?: {
1262
+ accessList?: import('viem').AccessList;
1263
+ authorizationList?: import('viem').AuthorizationList;
1264
+ chain?: import('viem').Chain | null;
1265
+ dataSuffix?: `0x${string}`;
1266
+ gas?: bigint;
1267
+ gasPrice?: bigint;
1268
+ maxFeePerGas?: bigint;
1269
+ maxPriorityFeePerGas?: bigint;
1270
+ nonce?: number;
1271
+ value?: bigint;
1272
+ }): Promise<`0x${string}`>;
1273
+ /**
1274
+ * transferOwnership
1275
+ * nonpayable
1276
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1277
+ */
1278
+ transferOwnership(newOwner: `0x${string}`, options?: {
1279
+ accessList?: import('viem').AccessList;
1280
+ authorizationList?: import('viem').AuthorizationList;
1281
+ chain?: import('viem').Chain | null;
1282
+ dataSuffix?: `0x${string}`;
1283
+ gas?: bigint;
1284
+ gasPrice?: bigint;
1285
+ maxFeePerGas?: bigint;
1286
+ maxPriorityFeePerGas?: bigint;
1287
+ nonce?: number;
1288
+ value?: bigint;
1289
+ }): Promise<`0x${string}`>;
1290
+ /**
1291
+ * updateAccount
1292
+ * nonpayable
1293
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1294
+ */
1295
+ updateAccount(_id: bigint, _from: `0x${string}`, _to: `0x${string}`, options?: {
1296
+ accessList?: import('viem').AccessList;
1297
+ authorizationList?: import('viem').AuthorizationList;
1298
+ chain?: import('viem').Chain | null;
1299
+ dataSuffix?: `0x${string}`;
1300
+ gas?: bigint;
1301
+ gasPrice?: bigint;
1302
+ maxFeePerGas?: bigint;
1303
+ maxPriorityFeePerGas?: bigint;
1304
+ nonce?: number;
1305
+ value?: bigint;
1306
+ }): Promise<`0x${string}`>;
1307
+ /**
1308
+ * Simulate contract write operations (dry-run without sending transaction)
1309
+ *
1310
+ * @example
1311
+ * const result = await contract.simulate.transfer('0x...', 1000n);
1312
+ * console.log('Gas estimate:', result.request.gas);
1313
+ * console.log('Would succeed:', result.result);
1314
+ */
1315
+ get simulate(): {
1316
+ /**
1317
+ * Simulate __ERC1155RaribleUser_init
1318
+ * Returns gas estimate and result without sending transaction
1319
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1320
+ */
1321
+ __ERC1155RaribleUser_init(_name: string, _symbol: string, baseURI: string, contractURI: string, operators: `0x${string}`[], transferProxy: `0x${string}`, lazyTransferProxy: `0x${string}`, options?: {
1322
+ accessList?: import("viem").AccessList;
1323
+ authorizationList?: import("viem").AuthorizationList;
1324
+ chain?: import("viem").Chain | null;
1325
+ dataSuffix?: `0x${string}`;
1326
+ gas?: bigint;
1327
+ gasPrice?: bigint;
1328
+ maxFeePerGas?: bigint;
1329
+ maxPriorityFeePerGas?: bigint;
1330
+ nonce?: number;
1331
+ value?: bigint;
1332
+ }): Promise<void>;
1333
+ /**
1334
+ * Simulate __ERC1155Rarible_init
1335
+ * Returns gas estimate and result without sending transaction
1336
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1337
+ */
1338
+ __ERC1155Rarible_init(_name: string, _symbol: string, baseURI: string, contractURI: string, transferProxy: `0x${string}`, lazyTransferProxy: `0x${string}`, options?: {
1339
+ accessList?: import("viem").AccessList;
1340
+ authorizationList?: import("viem").AuthorizationList;
1341
+ chain?: import("viem").Chain | null;
1342
+ dataSuffix?: `0x${string}`;
1343
+ gas?: bigint;
1344
+ gasPrice?: bigint;
1345
+ maxFeePerGas?: bigint;
1346
+ maxPriorityFeePerGas?: bigint;
1347
+ nonce?: number;
1348
+ value?: bigint;
1349
+ }): Promise<void>;
1350
+ /**
1351
+ * Simulate addMinter
1352
+ * Returns gas estimate and result without sending transaction
1353
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1354
+ */
1355
+ addMinter(minter: `0x${string}`, options?: {
1356
+ accessList?: import("viem").AccessList;
1357
+ authorizationList?: import("viem").AuthorizationList;
1358
+ chain?: import("viem").Chain | null;
1359
+ dataSuffix?: `0x${string}`;
1360
+ gas?: bigint;
1361
+ gasPrice?: bigint;
1362
+ maxFeePerGas?: bigint;
1363
+ maxPriorityFeePerGas?: bigint;
1364
+ nonce?: number;
1365
+ value?: bigint;
1366
+ }): Promise<void>;
1367
+ /**
1368
+ * Simulate addMinters
1369
+ * Returns gas estimate and result without sending transaction
1370
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1371
+ */
1372
+ addMinters(minters: `0x${string}`[], options?: {
1373
+ accessList?: import("viem").AccessList;
1374
+ authorizationList?: import("viem").AuthorizationList;
1375
+ chain?: import("viem").Chain | null;
1376
+ dataSuffix?: `0x${string}`;
1377
+ gas?: bigint;
1378
+ gasPrice?: bigint;
1379
+ maxFeePerGas?: bigint;
1380
+ maxPriorityFeePerGas?: bigint;
1381
+ nonce?: number;
1382
+ value?: bigint;
1383
+ }): Promise<void>;
1384
+ /**
1385
+ * Simulate burn
1386
+ * Returns gas estimate and result without sending transaction
1387
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1388
+ */
1389
+ burn(account: `0x${string}`, id: bigint, amount: bigint, options?: {
1390
+ accessList?: import("viem").AccessList;
1391
+ authorizationList?: import("viem").AuthorizationList;
1392
+ chain?: import("viem").Chain | null;
1393
+ dataSuffix?: `0x${string}`;
1394
+ gas?: bigint;
1395
+ gasPrice?: bigint;
1396
+ maxFeePerGas?: bigint;
1397
+ maxPriorityFeePerGas?: bigint;
1398
+ nonce?: number;
1399
+ value?: bigint;
1400
+ }): Promise<void>;
1401
+ /**
1402
+ * Simulate burnBatch
1403
+ * Returns gas estimate and result without sending transaction
1404
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1405
+ */
1406
+ burnBatch(account: `0x${string}`, ids: bigint[], amounts: bigint[], options?: {
1407
+ accessList?: import("viem").AccessList;
1408
+ authorizationList?: import("viem").AuthorizationList;
1409
+ chain?: import("viem").Chain | null;
1410
+ dataSuffix?: `0x${string}`;
1411
+ gas?: bigint;
1412
+ gasPrice?: bigint;
1413
+ maxFeePerGas?: bigint;
1414
+ maxPriorityFeePerGas?: bigint;
1415
+ nonce?: number;
1416
+ value?: bigint;
1417
+ }): Promise<void>;
1418
+ /**
1419
+ * Simulate mintAndTransfer
1420
+ * Returns gas estimate and result without sending transaction
1421
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1422
+ */
1423
+ mintAndTransfer(data: LibERC1155LazyMint_Mint1155Data, to: `0x${string}`, _amount: bigint, options?: {
1424
+ accessList?: import("viem").AccessList;
1425
+ authorizationList?: import("viem").AuthorizationList;
1426
+ chain?: import("viem").Chain | null;
1427
+ dataSuffix?: `0x${string}`;
1428
+ gas?: bigint;
1429
+ gasPrice?: bigint;
1430
+ maxFeePerGas?: bigint;
1431
+ maxPriorityFeePerGas?: bigint;
1432
+ nonce?: number;
1433
+ value?: bigint;
1434
+ }): Promise<void>;
1435
+ /**
1436
+ * Simulate removeMinter
1437
+ * Returns gas estimate and result without sending transaction
1438
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1439
+ */
1440
+ removeMinter(_minter: `0x${string}`, options?: {
1441
+ accessList?: import("viem").AccessList;
1442
+ authorizationList?: import("viem").AuthorizationList;
1443
+ chain?: import("viem").Chain | null;
1444
+ dataSuffix?: `0x${string}`;
1445
+ gas?: bigint;
1446
+ gasPrice?: bigint;
1447
+ maxFeePerGas?: bigint;
1448
+ maxPriorityFeePerGas?: bigint;
1449
+ nonce?: number;
1450
+ value?: bigint;
1451
+ }): Promise<void>;
1452
+ /**
1453
+ * Simulate renounceOwnership
1454
+ * Returns gas estimate and result without sending transaction
1455
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1456
+ */
1457
+ renounceOwnership(options?: {
1458
+ accessList?: import("viem").AccessList;
1459
+ authorizationList?: import("viem").AuthorizationList;
1460
+ chain?: import("viem").Chain | null;
1461
+ dataSuffix?: `0x${string}`;
1462
+ gas?: bigint;
1463
+ gasPrice?: bigint;
1464
+ maxFeePerGas?: bigint;
1465
+ maxPriorityFeePerGas?: bigint;
1466
+ nonce?: number;
1467
+ value?: bigint;
1468
+ }): Promise<void>;
1469
+ /**
1470
+ * Simulate safeBatchTransferFrom
1471
+ * Returns gas estimate and result without sending transaction
1472
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1473
+ */
1474
+ safeBatchTransferFrom(from: `0x${string}`, to: `0x${string}`, ids: bigint[], amounts: bigint[], data: `0x${string}`, options?: {
1475
+ accessList?: import("viem").AccessList;
1476
+ authorizationList?: import("viem").AuthorizationList;
1477
+ chain?: import("viem").Chain | null;
1478
+ dataSuffix?: `0x${string}`;
1479
+ gas?: bigint;
1480
+ gasPrice?: bigint;
1481
+ maxFeePerGas?: bigint;
1482
+ maxPriorityFeePerGas?: bigint;
1483
+ nonce?: number;
1484
+ value?: bigint;
1485
+ }): Promise<void>;
1486
+ /**
1487
+ * Simulate safeTransferFrom
1488
+ * Returns gas estimate and result without sending transaction
1489
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1490
+ */
1491
+ safeTransferFrom(from: `0x${string}`, to: `0x${string}`, id: bigint, amount: bigint, data: `0x${string}`, options?: {
1492
+ accessList?: import("viem").AccessList;
1493
+ authorizationList?: import("viem").AuthorizationList;
1494
+ chain?: import("viem").Chain | null;
1495
+ dataSuffix?: `0x${string}`;
1496
+ gas?: bigint;
1497
+ gasPrice?: bigint;
1498
+ maxFeePerGas?: bigint;
1499
+ maxPriorityFeePerGas?: bigint;
1500
+ nonce?: number;
1501
+ value?: bigint;
1502
+ }): Promise<void>;
1503
+ /**
1504
+ * Simulate setApprovalForAll
1505
+ * Returns gas estimate and result without sending transaction
1506
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1507
+ */
1508
+ setApprovalForAll(operator: `0x${string}`, approved: boolean, options?: {
1509
+ accessList?: import("viem").AccessList;
1510
+ authorizationList?: import("viem").AuthorizationList;
1511
+ chain?: import("viem").Chain | null;
1512
+ dataSuffix?: `0x${string}`;
1513
+ gas?: bigint;
1514
+ gasPrice?: bigint;
1515
+ maxFeePerGas?: bigint;
1516
+ maxPriorityFeePerGas?: bigint;
1517
+ nonce?: number;
1518
+ value?: bigint;
1519
+ }): Promise<void>;
1520
+ /**
1521
+ * Simulate setBaseURI
1522
+ * Returns gas estimate and result without sending transaction
1523
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1524
+ */
1525
+ setBaseURI(newBaseURI: string, options?: {
1526
+ accessList?: import("viem").AccessList;
1527
+ authorizationList?: import("viem").AuthorizationList;
1528
+ chain?: import("viem").Chain | null;
1529
+ dataSuffix?: `0x${string}`;
1530
+ gas?: bigint;
1531
+ gasPrice?: bigint;
1532
+ maxFeePerGas?: bigint;
1533
+ maxPriorityFeePerGas?: bigint;
1534
+ nonce?: number;
1535
+ value?: bigint;
1536
+ }): Promise<void>;
1537
+ /**
1538
+ * Simulate transferFromOrMint
1539
+ * Returns gas estimate and result without sending transaction
1540
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1541
+ */
1542
+ transferFromOrMint(data: LibERC1155LazyMint_Mint1155Data, from: `0x${string}`, to: `0x${string}`, amount: bigint, options?: {
1543
+ accessList?: import("viem").AccessList;
1544
+ authorizationList?: import("viem").AuthorizationList;
1545
+ chain?: import("viem").Chain | null;
1546
+ dataSuffix?: `0x${string}`;
1547
+ gas?: bigint;
1548
+ gasPrice?: bigint;
1549
+ maxFeePerGas?: bigint;
1550
+ maxPriorityFeePerGas?: bigint;
1551
+ nonce?: number;
1552
+ value?: bigint;
1553
+ }): Promise<void>;
1554
+ /**
1555
+ * Simulate transferOwnership
1556
+ * Returns gas estimate and result without sending transaction
1557
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1558
+ */
1559
+ transferOwnership(newOwner: `0x${string}`, options?: {
1560
+ accessList?: import("viem").AccessList;
1561
+ authorizationList?: import("viem").AuthorizationList;
1562
+ chain?: import("viem").Chain | null;
1563
+ dataSuffix?: `0x${string}`;
1564
+ gas?: bigint;
1565
+ gasPrice?: bigint;
1566
+ maxFeePerGas?: bigint;
1567
+ maxPriorityFeePerGas?: bigint;
1568
+ nonce?: number;
1569
+ value?: bigint;
1570
+ }): Promise<void>;
1571
+ /**
1572
+ * Simulate updateAccount
1573
+ * Returns gas estimate and result without sending transaction
1574
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1575
+ */
1576
+ updateAccount(_id: bigint, _from: `0x${string}`, _to: `0x${string}`, options?: {
1577
+ accessList?: import("viem").AccessList;
1578
+ authorizationList?: import("viem").AuthorizationList;
1579
+ chain?: import("viem").Chain | null;
1580
+ dataSuffix?: `0x${string}`;
1581
+ gas?: bigint;
1582
+ gasPrice?: bigint;
1583
+ maxFeePerGas?: bigint;
1584
+ maxPriorityFeePerGas?: bigint;
1585
+ nonce?: number;
1586
+ value?: bigint;
1587
+ }): Promise<void>;
1588
+ };
1589
+ /**
1590
+ * Watch contract events
1591
+ *
1592
+ * @example
1593
+ * // Watch all Transfer events
1594
+ * const unwatch = contract.watch.Transfer((event) => {
1595
+ * console.log('Transfer:', event);
1596
+ * });
1597
+ *
1598
+ * // Stop watching
1599
+ * unwatch();
1600
+ */
1601
+ get watch(): {
1602
+ /**
1603
+ * Watch ApprovalForAll events
1604
+ * @param callback Function to call when event is emitted
1605
+ * @param filter Optional filter for indexed parameters
1606
+ * @returns Unwatch function to stop listening
1607
+ */
1608
+ ApprovalForAll: (callback: (event: {
1609
+ account: `0x${string}`;
1610
+ operator: `0x${string}`;
1611
+ approved: boolean;
1612
+ }) => void, filter?: {
1613
+ account: `0x${string}`;
1614
+ operator: `0x${string}`;
1615
+ }) => () => void;
1616
+ /**
1617
+ * Watch BaseUriChanged events
1618
+ * @param callback Function to call when event is emitted
1619
+ * @param filter Optional filter for indexed parameters
1620
+ * @returns Unwatch function to stop listening
1621
+ */
1622
+ BaseUriChanged: (callback: (event: {
1623
+ newBaseURI: string;
1624
+ }) => void) => () => void;
1625
+ /**
1626
+ * Watch BurnLazy events
1627
+ * @param callback Function to call when event is emitted
1628
+ * @param filter Optional filter for indexed parameters
1629
+ * @returns Unwatch function to stop listening
1630
+ */
1631
+ BurnLazy: (callback: (event: {
1632
+ operator: `0x${string}`;
1633
+ account: `0x${string}`;
1634
+ id: bigint;
1635
+ amount: bigint;
1636
+ }) => void, filter?: {
1637
+ operator: `0x${string}`;
1638
+ account: `0x${string}`;
1639
+ }) => () => void;
1640
+ /**
1641
+ * Watch BurnLazyBatch events
1642
+ * @param callback Function to call when event is emitted
1643
+ * @param filter Optional filter for indexed parameters
1644
+ * @returns Unwatch function to stop listening
1645
+ */
1646
+ BurnLazyBatch: (callback: (event: {
1647
+ operator: `0x${string}`;
1648
+ account: `0x${string}`;
1649
+ ids: bigint[];
1650
+ amounts: bigint[];
1651
+ }) => void, filter?: {
1652
+ operator: `0x${string}`;
1653
+ account: `0x${string}`;
1654
+ }) => () => void;
1655
+ /**
1656
+ * Watch CreateERC1155Rarible events
1657
+ * @param callback Function to call when event is emitted
1658
+ * @param filter Optional filter for indexed parameters
1659
+ * @returns Unwatch function to stop listening
1660
+ */
1661
+ CreateERC1155Rarible: (callback: (event: {
1662
+ owner: `0x${string}`;
1663
+ name: string;
1664
+ symbol: string;
1665
+ }) => void) => () => void;
1666
+ /**
1667
+ * Watch CreateERC1155RaribleUser events
1668
+ * @param callback Function to call when event is emitted
1669
+ * @param filter Optional filter for indexed parameters
1670
+ * @returns Unwatch function to stop listening
1671
+ */
1672
+ CreateERC1155RaribleUser: (callback: (event: {
1673
+ owner: `0x${string}`;
1674
+ name: string;
1675
+ symbol: string;
1676
+ }) => void) => () => void;
1677
+ /**
1678
+ * Watch Creators events
1679
+ * @param callback Function to call when event is emitted
1680
+ * @param filter Optional filter for indexed parameters
1681
+ * @returns Unwatch function to stop listening
1682
+ */
1683
+ Creators: (callback: (event: {
1684
+ tokenId: bigint;
1685
+ creators: LibPart_Part[];
1686
+ }) => void) => () => void;
1687
+ /**
1688
+ * Watch DefaultApproval events
1689
+ * @param callback Function to call when event is emitted
1690
+ * @param filter Optional filter for indexed parameters
1691
+ * @returns Unwatch function to stop listening
1692
+ */
1693
+ DefaultApproval: (callback: (event: {
1694
+ operator: `0x${string}`;
1695
+ hasApproval: boolean;
1696
+ }) => void, filter?: {
1697
+ operator: `0x${string}`;
1698
+ }) => () => void;
1699
+ /**
1700
+ * Watch MinterStatusChanged events
1701
+ * @param callback Function to call when event is emitted
1702
+ * @param filter Optional filter for indexed parameters
1703
+ * @returns Unwatch function to stop listening
1704
+ */
1705
+ MinterStatusChanged: (callback: (event: {
1706
+ minter: `0x${string}`;
1707
+ status: boolean;
1708
+ }) => void, filter?: {
1709
+ minter: `0x${string}`;
1710
+ status: boolean;
1711
+ }) => () => void;
1712
+ /**
1713
+ * Watch OwnershipTransferred events
1714
+ * @param callback Function to call when event is emitted
1715
+ * @param filter Optional filter for indexed parameters
1716
+ * @returns Unwatch function to stop listening
1717
+ */
1718
+ OwnershipTransferred: (callback: (event: {
1719
+ previousOwner: `0x${string}`;
1720
+ newOwner: `0x${string}`;
1721
+ }) => void, filter?: {
1722
+ previousOwner: `0x${string}`;
1723
+ newOwner: `0x${string}`;
1724
+ }) => () => void;
1725
+ /**
1726
+ * Watch RoyaltiesSet events
1727
+ * @param callback Function to call when event is emitted
1728
+ * @param filter Optional filter for indexed parameters
1729
+ * @returns Unwatch function to stop listening
1730
+ */
1731
+ RoyaltiesSet: (callback: (event: {
1732
+ tokenId: bigint;
1733
+ royalties: LibPart_Part[];
1734
+ }) => void) => () => void;
1735
+ /**
1736
+ * Watch Supply events
1737
+ * @param callback Function to call when event is emitted
1738
+ * @param filter Optional filter for indexed parameters
1739
+ * @returns Unwatch function to stop listening
1740
+ */
1741
+ Supply: (callback: (event: {
1742
+ tokenId: bigint;
1743
+ value: bigint;
1744
+ }) => void) => () => void;
1745
+ /**
1746
+ * Watch TransferBatch events
1747
+ * @param callback Function to call when event is emitted
1748
+ * @param filter Optional filter for indexed parameters
1749
+ * @returns Unwatch function to stop listening
1750
+ */
1751
+ TransferBatch: (callback: (event: {
1752
+ operator: `0x${string}`;
1753
+ from: `0x${string}`;
1754
+ to: `0x${string}`;
1755
+ ids: bigint[];
1756
+ values: bigint[];
1757
+ }) => void, filter?: {
1758
+ operator: `0x${string}`;
1759
+ from: `0x${string}`;
1760
+ to: `0x${string}`;
1761
+ }) => () => void;
1762
+ /**
1763
+ * Watch TransferSingle events
1764
+ * @param callback Function to call when event is emitted
1765
+ * @param filter Optional filter for indexed parameters
1766
+ * @returns Unwatch function to stop listening
1767
+ */
1768
+ TransferSingle: (callback: (event: {
1769
+ operator: `0x${string}`;
1770
+ from: `0x${string}`;
1771
+ to: `0x${string}`;
1772
+ id: bigint;
1773
+ value: bigint;
1774
+ }) => void, filter?: {
1775
+ operator: `0x${string}`;
1776
+ from: `0x${string}`;
1777
+ to: `0x${string}`;
1778
+ }) => () => void;
1779
+ /**
1780
+ * Watch URI events
1781
+ * @param callback Function to call when event is emitted
1782
+ * @param filter Optional filter for indexed parameters
1783
+ * @returns Unwatch function to stop listening
1784
+ */
1785
+ URI: (callback: (event: {
1786
+ id: bigint;
1787
+ value: string;
1788
+ }) => void, filter?: {
1789
+ id: bigint;
1790
+ }) => () => void;
1791
+ };
1792
+ }