@gitmyabi/dusd 0.0.0-stage → 1.0.1

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