@gitmyabi/rari 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.
@@ -0,0 +1,1179 @@
1
+ import type { Address, PublicClient, WalletClient } from 'viem';
2
+ /**
3
+ * ERC721Base.Fee struct type
4
+ */
5
+ export type ERC721Base_Fee = {
6
+ recipient: `0x${string}`;
7
+ value: bigint;
8
+ };
9
+ /**
10
+ * MintableToken_json ABI
11
+ *
12
+ * This ABI is typed using viem's type system for full type safety.
13
+ */
14
+ export declare const MintableToken_jsonAbi: readonly [{
15
+ readonly inputs: readonly [{
16
+ readonly internalType: "string";
17
+ readonly name: "name";
18
+ readonly type: "string";
19
+ }, {
20
+ readonly internalType: "string";
21
+ readonly name: "symbol";
22
+ readonly type: "string";
23
+ }, {
24
+ readonly internalType: "address";
25
+ readonly name: "newOwner";
26
+ readonly type: "address";
27
+ }, {
28
+ readonly internalType: "string";
29
+ readonly name: "contractURI";
30
+ readonly type: "string";
31
+ }, {
32
+ readonly internalType: "string";
33
+ readonly name: "tokenURIPrefix";
34
+ readonly type: "string";
35
+ }];
36
+ readonly payable: false;
37
+ readonly stateMutability: "nonpayable";
38
+ readonly type: "constructor";
39
+ }, {
40
+ readonly anonymous: false;
41
+ readonly inputs: readonly [{
42
+ readonly indexed: true;
43
+ readonly internalType: "address";
44
+ readonly name: "owner";
45
+ readonly type: "address";
46
+ }, {
47
+ readonly indexed: true;
48
+ readonly internalType: "address";
49
+ readonly name: "approved";
50
+ readonly type: "address";
51
+ }, {
52
+ readonly indexed: true;
53
+ readonly internalType: "uint256";
54
+ readonly name: "tokenId";
55
+ readonly type: "uint256";
56
+ }];
57
+ readonly name: "Approval";
58
+ readonly type: "event";
59
+ }, {
60
+ readonly anonymous: false;
61
+ readonly inputs: readonly [{
62
+ readonly indexed: true;
63
+ readonly internalType: "address";
64
+ readonly name: "owner";
65
+ readonly type: "address";
66
+ }, {
67
+ readonly indexed: true;
68
+ readonly internalType: "address";
69
+ readonly name: "operator";
70
+ readonly type: "address";
71
+ }, {
72
+ readonly indexed: false;
73
+ readonly internalType: "bool";
74
+ readonly name: "approved";
75
+ readonly type: "bool";
76
+ }];
77
+ readonly name: "ApprovalForAll";
78
+ readonly type: "event";
79
+ }, {
80
+ readonly anonymous: false;
81
+ readonly inputs: readonly [{
82
+ readonly indexed: true;
83
+ readonly internalType: "address";
84
+ readonly name: "previousOwner";
85
+ readonly type: "address";
86
+ }, {
87
+ readonly indexed: true;
88
+ readonly internalType: "address";
89
+ readonly name: "newOwner";
90
+ readonly type: "address";
91
+ }];
92
+ readonly name: "OwnershipTransferred";
93
+ readonly type: "event";
94
+ }, {
95
+ readonly anonymous: false;
96
+ readonly inputs: readonly [{
97
+ readonly indexed: false;
98
+ readonly internalType: "uint256";
99
+ readonly name: "tokenId";
100
+ readonly type: "uint256";
101
+ }, {
102
+ readonly indexed: false;
103
+ readonly internalType: "address[]";
104
+ readonly name: "recipients";
105
+ readonly type: "address[]";
106
+ }, {
107
+ readonly indexed: false;
108
+ readonly internalType: "uint256[]";
109
+ readonly name: "bps";
110
+ readonly type: "uint256[]";
111
+ }];
112
+ readonly name: "SecondarySaleFees";
113
+ readonly type: "event";
114
+ }, {
115
+ readonly anonymous: false;
116
+ readonly inputs: readonly [{
117
+ readonly indexed: true;
118
+ readonly internalType: "address";
119
+ readonly name: "from";
120
+ readonly type: "address";
121
+ }, {
122
+ readonly indexed: true;
123
+ readonly internalType: "address";
124
+ readonly name: "to";
125
+ readonly type: "address";
126
+ }, {
127
+ readonly indexed: true;
128
+ readonly internalType: "uint256";
129
+ readonly name: "tokenId";
130
+ readonly type: "uint256";
131
+ }];
132
+ readonly name: "Transfer";
133
+ readonly type: "event";
134
+ }, {
135
+ readonly constant: false;
136
+ readonly inputs: readonly [{
137
+ readonly internalType: "address";
138
+ readonly name: "to";
139
+ readonly type: "address";
140
+ }, {
141
+ readonly internalType: "uint256";
142
+ readonly name: "tokenId";
143
+ readonly type: "uint256";
144
+ }];
145
+ readonly name: "approve";
146
+ readonly outputs: readonly [];
147
+ readonly payable: false;
148
+ readonly stateMutability: "nonpayable";
149
+ readonly type: "function";
150
+ }, {
151
+ readonly constant: true;
152
+ readonly inputs: readonly [{
153
+ readonly internalType: "address";
154
+ readonly name: "owner";
155
+ readonly type: "address";
156
+ }];
157
+ readonly name: "balanceOf";
158
+ readonly outputs: readonly [{
159
+ readonly internalType: "uint256";
160
+ readonly name: "";
161
+ readonly type: "uint256";
162
+ }];
163
+ readonly payable: false;
164
+ readonly stateMutability: "view";
165
+ readonly type: "function";
166
+ }, {
167
+ readonly constant: false;
168
+ readonly inputs: readonly [{
169
+ readonly internalType: "uint256";
170
+ readonly name: "tokenId";
171
+ readonly type: "uint256";
172
+ }];
173
+ readonly name: "burn";
174
+ readonly outputs: readonly [];
175
+ readonly payable: false;
176
+ readonly stateMutability: "nonpayable";
177
+ readonly type: "function";
178
+ }, {
179
+ readonly constant: true;
180
+ readonly inputs: readonly [];
181
+ readonly name: "contractURI";
182
+ readonly outputs: readonly [{
183
+ readonly internalType: "string";
184
+ readonly name: "";
185
+ readonly type: "string";
186
+ }];
187
+ readonly payable: false;
188
+ readonly stateMutability: "view";
189
+ readonly type: "function";
190
+ }, {
191
+ readonly constant: true;
192
+ readonly inputs: readonly [{
193
+ readonly internalType: "uint256";
194
+ readonly name: "";
195
+ readonly type: "uint256";
196
+ }, {
197
+ readonly internalType: "uint256";
198
+ readonly name: "";
199
+ readonly type: "uint256";
200
+ }];
201
+ readonly name: "fees";
202
+ readonly outputs: readonly [{
203
+ readonly internalType: "address payable";
204
+ readonly name: "recipient";
205
+ readonly type: "address";
206
+ }, {
207
+ readonly internalType: "uint256";
208
+ readonly name: "value";
209
+ readonly type: "uint256";
210
+ }];
211
+ readonly payable: false;
212
+ readonly stateMutability: "view";
213
+ readonly type: "function";
214
+ }, {
215
+ readonly constant: true;
216
+ readonly inputs: readonly [{
217
+ readonly internalType: "uint256";
218
+ readonly name: "tokenId";
219
+ readonly type: "uint256";
220
+ }];
221
+ readonly name: "getApproved";
222
+ readonly outputs: readonly [{
223
+ readonly internalType: "address";
224
+ readonly name: "";
225
+ readonly type: "address";
226
+ }];
227
+ readonly payable: false;
228
+ readonly stateMutability: "view";
229
+ readonly type: "function";
230
+ }, {
231
+ readonly constant: true;
232
+ readonly inputs: readonly [{
233
+ readonly internalType: "uint256";
234
+ readonly name: "id";
235
+ readonly type: "uint256";
236
+ }];
237
+ readonly name: "getFeeBps";
238
+ readonly outputs: readonly [{
239
+ readonly internalType: "uint256[]";
240
+ readonly name: "";
241
+ readonly type: "uint256[]";
242
+ }];
243
+ readonly payable: false;
244
+ readonly stateMutability: "view";
245
+ readonly type: "function";
246
+ }, {
247
+ readonly constant: true;
248
+ readonly inputs: readonly [{
249
+ readonly internalType: "uint256";
250
+ readonly name: "id";
251
+ readonly type: "uint256";
252
+ }];
253
+ readonly name: "getFeeRecipients";
254
+ readonly outputs: readonly [{
255
+ readonly internalType: "address payable[]";
256
+ readonly name: "";
257
+ readonly type: "address[]";
258
+ }];
259
+ readonly payable: false;
260
+ readonly stateMutability: "view";
261
+ readonly type: "function";
262
+ }, {
263
+ readonly constant: true;
264
+ readonly inputs: readonly [{
265
+ readonly internalType: "address";
266
+ readonly name: "owner";
267
+ readonly type: "address";
268
+ }, {
269
+ readonly internalType: "address";
270
+ readonly name: "operator";
271
+ readonly type: "address";
272
+ }];
273
+ readonly name: "isApprovedForAll";
274
+ readonly outputs: readonly [{
275
+ readonly internalType: "bool";
276
+ readonly name: "";
277
+ readonly type: "bool";
278
+ }];
279
+ readonly payable: false;
280
+ readonly stateMutability: "view";
281
+ readonly type: "function";
282
+ }, {
283
+ readonly constant: true;
284
+ readonly inputs: readonly [];
285
+ readonly name: "isOwner";
286
+ readonly outputs: readonly [{
287
+ readonly internalType: "bool";
288
+ readonly name: "";
289
+ readonly type: "bool";
290
+ }];
291
+ readonly payable: false;
292
+ readonly stateMutability: "view";
293
+ readonly type: "function";
294
+ }, {
295
+ readonly constant: false;
296
+ readonly inputs: readonly [{
297
+ readonly internalType: "uint256";
298
+ readonly name: "tokenId";
299
+ readonly type: "uint256";
300
+ }, {
301
+ readonly internalType: "uint8";
302
+ readonly name: "v";
303
+ readonly type: "uint8";
304
+ }, {
305
+ readonly internalType: "bytes32";
306
+ readonly name: "r";
307
+ readonly type: "bytes32";
308
+ }, {
309
+ readonly internalType: "bytes32";
310
+ readonly name: "s";
311
+ readonly type: "bytes32";
312
+ }, {
313
+ readonly components: readonly [{
314
+ readonly internalType: "address payable";
315
+ readonly name: "recipient";
316
+ readonly type: "address";
317
+ }, {
318
+ readonly internalType: "uint256";
319
+ readonly name: "value";
320
+ readonly type: "uint256";
321
+ }];
322
+ readonly internalType: "struct ERC721Base.Fee[]";
323
+ readonly name: "_fees";
324
+ readonly type: "tuple[]";
325
+ }, {
326
+ readonly internalType: "string";
327
+ readonly name: "tokenURI";
328
+ readonly type: "string";
329
+ }];
330
+ readonly name: "mint";
331
+ readonly outputs: readonly [];
332
+ readonly payable: false;
333
+ readonly stateMutability: "nonpayable";
334
+ readonly type: "function";
335
+ }, {
336
+ readonly constant: true;
337
+ readonly inputs: readonly [];
338
+ readonly name: "name";
339
+ readonly outputs: readonly [{
340
+ readonly internalType: "string";
341
+ readonly name: "";
342
+ readonly type: "string";
343
+ }];
344
+ readonly payable: false;
345
+ readonly stateMutability: "view";
346
+ readonly type: "function";
347
+ }, {
348
+ readonly constant: true;
349
+ readonly inputs: readonly [];
350
+ readonly name: "owner";
351
+ readonly outputs: readonly [{
352
+ readonly internalType: "address";
353
+ readonly name: "";
354
+ readonly type: "address";
355
+ }];
356
+ readonly payable: false;
357
+ readonly stateMutability: "view";
358
+ readonly type: "function";
359
+ }, {
360
+ readonly constant: true;
361
+ readonly inputs: readonly [{
362
+ readonly internalType: "uint256";
363
+ readonly name: "tokenId";
364
+ readonly type: "uint256";
365
+ }];
366
+ readonly name: "ownerOf";
367
+ readonly outputs: readonly [{
368
+ readonly internalType: "address";
369
+ readonly name: "";
370
+ readonly type: "address";
371
+ }];
372
+ readonly payable: false;
373
+ readonly stateMutability: "view";
374
+ readonly type: "function";
375
+ }, {
376
+ readonly constant: false;
377
+ readonly inputs: readonly [];
378
+ readonly name: "renounceOwnership";
379
+ readonly outputs: readonly [];
380
+ readonly payable: false;
381
+ readonly stateMutability: "nonpayable";
382
+ readonly type: "function";
383
+ }, {
384
+ readonly constant: false;
385
+ readonly inputs: readonly [{
386
+ readonly internalType: "address";
387
+ readonly name: "from";
388
+ readonly type: "address";
389
+ }, {
390
+ readonly internalType: "address";
391
+ readonly name: "to";
392
+ readonly type: "address";
393
+ }, {
394
+ readonly internalType: "uint256";
395
+ readonly name: "tokenId";
396
+ readonly type: "uint256";
397
+ }];
398
+ readonly name: "safeTransferFrom";
399
+ readonly outputs: readonly [];
400
+ readonly payable: false;
401
+ readonly stateMutability: "nonpayable";
402
+ readonly type: "function";
403
+ }, {
404
+ readonly constant: false;
405
+ readonly inputs: readonly [{
406
+ readonly internalType: "address";
407
+ readonly name: "from";
408
+ readonly type: "address";
409
+ }, {
410
+ readonly internalType: "address";
411
+ readonly name: "to";
412
+ readonly type: "address";
413
+ }, {
414
+ readonly internalType: "uint256";
415
+ readonly name: "tokenId";
416
+ readonly type: "uint256";
417
+ }, {
418
+ readonly internalType: "bytes";
419
+ readonly name: "_data";
420
+ readonly type: "bytes";
421
+ }];
422
+ readonly name: "safeTransferFrom";
423
+ readonly outputs: readonly [];
424
+ readonly payable: false;
425
+ readonly stateMutability: "nonpayable";
426
+ readonly type: "function";
427
+ }, {
428
+ readonly constant: false;
429
+ readonly inputs: readonly [{
430
+ readonly internalType: "address";
431
+ readonly name: "to";
432
+ readonly type: "address";
433
+ }, {
434
+ readonly internalType: "bool";
435
+ readonly name: "approved";
436
+ readonly type: "bool";
437
+ }];
438
+ readonly name: "setApprovalForAll";
439
+ readonly outputs: readonly [];
440
+ readonly payable: false;
441
+ readonly stateMutability: "nonpayable";
442
+ readonly type: "function";
443
+ }, {
444
+ readonly constant: false;
445
+ readonly inputs: readonly [{
446
+ readonly internalType: "string";
447
+ readonly name: "contractURI";
448
+ readonly type: "string";
449
+ }];
450
+ readonly name: "setContractURI";
451
+ readonly outputs: readonly [];
452
+ readonly payable: false;
453
+ readonly stateMutability: "nonpayable";
454
+ readonly type: "function";
455
+ }, {
456
+ readonly constant: false;
457
+ readonly inputs: readonly [{
458
+ readonly internalType: "string";
459
+ readonly name: "tokenURIPrefix";
460
+ readonly type: "string";
461
+ }];
462
+ readonly name: "setTokenURIPrefix";
463
+ readonly outputs: readonly [];
464
+ readonly payable: false;
465
+ readonly stateMutability: "nonpayable";
466
+ readonly type: "function";
467
+ }, {
468
+ readonly constant: true;
469
+ readonly inputs: readonly [{
470
+ readonly internalType: "bytes4";
471
+ readonly name: "interfaceId";
472
+ readonly type: "bytes4";
473
+ }];
474
+ readonly name: "supportsInterface";
475
+ readonly outputs: readonly [{
476
+ readonly internalType: "bool";
477
+ readonly name: "";
478
+ readonly type: "bool";
479
+ }];
480
+ readonly payable: false;
481
+ readonly stateMutability: "view";
482
+ readonly type: "function";
483
+ }, {
484
+ readonly constant: true;
485
+ readonly inputs: readonly [];
486
+ readonly name: "symbol";
487
+ readonly outputs: readonly [{
488
+ readonly internalType: "string";
489
+ readonly name: "";
490
+ readonly type: "string";
491
+ }];
492
+ readonly payable: false;
493
+ readonly stateMutability: "view";
494
+ readonly type: "function";
495
+ }, {
496
+ readonly constant: true;
497
+ readonly inputs: readonly [{
498
+ readonly internalType: "uint256";
499
+ readonly name: "index";
500
+ readonly type: "uint256";
501
+ }];
502
+ readonly name: "tokenByIndex";
503
+ readonly outputs: readonly [{
504
+ readonly internalType: "uint256";
505
+ readonly name: "";
506
+ readonly type: "uint256";
507
+ }];
508
+ readonly payable: false;
509
+ readonly stateMutability: "view";
510
+ readonly type: "function";
511
+ }, {
512
+ readonly constant: true;
513
+ readonly inputs: readonly [{
514
+ readonly internalType: "address";
515
+ readonly name: "owner";
516
+ readonly type: "address";
517
+ }, {
518
+ readonly internalType: "uint256";
519
+ readonly name: "index";
520
+ readonly type: "uint256";
521
+ }];
522
+ readonly name: "tokenOfOwnerByIndex";
523
+ readonly outputs: readonly [{
524
+ readonly internalType: "uint256";
525
+ readonly name: "";
526
+ readonly type: "uint256";
527
+ }];
528
+ readonly payable: false;
529
+ readonly stateMutability: "view";
530
+ readonly type: "function";
531
+ }, {
532
+ readonly constant: true;
533
+ readonly inputs: readonly [{
534
+ readonly internalType: "uint256";
535
+ readonly name: "tokenId";
536
+ readonly type: "uint256";
537
+ }];
538
+ readonly name: "tokenURI";
539
+ readonly outputs: readonly [{
540
+ readonly internalType: "string";
541
+ readonly name: "";
542
+ readonly type: "string";
543
+ }];
544
+ readonly payable: false;
545
+ readonly stateMutability: "view";
546
+ readonly type: "function";
547
+ }, {
548
+ readonly constant: true;
549
+ readonly inputs: readonly [];
550
+ readonly name: "tokenURIPrefix";
551
+ readonly outputs: readonly [{
552
+ readonly internalType: "string";
553
+ readonly name: "";
554
+ readonly type: "string";
555
+ }];
556
+ readonly payable: false;
557
+ readonly stateMutability: "view";
558
+ readonly type: "function";
559
+ }, {
560
+ readonly constant: true;
561
+ readonly inputs: readonly [];
562
+ readonly name: "totalSupply";
563
+ readonly outputs: readonly [{
564
+ readonly internalType: "uint256";
565
+ readonly name: "";
566
+ readonly type: "uint256";
567
+ }];
568
+ readonly payable: false;
569
+ readonly stateMutability: "view";
570
+ readonly type: "function";
571
+ }, {
572
+ readonly constant: false;
573
+ readonly inputs: readonly [{
574
+ readonly internalType: "address";
575
+ readonly name: "from";
576
+ readonly type: "address";
577
+ }, {
578
+ readonly internalType: "address";
579
+ readonly name: "to";
580
+ readonly type: "address";
581
+ }, {
582
+ readonly internalType: "uint256";
583
+ readonly name: "tokenId";
584
+ readonly type: "uint256";
585
+ }];
586
+ readonly name: "transferFrom";
587
+ readonly outputs: readonly [];
588
+ readonly payable: false;
589
+ readonly stateMutability: "nonpayable";
590
+ readonly type: "function";
591
+ }, {
592
+ readonly constant: false;
593
+ readonly inputs: readonly [{
594
+ readonly internalType: "address";
595
+ readonly name: "newOwner";
596
+ readonly type: "address";
597
+ }];
598
+ readonly name: "transferOwnership";
599
+ readonly outputs: readonly [];
600
+ readonly payable: false;
601
+ readonly stateMutability: "nonpayable";
602
+ readonly type: "function";
603
+ }];
604
+ /**
605
+ * Type-safe ABI for MintableToken_json
606
+ */
607
+ export type MintableToken_jsonAbi = typeof MintableToken_jsonAbi;
608
+ /**
609
+ * Contract instance type for MintableToken_json
610
+ */
611
+ export type MintableToken_jsonContract = any;
612
+ /**
613
+ * MintableToken_json Contract Class
614
+ *
615
+ * Provides a class-based API similar to TypeChain for interacting with the contract.
616
+ *
617
+ * @example
618
+ * ```typescript
619
+ * import { createPublicClient, createWalletClient, http } from 'viem';
620
+ * import { mainnet } from 'viem/chains';
621
+ * import { MintableToken_json } from 'MintableToken_json';
622
+ *
623
+ * const publicClient = createPublicClient({ chain: mainnet, transport: http() });
624
+ * const walletClient = createWalletClient({ chain: mainnet, transport: http() });
625
+ *
626
+ * const contract = new MintableToken_json('0x...', { publicClient, walletClient });
627
+ *
628
+ * // Read functions
629
+ * const result = await contract.balanceOf('0x...');
630
+ *
631
+ * // Write functions
632
+ * const hash = await contract.transfer('0x...', 1000n);
633
+ *
634
+ * // Simulate transactions (dry-run)
635
+ * const simulation = await contract.simulate.transfer('0x...', 1000n);
636
+ * console.log('Gas estimate:', simulation.request.gas);
637
+ *
638
+ * // Watch events
639
+ * const unwatch = contract.watch.Transfer((event) => {
640
+ * console.log('Transfer event:', event);
641
+ * });
642
+ * ```
643
+ */
644
+ export declare class MintableToken_json {
645
+ private contract;
646
+ private contractAddress;
647
+ private publicClient;
648
+ constructor(address: Address, clients: {
649
+ publicClient: PublicClient;
650
+ walletClient?: WalletClient;
651
+ });
652
+ /**
653
+ * Get the contract address
654
+ */
655
+ get address(): Address;
656
+ /**
657
+ * Get the underlying viem contract instance
658
+ */
659
+ getContract(): MintableToken_jsonContract;
660
+ /**
661
+ * balanceOf
662
+ * view
663
+ */
664
+ balanceOf(owner: `0x${string}`): Promise<bigint>;
665
+ /**
666
+ * contractURI
667
+ * view
668
+ */
669
+ contractURI(): Promise<string>;
670
+ /**
671
+ * fees
672
+ * view
673
+ */
674
+ fees(arg0: bigint, arg1: bigint): Promise<[`0x${string}`, bigint]>;
675
+ /**
676
+ * getApproved
677
+ * view
678
+ */
679
+ getApproved(tokenId: bigint): Promise<`0x${string}`>;
680
+ /**
681
+ * getFeeBps
682
+ * view
683
+ */
684
+ getFeeBps(id: bigint): Promise<bigint[]>;
685
+ /**
686
+ * getFeeRecipients
687
+ * view
688
+ */
689
+ getFeeRecipients(id: bigint): Promise<`0x${string}`[]>;
690
+ /**
691
+ * isApprovedForAll
692
+ * view
693
+ */
694
+ isApprovedForAll(owner: `0x${string}`, operator: `0x${string}`): Promise<boolean>;
695
+ /**
696
+ * isOwner
697
+ * view
698
+ */
699
+ isOwner(): Promise<boolean>;
700
+ /**
701
+ * name
702
+ * view
703
+ */
704
+ name(): Promise<string>;
705
+ /**
706
+ * owner
707
+ * view
708
+ */
709
+ owner(): Promise<`0x${string}`>;
710
+ /**
711
+ * ownerOf
712
+ * view
713
+ */
714
+ ownerOf(tokenId: bigint): Promise<`0x${string}`>;
715
+ /**
716
+ * supportsInterface
717
+ * view
718
+ */
719
+ supportsInterface(interfaceId: `0x${string}`): Promise<boolean>;
720
+ /**
721
+ * symbol
722
+ * view
723
+ */
724
+ symbol(): Promise<string>;
725
+ /**
726
+ * tokenByIndex
727
+ * view
728
+ */
729
+ tokenByIndex(index: bigint): Promise<bigint>;
730
+ /**
731
+ * tokenOfOwnerByIndex
732
+ * view
733
+ */
734
+ tokenOfOwnerByIndex(owner: `0x${string}`, index: bigint): Promise<bigint>;
735
+ /**
736
+ * tokenURI
737
+ * view
738
+ */
739
+ tokenURI(tokenId: bigint): Promise<string>;
740
+ /**
741
+ * tokenURIPrefix
742
+ * view
743
+ */
744
+ tokenURIPrefix(): Promise<string>;
745
+ /**
746
+ * totalSupply
747
+ * view
748
+ */
749
+ totalSupply(): Promise<bigint>;
750
+ /**
751
+ * approve
752
+ * nonpayable
753
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
754
+ */
755
+ approve(to: `0x${string}`, tokenId: bigint, options?: {
756
+ accessList?: import('viem').AccessList;
757
+ authorizationList?: import('viem').AuthorizationList;
758
+ chain?: import('viem').Chain | null;
759
+ dataSuffix?: `0x${string}`;
760
+ gas?: bigint;
761
+ gasPrice?: bigint;
762
+ maxFeePerGas?: bigint;
763
+ maxPriorityFeePerGas?: bigint;
764
+ nonce?: number;
765
+ value?: bigint;
766
+ }): Promise<`0x${string}`>;
767
+ /**
768
+ * burn
769
+ * nonpayable
770
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
771
+ */
772
+ burn(tokenId: bigint, options?: {
773
+ accessList?: import('viem').AccessList;
774
+ authorizationList?: import('viem').AuthorizationList;
775
+ chain?: import('viem').Chain | null;
776
+ dataSuffix?: `0x${string}`;
777
+ gas?: bigint;
778
+ gasPrice?: bigint;
779
+ maxFeePerGas?: bigint;
780
+ maxPriorityFeePerGas?: bigint;
781
+ nonce?: number;
782
+ value?: bigint;
783
+ }): Promise<`0x${string}`>;
784
+ /**
785
+ * mint
786
+ * nonpayable
787
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
788
+ */
789
+ mint(tokenId: bigint, v: bigint, r: `0x${string}`, s: `0x${string}`, _fees: ERC721Base_Fee[], tokenURI: string, options?: {
790
+ accessList?: import('viem').AccessList;
791
+ authorizationList?: import('viem').AuthorizationList;
792
+ chain?: import('viem').Chain | null;
793
+ dataSuffix?: `0x${string}`;
794
+ gas?: bigint;
795
+ gasPrice?: bigint;
796
+ maxFeePerGas?: bigint;
797
+ maxPriorityFeePerGas?: bigint;
798
+ nonce?: number;
799
+ value?: bigint;
800
+ }): Promise<`0x${string}`>;
801
+ /**
802
+ * renounceOwnership
803
+ * nonpayable
804
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
805
+ */
806
+ renounceOwnership(options?: {
807
+ accessList?: import('viem').AccessList;
808
+ authorizationList?: import('viem').AuthorizationList;
809
+ chain?: import('viem').Chain | null;
810
+ dataSuffix?: `0x${string}`;
811
+ gas?: bigint;
812
+ gasPrice?: bigint;
813
+ maxFeePerGas?: bigint;
814
+ maxPriorityFeePerGas?: bigint;
815
+ nonce?: number;
816
+ value?: bigint;
817
+ }): Promise<`0x${string}`>;
818
+ safeTransferFrom(from: `0x${string}`, to: `0x${string}`, tokenId: bigint, options?: {
819
+ accessList?: import('viem').AccessList;
820
+ authorizationList?: import('viem').AuthorizationList;
821
+ chain?: import('viem').Chain | null;
822
+ dataSuffix?: `0x${string}`;
823
+ gas?: bigint;
824
+ gasPrice?: bigint;
825
+ maxFeePerGas?: bigint;
826
+ maxPriorityFeePerGas?: bigint;
827
+ nonce?: number;
828
+ value?: bigint;
829
+ }): Promise<`0x${string}`>;
830
+ safeTransferFrom(from: `0x${string}`, to: `0x${string}`, tokenId: bigint, _data: `0x${string}`, options?: {
831
+ accessList?: import('viem').AccessList;
832
+ authorizationList?: import('viem').AuthorizationList;
833
+ chain?: import('viem').Chain | null;
834
+ dataSuffix?: `0x${string}`;
835
+ gas?: bigint;
836
+ gasPrice?: bigint;
837
+ maxFeePerGas?: bigint;
838
+ maxPriorityFeePerGas?: bigint;
839
+ nonce?: number;
840
+ value?: bigint;
841
+ }): Promise<`0x${string}`>;
842
+ /**
843
+ * setApprovalForAll
844
+ * nonpayable
845
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
846
+ */
847
+ setApprovalForAll(to: `0x${string}`, approved: boolean, options?: {
848
+ accessList?: import('viem').AccessList;
849
+ authorizationList?: import('viem').AuthorizationList;
850
+ chain?: import('viem').Chain | null;
851
+ dataSuffix?: `0x${string}`;
852
+ gas?: bigint;
853
+ gasPrice?: bigint;
854
+ maxFeePerGas?: bigint;
855
+ maxPriorityFeePerGas?: bigint;
856
+ nonce?: number;
857
+ value?: bigint;
858
+ }): Promise<`0x${string}`>;
859
+ /**
860
+ * setContractURI
861
+ * nonpayable
862
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
863
+ */
864
+ setContractURI(contractURI: string, options?: {
865
+ accessList?: import('viem').AccessList;
866
+ authorizationList?: import('viem').AuthorizationList;
867
+ chain?: import('viem').Chain | null;
868
+ dataSuffix?: `0x${string}`;
869
+ gas?: bigint;
870
+ gasPrice?: bigint;
871
+ maxFeePerGas?: bigint;
872
+ maxPriorityFeePerGas?: bigint;
873
+ nonce?: number;
874
+ value?: bigint;
875
+ }): Promise<`0x${string}`>;
876
+ /**
877
+ * setTokenURIPrefix
878
+ * nonpayable
879
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
880
+ */
881
+ setTokenURIPrefix(tokenURIPrefix: string, options?: {
882
+ accessList?: import('viem').AccessList;
883
+ authorizationList?: import('viem').AuthorizationList;
884
+ chain?: import('viem').Chain | null;
885
+ dataSuffix?: `0x${string}`;
886
+ gas?: bigint;
887
+ gasPrice?: bigint;
888
+ maxFeePerGas?: bigint;
889
+ maxPriorityFeePerGas?: bigint;
890
+ nonce?: number;
891
+ value?: bigint;
892
+ }): Promise<`0x${string}`>;
893
+ /**
894
+ * transferFrom
895
+ * nonpayable
896
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
897
+ */
898
+ transferFrom(from: `0x${string}`, to: `0x${string}`, tokenId: bigint, options?: {
899
+ accessList?: import('viem').AccessList;
900
+ authorizationList?: import('viem').AuthorizationList;
901
+ chain?: import('viem').Chain | null;
902
+ dataSuffix?: `0x${string}`;
903
+ gas?: bigint;
904
+ gasPrice?: bigint;
905
+ maxFeePerGas?: bigint;
906
+ maxPriorityFeePerGas?: bigint;
907
+ nonce?: number;
908
+ value?: bigint;
909
+ }): Promise<`0x${string}`>;
910
+ /**
911
+ * transferOwnership
912
+ * nonpayable
913
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
914
+ */
915
+ transferOwnership(newOwner: `0x${string}`, options?: {
916
+ accessList?: import('viem').AccessList;
917
+ authorizationList?: import('viem').AuthorizationList;
918
+ chain?: import('viem').Chain | null;
919
+ dataSuffix?: `0x${string}`;
920
+ gas?: bigint;
921
+ gasPrice?: bigint;
922
+ maxFeePerGas?: bigint;
923
+ maxPriorityFeePerGas?: bigint;
924
+ nonce?: number;
925
+ value?: bigint;
926
+ }): Promise<`0x${string}`>;
927
+ /**
928
+ * Simulate contract write operations (dry-run without sending transaction)
929
+ *
930
+ * @example
931
+ * const result = await contract.simulate.transfer('0x...', 1000n);
932
+ * console.log('Gas estimate:', result.request.gas);
933
+ * console.log('Would succeed:', result.result);
934
+ */
935
+ get simulate(): {
936
+ /**
937
+ * Simulate approve
938
+ * Returns gas estimate and result without sending transaction
939
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
940
+ */
941
+ approve(to: `0x${string}`, tokenId: bigint, options?: {
942
+ accessList?: import("viem").AccessList;
943
+ authorizationList?: import("viem").AuthorizationList;
944
+ chain?: import("viem").Chain | null;
945
+ dataSuffix?: `0x${string}`;
946
+ gas?: bigint;
947
+ gasPrice?: bigint;
948
+ maxFeePerGas?: bigint;
949
+ maxPriorityFeePerGas?: bigint;
950
+ nonce?: number;
951
+ value?: bigint;
952
+ }): Promise<void>;
953
+ /**
954
+ * Simulate burn
955
+ * Returns gas estimate and result without sending transaction
956
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
957
+ */
958
+ burn(tokenId: bigint, options?: {
959
+ accessList?: import("viem").AccessList;
960
+ authorizationList?: import("viem").AuthorizationList;
961
+ chain?: import("viem").Chain | null;
962
+ dataSuffix?: `0x${string}`;
963
+ gas?: bigint;
964
+ gasPrice?: bigint;
965
+ maxFeePerGas?: bigint;
966
+ maxPriorityFeePerGas?: bigint;
967
+ nonce?: number;
968
+ value?: bigint;
969
+ }): Promise<void>;
970
+ /**
971
+ * Simulate mint
972
+ * Returns gas estimate and result without sending transaction
973
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
974
+ */
975
+ mint(tokenId: bigint, v: bigint, r: `0x${string}`, s: `0x${string}`, _fees: ERC721Base_Fee[], tokenURI: string, options?: {
976
+ accessList?: import("viem").AccessList;
977
+ authorizationList?: import("viem").AuthorizationList;
978
+ chain?: import("viem").Chain | null;
979
+ dataSuffix?: `0x${string}`;
980
+ gas?: bigint;
981
+ gasPrice?: bigint;
982
+ maxFeePerGas?: bigint;
983
+ maxPriorityFeePerGas?: bigint;
984
+ nonce?: number;
985
+ value?: bigint;
986
+ }): Promise<void>;
987
+ /**
988
+ * Simulate renounceOwnership
989
+ * Returns gas estimate and result without sending transaction
990
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
991
+ */
992
+ renounceOwnership(options?: {
993
+ accessList?: import("viem").AccessList;
994
+ authorizationList?: import("viem").AuthorizationList;
995
+ chain?: import("viem").Chain | null;
996
+ dataSuffix?: `0x${string}`;
997
+ gas?: bigint;
998
+ gasPrice?: bigint;
999
+ maxFeePerGas?: bigint;
1000
+ maxPriorityFeePerGas?: bigint;
1001
+ nonce?: number;
1002
+ value?: bigint;
1003
+ }): Promise<void>;
1004
+ /**
1005
+ * Simulate safeTransferFrom
1006
+ * Returns gas estimate and result without sending transaction
1007
+ * Supports multiple overloads: (address, address, uint256), (address, address, uint256, bytes)
1008
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1009
+ */
1010
+ safeTransferFrom(...args: any[]): Promise<any>;
1011
+ /**
1012
+ * Simulate setApprovalForAll
1013
+ * Returns gas estimate and result without sending transaction
1014
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1015
+ */
1016
+ setApprovalForAll(to: `0x${string}`, approved: boolean, options?: {
1017
+ accessList?: import("viem").AccessList;
1018
+ authorizationList?: import("viem").AuthorizationList;
1019
+ chain?: import("viem").Chain | null;
1020
+ dataSuffix?: `0x${string}`;
1021
+ gas?: bigint;
1022
+ gasPrice?: bigint;
1023
+ maxFeePerGas?: bigint;
1024
+ maxPriorityFeePerGas?: bigint;
1025
+ nonce?: number;
1026
+ value?: bigint;
1027
+ }): Promise<void>;
1028
+ /**
1029
+ * Simulate setContractURI
1030
+ * Returns gas estimate and result without sending transaction
1031
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1032
+ */
1033
+ setContractURI(contractURI: string, options?: {
1034
+ accessList?: import("viem").AccessList;
1035
+ authorizationList?: import("viem").AuthorizationList;
1036
+ chain?: import("viem").Chain | null;
1037
+ dataSuffix?: `0x${string}`;
1038
+ gas?: bigint;
1039
+ gasPrice?: bigint;
1040
+ maxFeePerGas?: bigint;
1041
+ maxPriorityFeePerGas?: bigint;
1042
+ nonce?: number;
1043
+ value?: bigint;
1044
+ }): Promise<void>;
1045
+ /**
1046
+ * Simulate setTokenURIPrefix
1047
+ * Returns gas estimate and result without sending transaction
1048
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1049
+ */
1050
+ setTokenURIPrefix(tokenURIPrefix: string, options?: {
1051
+ accessList?: import("viem").AccessList;
1052
+ authorizationList?: import("viem").AuthorizationList;
1053
+ chain?: import("viem").Chain | null;
1054
+ dataSuffix?: `0x${string}`;
1055
+ gas?: bigint;
1056
+ gasPrice?: bigint;
1057
+ maxFeePerGas?: bigint;
1058
+ maxPriorityFeePerGas?: bigint;
1059
+ nonce?: number;
1060
+ value?: bigint;
1061
+ }): Promise<void>;
1062
+ /**
1063
+ * Simulate transferFrom
1064
+ * Returns gas estimate and result without sending transaction
1065
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1066
+ */
1067
+ transferFrom(from: `0x${string}`, to: `0x${string}`, tokenId: bigint, options?: {
1068
+ accessList?: import("viem").AccessList;
1069
+ authorizationList?: import("viem").AuthorizationList;
1070
+ chain?: import("viem").Chain | null;
1071
+ dataSuffix?: `0x${string}`;
1072
+ gas?: bigint;
1073
+ gasPrice?: bigint;
1074
+ maxFeePerGas?: bigint;
1075
+ maxPriorityFeePerGas?: bigint;
1076
+ nonce?: number;
1077
+ value?: bigint;
1078
+ }): Promise<void>;
1079
+ /**
1080
+ * Simulate transferOwnership
1081
+ * Returns gas estimate and result without sending transaction
1082
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
1083
+ */
1084
+ transferOwnership(newOwner: `0x${string}`, options?: {
1085
+ accessList?: import("viem").AccessList;
1086
+ authorizationList?: import("viem").AuthorizationList;
1087
+ chain?: import("viem").Chain | null;
1088
+ dataSuffix?: `0x${string}`;
1089
+ gas?: bigint;
1090
+ gasPrice?: bigint;
1091
+ maxFeePerGas?: bigint;
1092
+ maxPriorityFeePerGas?: bigint;
1093
+ nonce?: number;
1094
+ value?: bigint;
1095
+ }): Promise<void>;
1096
+ };
1097
+ /**
1098
+ * Watch contract events
1099
+ *
1100
+ * @example
1101
+ * // Watch all Transfer events
1102
+ * const unwatch = contract.watch.Transfer((event) => {
1103
+ * console.log('Transfer:', event);
1104
+ * });
1105
+ *
1106
+ * // Stop watching
1107
+ * unwatch();
1108
+ */
1109
+ get watch(): {
1110
+ /**
1111
+ * Watch Approval events
1112
+ * @param callback Function to call when event is emitted
1113
+ * @param filter Optional filter for indexed parameters
1114
+ * @returns Unwatch function to stop listening
1115
+ */
1116
+ Approval: (callback: (event: {
1117
+ owner: `0x${string}`;
1118
+ approved: `0x${string}`;
1119
+ tokenId: bigint;
1120
+ }) => void, filter?: {
1121
+ owner: `0x${string}`;
1122
+ approved: `0x${string}`;
1123
+ tokenId: bigint;
1124
+ }) => () => void;
1125
+ /**
1126
+ * Watch ApprovalForAll events
1127
+ * @param callback Function to call when event is emitted
1128
+ * @param filter Optional filter for indexed parameters
1129
+ * @returns Unwatch function to stop listening
1130
+ */
1131
+ ApprovalForAll: (callback: (event: {
1132
+ owner: `0x${string}`;
1133
+ operator: `0x${string}`;
1134
+ approved: boolean;
1135
+ }) => void, filter?: {
1136
+ owner: `0x${string}`;
1137
+ operator: `0x${string}`;
1138
+ }) => () => void;
1139
+ /**
1140
+ * Watch OwnershipTransferred events
1141
+ * @param callback Function to call when event is emitted
1142
+ * @param filter Optional filter for indexed parameters
1143
+ * @returns Unwatch function to stop listening
1144
+ */
1145
+ OwnershipTransferred: (callback: (event: {
1146
+ previousOwner: `0x${string}`;
1147
+ newOwner: `0x${string}`;
1148
+ }) => void, filter?: {
1149
+ previousOwner: `0x${string}`;
1150
+ newOwner: `0x${string}`;
1151
+ }) => () => void;
1152
+ /**
1153
+ * Watch SecondarySaleFees events
1154
+ * @param callback Function to call when event is emitted
1155
+ * @param filter Optional filter for indexed parameters
1156
+ * @returns Unwatch function to stop listening
1157
+ */
1158
+ SecondarySaleFees: (callback: (event: {
1159
+ tokenId: bigint;
1160
+ recipients: `0x${string}`[];
1161
+ bps: bigint[];
1162
+ }) => void) => () => void;
1163
+ /**
1164
+ * Watch Transfer events
1165
+ * @param callback Function to call when event is emitted
1166
+ * @param filter Optional filter for indexed parameters
1167
+ * @returns Unwatch function to stop listening
1168
+ */
1169
+ Transfer: (callback: (event: {
1170
+ from: `0x${string}`;
1171
+ to: `0x${string}`;
1172
+ tokenId: bigint;
1173
+ }) => void, filter?: {
1174
+ from: `0x${string}`;
1175
+ to: `0x${string}`;
1176
+ tokenId: bigint;
1177
+ }) => () => void;
1178
+ };
1179
+ }