@gitmyabi/minerpass 0.0.0-stage → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,867 @@
1
+ import type { Address, PublicClient, WalletClient } from 'viem';
2
+ /**
3
+ * MinerPass ABI
4
+ *
5
+ * This ABI is typed using viem's type system for full type safety.
6
+ */
7
+ export declare const MinerPassAbi: readonly [{
8
+ readonly inputs: readonly [{
9
+ readonly internalType: "address";
10
+ readonly name: "owner_";
11
+ readonly type: "address";
12
+ }];
13
+ readonly stateMutability: "nonpayable";
14
+ readonly type: "constructor";
15
+ }, {
16
+ readonly inputs: readonly [{
17
+ readonly internalType: "address";
18
+ readonly name: "sender";
19
+ readonly type: "address";
20
+ }, {
21
+ readonly internalType: "uint256";
22
+ readonly name: "balance";
23
+ readonly type: "uint256";
24
+ }, {
25
+ readonly internalType: "uint256";
26
+ readonly name: "needed";
27
+ readonly type: "uint256";
28
+ }, {
29
+ readonly internalType: "uint256";
30
+ readonly name: "tokenId";
31
+ readonly type: "uint256";
32
+ }];
33
+ readonly name: "ERC1155InsufficientBalance";
34
+ readonly type: "error";
35
+ }, {
36
+ readonly inputs: readonly [{
37
+ readonly internalType: "address";
38
+ readonly name: "approver";
39
+ readonly type: "address";
40
+ }];
41
+ readonly name: "ERC1155InvalidApprover";
42
+ readonly type: "error";
43
+ }, {
44
+ readonly inputs: readonly [{
45
+ readonly internalType: "uint256";
46
+ readonly name: "idsLength";
47
+ readonly type: "uint256";
48
+ }, {
49
+ readonly internalType: "uint256";
50
+ readonly name: "valuesLength";
51
+ readonly type: "uint256";
52
+ }];
53
+ readonly name: "ERC1155InvalidArrayLength";
54
+ readonly type: "error";
55
+ }, {
56
+ readonly inputs: readonly [{
57
+ readonly internalType: "address";
58
+ readonly name: "operator";
59
+ readonly type: "address";
60
+ }];
61
+ readonly name: "ERC1155InvalidOperator";
62
+ readonly type: "error";
63
+ }, {
64
+ readonly inputs: readonly [{
65
+ readonly internalType: "address";
66
+ readonly name: "receiver";
67
+ readonly type: "address";
68
+ }];
69
+ readonly name: "ERC1155InvalidReceiver";
70
+ readonly type: "error";
71
+ }, {
72
+ readonly inputs: readonly [{
73
+ readonly internalType: "address";
74
+ readonly name: "sender";
75
+ readonly type: "address";
76
+ }];
77
+ readonly name: "ERC1155InvalidSender";
78
+ readonly type: "error";
79
+ }, {
80
+ readonly inputs: readonly [{
81
+ readonly internalType: "address";
82
+ readonly name: "operator";
83
+ readonly type: "address";
84
+ }, {
85
+ readonly internalType: "address";
86
+ readonly name: "owner";
87
+ readonly type: "address";
88
+ }];
89
+ readonly name: "ERC1155MissingApprovalForAll";
90
+ readonly type: "error";
91
+ }, {
92
+ readonly inputs: readonly [{
93
+ readonly internalType: "address";
94
+ readonly name: "owner";
95
+ readonly type: "address";
96
+ }];
97
+ readonly name: "OwnableInvalidOwner";
98
+ readonly type: "error";
99
+ }, {
100
+ readonly inputs: readonly [{
101
+ readonly internalType: "address";
102
+ readonly name: "account";
103
+ readonly type: "address";
104
+ }];
105
+ readonly name: "OwnableUnauthorizedAccount";
106
+ readonly type: "error";
107
+ }, {
108
+ readonly inputs: readonly [];
109
+ readonly name: "Sealed";
110
+ readonly type: "error";
111
+ }, {
112
+ readonly inputs: readonly [];
113
+ readonly name: "Soulbound";
114
+ readonly type: "error";
115
+ }, {
116
+ readonly anonymous: false;
117
+ readonly inputs: readonly [{
118
+ readonly indexed: true;
119
+ readonly internalType: "address";
120
+ readonly name: "account";
121
+ readonly type: "address";
122
+ }, {
123
+ readonly indexed: true;
124
+ readonly internalType: "address";
125
+ readonly name: "operator";
126
+ readonly type: "address";
127
+ }, {
128
+ readonly indexed: false;
129
+ readonly internalType: "bool";
130
+ readonly name: "approved";
131
+ readonly type: "bool";
132
+ }];
133
+ readonly name: "ApprovalForAll";
134
+ readonly type: "event";
135
+ }, {
136
+ readonly anonymous: false;
137
+ readonly inputs: readonly [{
138
+ readonly indexed: true;
139
+ readonly internalType: "address";
140
+ readonly name: "previousOwner";
141
+ readonly type: "address";
142
+ }, {
143
+ readonly indexed: true;
144
+ readonly internalType: "address";
145
+ readonly name: "newOwner";
146
+ readonly type: "address";
147
+ }];
148
+ readonly name: "OwnershipTransferred";
149
+ readonly type: "event";
150
+ }, {
151
+ readonly anonymous: false;
152
+ readonly inputs: readonly [{
153
+ readonly indexed: true;
154
+ readonly internalType: "address";
155
+ readonly name: "operator";
156
+ readonly type: "address";
157
+ }, {
158
+ readonly indexed: true;
159
+ readonly internalType: "address";
160
+ readonly name: "from";
161
+ readonly type: "address";
162
+ }, {
163
+ readonly indexed: true;
164
+ readonly internalType: "address";
165
+ readonly name: "to";
166
+ readonly type: "address";
167
+ }, {
168
+ readonly indexed: false;
169
+ readonly internalType: "uint256[]";
170
+ readonly name: "ids";
171
+ readonly type: "uint256[]";
172
+ }, {
173
+ readonly indexed: false;
174
+ readonly internalType: "uint256[]";
175
+ readonly name: "values";
176
+ readonly type: "uint256[]";
177
+ }];
178
+ readonly name: "TransferBatch";
179
+ readonly type: "event";
180
+ }, {
181
+ readonly anonymous: false;
182
+ readonly inputs: readonly [{
183
+ readonly indexed: true;
184
+ readonly internalType: "address";
185
+ readonly name: "operator";
186
+ readonly type: "address";
187
+ }, {
188
+ readonly indexed: true;
189
+ readonly internalType: "address";
190
+ readonly name: "from";
191
+ readonly type: "address";
192
+ }, {
193
+ readonly indexed: true;
194
+ readonly internalType: "address";
195
+ readonly name: "to";
196
+ readonly type: "address";
197
+ }, {
198
+ readonly indexed: false;
199
+ readonly internalType: "uint256";
200
+ readonly name: "id";
201
+ readonly type: "uint256";
202
+ }, {
203
+ readonly indexed: false;
204
+ readonly internalType: "uint256";
205
+ readonly name: "value";
206
+ readonly type: "uint256";
207
+ }];
208
+ readonly name: "TransferSingle";
209
+ readonly type: "event";
210
+ }, {
211
+ readonly anonymous: false;
212
+ readonly inputs: readonly [{
213
+ readonly indexed: false;
214
+ readonly internalType: "string";
215
+ readonly name: "value";
216
+ readonly type: "string";
217
+ }, {
218
+ readonly indexed: true;
219
+ readonly internalType: "uint256";
220
+ readonly name: "id";
221
+ readonly type: "uint256";
222
+ }];
223
+ readonly name: "URI";
224
+ readonly type: "event";
225
+ }, {
226
+ readonly inputs: readonly [];
227
+ readonly name: "ID";
228
+ readonly outputs: readonly [{
229
+ readonly internalType: "uint256";
230
+ readonly name: "";
231
+ readonly type: "uint256";
232
+ }];
233
+ readonly stateMutability: "view";
234
+ readonly type: "function";
235
+ }, {
236
+ readonly inputs: readonly [{
237
+ readonly internalType: "address";
238
+ readonly name: "account";
239
+ readonly type: "address";
240
+ }, {
241
+ readonly internalType: "uint256";
242
+ readonly name: "id";
243
+ readonly type: "uint256";
244
+ }];
245
+ readonly name: "balanceOf";
246
+ readonly outputs: readonly [{
247
+ readonly internalType: "uint256";
248
+ readonly name: "";
249
+ readonly type: "uint256";
250
+ }];
251
+ readonly stateMutability: "view";
252
+ readonly type: "function";
253
+ }, {
254
+ readonly inputs: readonly [{
255
+ readonly internalType: "address[]";
256
+ readonly name: "accounts";
257
+ readonly type: "address[]";
258
+ }, {
259
+ readonly internalType: "uint256[]";
260
+ readonly name: "ids";
261
+ readonly type: "uint256[]";
262
+ }];
263
+ readonly name: "balanceOfBatch";
264
+ readonly outputs: readonly [{
265
+ readonly internalType: "uint256[]";
266
+ readonly name: "";
267
+ readonly type: "uint256[]";
268
+ }];
269
+ readonly stateMutability: "view";
270
+ readonly type: "function";
271
+ }, {
272
+ readonly inputs: readonly [];
273
+ readonly name: "closed";
274
+ readonly outputs: readonly [{
275
+ readonly internalType: "bool";
276
+ readonly name: "";
277
+ readonly type: "bool";
278
+ }];
279
+ readonly stateMutability: "view";
280
+ readonly type: "function";
281
+ }, {
282
+ readonly inputs: readonly [{
283
+ readonly internalType: "address";
284
+ readonly name: "account";
285
+ readonly type: "address";
286
+ }, {
287
+ readonly internalType: "address";
288
+ readonly name: "operator";
289
+ readonly type: "address";
290
+ }];
291
+ readonly name: "isApprovedForAll";
292
+ readonly outputs: readonly [{
293
+ readonly internalType: "bool";
294
+ readonly name: "";
295
+ readonly type: "bool";
296
+ }];
297
+ readonly stateMutability: "view";
298
+ readonly type: "function";
299
+ }, {
300
+ readonly inputs: readonly [{
301
+ readonly internalType: "address[]";
302
+ readonly name: "wallets";
303
+ readonly type: "address[]";
304
+ }];
305
+ readonly name: "mint";
306
+ readonly outputs: readonly [];
307
+ readonly stateMutability: "nonpayable";
308
+ readonly type: "function";
309
+ }, {
310
+ readonly inputs: readonly [];
311
+ readonly name: "owner";
312
+ readonly outputs: readonly [{
313
+ readonly internalType: "address";
314
+ readonly name: "";
315
+ readonly type: "address";
316
+ }];
317
+ readonly stateMutability: "view";
318
+ readonly type: "function";
319
+ }, {
320
+ readonly inputs: readonly [];
321
+ readonly name: "renounceOwnership";
322
+ readonly outputs: readonly [];
323
+ readonly stateMutability: "nonpayable";
324
+ readonly type: "function";
325
+ }, {
326
+ readonly inputs: readonly [{
327
+ readonly internalType: "address";
328
+ readonly name: "from";
329
+ readonly type: "address";
330
+ }, {
331
+ readonly internalType: "address";
332
+ readonly name: "to";
333
+ readonly type: "address";
334
+ }, {
335
+ readonly internalType: "uint256[]";
336
+ readonly name: "ids";
337
+ readonly type: "uint256[]";
338
+ }, {
339
+ readonly internalType: "uint256[]";
340
+ readonly name: "values";
341
+ readonly type: "uint256[]";
342
+ }, {
343
+ readonly internalType: "bytes";
344
+ readonly name: "data";
345
+ readonly type: "bytes";
346
+ }];
347
+ readonly name: "safeBatchTransferFrom";
348
+ readonly outputs: readonly [];
349
+ readonly stateMutability: "nonpayable";
350
+ readonly type: "function";
351
+ }, {
352
+ readonly inputs: readonly [{
353
+ readonly internalType: "address";
354
+ readonly name: "from";
355
+ readonly type: "address";
356
+ }, {
357
+ readonly internalType: "address";
358
+ readonly name: "to";
359
+ readonly type: "address";
360
+ }, {
361
+ readonly internalType: "uint256";
362
+ readonly name: "id";
363
+ readonly type: "uint256";
364
+ }, {
365
+ readonly internalType: "uint256";
366
+ readonly name: "value";
367
+ readonly type: "uint256";
368
+ }, {
369
+ readonly internalType: "bytes";
370
+ readonly name: "data";
371
+ readonly type: "bytes";
372
+ }];
373
+ readonly name: "safeTransferFrom";
374
+ readonly outputs: readonly [];
375
+ readonly stateMutability: "nonpayable";
376
+ readonly type: "function";
377
+ }, {
378
+ readonly inputs: readonly [];
379
+ readonly name: "seal";
380
+ readonly outputs: readonly [];
381
+ readonly stateMutability: "nonpayable";
382
+ readonly type: "function";
383
+ }, {
384
+ readonly inputs: readonly [{
385
+ readonly internalType: "address";
386
+ readonly name: "operator";
387
+ readonly type: "address";
388
+ }, {
389
+ readonly internalType: "bool";
390
+ readonly name: "approved";
391
+ readonly type: "bool";
392
+ }];
393
+ readonly name: "setApprovalForAll";
394
+ readonly outputs: readonly [];
395
+ readonly stateMutability: "nonpayable";
396
+ readonly type: "function";
397
+ }, {
398
+ readonly inputs: readonly [{
399
+ readonly internalType: "bytes4";
400
+ readonly name: "interfaceId";
401
+ readonly type: "bytes4";
402
+ }];
403
+ readonly name: "supportsInterface";
404
+ readonly outputs: readonly [{
405
+ readonly internalType: "bool";
406
+ readonly name: "";
407
+ readonly type: "bool";
408
+ }];
409
+ readonly stateMutability: "view";
410
+ readonly type: "function";
411
+ }, {
412
+ readonly inputs: readonly [{
413
+ readonly internalType: "address";
414
+ readonly name: "newOwner";
415
+ readonly type: "address";
416
+ }];
417
+ readonly name: "transferOwnership";
418
+ readonly outputs: readonly [];
419
+ readonly stateMutability: "nonpayable";
420
+ readonly type: "function";
421
+ }, {
422
+ readonly inputs: readonly [{
423
+ readonly internalType: "uint256";
424
+ readonly name: "";
425
+ readonly type: "uint256";
426
+ }];
427
+ readonly name: "uri";
428
+ readonly outputs: readonly [{
429
+ readonly internalType: "string";
430
+ readonly name: "";
431
+ readonly type: "string";
432
+ }];
433
+ readonly stateMutability: "view";
434
+ readonly type: "function";
435
+ }];
436
+ /**
437
+ * Type-safe ABI for MinerPass
438
+ */
439
+ export type MinerPassAbi = typeof MinerPassAbi;
440
+ /**
441
+ * Contract instance type for MinerPass
442
+ */
443
+ export type MinerPassContract = any;
444
+ /**
445
+ * MinerPass Contract Class
446
+ *
447
+ * Provides a class-based API similar to TypeChain for interacting with the contract.
448
+ *
449
+ * @example
450
+ * ```typescript
451
+ * import { createPublicClient, createWalletClient, http } from 'viem';
452
+ * import { mainnet } from 'viem/chains';
453
+ * import { MinerPass } from 'MinerPass';
454
+ *
455
+ * const publicClient = createPublicClient({ chain: mainnet, transport: http() });
456
+ * const walletClient = createWalletClient({ chain: mainnet, transport: http() });
457
+ *
458
+ * const contract = new MinerPass('0x...', { publicClient, walletClient });
459
+ *
460
+ * // Read functions
461
+ * const result = await contract.balanceOf('0x...');
462
+ *
463
+ * // Write functions
464
+ * const hash = await contract.transfer('0x...', 1000n);
465
+ *
466
+ * // Simulate transactions (dry-run)
467
+ * const simulation = await contract.simulate.transfer('0x...', 1000n);
468
+ * console.log('Gas estimate:', simulation.request.gas);
469
+ *
470
+ * // Watch events
471
+ * const unwatch = contract.watch.Transfer((event) => {
472
+ * console.log('Transfer event:', event);
473
+ * });
474
+ * ```
475
+ */
476
+ export declare class MinerPass {
477
+ private contract;
478
+ private contractAddress;
479
+ private publicClient;
480
+ constructor(address: Address, clients: {
481
+ publicClient: PublicClient;
482
+ walletClient?: WalletClient;
483
+ });
484
+ /**
485
+ * Get the contract address
486
+ */
487
+ get address(): Address;
488
+ /**
489
+ * Get the underlying viem contract instance.
490
+ */
491
+ getContract(): MinerPassContract;
492
+ /**
493
+ * ID
494
+ * view
495
+ */
496
+ ID(): Promise<bigint>;
497
+ /**
498
+ * balanceOf
499
+ * view
500
+ */
501
+ balanceOf(account: `0x${string}`, id: bigint): Promise<bigint>;
502
+ /**
503
+ * balanceOfBatch
504
+ * view
505
+ */
506
+ balanceOfBatch(accounts: `0x${string}`[], ids: bigint[]): Promise<bigint[]>;
507
+ /**
508
+ * closed
509
+ * view
510
+ */
511
+ closed(): Promise<boolean>;
512
+ /**
513
+ * isApprovedForAll
514
+ * view
515
+ */
516
+ isApprovedForAll(account: `0x${string}`, operator: `0x${string}`): Promise<boolean>;
517
+ /**
518
+ * owner
519
+ * view
520
+ */
521
+ owner(): Promise<`0x${string}`>;
522
+ /**
523
+ * supportsInterface
524
+ * view
525
+ */
526
+ supportsInterface(interfaceId: `0x${string}`): Promise<boolean>;
527
+ /**
528
+ * uri
529
+ * view
530
+ */
531
+ uri(arg0: bigint): Promise<string>;
532
+ /**
533
+ * mint
534
+ * nonpayable
535
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
536
+ */
537
+ mint(wallets: `0x${string}`[], options?: {
538
+ accessList?: import('viem').AccessList;
539
+ authorizationList?: import('viem').AuthorizationList;
540
+ chain?: import('viem').Chain | null;
541
+ dataSuffix?: `0x${string}`;
542
+ gas?: bigint;
543
+ gasPrice?: bigint;
544
+ maxFeePerGas?: bigint;
545
+ maxPriorityFeePerGas?: bigint;
546
+ nonce?: number;
547
+ value?: bigint;
548
+ }): Promise<`0x${string}`>;
549
+ /**
550
+ * renounceOwnership
551
+ * nonpayable
552
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
553
+ */
554
+ renounceOwnership(options?: {
555
+ accessList?: import('viem').AccessList;
556
+ authorizationList?: import('viem').AuthorizationList;
557
+ chain?: import('viem').Chain | null;
558
+ dataSuffix?: `0x${string}`;
559
+ gas?: bigint;
560
+ gasPrice?: bigint;
561
+ maxFeePerGas?: bigint;
562
+ maxPriorityFeePerGas?: bigint;
563
+ nonce?: number;
564
+ value?: bigint;
565
+ }): Promise<`0x${string}`>;
566
+ /**
567
+ * safeBatchTransferFrom
568
+ * nonpayable
569
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
570
+ */
571
+ safeBatchTransferFrom(from: `0x${string}`, to: `0x${string}`, ids: bigint[], values: bigint[], data: `0x${string}`, options?: {
572
+ accessList?: import('viem').AccessList;
573
+ authorizationList?: import('viem').AuthorizationList;
574
+ chain?: import('viem').Chain | null;
575
+ dataSuffix?: `0x${string}`;
576
+ gas?: bigint;
577
+ gasPrice?: bigint;
578
+ maxFeePerGas?: bigint;
579
+ maxPriorityFeePerGas?: bigint;
580
+ nonce?: number;
581
+ value?: bigint;
582
+ }): Promise<`0x${string}`>;
583
+ /**
584
+ * safeTransferFrom
585
+ * nonpayable
586
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
587
+ */
588
+ safeTransferFrom(from: `0x${string}`, to: `0x${string}`, id: bigint, value: bigint, data: `0x${string}`, options?: {
589
+ accessList?: import('viem').AccessList;
590
+ authorizationList?: import('viem').AuthorizationList;
591
+ chain?: import('viem').Chain | null;
592
+ dataSuffix?: `0x${string}`;
593
+ gas?: bigint;
594
+ gasPrice?: bigint;
595
+ maxFeePerGas?: bigint;
596
+ maxPriorityFeePerGas?: bigint;
597
+ nonce?: number;
598
+ value?: bigint;
599
+ }): Promise<`0x${string}`>;
600
+ /**
601
+ * seal
602
+ * nonpayable
603
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
604
+ */
605
+ seal(options?: {
606
+ accessList?: import('viem').AccessList;
607
+ authorizationList?: import('viem').AuthorizationList;
608
+ chain?: import('viem').Chain | null;
609
+ dataSuffix?: `0x${string}`;
610
+ gas?: bigint;
611
+ gasPrice?: bigint;
612
+ maxFeePerGas?: bigint;
613
+ maxPriorityFeePerGas?: bigint;
614
+ nonce?: number;
615
+ value?: bigint;
616
+ }): Promise<`0x${string}`>;
617
+ /**
618
+ * setApprovalForAll
619
+ * nonpayable
620
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
621
+ */
622
+ setApprovalForAll(operator: `0x${string}`, approved: boolean, options?: {
623
+ accessList?: import('viem').AccessList;
624
+ authorizationList?: import('viem').AuthorizationList;
625
+ chain?: import('viem').Chain | null;
626
+ dataSuffix?: `0x${string}`;
627
+ gas?: bigint;
628
+ gasPrice?: bigint;
629
+ maxFeePerGas?: bigint;
630
+ maxPriorityFeePerGas?: bigint;
631
+ nonce?: number;
632
+ value?: bigint;
633
+ }): Promise<`0x${string}`>;
634
+ /**
635
+ * transferOwnership
636
+ * nonpayable
637
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
638
+ */
639
+ transferOwnership(newOwner: `0x${string}`, options?: {
640
+ accessList?: import('viem').AccessList;
641
+ authorizationList?: import('viem').AuthorizationList;
642
+ chain?: import('viem').Chain | null;
643
+ dataSuffix?: `0x${string}`;
644
+ gas?: bigint;
645
+ gasPrice?: bigint;
646
+ maxFeePerGas?: bigint;
647
+ maxPriorityFeePerGas?: bigint;
648
+ nonce?: number;
649
+ value?: bigint;
650
+ }): Promise<`0x${string}`>;
651
+ /**
652
+ * Simulate contract write operations (dry-run without sending transaction)
653
+ *
654
+ * @example
655
+ * const result = await contract.simulate.transfer('0x...', 1000n);
656
+ * console.log('Gas estimate:', result.request.gas);
657
+ * console.log('Would succeed:', result.result);
658
+ */
659
+ get simulate(): {
660
+ /**
661
+ * Simulate mint
662
+ * Returns gas estimate and result without sending transaction
663
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
664
+ */
665
+ mint(wallets: `0x${string}`[], options?: {
666
+ accessList?: import("viem").AccessList;
667
+ authorizationList?: import("viem").AuthorizationList;
668
+ chain?: import("viem").Chain | null;
669
+ dataSuffix?: `0x${string}`;
670
+ gas?: bigint;
671
+ gasPrice?: bigint;
672
+ maxFeePerGas?: bigint;
673
+ maxPriorityFeePerGas?: bigint;
674
+ nonce?: number;
675
+ value?: bigint;
676
+ }): Promise<void>;
677
+ /**
678
+ * Simulate renounceOwnership
679
+ * Returns gas estimate and result without sending transaction
680
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
681
+ */
682
+ renounceOwnership(options?: {
683
+ accessList?: import("viem").AccessList;
684
+ authorizationList?: import("viem").AuthorizationList;
685
+ chain?: import("viem").Chain | null;
686
+ dataSuffix?: `0x${string}`;
687
+ gas?: bigint;
688
+ gasPrice?: bigint;
689
+ maxFeePerGas?: bigint;
690
+ maxPriorityFeePerGas?: bigint;
691
+ nonce?: number;
692
+ value?: bigint;
693
+ }): Promise<void>;
694
+ /**
695
+ * Simulate safeBatchTransferFrom
696
+ * Returns gas estimate and result without sending transaction
697
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
698
+ */
699
+ safeBatchTransferFrom(from: `0x${string}`, to: `0x${string}`, ids: bigint[], values: bigint[], data: `0x${string}`, options?: {
700
+ accessList?: import("viem").AccessList;
701
+ authorizationList?: import("viem").AuthorizationList;
702
+ chain?: import("viem").Chain | null;
703
+ dataSuffix?: `0x${string}`;
704
+ gas?: bigint;
705
+ gasPrice?: bigint;
706
+ maxFeePerGas?: bigint;
707
+ maxPriorityFeePerGas?: bigint;
708
+ nonce?: number;
709
+ value?: bigint;
710
+ }): Promise<void>;
711
+ /**
712
+ * Simulate safeTransferFrom
713
+ * Returns gas estimate and result without sending transaction
714
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
715
+ */
716
+ safeTransferFrom(from: `0x${string}`, to: `0x${string}`, id: bigint, value: bigint, data: `0x${string}`, options?: {
717
+ accessList?: import("viem").AccessList;
718
+ authorizationList?: import("viem").AuthorizationList;
719
+ chain?: import("viem").Chain | null;
720
+ dataSuffix?: `0x${string}`;
721
+ gas?: bigint;
722
+ gasPrice?: bigint;
723
+ maxFeePerGas?: bigint;
724
+ maxPriorityFeePerGas?: bigint;
725
+ nonce?: number;
726
+ value?: bigint;
727
+ }): Promise<void>;
728
+ /**
729
+ * Simulate seal
730
+ * Returns gas estimate and result without sending transaction
731
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
732
+ */
733
+ seal(options?: {
734
+ accessList?: import("viem").AccessList;
735
+ authorizationList?: import("viem").AuthorizationList;
736
+ chain?: import("viem").Chain | null;
737
+ dataSuffix?: `0x${string}`;
738
+ gas?: bigint;
739
+ gasPrice?: bigint;
740
+ maxFeePerGas?: bigint;
741
+ maxPriorityFeePerGas?: bigint;
742
+ nonce?: number;
743
+ value?: bigint;
744
+ }): Promise<void>;
745
+ /**
746
+ * Simulate setApprovalForAll
747
+ * Returns gas estimate and result without sending transaction
748
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
749
+ */
750
+ setApprovalForAll(operator: `0x${string}`, approved: boolean, options?: {
751
+ accessList?: import("viem").AccessList;
752
+ authorizationList?: import("viem").AuthorizationList;
753
+ chain?: import("viem").Chain | null;
754
+ dataSuffix?: `0x${string}`;
755
+ gas?: bigint;
756
+ gasPrice?: bigint;
757
+ maxFeePerGas?: bigint;
758
+ maxPriorityFeePerGas?: bigint;
759
+ nonce?: number;
760
+ value?: bigint;
761
+ }): Promise<void>;
762
+ /**
763
+ * Simulate transferOwnership
764
+ * Returns gas estimate and result without sending transaction
765
+ * @param options Optional transaction parameters (value, gas, nonce, etc.)
766
+ */
767
+ transferOwnership(newOwner: `0x${string}`, options?: {
768
+ accessList?: import("viem").AccessList;
769
+ authorizationList?: import("viem").AuthorizationList;
770
+ chain?: import("viem").Chain | null;
771
+ dataSuffix?: `0x${string}`;
772
+ gas?: bigint;
773
+ gasPrice?: bigint;
774
+ maxFeePerGas?: bigint;
775
+ maxPriorityFeePerGas?: bigint;
776
+ nonce?: number;
777
+ value?: bigint;
778
+ }): Promise<void>;
779
+ };
780
+ /**
781
+ * Watch contract events
782
+ *
783
+ * @example
784
+ * // Watch all Transfer events
785
+ * const unwatch = contract.watch.Transfer((event) => {
786
+ * console.log('Transfer:', event);
787
+ * });
788
+ *
789
+ * // Stop watching
790
+ * unwatch();
791
+ */
792
+ get watch(): {
793
+ /**
794
+ * Watch ApprovalForAll events
795
+ * @param callback Function to call when event is emitted
796
+ * @param filter Optional filter for indexed parameters
797
+ * @returns Unwatch function to stop listening
798
+ */
799
+ ApprovalForAll: (callback: (event: {
800
+ account: `0x${string}`;
801
+ operator: `0x${string}`;
802
+ approved: boolean;
803
+ }) => void, filter?: {
804
+ account?: `0x${string}` | `0x${string}`[] | null;
805
+ operator?: `0x${string}` | `0x${string}`[] | null;
806
+ }) => () => void;
807
+ /**
808
+ * Watch OwnershipTransferred events
809
+ * @param callback Function to call when event is emitted
810
+ * @param filter Optional filter for indexed parameters
811
+ * @returns Unwatch function to stop listening
812
+ */
813
+ OwnershipTransferred: (callback: (event: {
814
+ previousOwner: `0x${string}`;
815
+ newOwner: `0x${string}`;
816
+ }) => void, filter?: {
817
+ previousOwner?: `0x${string}` | `0x${string}`[] | null;
818
+ newOwner?: `0x${string}` | `0x${string}`[] | null;
819
+ }) => () => void;
820
+ /**
821
+ * Watch TransferBatch events
822
+ * @param callback Function to call when event is emitted
823
+ * @param filter Optional filter for indexed parameters
824
+ * @returns Unwatch function to stop listening
825
+ */
826
+ TransferBatch: (callback: (event: {
827
+ operator: `0x${string}`;
828
+ from: `0x${string}`;
829
+ to: `0x${string}`;
830
+ ids: bigint[];
831
+ values: bigint[];
832
+ }) => void, filter?: {
833
+ operator?: `0x${string}` | `0x${string}`[] | null;
834
+ from?: `0x${string}` | `0x${string}`[] | null;
835
+ to?: `0x${string}` | `0x${string}`[] | null;
836
+ }) => () => void;
837
+ /**
838
+ * Watch TransferSingle events
839
+ * @param callback Function to call when event is emitted
840
+ * @param filter Optional filter for indexed parameters
841
+ * @returns Unwatch function to stop listening
842
+ */
843
+ TransferSingle: (callback: (event: {
844
+ operator: `0x${string}`;
845
+ from: `0x${string}`;
846
+ to: `0x${string}`;
847
+ id: bigint;
848
+ value: bigint;
849
+ }) => void, filter?: {
850
+ operator?: `0x${string}` | `0x${string}`[] | null;
851
+ from?: `0x${string}` | `0x${string}`[] | null;
852
+ to?: `0x${string}` | `0x${string}`[] | null;
853
+ }) => () => void;
854
+ /**
855
+ * Watch URI events
856
+ * @param callback Function to call when event is emitted
857
+ * @param filter Optional filter for indexed parameters
858
+ * @returns Unwatch function to stop listening
859
+ */
860
+ URI: (callback: (event: {
861
+ value: string;
862
+ id: bigint;
863
+ }) => void, filter?: {
864
+ id?: bigint | bigint[] | null;
865
+ }) => () => void;
866
+ };
867
+ }