@rhinestone/shared-configs 2.0.1 → 2.1.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.
Files changed (15) hide show
  1. package/README.md +41 -0
  2. package/dist/configs/chains.json +452 -0
  3. package/dist/scripts/__tests__/validation.test.js +215 -0
  4. package/dist/scripts/audit-token-authorizations.d.ts +1 -0
  5. package/dist/scripts/audit-token-authorizations.js +541 -0
  6. package/dist/scripts/generate.js +3 -1
  7. package/dist/scripts/validation.js +97 -2
  8. package/dist/src/chains.d.ts +3 -1
  9. package/dist/src/chains.js +452 -0
  10. package/dist/src/generated/networks.d.ts +1105 -1105
  11. package/dist/src/generated/packageVersion.d.ts +1 -1
  12. package/dist/src/generated/packageVersion.js +1 -1
  13. package/dist/src/index.d.ts +2 -2
  14. package/dist/src/types.d.ts +47 -2
  15. package/package.json +2 -1
package/dist/src/generated/networks.d.ts CHANGED
@@ -1,21 +1,25 @@
1
1
  declare const mainnetChains: ({
2
2
  blockExplorers: {
3
3
  readonly default: {
4
- readonly name: "Arbiscan";
5
- readonly url: "https://arbiscan.io";
6
- readonly apiUrl: "https://api.arbiscan.io/api";
4
+ readonly name: "Etherscan";
5
+ readonly url: "https://etherscan.io";
6
+ readonly apiUrl: "https://api.etherscan.io/api";
7
7
  };
8
8
  };
9
- blockTime: 250;
9
+ blockTime: 12000;
10
10
  contracts: {
11
+ readonly ensUniversalResolver: {
12
+ readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
13
+ readonly blockCreated: 23085558;
14
+ };
11
15
  readonly multicall3: {
12
16
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
13
- readonly blockCreated: 7654707;
17
+ readonly blockCreated: 14353601;
14
18
  };
15
19
  };
16
20
  ensTlds?: readonly string[] | undefined;
17
- id: 42161;
18
- name: "Arbitrum One";
21
+ id: 1;
22
+ name: "Ethereum";
19
23
  nativeCurrency: {
20
24
  readonly name: "Ether";
21
25
  readonly symbol: "ETH";
@@ -24,53 +28,7 @@ declare const mainnetChains: ({
24
28
  experimental_preconfirmationTime?: number | undefined | undefined;
25
29
  rpcUrls: {
26
30
  readonly default: {
27
- readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
28
- };
29
- };
30
- sourceId?: number | undefined | undefined;
31
- testnet?: boolean | undefined | undefined;
32
- custom?: Record<string, unknown> | undefined;
33
- extendSchema?: Record<string, unknown> | undefined;
34
- fees?: import("viem").ChainFees<undefined> | undefined;
35
- formatters?: undefined;
36
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
37
- client: import("viem").Client;
38
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
39
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
40
- client: import("viem").Client;
41
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
42
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
43
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
44
- }] | undefined;
45
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
46
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
47
- } | {
48
- blockExplorers: {
49
- readonly default: {
50
- readonly name: "SnowTrace";
51
- readonly url: "https://snowtrace.io";
52
- readonly apiUrl: "https://api.snowtrace.io";
53
- };
54
- };
55
- blockTime: 1700;
56
- contracts: {
57
- readonly multicall3: {
58
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
59
- readonly blockCreated: 11907934;
60
- };
61
- };
62
- ensTlds?: readonly string[] | undefined;
63
- id: 43114;
64
- name: "Avalanche";
65
- nativeCurrency: {
66
- readonly decimals: 18;
67
- readonly name: "Avalanche";
68
- readonly symbol: "AVAX";
69
- };
70
- experimental_preconfirmationTime?: number | undefined | undefined;
71
- rpcUrls: {
72
- readonly default: {
73
- readonly http: readonly ["https://api.avax.network/ext/bc/C/rpc"];
31
+ readonly http: readonly ["https://eth.merkle.io"];
74
32
  };
75
33
  };
76
34
  sourceId?: number | undefined | undefined;
@@ -93,37 +51,35 @@ declare const mainnetChains: ({
93
51
  } | {
94
52
  blockExplorers: {
95
53
  readonly default: {
96
- readonly name: "Basescan";
97
- readonly url: "https://basescan.org";
98
- readonly apiUrl: "https://api.basescan.org/api";
54
+ readonly name: "Optimism Explorer";
55
+ readonly url: "https://optimistic.etherscan.io";
56
+ readonly apiUrl: "https://api-optimistic.etherscan.io/api";
99
57
  };
100
58
  };
101
59
  blockTime: 2000;
102
60
  contracts: {
103
61
  readonly disputeGameFactory: {
104
62
  readonly 1: {
105
- readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
63
+ readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
106
64
  };
107
65
  };
108
66
  readonly l2OutputOracle: {
109
67
  readonly 1: {
110
- readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
68
+ readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
111
69
  };
112
70
  };
113
71
  readonly multicall3: {
114
72
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
115
- readonly blockCreated: 5022;
73
+ readonly blockCreated: 4286263;
116
74
  };
117
75
  readonly portal: {
118
76
  readonly 1: {
119
- readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
120
- readonly blockCreated: 17482143;
77
+ readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
121
78
  };
122
79
  };
123
80
  readonly l1StandardBridge: {
124
81
  readonly 1: {
125
- readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
126
- readonly blockCreated: 17482143;
82
+ readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
127
83
  };
128
84
  };
129
85
  readonly gasPriceOracle: {
@@ -146,8 +102,8 @@ declare const mainnetChains: ({
146
102
  };
147
103
  };
148
104
  ensTlds?: readonly string[] | undefined;
149
- id: 8453;
150
- name: "Base";
105
+ id: 10;
106
+ name: "OP Mainnet";
151
107
  nativeCurrency: {
152
108
  readonly name: "Ether";
153
109
  readonly symbol: "ETH";
@@ -156,7 +112,7 @@ declare const mainnetChains: ({
156
112
  experimental_preconfirmationTime?: number | undefined | undefined;
157
113
  rpcUrls: {
158
114
  readonly default: {
159
- readonly http: readonly ["https://mainnet.base.org"];
115
+ readonly http: readonly ["https://mainnet.optimism.io"];
160
116
  };
161
117
  };
162
118
  sourceId: 1;
@@ -420,357 +376,74 @@ declare const mainnetChains: ({
420
376
  } | {
421
377
  blockExplorers: {
422
378
  readonly default: {
423
- readonly name: "BscScan";
424
- readonly url: "https://bscscan.com";
425
- readonly apiUrl: "https://api.bscscan.com/api";
379
+ readonly name: "Basescan";
380
+ readonly url: "https://basescan.org";
381
+ readonly apiUrl: "https://api.basescan.org/api";
426
382
  };
427
383
  };
428
- blockTime: 750;
384
+ blockTime: 2000;
429
385
  contracts: {
386
+ readonly disputeGameFactory: {
387
+ readonly 1: {
388
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
389
+ };
390
+ };
391
+ readonly l2OutputOracle: {
392
+ readonly 1: {
393
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
394
+ };
395
+ };
430
396
  readonly multicall3: {
431
397
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
432
- readonly blockCreated: 15921452;
398
+ readonly blockCreated: 5022;
433
399
  };
434
- };
435
- ensTlds?: readonly string[] | undefined;
436
- id: 56;
437
- name: "BNB Smart Chain";
438
- nativeCurrency: {
439
- readonly decimals: 18;
440
- readonly name: "BNB";
441
- readonly symbol: "BNB";
442
- };
443
- experimental_preconfirmationTime?: number | undefined | undefined;
444
- rpcUrls: {
445
- readonly default: {
446
- readonly http: readonly ["https://56.rpc.thirdweb.com"];
400
+ readonly portal: {
401
+ readonly 1: {
402
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
403
+ readonly blockCreated: 17482143;
404
+ };
447
405
  };
448
- };
449
- sourceId?: number | undefined | undefined;
450
- testnet?: boolean | undefined | undefined;
451
- custom?: Record<string, unknown> | undefined;
452
- extendSchema?: Record<string, unknown> | undefined;
453
- fees?: import("viem").ChainFees<undefined> | undefined;
454
- formatters?: undefined;
455
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
456
- client: import("viem").Client;
457
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
458
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
459
- client: import("viem").Client;
460
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
461
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
462
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
463
- }] | undefined;
464
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
465
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
466
- } | {
467
- blockExplorers: {
468
- readonly default: {
469
- readonly name: "Gnosisscan";
470
- readonly url: "https://gnosisscan.io";
471
- readonly apiUrl: "https://api.gnosisscan.io/api";
406
+ readonly l1StandardBridge: {
407
+ readonly 1: {
408
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
409
+ readonly blockCreated: 17482143;
410
+ };
472
411
  };
473
- };
474
- blockTime: 5000;
475
- contracts: {
476
- readonly multicall3: {
477
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
478
- readonly blockCreated: 21022491;
412
+ readonly gasPriceOracle: {
413
+ readonly address: "0x420000000000000000000000000000000000000F";
479
414
  };
480
- };
481
- ensTlds?: readonly string[] | undefined;
482
- id: 100;
483
- name: "Gnosis";
484
- nativeCurrency: {
485
- readonly decimals: 18;
486
- readonly name: "xDAI";
487
- readonly symbol: "XDAI";
488
- };
489
- experimental_preconfirmationTime?: number | undefined | undefined;
490
- rpcUrls: {
491
- readonly default: {
492
- readonly http: readonly ["https://rpc.gnosischain.com"];
493
- readonly webSocket: readonly ["wss://rpc.gnosischain.com/wss"];
415
+ readonly l1Block: {
416
+ readonly address: "0x4200000000000000000000000000000000000015";
494
417
  };
495
- };
496
- sourceId?: number | undefined | undefined;
497
- testnet?: boolean | undefined | undefined;
498
- custom?: Record<string, unknown> | undefined;
499
- extendSchema?: Record<string, unknown> | undefined;
500
- fees?: import("viem").ChainFees<undefined> | undefined;
501
- formatters?: undefined;
502
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
503
- client: import("viem").Client;
504
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
505
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
506
- client: import("viem").Client;
507
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
508
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
509
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
510
- }] | undefined;
511
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
512
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
513
- } | {
514
- blockExplorers: {
515
- readonly default: {
516
- readonly name: "HyperEVMScan";
517
- readonly url: "https://hyperevmscan.io";
418
+ readonly l2CrossDomainMessenger: {
419
+ readonly address: "0x4200000000000000000000000000000000000007";
518
420
  };
519
- };
520
- blockTime?: number | undefined | undefined;
521
- contracts: {
522
- readonly multicall3: {
523
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
524
- readonly blockCreated: 13051;
421
+ readonly l2Erc721Bridge: {
422
+ readonly address: "0x4200000000000000000000000000000000000014";
423
+ };
424
+ readonly l2StandardBridge: {
425
+ readonly address: "0x4200000000000000000000000000000000000010";
426
+ };
427
+ readonly l2ToL1MessagePasser: {
428
+ readonly address: "0x4200000000000000000000000000000000000016";
525
429
  };
526
430
  };
527
431
  ensTlds?: readonly string[] | undefined;
528
- id: 999;
529
- name: "HyperEVM";
432
+ id: 8453;
433
+ name: "Base";
530
434
  nativeCurrency: {
531
- readonly name: "HYPE";
532
- readonly symbol: "HYPE";
435
+ readonly name: "Ether";
436
+ readonly symbol: "ETH";
533
437
  readonly decimals: 18;
534
438
  };
535
439
  experimental_preconfirmationTime?: number | undefined | undefined;
536
440
  rpcUrls: {
537
441
  readonly default: {
538
- readonly http: readonly ["https://rpc.hyperliquid.xyz/evm"];
442
+ readonly http: readonly ["https://mainnet.base.org"];
539
443
  };
540
444
  };
541
- sourceId?: number | undefined | undefined;
542
- testnet: false;
543
- custom?: Record<string, unknown> | undefined;
544
- extendSchema?: Record<string, unknown> | undefined;
545
- fees?: import("viem").ChainFees<undefined> | undefined;
546
- formatters?: undefined;
547
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
548
- client: import("viem").Client;
549
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
550
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
551
- client: import("viem").Client;
552
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
553
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
554
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
555
- }] | undefined;
556
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
557
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
558
- } | {
559
- blockExplorers: {
560
- readonly default: {
561
- readonly name: "katana explorer";
562
- readonly url: "https://katanascan.com";
563
- };
564
- };
565
- blockTime?: number | undefined | undefined;
566
- contracts: {
567
- readonly multicall3: {
568
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
569
- readonly blockCreated: 0;
570
- };
571
- };
572
- ensTlds?: readonly string[] | undefined;
573
- id: 747474;
574
- name: "Katana";
575
- nativeCurrency: {
576
- readonly name: "Ether";
577
- readonly symbol: "ETH";
578
- readonly decimals: 18;
579
- };
580
- experimental_preconfirmationTime?: number | undefined | undefined;
581
- rpcUrls: {
582
- readonly default: {
583
- readonly http: readonly ["https://rpc.katana.network"];
584
- };
585
- };
586
- sourceId?: number | undefined | undefined;
587
- testnet: false;
588
- custom?: Record<string, unknown> | undefined;
589
- extendSchema?: Record<string, unknown> | undefined;
590
- fees?: import("viem").ChainFees<undefined> | undefined;
591
- formatters?: undefined;
592
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
593
- client: import("viem").Client;
594
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
595
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
596
- client: import("viem").Client;
597
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
598
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
599
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
600
- }] | undefined;
601
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
602
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
603
- readonly network: "katana";
604
- } | {
605
- blockExplorers: {
606
- readonly default: {
607
- readonly name: "Etherscan";
608
- readonly url: "https://etherscan.io";
609
- readonly apiUrl: "https://api.etherscan.io/api";
610
- };
611
- };
612
- blockTime: 12000;
613
- contracts: {
614
- readonly ensUniversalResolver: {
615
- readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
616
- readonly blockCreated: 23085558;
617
- };
618
- readonly multicall3: {
619
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
620
- readonly blockCreated: 14353601;
621
- };
622
- };
623
- ensTlds?: readonly string[] | undefined;
624
- id: 1;
625
- name: "Ethereum";
626
- nativeCurrency: {
627
- readonly name: "Ether";
628
- readonly symbol: "ETH";
629
- readonly decimals: 18;
630
- };
631
- experimental_preconfirmationTime?: number | undefined | undefined;
632
- rpcUrls: {
633
- readonly default: {
634
- readonly http: readonly ["https://eth.merkle.io"];
635
- };
636
- };
637
- sourceId?: number | undefined | undefined;
638
- testnet?: boolean | undefined | undefined;
639
- custom?: Record<string, unknown> | undefined;
640
- extendSchema?: Record<string, unknown> | undefined;
641
- fees?: import("viem").ChainFees<undefined> | undefined;
642
- formatters?: undefined;
643
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
644
- client: import("viem").Client;
645
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
646
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
647
- client: import("viem").Client;
648
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
649
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
650
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
651
- }] | undefined;
652
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
653
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
654
- } | {
655
- blockExplorers: {
656
- readonly default: {
657
- readonly name: "Monadscan";
658
- readonly url: "https://monadscan.com";
659
- readonly apiUrl: "https://api.etherscan.io/v2/api?chainid=143";
660
- };
661
- readonly monadvision: {
662
- readonly name: "MonadVision";
663
- readonly url: "https://monadvision.com";
664
- };
665
- };
666
- blockTime: 400;
667
- contracts: {
668
- readonly multicall3: {
669
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
670
- readonly blockCreated: 9248132;
671
- };
672
- };
673
- ensTlds?: readonly string[] | undefined;
674
- id: 143;
675
- name: "Monad";
676
- nativeCurrency: {
677
- readonly name: "Monad";
678
- readonly symbol: "MON";
679
- readonly decimals: 18;
680
- };
681
- experimental_preconfirmationTime?: number | undefined | undefined;
682
- rpcUrls: {
683
- readonly default: {
684
- readonly http: readonly ["https://rpc.monad.xyz", "https://rpc1.monad.xyz"];
685
- readonly webSocket: readonly ["wss://rpc.monad.xyz", "wss://rpc1.monad.xyz"];
686
- };
687
- };
688
- sourceId?: number | undefined | undefined;
689
- testnet: false;
690
- custom?: Record<string, unknown> | undefined;
691
- extendSchema?: Record<string, unknown> | undefined;
692
- fees?: import("viem").ChainFees<undefined> | undefined;
693
- formatters?: undefined;
694
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
695
- client: import("viem").Client;
696
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
697
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
698
- client: import("viem").Client;
699
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
700
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
701
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
702
- }] | undefined;
703
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
704
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
705
- } | {
706
- blockExplorers: {
707
- readonly default: {
708
- readonly name: "Optimism Explorer";
709
- readonly url: "https://optimistic.etherscan.io";
710
- readonly apiUrl: "https://api-optimistic.etherscan.io/api";
711
- };
712
- };
713
- blockTime: 2000;
714
- contracts: {
715
- readonly disputeGameFactory: {
716
- readonly 1: {
717
- readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
718
- };
719
- };
720
- readonly l2OutputOracle: {
721
- readonly 1: {
722
- readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
723
- };
724
- };
725
- readonly multicall3: {
726
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
727
- readonly blockCreated: 4286263;
728
- };
729
- readonly portal: {
730
- readonly 1: {
731
- readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
732
- };
733
- };
734
- readonly l1StandardBridge: {
735
- readonly 1: {
736
- readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
737
- };
738
- };
739
- readonly gasPriceOracle: {
740
- readonly address: "0x420000000000000000000000000000000000000F";
741
- };
742
- readonly l1Block: {
743
- readonly address: "0x4200000000000000000000000000000000000015";
744
- };
745
- readonly l2CrossDomainMessenger: {
746
- readonly address: "0x4200000000000000000000000000000000000007";
747
- };
748
- readonly l2Erc721Bridge: {
749
- readonly address: "0x4200000000000000000000000000000000000014";
750
- };
751
- readonly l2StandardBridge: {
752
- readonly address: "0x4200000000000000000000000000000000000010";
753
- };
754
- readonly l2ToL1MessagePasser: {
755
- readonly address: "0x4200000000000000000000000000000000000016";
756
- };
757
- };
758
- ensTlds?: readonly string[] | undefined;
759
- id: 10;
760
- name: "OP Mainnet";
761
- nativeCurrency: {
762
- readonly name: "Ether";
763
- readonly symbol: "ETH";
764
- readonly decimals: 18;
765
- };
766
- experimental_preconfirmationTime?: number | undefined | undefined;
767
- rpcUrls: {
768
- readonly default: {
769
- readonly http: readonly ["https://mainnet.optimism.io"];
770
- };
771
- };
772
- sourceId: 1;
773
- testnet?: boolean | undefined | undefined;
445
+ sourceId: 1;
446
+ testnet?: boolean | undefined | undefined;
774
447
  custom?: Record<string, unknown> | undefined;
775
448
  extendSchema?: Record<string, unknown> | undefined;
776
449
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -1030,29 +703,30 @@ declare const mainnetChains: ({
1030
703
  } | {
1031
704
  blockExplorers: {
1032
705
  readonly default: {
1033
- readonly name: "PlasmaScan";
1034
- readonly url: "https://plasmascan.to";
706
+ readonly name: "Arbiscan";
707
+ readonly url: "https://arbiscan.io";
708
+ readonly apiUrl: "https://api.arbiscan.io/api";
1035
709
  };
1036
710
  };
1037
- blockTime: 1000;
711
+ blockTime: 250;
1038
712
  contracts: {
1039
713
  readonly multicall3: {
1040
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
1041
- readonly blockCreated: 0;
714
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
715
+ readonly blockCreated: 7654707;
1042
716
  };
1043
717
  };
1044
718
  ensTlds?: readonly string[] | undefined;
1045
- id: 9745;
1046
- name: "Plasma";
719
+ id: 42161;
720
+ name: "Arbitrum One";
1047
721
  nativeCurrency: {
1048
- readonly name: "Plasma";
1049
- readonly symbol: "XPL";
722
+ readonly name: "Ether";
723
+ readonly symbol: "ETH";
1050
724
  readonly decimals: 18;
1051
725
  };
1052
726
  experimental_preconfirmationTime?: number | undefined | undefined;
1053
727
  rpcUrls: {
1054
728
  readonly default: {
1055
- readonly http: readonly ["https://rpc.plasma.to"];
729
+ readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
1056
730
  };
1057
731
  };
1058
732
  sourceId?: number | undefined | undefined;
@@ -1118,51 +792,6 @@ declare const mainnetChains: ({
1118
792
  }] | undefined;
1119
793
  serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1120
794
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1121
- } | {
1122
- blockExplorers: {
1123
- readonly default: {
1124
- readonly name: "Blockscout";
1125
- readonly url: "https://robinhoodchain.blockscout.com";
1126
- readonly apiUrl: "https://robinhoodchain.blockscout.com/api";
1127
- };
1128
- };
1129
- blockTime?: number | undefined | undefined;
1130
- contracts: {
1131
- readonly multicall3: {
1132
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1133
- };
1134
- };
1135
- ensTlds?: readonly string[] | undefined;
1136
- id: 4663;
1137
- name: "Robinhood Chain";
1138
- nativeCurrency: {
1139
- readonly name: "Ether";
1140
- readonly symbol: "ETH";
1141
- readonly decimals: 18;
1142
- };
1143
- experimental_preconfirmationTime?: number | undefined | undefined;
1144
- rpcUrls: {
1145
- readonly default: {
1146
- readonly http: readonly ["https://rpc.mainnet.chain.robinhood.com"];
1147
- };
1148
- };
1149
- sourceId?: number | undefined | undefined;
1150
- testnet?: boolean | undefined | undefined;
1151
- custom?: Record<string, unknown> | undefined;
1152
- extendSchema?: Record<string, unknown> | undefined;
1153
- fees?: import("viem").ChainFees<undefined> | undefined;
1154
- formatters?: undefined;
1155
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1156
- client: import("viem").Client;
1157
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1158
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1159
- client: import("viem").Client;
1160
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1161
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
1162
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1163
- }] | undefined;
1164
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1165
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1166
795
  } | {
1167
796
  blockExplorers: {
1168
797
  readonly default: {
@@ -1486,36 +1115,270 @@ declare const mainnetChains: ({
1486
1115
  }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
1487
1116
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1488
1117
  }] | undefined;
1489
- serializers: {
1490
- readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
1118
+ serializers: {
1119
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
1120
+ };
1121
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1122
+ } | {
1123
+ blockExplorers: {
1124
+ readonly default: {
1125
+ readonly name: "Sonic Explorer";
1126
+ readonly url: "https://sonicscan.org";
1127
+ };
1128
+ };
1129
+ blockTime: 630;
1130
+ contracts: {
1131
+ readonly multicall3: {
1132
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1133
+ readonly blockCreated: 60;
1134
+ };
1135
+ };
1136
+ ensTlds?: readonly string[] | undefined;
1137
+ id: 146;
1138
+ name: "Sonic";
1139
+ nativeCurrency: {
1140
+ readonly decimals: 18;
1141
+ readonly name: "Sonic";
1142
+ readonly symbol: "S";
1143
+ };
1144
+ experimental_preconfirmationTime?: number | undefined | undefined;
1145
+ rpcUrls: {
1146
+ readonly default: {
1147
+ readonly http: readonly ["https://rpc.soniclabs.com"];
1148
+ };
1149
+ };
1150
+ sourceId?: number | undefined | undefined;
1151
+ testnet: false;
1152
+ custom?: Record<string, unknown> | undefined;
1153
+ extendSchema?: Record<string, unknown> | undefined;
1154
+ fees?: import("viem").ChainFees<undefined> | undefined;
1155
+ formatters?: undefined;
1156
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1157
+ client: import("viem").Client;
1158
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1159
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1160
+ client: import("viem").Client;
1161
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1162
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
1163
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1164
+ }] | undefined;
1165
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1166
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1167
+ } | {
1168
+ blockExplorers: {
1169
+ readonly default: {
1170
+ readonly name: "PlasmaScan";
1171
+ readonly url: "https://plasmascan.to";
1172
+ };
1173
+ };
1174
+ blockTime: 1000;
1175
+ contracts: {
1176
+ readonly multicall3: {
1177
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
1178
+ readonly blockCreated: 0;
1179
+ };
1180
+ };
1181
+ ensTlds?: readonly string[] | undefined;
1182
+ id: 9745;
1183
+ name: "Plasma";
1184
+ nativeCurrency: {
1185
+ readonly name: "Plasma";
1186
+ readonly symbol: "XPL";
1187
+ readonly decimals: 18;
1188
+ };
1189
+ experimental_preconfirmationTime?: number | undefined | undefined;
1190
+ rpcUrls: {
1191
+ readonly default: {
1192
+ readonly http: readonly ["https://rpc.plasma.to"];
1193
+ };
1194
+ };
1195
+ sourceId?: number | undefined | undefined;
1196
+ testnet?: boolean | undefined | undefined;
1197
+ custom?: Record<string, unknown> | undefined;
1198
+ extendSchema?: Record<string, unknown> | undefined;
1199
+ fees?: import("viem").ChainFees<undefined> | undefined;
1200
+ formatters?: undefined;
1201
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1202
+ client: import("viem").Client;
1203
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1204
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1205
+ client: import("viem").Client;
1206
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1207
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
1208
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1209
+ }] | undefined;
1210
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1211
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1212
+ } | {
1213
+ blockExplorers: {
1214
+ readonly default: {
1215
+ readonly name: "Gnosisscan";
1216
+ readonly url: "https://gnosisscan.io";
1217
+ readonly apiUrl: "https://api.gnosisscan.io/api";
1218
+ };
1219
+ };
1220
+ blockTime: 5000;
1221
+ contracts: {
1222
+ readonly multicall3: {
1223
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1224
+ readonly blockCreated: 21022491;
1225
+ };
1226
+ };
1227
+ ensTlds?: readonly string[] | undefined;
1228
+ id: 100;
1229
+ name: "Gnosis";
1230
+ nativeCurrency: {
1231
+ readonly decimals: 18;
1232
+ readonly name: "xDAI";
1233
+ readonly symbol: "XDAI";
1234
+ };
1235
+ experimental_preconfirmationTime?: number | undefined | undefined;
1236
+ rpcUrls: {
1237
+ readonly default: {
1238
+ readonly http: readonly ["https://rpc.gnosischain.com"];
1239
+ readonly webSocket: readonly ["wss://rpc.gnosischain.com/wss"];
1240
+ };
1241
+ };
1242
+ sourceId?: number | undefined | undefined;
1243
+ testnet?: boolean | undefined | undefined;
1244
+ custom?: Record<string, unknown> | undefined;
1245
+ extendSchema?: Record<string, unknown> | undefined;
1246
+ fees?: import("viem").ChainFees<undefined> | undefined;
1247
+ formatters?: undefined;
1248
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1249
+ client: import("viem").Client;
1250
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1251
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1252
+ client: import("viem").Client;
1253
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1254
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
1255
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1256
+ }] | undefined;
1257
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1258
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1259
+ } | {
1260
+ blockExplorers: {
1261
+ readonly default: {
1262
+ readonly name: "BscScan";
1263
+ readonly url: "https://bscscan.com";
1264
+ readonly apiUrl: "https://api.bscscan.com/api";
1265
+ };
1266
+ };
1267
+ blockTime: 750;
1268
+ contracts: {
1269
+ readonly multicall3: {
1270
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1271
+ readonly blockCreated: 15921452;
1272
+ };
1273
+ };
1274
+ ensTlds?: readonly string[] | undefined;
1275
+ id: 56;
1276
+ name: "BNB Smart Chain";
1277
+ nativeCurrency: {
1278
+ readonly decimals: 18;
1279
+ readonly name: "BNB";
1280
+ readonly symbol: "BNB";
1281
+ };
1282
+ experimental_preconfirmationTime?: number | undefined | undefined;
1283
+ rpcUrls: {
1284
+ readonly default: {
1285
+ readonly http: readonly ["https://56.rpc.thirdweb.com"];
1286
+ };
1287
+ };
1288
+ sourceId?: number | undefined | undefined;
1289
+ testnet?: boolean | undefined | undefined;
1290
+ custom?: Record<string, unknown> | undefined;
1291
+ extendSchema?: Record<string, unknown> | undefined;
1292
+ fees?: import("viem").ChainFees<undefined> | undefined;
1293
+ formatters?: undefined;
1294
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1295
+ client: import("viem").Client;
1296
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1297
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1298
+ client: import("viem").Client;
1299
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1300
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
1301
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1302
+ }] | undefined;
1303
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1304
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1305
+ } | {
1306
+ blockExplorers: {
1307
+ readonly default: {
1308
+ readonly name: "HyperEVMScan";
1309
+ readonly url: "https://hyperevmscan.io";
1310
+ };
1311
+ };
1312
+ blockTime?: number | undefined | undefined;
1313
+ contracts: {
1314
+ readonly multicall3: {
1315
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
1316
+ readonly blockCreated: 13051;
1317
+ };
1318
+ };
1319
+ ensTlds?: readonly string[] | undefined;
1320
+ id: 999;
1321
+ name: "HyperEVM";
1322
+ nativeCurrency: {
1323
+ readonly name: "HYPE";
1324
+ readonly symbol: "HYPE";
1325
+ readonly decimals: 18;
1326
+ };
1327
+ experimental_preconfirmationTime?: number | undefined | undefined;
1328
+ rpcUrls: {
1329
+ readonly default: {
1330
+ readonly http: readonly ["https://rpc.hyperliquid.xyz/evm"];
1331
+ };
1491
1332
  };
1333
+ sourceId?: number | undefined | undefined;
1334
+ testnet: false;
1335
+ custom?: Record<string, unknown> | undefined;
1336
+ extendSchema?: Record<string, unknown> | undefined;
1337
+ fees?: import("viem").ChainFees<undefined> | undefined;
1338
+ formatters?: undefined;
1339
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1340
+ client: import("viem").Client;
1341
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1342
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1343
+ client: import("viem").Client;
1344
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1345
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
1346
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1347
+ }] | undefined;
1348
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1492
1349
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1493
1350
  } | {
1494
1351
  blockExplorers: {
1495
1352
  readonly default: {
1496
- readonly name: "Sonic Explorer";
1497
- readonly url: "https://sonicscan.org";
1353
+ readonly name: "Monadscan";
1354
+ readonly url: "https://monadscan.com";
1355
+ readonly apiUrl: "https://api.etherscan.io/v2/api?chainid=143";
1356
+ };
1357
+ readonly monadvision: {
1358
+ readonly name: "MonadVision";
1359
+ readonly url: "https://monadvision.com";
1498
1360
  };
1499
1361
  };
1500
- blockTime: 630;
1362
+ blockTime: 400;
1501
1363
  contracts: {
1502
1364
  readonly multicall3: {
1503
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1504
- readonly blockCreated: 60;
1365
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
1366
+ readonly blockCreated: 9248132;
1505
1367
  };
1506
1368
  };
1507
1369
  ensTlds?: readonly string[] | undefined;
1508
- id: 146;
1509
- name: "Sonic";
1370
+ id: 143;
1371
+ name: "Monad";
1510
1372
  nativeCurrency: {
1373
+ readonly name: "Monad";
1374
+ readonly symbol: "MON";
1511
1375
  readonly decimals: 18;
1512
- readonly name: "Sonic";
1513
- readonly symbol: "S";
1514
1376
  };
1515
1377
  experimental_preconfirmationTime?: number | undefined | undefined;
1516
1378
  rpcUrls: {
1517
1379
  readonly default: {
1518
- readonly http: readonly ["https://rpc.soniclabs.com"];
1380
+ readonly http: readonly ["https://rpc.monad.xyz", "https://rpc1.monad.xyz"];
1381
+ readonly webSocket: readonly ["wss://rpc.monad.xyz", "wss://rpc1.monad.xyz"];
1519
1382
  };
1520
1383
  };
1521
1384
  sourceId?: number | undefined | undefined;
@@ -1855,34 +1718,175 @@ declare const mainnetChains: ({
1855
1718
  readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
1856
1719
  };
1857
1720
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1721
+ } | {
1722
+ blockExplorers: {
1723
+ readonly default: {
1724
+ readonly name: "katana explorer";
1725
+ readonly url: "https://katanascan.com";
1726
+ };
1727
+ };
1728
+ blockTime?: number | undefined | undefined;
1729
+ contracts: {
1730
+ readonly multicall3: {
1731
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
1732
+ readonly blockCreated: 0;
1733
+ };
1734
+ };
1735
+ ensTlds?: readonly string[] | undefined;
1736
+ id: 747474;
1737
+ name: "Katana";
1738
+ nativeCurrency: {
1739
+ readonly name: "Ether";
1740
+ readonly symbol: "ETH";
1741
+ readonly decimals: 18;
1742
+ };
1743
+ experimental_preconfirmationTime?: number | undefined | undefined;
1744
+ rpcUrls: {
1745
+ readonly default: {
1746
+ readonly http: readonly ["https://rpc.katana.network"];
1747
+ };
1748
+ };
1749
+ sourceId?: number | undefined | undefined;
1750
+ testnet: false;
1751
+ custom?: Record<string, unknown> | undefined;
1752
+ extendSchema?: Record<string, unknown> | undefined;
1753
+ fees?: import("viem").ChainFees<undefined> | undefined;
1754
+ formatters?: undefined;
1755
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1756
+ client: import("viem").Client;
1757
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1758
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1759
+ client: import("viem").Client;
1760
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1761
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
1762
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1763
+ }] | undefined;
1764
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1765
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1766
+ readonly network: "katana";
1767
+ } | {
1768
+ blockExplorers: {
1769
+ readonly default: {
1770
+ readonly name: "Blockscout";
1771
+ readonly url: "https://robinhoodchain.blockscout.com";
1772
+ readonly apiUrl: "https://robinhoodchain.blockscout.com/api";
1773
+ };
1774
+ };
1775
+ blockTime?: number | undefined | undefined;
1776
+ contracts: {
1777
+ readonly multicall3: {
1778
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1779
+ };
1780
+ };
1781
+ ensTlds?: readonly string[] | undefined;
1782
+ id: 4663;
1783
+ name: "Robinhood Chain";
1784
+ nativeCurrency: {
1785
+ readonly name: "Ether";
1786
+ readonly symbol: "ETH";
1787
+ readonly decimals: 18;
1788
+ };
1789
+ experimental_preconfirmationTime?: number | undefined | undefined;
1790
+ rpcUrls: {
1791
+ readonly default: {
1792
+ readonly http: readonly ["https://rpc.mainnet.chain.robinhood.com"];
1793
+ };
1794
+ };
1795
+ sourceId?: number | undefined | undefined;
1796
+ testnet?: boolean | undefined | undefined;
1797
+ custom?: Record<string, unknown> | undefined;
1798
+ extendSchema?: Record<string, unknown> | undefined;
1799
+ fees?: import("viem").ChainFees<undefined> | undefined;
1800
+ formatters?: undefined;
1801
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1802
+ client: import("viem").Client;
1803
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1804
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1805
+ client: import("viem").Client;
1806
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1807
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
1808
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1809
+ }] | undefined;
1810
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1811
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1812
+ } | {
1813
+ blockExplorers: {
1814
+ readonly default: {
1815
+ readonly name: "SnowTrace";
1816
+ readonly url: "https://snowtrace.io";
1817
+ readonly apiUrl: "https://api.snowtrace.io";
1818
+ };
1819
+ };
1820
+ blockTime: 1700;
1821
+ contracts: {
1822
+ readonly multicall3: {
1823
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1824
+ readonly blockCreated: 11907934;
1825
+ };
1826
+ };
1827
+ ensTlds?: readonly string[] | undefined;
1828
+ id: 43114;
1829
+ name: "Avalanche";
1830
+ nativeCurrency: {
1831
+ readonly decimals: 18;
1832
+ readonly name: "Avalanche";
1833
+ readonly symbol: "AVAX";
1834
+ };
1835
+ experimental_preconfirmationTime?: number | undefined | undefined;
1836
+ rpcUrls: {
1837
+ readonly default: {
1838
+ readonly http: readonly ["https://api.avax.network/ext/bc/C/rpc"];
1839
+ };
1840
+ };
1841
+ sourceId?: number | undefined | undefined;
1842
+ testnet?: boolean | undefined | undefined;
1843
+ custom?: Record<string, unknown> | undefined;
1844
+ extendSchema?: Record<string, unknown> | undefined;
1845
+ fees?: import("viem").ChainFees<undefined> | undefined;
1846
+ formatters?: undefined;
1847
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1848
+ client: import("viem").Client;
1849
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1850
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1851
+ client: import("viem").Client;
1852
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1853
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
1854
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1855
+ }] | undefined;
1856
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1857
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1858
1858
  })[];
1859
1859
  declare const testnetChains: ({
1860
1860
  blockExplorers: {
1861
1861
  readonly default: {
1862
- readonly name: "Arbiscan";
1863
- readonly url: "https://sepolia.arbiscan.io";
1864
- readonly apiUrl: "https://api-sepolia.arbiscan.io/api";
1862
+ readonly name: "Etherscan";
1863
+ readonly url: "https://sepolia.etherscan.io";
1864
+ readonly apiUrl: "https://api-sepolia.etherscan.io/api";
1865
1865
  };
1866
1866
  };
1867
- blockTime: 250;
1867
+ blockTime?: number | undefined | undefined;
1868
1868
  contracts: {
1869
1869
  readonly multicall3: {
1870
1870
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1871
- readonly blockCreated: 81930;
1871
+ readonly blockCreated: 751532;
1872
+ };
1873
+ readonly ensUniversalResolver: {
1874
+ readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
1875
+ readonly blockCreated: 8928790;
1872
1876
  };
1873
1877
  };
1874
1878
  ensTlds?: readonly string[] | undefined;
1875
- id: 421614;
1876
- name: "Arbitrum Sepolia";
1879
+ id: 11155111;
1880
+ name: "Sepolia";
1877
1881
  nativeCurrency: {
1878
- readonly name: "Arbitrum Sepolia Ether";
1882
+ readonly name: "Sepolia Ether";
1879
1883
  readonly symbol: "ETH";
1880
1884
  readonly decimals: 18;
1881
1885
  };
1882
1886
  experimental_preconfirmationTime?: number | undefined | undefined;
1883
1887
  rpcUrls: {
1884
1888
  readonly default: {
1885
- readonly http: readonly ["https://sepolia-rollup.arbitrum.io/rpc"];
1889
+ readonly http: readonly ["https://11155111.rpc.thirdweb.com"];
1886
1890
  };
1887
1891
  };
1888
1892
  sourceId?: number | undefined | undefined;
@@ -1905,39 +1909,37 @@ declare const testnetChains: ({
1905
1909
  } | {
1906
1910
  blockExplorers: {
1907
1911
  readonly default: {
1908
- readonly name: "Basescan";
1909
- readonly url: "https://sepolia.basescan.org";
1910
- readonly apiUrl: "https://api-sepolia.basescan.org/api";
1912
+ readonly name: "Blockscout";
1913
+ readonly url: "https://optimism-sepolia.blockscout.com";
1914
+ readonly apiUrl: "https://optimism-sepolia.blockscout.com/api";
1911
1915
  };
1912
1916
  };
1913
1917
  blockTime: 2000;
1914
1918
  contracts: {
1915
1919
  readonly disputeGameFactory: {
1916
1920
  readonly 11155111: {
1917
- readonly address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1";
1921
+ readonly address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1";
1918
1922
  };
1919
1923
  };
1920
1924
  readonly l2OutputOracle: {
1921
1925
  readonly 11155111: {
1922
- readonly address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254";
1926
+ readonly address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F";
1923
1927
  };
1924
1928
  };
1929
+ readonly multicall3: {
1930
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1931
+ readonly blockCreated: 1620204;
1932
+ };
1925
1933
  readonly portal: {
1926
1934
  readonly 11155111: {
1927
- readonly address: "0x49f53e41452c74589e85ca1677426ba426459e85";
1928
- readonly blockCreated: 4446677;
1935
+ readonly address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC";
1929
1936
  };
1930
1937
  };
1931
1938
  readonly l1StandardBridge: {
1932
1939
  readonly 11155111: {
1933
- readonly address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120";
1934
- readonly blockCreated: 4446677;
1940
+ readonly address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1";
1935
1941
  };
1936
1942
  };
1937
- readonly multicall3: {
1938
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1939
- readonly blockCreated: 1059647;
1940
- };
1941
1943
  readonly gasPriceOracle: {
1942
1944
  readonly address: "0x420000000000000000000000000000000000000F";
1943
1945
  };
@@ -1958,8 +1960,8 @@ declare const testnetChains: ({
1958
1960
  };
1959
1961
  };
1960
1962
  ensTlds?: readonly string[] | undefined;
1961
- id: 84532;
1962
- name: "Base Sepolia";
1963
+ id: 11155420;
1964
+ name: "OP Sepolia";
1963
1965
  nativeCurrency: {
1964
1966
  readonly name: "Sepolia Ether";
1965
1967
  readonly symbol: "ETH";
@@ -1968,7 +1970,7 @@ declare const testnetChains: ({
1968
1970
  experimental_preconfirmationTime?: number | undefined | undefined;
1969
1971
  rpcUrls: {
1970
1972
  readonly default: {
1971
- readonly http: readonly ["https://sepolia.base.org"];
1973
+ readonly http: readonly ["https://sepolia.optimism.io"];
1972
1974
  };
1973
1975
  };
1974
1976
  sourceId: 11155111;
@@ -2229,41 +2231,42 @@ declare const testnetChains: ({
2229
2231
  readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
2230
2232
  };
2231
2233
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2232
- readonly network: "base-sepolia";
2233
2234
  } | {
2234
2235
  blockExplorers: {
2235
2236
  readonly default: {
2236
- readonly name: "Blockscout";
2237
- readonly url: "https://optimism-sepolia.blockscout.com";
2238
- readonly apiUrl: "https://optimism-sepolia.blockscout.com/api";
2237
+ readonly name: "Basescan";
2238
+ readonly url: "https://sepolia.basescan.org";
2239
+ readonly apiUrl: "https://api-sepolia.basescan.org/api";
2239
2240
  };
2240
2241
  };
2241
2242
  blockTime: 2000;
2242
2243
  contracts: {
2243
2244
  readonly disputeGameFactory: {
2244
2245
  readonly 11155111: {
2245
- readonly address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1";
2246
+ readonly address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1";
2246
2247
  };
2247
2248
  };
2248
2249
  readonly l2OutputOracle: {
2249
2250
  readonly 11155111: {
2250
- readonly address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F";
2251
+ readonly address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254";
2251
2252
  };
2252
2253
  };
2253
- readonly multicall3: {
2254
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2255
- readonly blockCreated: 1620204;
2256
- };
2257
2254
  readonly portal: {
2258
2255
  readonly 11155111: {
2259
- readonly address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC";
2256
+ readonly address: "0x49f53e41452c74589e85ca1677426ba426459e85";
2257
+ readonly blockCreated: 4446677;
2260
2258
  };
2261
2259
  };
2262
2260
  readonly l1StandardBridge: {
2263
2261
  readonly 11155111: {
2264
- readonly address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1";
2262
+ readonly address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120";
2263
+ readonly blockCreated: 4446677;
2265
2264
  };
2266
2265
  };
2266
+ readonly multicall3: {
2267
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2268
+ readonly blockCreated: 1059647;
2269
+ };
2267
2270
  readonly gasPriceOracle: {
2268
2271
  readonly address: "0x420000000000000000000000000000000000000F";
2269
2272
  };
@@ -2284,8 +2287,8 @@ declare const testnetChains: ({
2284
2287
  };
2285
2288
  };
2286
2289
  ensTlds?: readonly string[] | undefined;
2287
- id: 11155420;
2288
- name: "OP Sepolia";
2290
+ id: 84532;
2291
+ name: "Base Sepolia";
2289
2292
  nativeCurrency: {
2290
2293
  readonly name: "Sepolia Ether";
2291
2294
  readonly symbol: "ETH";
@@ -2294,7 +2297,7 @@ declare const testnetChains: ({
2294
2297
  experimental_preconfirmationTime?: number | undefined | undefined;
2295
2298
  rpcUrls: {
2296
2299
  readonly default: {
2297
- readonly http: readonly ["https://sepolia.optimism.io"];
2300
+ readonly http: readonly ["https://sepolia.base.org"];
2298
2301
  };
2299
2302
  };
2300
2303
  sourceId: 11155111;
@@ -2555,32 +2558,34 @@ declare const testnetChains: ({
2555
2558
  readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
2556
2559
  };
2557
2560
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2561
+ readonly network: "base-sepolia";
2558
2562
  } | {
2559
2563
  blockExplorers: {
2560
2564
  readonly default: {
2561
- readonly name: "RouteScan";
2562
- readonly url: "https://testnet.plasmascan.to";
2565
+ readonly name: "Arbiscan";
2566
+ readonly url: "https://sepolia.arbiscan.io";
2567
+ readonly apiUrl: "https://api-sepolia.arbiscan.io/api";
2563
2568
  };
2564
2569
  };
2565
- blockTime?: number | undefined | undefined;
2570
+ blockTime: 250;
2566
2571
  contracts: {
2567
2572
  readonly multicall3: {
2568
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
2569
- readonly blockCreated: 0;
2573
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2574
+ readonly blockCreated: 81930;
2570
2575
  };
2571
2576
  };
2572
2577
  ensTlds?: readonly string[] | undefined;
2573
- id: 9746;
2574
- name: "Plasma Testnet";
2578
+ id: 421614;
2579
+ name: "Arbitrum Sepolia";
2575
2580
  nativeCurrency: {
2576
- readonly name: "Testnet Plasma";
2577
- readonly symbol: "XPL";
2581
+ readonly name: "Arbitrum Sepolia Ether";
2582
+ readonly symbol: "ETH";
2578
2583
  readonly decimals: 18;
2579
2584
  };
2580
2585
  experimental_preconfirmationTime?: number | undefined | undefined;
2581
2586
  rpcUrls: {
2582
2587
  readonly default: {
2583
- readonly http: readonly ["https://testnet-rpc.plasma.to"];
2588
+ readonly http: readonly ["https://sepolia-rollup.arbitrum.io/rpc"];
2584
2589
  };
2585
2590
  };
2586
2591
  sourceId?: number | undefined | undefined;
@@ -2603,34 +2608,29 @@ declare const testnetChains: ({
2603
2608
  } | {
2604
2609
  blockExplorers: {
2605
2610
  readonly default: {
2606
- readonly name: "Etherscan";
2607
- readonly url: "https://sepolia.etherscan.io";
2608
- readonly apiUrl: "https://api-sepolia.etherscan.io/api";
2611
+ readonly name: "RouteScan";
2612
+ readonly url: "https://testnet.plasmascan.to";
2609
2613
  };
2610
2614
  };
2611
2615
  blockTime?: number | undefined | undefined;
2612
2616
  contracts: {
2613
2617
  readonly multicall3: {
2614
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2615
- readonly blockCreated: 751532;
2616
- };
2617
- readonly ensUniversalResolver: {
2618
- readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
2619
- readonly blockCreated: 8928790;
2618
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
2619
+ readonly blockCreated: 0;
2620
2620
  };
2621
2621
  };
2622
2622
  ensTlds?: readonly string[] | undefined;
2623
- id: 11155111;
2624
- name: "Sepolia";
2623
+ id: 9746;
2624
+ name: "Plasma Testnet";
2625
2625
  nativeCurrency: {
2626
- readonly name: "Sepolia Ether";
2627
- readonly symbol: "ETH";
2626
+ readonly name: "Testnet Plasma";
2627
+ readonly symbol: "XPL";
2628
2628
  readonly decimals: 18;
2629
2629
  };
2630
2630
  experimental_preconfirmationTime?: number | undefined | undefined;
2631
2631
  rpcUrls: {
2632
2632
  readonly default: {
2633
- readonly http: readonly ["https://11155111.rpc.thirdweb.com"];
2633
+ readonly http: readonly ["https://testnet-rpc.plasma.to"];
2634
2634
  };
2635
2635
  };
2636
2636
  sourceId?: number | undefined | undefined;
@@ -2654,122 +2654,34 @@ declare const testnetChains: ({
2654
2654
  declare const chains: ({
2655
2655
  blockExplorers: {
2656
2656
  readonly default: {
2657
- readonly name: "Arbiscan";
2658
- readonly url: "https://arbiscan.io";
2659
- readonly apiUrl: "https://api.arbiscan.io/api";
2657
+ readonly name: "Etherscan";
2658
+ readonly url: "https://etherscan.io";
2659
+ readonly apiUrl: "https://api.etherscan.io/api";
2660
2660
  };
2661
2661
  };
2662
- blockTime: 250;
2662
+ blockTime: 12000;
2663
2663
  contracts: {
2664
- readonly multicall3: {
2665
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2666
- readonly blockCreated: 7654707;
2667
- };
2668
- };
2669
- ensTlds?: readonly string[] | undefined;
2670
- id: 42161;
2671
- name: "Arbitrum One";
2672
- nativeCurrency: {
2673
- readonly name: "Ether";
2674
- readonly symbol: "ETH";
2675
- readonly decimals: 18;
2676
- };
2677
- experimental_preconfirmationTime?: number | undefined | undefined;
2678
- rpcUrls: {
2679
- readonly default: {
2680
- readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
2681
- };
2682
- };
2683
- sourceId?: number | undefined | undefined;
2684
- testnet?: boolean | undefined | undefined;
2685
- custom?: Record<string, unknown> | undefined;
2686
- extendSchema?: Record<string, unknown> | undefined;
2687
- fees?: import("viem").ChainFees<undefined> | undefined;
2688
- formatters?: undefined;
2689
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2690
- client: import("viem").Client;
2691
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2692
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2693
- client: import("viem").Client;
2694
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2695
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2696
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2697
- }] | undefined;
2698
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2699
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2700
- } | {
2701
- blockExplorers: {
2702
- readonly default: {
2703
- readonly name: "Arbiscan";
2704
- readonly url: "https://sepolia.arbiscan.io";
2705
- readonly apiUrl: "https://api-sepolia.arbiscan.io/api";
2664
+ readonly ensUniversalResolver: {
2665
+ readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
2666
+ readonly blockCreated: 23085558;
2706
2667
  };
2707
- };
2708
- blockTime: 250;
2709
- contracts: {
2710
2668
  readonly multicall3: {
2711
2669
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2712
- readonly blockCreated: 81930;
2670
+ readonly blockCreated: 14353601;
2713
2671
  };
2714
2672
  };
2715
2673
  ensTlds?: readonly string[] | undefined;
2716
- id: 421614;
2717
- name: "Arbitrum Sepolia";
2674
+ id: 1;
2675
+ name: "Ethereum";
2718
2676
  nativeCurrency: {
2719
- readonly name: "Arbitrum Sepolia Ether";
2677
+ readonly name: "Ether";
2720
2678
  readonly symbol: "ETH";
2721
2679
  readonly decimals: 18;
2722
2680
  };
2723
2681
  experimental_preconfirmationTime?: number | undefined | undefined;
2724
2682
  rpcUrls: {
2725
2683
  readonly default: {
2726
- readonly http: readonly ["https://sepolia-rollup.arbitrum.io/rpc"];
2727
- };
2728
- };
2729
- sourceId?: number | undefined | undefined;
2730
- testnet: true;
2731
- custom?: Record<string, unknown> | undefined;
2732
- extendSchema?: Record<string, unknown> | undefined;
2733
- fees?: import("viem").ChainFees<undefined> | undefined;
2734
- formatters?: undefined;
2735
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2736
- client: import("viem").Client;
2737
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2738
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2739
- client: import("viem").Client;
2740
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2741
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2742
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2743
- }] | undefined;
2744
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2745
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2746
- } | {
2747
- blockExplorers: {
2748
- readonly default: {
2749
- readonly name: "SnowTrace";
2750
- readonly url: "https://snowtrace.io";
2751
- readonly apiUrl: "https://api.snowtrace.io";
2752
- };
2753
- };
2754
- blockTime: 1700;
2755
- contracts: {
2756
- readonly multicall3: {
2757
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2758
- readonly blockCreated: 11907934;
2759
- };
2760
- };
2761
- ensTlds?: readonly string[] | undefined;
2762
- id: 43114;
2763
- name: "Avalanche";
2764
- nativeCurrency: {
2765
- readonly decimals: 18;
2766
- readonly name: "Avalanche";
2767
- readonly symbol: "AVAX";
2768
- };
2769
- experimental_preconfirmationTime?: number | undefined | undefined;
2770
- rpcUrls: {
2771
- readonly default: {
2772
- readonly http: readonly ["https://api.avax.network/ext/bc/C/rpc"];
2684
+ readonly http: readonly ["https://eth.merkle.io"];
2773
2685
  };
2774
2686
  };
2775
2687
  sourceId?: number | undefined | undefined;
@@ -2792,37 +2704,35 @@ declare const chains: ({
2792
2704
  } | {
2793
2705
  blockExplorers: {
2794
2706
  readonly default: {
2795
- readonly name: "Basescan";
2796
- readonly url: "https://basescan.org";
2797
- readonly apiUrl: "https://api.basescan.org/api";
2707
+ readonly name: "Optimism Explorer";
2708
+ readonly url: "https://optimistic.etherscan.io";
2709
+ readonly apiUrl: "https://api-optimistic.etherscan.io/api";
2798
2710
  };
2799
2711
  };
2800
2712
  blockTime: 2000;
2801
2713
  contracts: {
2802
2714
  readonly disputeGameFactory: {
2803
2715
  readonly 1: {
2804
- readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
2716
+ readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
2805
2717
  };
2806
2718
  };
2807
2719
  readonly l2OutputOracle: {
2808
2720
  readonly 1: {
2809
- readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
2721
+ readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
2810
2722
  };
2811
2723
  };
2812
2724
  readonly multicall3: {
2813
2725
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2814
- readonly blockCreated: 5022;
2726
+ readonly blockCreated: 4286263;
2815
2727
  };
2816
2728
  readonly portal: {
2817
2729
  readonly 1: {
2818
- readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
2819
- readonly blockCreated: 17482143;
2730
+ readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
2820
2731
  };
2821
2732
  };
2822
2733
  readonly l1StandardBridge: {
2823
2734
  readonly 1: {
2824
- readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
2825
- readonly blockCreated: 17482143;
2735
+ readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
2826
2736
  };
2827
2737
  };
2828
2738
  readonly gasPriceOracle: {
@@ -2845,8 +2755,8 @@ declare const chains: ({
2845
2755
  };
2846
2756
  };
2847
2757
  ensTlds?: readonly string[] | undefined;
2848
- id: 8453;
2849
- name: "Base";
2758
+ id: 10;
2759
+ name: "OP Mainnet";
2850
2760
  nativeCurrency: {
2851
2761
  readonly name: "Ether";
2852
2762
  readonly symbol: "ETH";
@@ -2855,7 +2765,7 @@ declare const chains: ({
2855
2765
  experimental_preconfirmationTime?: number | undefined | undefined;
2856
2766
  rpcUrls: {
2857
2767
  readonly default: {
2858
- readonly http: readonly ["https://mainnet.base.org"];
2768
+ readonly http: readonly ["https://mainnet.optimism.io"];
2859
2769
  };
2860
2770
  };
2861
2771
  sourceId: 1;
@@ -3120,38 +3030,38 @@ declare const chains: ({
3120
3030
  blockExplorers: {
3121
3031
  readonly default: {
3122
3032
  readonly name: "Basescan";
3123
- readonly url: "https://sepolia.basescan.org";
3124
- readonly apiUrl: "https://api-sepolia.basescan.org/api";
3033
+ readonly url: "https://basescan.org";
3034
+ readonly apiUrl: "https://api.basescan.org/api";
3125
3035
  };
3126
3036
  };
3127
3037
  blockTime: 2000;
3128
3038
  contracts: {
3129
3039
  readonly disputeGameFactory: {
3130
- readonly 11155111: {
3131
- readonly address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1";
3040
+ readonly 1: {
3041
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
3132
3042
  };
3133
3043
  };
3134
3044
  readonly l2OutputOracle: {
3135
- readonly 11155111: {
3136
- readonly address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254";
3045
+ readonly 1: {
3046
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
3137
3047
  };
3138
3048
  };
3049
+ readonly multicall3: {
3050
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3051
+ readonly blockCreated: 5022;
3052
+ };
3139
3053
  readonly portal: {
3140
- readonly 11155111: {
3141
- readonly address: "0x49f53e41452c74589e85ca1677426ba426459e85";
3142
- readonly blockCreated: 4446677;
3054
+ readonly 1: {
3055
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
3056
+ readonly blockCreated: 17482143;
3143
3057
  };
3144
3058
  };
3145
3059
  readonly l1StandardBridge: {
3146
- readonly 11155111: {
3147
- readonly address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120";
3148
- readonly blockCreated: 4446677;
3060
+ readonly 1: {
3061
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
3062
+ readonly blockCreated: 17482143;
3149
3063
  };
3150
3064
  };
3151
- readonly multicall3: {
3152
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3153
- readonly blockCreated: 1059647;
3154
- };
3155
3065
  readonly gasPriceOracle: {
3156
3066
  readonly address: "0x420000000000000000000000000000000000000F";
3157
3067
  };
@@ -3172,21 +3082,21 @@ declare const chains: ({
3172
3082
  };
3173
3083
  };
3174
3084
  ensTlds?: readonly string[] | undefined;
3175
- id: 84532;
3176
- name: "Base Sepolia";
3085
+ id: 8453;
3086
+ name: "Base";
3177
3087
  nativeCurrency: {
3178
- readonly name: "Sepolia Ether";
3088
+ readonly name: "Ether";
3179
3089
  readonly symbol: "ETH";
3180
3090
  readonly decimals: 18;
3181
3091
  };
3182
3092
  experimental_preconfirmationTime?: number | undefined | undefined;
3183
3093
  rpcUrls: {
3184
3094
  readonly default: {
3185
- readonly http: readonly ["https://sepolia.base.org"];
3095
+ readonly http: readonly ["https://mainnet.base.org"];
3186
3096
  };
3187
3097
  };
3188
- sourceId: 11155111;
3189
- testnet: true;
3098
+ sourceId: 1;
3099
+ testnet?: boolean | undefined | undefined;
3190
3100
  custom?: Record<string, unknown> | undefined;
3191
3101
  extendSchema?: Record<string, unknown> | undefined;
3192
3102
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -3400,222 +3310,36 @@ declare const chains: ({
3400
3310
  type: "transaction";
3401
3311
  };
3402
3312
  readonly transactionReceipt: {
3403
- exclude: [] | undefined;
3404
- format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
3405
- blobGasPrice?: bigint | undefined;
3406
- blobGasUsed?: bigint | undefined;
3407
- blockHash: import("viem").Hash;
3408
- blockNumber: bigint;
3409
- blockTimestamp?: bigint | undefined;
3410
- contractAddress: import("abitype").Address | null | undefined;
3411
- cumulativeGasUsed: bigint;
3412
- effectiveGasPrice: bigint;
3413
- from: import("abitype").Address;
3414
- gasUsed: bigint;
3415
- logs: import("viem").Log<bigint, number, false>[];
3416
- logsBloom: import("viem").Hex;
3417
- root?: `0x${string}` | undefined;
3418
- status: "success" | "reverted";
3419
- to: import("abitype").Address | null;
3420
- transactionHash: import("viem").Hash;
3421
- transactionIndex: number;
3422
- type: import("viem").TransactionType;
3423
- depositNonce?: bigint | undefined | undefined;
3424
- depositReceiptVersion?: number | undefined | undefined;
3425
- l1GasPrice: bigint | null;
3426
- l1GasUsed: bigint | null;
3427
- l1Fee: bigint | null;
3428
- l1FeeScalar: number | null;
3429
- } & {};
3430
- type: "transactionReceipt";
3431
- };
3432
- };
3433
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3434
- client: import("viem").Client;
3435
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3436
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3437
- client: import("viem").Client;
3438
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3439
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3440
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3441
- }] | undefined;
3442
- serializers: {
3443
- readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
3444
- };
3445
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3446
- readonly network: "base-sepolia";
3447
- } | {
3448
- blockExplorers: {
3449
- readonly default: {
3450
- readonly name: "BscScan";
3451
- readonly url: "https://bscscan.com";
3452
- readonly apiUrl: "https://api.bscscan.com/api";
3453
- };
3454
- };
3455
- blockTime: 750;
3456
- contracts: {
3457
- readonly multicall3: {
3458
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3459
- readonly blockCreated: 15921452;
3460
- };
3461
- };
3462
- ensTlds?: readonly string[] | undefined;
3463
- id: 56;
3464
- name: "BNB Smart Chain";
3465
- nativeCurrency: {
3466
- readonly decimals: 18;
3467
- readonly name: "BNB";
3468
- readonly symbol: "BNB";
3469
- };
3470
- experimental_preconfirmationTime?: number | undefined | undefined;
3471
- rpcUrls: {
3472
- readonly default: {
3473
- readonly http: readonly ["https://56.rpc.thirdweb.com"];
3474
- };
3475
- };
3476
- sourceId?: number | undefined | undefined;
3477
- testnet?: boolean | undefined | undefined;
3478
- custom?: Record<string, unknown> | undefined;
3479
- extendSchema?: Record<string, unknown> | undefined;
3480
- fees?: import("viem").ChainFees<undefined> | undefined;
3481
- formatters?: undefined;
3482
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3483
- client: import("viem").Client;
3484
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3485
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3486
- client: import("viem").Client;
3487
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3488
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3489
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3490
- }] | undefined;
3491
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3492
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3493
- } | {
3494
- blockExplorers: {
3495
- readonly default: {
3496
- readonly name: "Gnosisscan";
3497
- readonly url: "https://gnosisscan.io";
3498
- readonly apiUrl: "https://api.gnosisscan.io/api";
3499
- };
3500
- };
3501
- blockTime: 5000;
3502
- contracts: {
3503
- readonly multicall3: {
3504
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3505
- readonly blockCreated: 21022491;
3506
- };
3507
- };
3508
- ensTlds?: readonly string[] | undefined;
3509
- id: 100;
3510
- name: "Gnosis";
3511
- nativeCurrency: {
3512
- readonly decimals: 18;
3513
- readonly name: "xDAI";
3514
- readonly symbol: "XDAI";
3515
- };
3516
- experimental_preconfirmationTime?: number | undefined | undefined;
3517
- rpcUrls: {
3518
- readonly default: {
3519
- readonly http: readonly ["https://rpc.gnosischain.com"];
3520
- readonly webSocket: readonly ["wss://rpc.gnosischain.com/wss"];
3521
- };
3522
- };
3523
- sourceId?: number | undefined | undefined;
3524
- testnet?: boolean | undefined | undefined;
3525
- custom?: Record<string, unknown> | undefined;
3526
- extendSchema?: Record<string, unknown> | undefined;
3527
- fees?: import("viem").ChainFees<undefined> | undefined;
3528
- formatters?: undefined;
3529
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3530
- client: import("viem").Client;
3531
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3532
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3533
- client: import("viem").Client;
3534
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3535
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3536
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3537
- }] | undefined;
3538
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3539
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3540
- } | {
3541
- blockExplorers: {
3542
- readonly default: {
3543
- readonly name: "HyperEVMScan";
3544
- readonly url: "https://hyperevmscan.io";
3545
- };
3546
- };
3547
- blockTime?: number | undefined | undefined;
3548
- contracts: {
3549
- readonly multicall3: {
3550
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
3551
- readonly blockCreated: 13051;
3552
- };
3553
- };
3554
- ensTlds?: readonly string[] | undefined;
3555
- id: 999;
3556
- name: "HyperEVM";
3557
- nativeCurrency: {
3558
- readonly name: "HYPE";
3559
- readonly symbol: "HYPE";
3560
- readonly decimals: 18;
3561
- };
3562
- experimental_preconfirmationTime?: number | undefined | undefined;
3563
- rpcUrls: {
3564
- readonly default: {
3565
- readonly http: readonly ["https://rpc.hyperliquid.xyz/evm"];
3566
- };
3567
- };
3568
- sourceId?: number | undefined | undefined;
3569
- testnet: false;
3570
- custom?: Record<string, unknown> | undefined;
3571
- extendSchema?: Record<string, unknown> | undefined;
3572
- fees?: import("viem").ChainFees<undefined> | undefined;
3573
- formatters?: undefined;
3574
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3575
- client: import("viem").Client;
3576
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3577
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3578
- client: import("viem").Client;
3579
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3580
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3581
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3582
- }] | undefined;
3583
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3584
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3585
- } | {
3586
- blockExplorers: {
3587
- readonly default: {
3588
- readonly name: "katana explorer";
3589
- readonly url: "https://katanascan.com";
3590
- };
3591
- };
3592
- blockTime?: number | undefined | undefined;
3593
- contracts: {
3594
- readonly multicall3: {
3595
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
3596
- readonly blockCreated: 0;
3597
- };
3598
- };
3599
- ensTlds?: readonly string[] | undefined;
3600
- id: 747474;
3601
- name: "Katana";
3602
- nativeCurrency: {
3603
- readonly name: "Ether";
3604
- readonly symbol: "ETH";
3605
- readonly decimals: 18;
3606
- };
3607
- experimental_preconfirmationTime?: number | undefined | undefined;
3608
- rpcUrls: {
3609
- readonly default: {
3610
- readonly http: readonly ["https://rpc.katana.network"];
3313
+ exclude: [] | undefined;
3314
+ format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
3315
+ blobGasPrice?: bigint | undefined;
3316
+ blobGasUsed?: bigint | undefined;
3317
+ blockHash: import("viem").Hash;
3318
+ blockNumber: bigint;
3319
+ blockTimestamp?: bigint | undefined;
3320
+ contractAddress: import("abitype").Address | null | undefined;
3321
+ cumulativeGasUsed: bigint;
3322
+ effectiveGasPrice: bigint;
3323
+ from: import("abitype").Address;
3324
+ gasUsed: bigint;
3325
+ logs: import("viem").Log<bigint, number, false>[];
3326
+ logsBloom: import("viem").Hex;
3327
+ root?: `0x${string}` | undefined;
3328
+ status: "success" | "reverted";
3329
+ to: import("abitype").Address | null;
3330
+ transactionHash: import("viem").Hash;
3331
+ transactionIndex: number;
3332
+ type: import("viem").TransactionType;
3333
+ depositNonce?: bigint | undefined | undefined;
3334
+ depositReceiptVersion?: number | undefined | undefined;
3335
+ l1GasPrice: bigint | null;
3336
+ l1GasUsed: bigint | null;
3337
+ l1Fee: bigint | null;
3338
+ l1FeeScalar: number | null;
3339
+ } & {};
3340
+ type: "transactionReceipt";
3611
3341
  };
3612
3342
  };
3613
- sourceId?: number | undefined | undefined;
3614
- testnet: false;
3615
- custom?: Record<string, unknown> | undefined;
3616
- extendSchema?: Record<string, unknown> | undefined;
3617
- fees?: import("viem").ChainFees<undefined> | undefined;
3618
- formatters?: undefined;
3619
3343
  prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3620
3344
  client: import("viem").Client;
3621
3345
  phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
@@ -3625,31 +3349,28 @@ declare const chains: ({
3625
3349
  }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3626
3350
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3627
3351
  }] | undefined;
3628
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3352
+ serializers: {
3353
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
3354
+ };
3629
3355
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3630
- readonly network: "katana";
3631
3356
  } | {
3632
3357
  blockExplorers: {
3633
3358
  readonly default: {
3634
- readonly name: "Etherscan";
3635
- readonly url: "https://etherscan.io";
3636
- readonly apiUrl: "https://api.etherscan.io/api";
3359
+ readonly name: "Arbiscan";
3360
+ readonly url: "https://arbiscan.io";
3361
+ readonly apiUrl: "https://api.arbiscan.io/api";
3637
3362
  };
3638
3363
  };
3639
- blockTime: 12000;
3364
+ blockTime: 250;
3640
3365
  contracts: {
3641
- readonly ensUniversalResolver: {
3642
- readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
3643
- readonly blockCreated: 23085558;
3644
- };
3645
3366
  readonly multicall3: {
3646
3367
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3647
- readonly blockCreated: 14353601;
3368
+ readonly blockCreated: 7654707;
3648
3369
  };
3649
3370
  };
3650
3371
  ensTlds?: readonly string[] | undefined;
3651
- id: 1;
3652
- name: "Ethereum";
3372
+ id: 42161;
3373
+ name: "Arbitrum One";
3653
3374
  nativeCurrency: {
3654
3375
  readonly name: "Ether";
3655
3376
  readonly symbol: "ETH";
@@ -3658,7 +3379,7 @@ declare const chains: ({
3658
3379
  experimental_preconfirmationTime?: number | undefined | undefined;
3659
3380
  rpcUrls: {
3660
3381
  readonly default: {
3661
- readonly http: readonly ["https://eth.merkle.io"];
3382
+ readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
3662
3383
  };
3663
3384
  };
3664
3385
  sourceId?: number | undefined | undefined;
@@ -3681,39 +3402,34 @@ declare const chains: ({
3681
3402
  } | {
3682
3403
  blockExplorers: {
3683
3404
  readonly default: {
3684
- readonly name: "Monadscan";
3685
- readonly url: "https://monadscan.com";
3686
- readonly apiUrl: "https://api.etherscan.io/v2/api?chainid=143";
3687
- };
3688
- readonly monadvision: {
3689
- readonly name: "MonadVision";
3690
- readonly url: "https://monadvision.com";
3405
+ readonly name: "PolygonScan";
3406
+ readonly url: "https://polygonscan.com";
3407
+ readonly apiUrl: "https://api.etherscan.io/v2/api";
3691
3408
  };
3692
3409
  };
3693
- blockTime: 400;
3410
+ blockTime: 2000;
3694
3411
  contracts: {
3695
3412
  readonly multicall3: {
3696
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
3697
- readonly blockCreated: 9248132;
3413
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3414
+ readonly blockCreated: 25770160;
3698
3415
  };
3699
3416
  };
3700
3417
  ensTlds?: readonly string[] | undefined;
3701
- id: 143;
3702
- name: "Monad";
3418
+ id: 137;
3419
+ name: "Polygon";
3703
3420
  nativeCurrency: {
3704
- readonly name: "Monad";
3705
- readonly symbol: "MON";
3421
+ readonly name: "POL";
3422
+ readonly symbol: "POL";
3706
3423
  readonly decimals: 18;
3707
3424
  };
3708
3425
  experimental_preconfirmationTime?: number | undefined | undefined;
3709
3426
  rpcUrls: {
3710
3427
  readonly default: {
3711
- readonly http: readonly ["https://rpc.monad.xyz", "https://rpc1.monad.xyz"];
3712
- readonly webSocket: readonly ["wss://rpc.monad.xyz", "wss://rpc1.monad.xyz"];
3428
+ readonly http: readonly ["https://polygon.drpc.org"];
3713
3429
  };
3714
3430
  };
3715
3431
  sourceId?: number | undefined | undefined;
3716
- testnet: false;
3432
+ testnet?: boolean | undefined | undefined;
3717
3433
  custom?: Record<string, unknown> | undefined;
3718
3434
  extendSchema?: Record<string, unknown> | undefined;
3719
3435
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -3732,37 +3448,39 @@ declare const chains: ({
3732
3448
  } | {
3733
3449
  blockExplorers: {
3734
3450
  readonly default: {
3735
- readonly name: "Optimism Explorer";
3736
- readonly url: "https://optimistic.etherscan.io";
3737
- readonly apiUrl: "https://api-optimistic.etherscan.io/api";
3451
+ readonly name: "Blockscout";
3452
+ readonly url: "https://soneium.blockscout.com";
3453
+ readonly apiUrl: "https://soneium.blockscout.com/api";
3738
3454
  };
3739
3455
  };
3740
3456
  blockTime: 2000;
3741
3457
  contracts: {
3742
3458
  readonly disputeGameFactory: {
3743
3459
  readonly 1: {
3744
- readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
3460
+ readonly address: "0x512a3d2c7a43bd9261d2b8e8c9c70d4bd4d503c0";
3745
3461
  };
3746
3462
  };
3747
3463
  readonly l2OutputOracle: {
3748
3464
  readonly 1: {
3749
- readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
3465
+ readonly address: "0x0000000000000000000000000000000000000000";
3750
3466
  };
3751
3467
  };
3752
- readonly multicall3: {
3753
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3754
- readonly blockCreated: 4286263;
3755
- };
3756
3468
  readonly portal: {
3757
3469
  readonly 1: {
3758
- readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
3470
+ readonly address: "0x88e529a6ccd302c948689cd5156c83d4614fae92";
3471
+ readonly blockCreated: 7061266;
3759
3472
  };
3760
3473
  };
3761
3474
  readonly l1StandardBridge: {
3762
3475
  readonly 1: {
3763
- readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
3476
+ readonly address: "0xeb9bf100225c214efc3e7c651ebbadcf85177607";
3477
+ readonly blockCreated: 7061266;
3764
3478
  };
3765
3479
  };
3480
+ readonly multicall3: {
3481
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
3482
+ readonly blockCreated: 1;
3483
+ };
3766
3484
  readonly gasPriceOracle: {
3767
3485
  readonly address: "0x420000000000000000000000000000000000000F";
3768
3486
  };
@@ -3783,8 +3501,8 @@ declare const chains: ({
3783
3501
  };
3784
3502
  };
3785
3503
  ensTlds?: readonly string[] | undefined;
3786
- id: 10;
3787
- name: "OP Mainnet";
3504
+ id: 1868;
3505
+ name: "Soneium Mainnet";
3788
3506
  nativeCurrency: {
3789
3507
  readonly name: "Ether";
3790
3508
  readonly symbol: "ETH";
@@ -3793,7 +3511,7 @@ declare const chains: ({
3793
3511
  experimental_preconfirmationTime?: number | undefined | undefined;
3794
3512
  rpcUrls: {
3795
3513
  readonly default: {
3796
- readonly http: readonly ["https://mainnet.optimism.io"];
3514
+ readonly http: readonly ["https://rpc.soneium.org"];
3797
3515
  };
3798
3516
  };
3799
3517
  sourceId: 1;
@@ -4050,42 +3768,316 @@ declare const chains: ({
4050
3768
  }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
4051
3769
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4052
3770
  }] | undefined;
4053
- serializers: {
4054
- readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
3771
+ serializers: {
3772
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
3773
+ };
3774
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3775
+ } | {
3776
+ blockExplorers: {
3777
+ readonly default: {
3778
+ readonly name: "Sonic Explorer";
3779
+ readonly url: "https://sonicscan.org";
3780
+ };
3781
+ };
3782
+ blockTime: 630;
3783
+ contracts: {
3784
+ readonly multicall3: {
3785
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3786
+ readonly blockCreated: 60;
3787
+ };
3788
+ };
3789
+ ensTlds?: readonly string[] | undefined;
3790
+ id: 146;
3791
+ name: "Sonic";
3792
+ nativeCurrency: {
3793
+ readonly decimals: 18;
3794
+ readonly name: "Sonic";
3795
+ readonly symbol: "S";
3796
+ };
3797
+ experimental_preconfirmationTime?: number | undefined | undefined;
3798
+ rpcUrls: {
3799
+ readonly default: {
3800
+ readonly http: readonly ["https://rpc.soniclabs.com"];
3801
+ };
3802
+ };
3803
+ sourceId?: number | undefined | undefined;
3804
+ testnet: false;
3805
+ custom?: Record<string, unknown> | undefined;
3806
+ extendSchema?: Record<string, unknown> | undefined;
3807
+ fees?: import("viem").ChainFees<undefined> | undefined;
3808
+ formatters?: undefined;
3809
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3810
+ client: import("viem").Client;
3811
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3812
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3813
+ client: import("viem").Client;
3814
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3815
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3816
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3817
+ }] | undefined;
3818
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3819
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3820
+ } | {
3821
+ blockExplorers: {
3822
+ readonly default: {
3823
+ readonly name: "PlasmaScan";
3824
+ readonly url: "https://plasmascan.to";
3825
+ };
3826
+ };
3827
+ blockTime: 1000;
3828
+ contracts: {
3829
+ readonly multicall3: {
3830
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
3831
+ readonly blockCreated: 0;
3832
+ };
3833
+ };
3834
+ ensTlds?: readonly string[] | undefined;
3835
+ id: 9745;
3836
+ name: "Plasma";
3837
+ nativeCurrency: {
3838
+ readonly name: "Plasma";
3839
+ readonly symbol: "XPL";
3840
+ readonly decimals: 18;
3841
+ };
3842
+ experimental_preconfirmationTime?: number | undefined | undefined;
3843
+ rpcUrls: {
3844
+ readonly default: {
3845
+ readonly http: readonly ["https://rpc.plasma.to"];
3846
+ };
3847
+ };
3848
+ sourceId?: number | undefined | undefined;
3849
+ testnet?: boolean | undefined | undefined;
3850
+ custom?: Record<string, unknown> | undefined;
3851
+ extendSchema?: Record<string, unknown> | undefined;
3852
+ fees?: import("viem").ChainFees<undefined> | undefined;
3853
+ formatters?: undefined;
3854
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3855
+ client: import("viem").Client;
3856
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3857
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3858
+ client: import("viem").Client;
3859
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3860
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3861
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3862
+ }] | undefined;
3863
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3864
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3865
+ } | {
3866
+ blockExplorers: {
3867
+ readonly default: {
3868
+ readonly name: "Gnosisscan";
3869
+ readonly url: "https://gnosisscan.io";
3870
+ readonly apiUrl: "https://api.gnosisscan.io/api";
3871
+ };
3872
+ };
3873
+ blockTime: 5000;
3874
+ contracts: {
3875
+ readonly multicall3: {
3876
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3877
+ readonly blockCreated: 21022491;
3878
+ };
3879
+ };
3880
+ ensTlds?: readonly string[] | undefined;
3881
+ id: 100;
3882
+ name: "Gnosis";
3883
+ nativeCurrency: {
3884
+ readonly decimals: 18;
3885
+ readonly name: "xDAI";
3886
+ readonly symbol: "XDAI";
3887
+ };
3888
+ experimental_preconfirmationTime?: number | undefined | undefined;
3889
+ rpcUrls: {
3890
+ readonly default: {
3891
+ readonly http: readonly ["https://rpc.gnosischain.com"];
3892
+ readonly webSocket: readonly ["wss://rpc.gnosischain.com/wss"];
3893
+ };
3894
+ };
3895
+ sourceId?: number | undefined | undefined;
3896
+ testnet?: boolean | undefined | undefined;
3897
+ custom?: Record<string, unknown> | undefined;
3898
+ extendSchema?: Record<string, unknown> | undefined;
3899
+ fees?: import("viem").ChainFees<undefined> | undefined;
3900
+ formatters?: undefined;
3901
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3902
+ client: import("viem").Client;
3903
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3904
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3905
+ client: import("viem").Client;
3906
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3907
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3908
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3909
+ }] | undefined;
3910
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3911
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3912
+ } | {
3913
+ blockExplorers: {
3914
+ readonly default: {
3915
+ readonly name: "BscScan";
3916
+ readonly url: "https://bscscan.com";
3917
+ readonly apiUrl: "https://api.bscscan.com/api";
3918
+ };
3919
+ };
3920
+ blockTime: 750;
3921
+ contracts: {
3922
+ readonly multicall3: {
3923
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3924
+ readonly blockCreated: 15921452;
3925
+ };
3926
+ };
3927
+ ensTlds?: readonly string[] | undefined;
3928
+ id: 56;
3929
+ name: "BNB Smart Chain";
3930
+ nativeCurrency: {
3931
+ readonly decimals: 18;
3932
+ readonly name: "BNB";
3933
+ readonly symbol: "BNB";
3934
+ };
3935
+ experimental_preconfirmationTime?: number | undefined | undefined;
3936
+ rpcUrls: {
3937
+ readonly default: {
3938
+ readonly http: readonly ["https://56.rpc.thirdweb.com"];
3939
+ };
3940
+ };
3941
+ sourceId?: number | undefined | undefined;
3942
+ testnet?: boolean | undefined | undefined;
3943
+ custom?: Record<string, unknown> | undefined;
3944
+ extendSchema?: Record<string, unknown> | undefined;
3945
+ fees?: import("viem").ChainFees<undefined> | undefined;
3946
+ formatters?: undefined;
3947
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3948
+ client: import("viem").Client;
3949
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3950
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3951
+ client: import("viem").Client;
3952
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3953
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3954
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3955
+ }] | undefined;
3956
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3957
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3958
+ } | {
3959
+ blockExplorers: {
3960
+ readonly default: {
3961
+ readonly name: "HyperEVMScan";
3962
+ readonly url: "https://hyperevmscan.io";
3963
+ };
3964
+ };
3965
+ blockTime?: number | undefined | undefined;
3966
+ contracts: {
3967
+ readonly multicall3: {
3968
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
3969
+ readonly blockCreated: 13051;
3970
+ };
4055
3971
  };
3972
+ ensTlds?: readonly string[] | undefined;
3973
+ id: 999;
3974
+ name: "HyperEVM";
3975
+ nativeCurrency: {
3976
+ readonly name: "HYPE";
3977
+ readonly symbol: "HYPE";
3978
+ readonly decimals: 18;
3979
+ };
3980
+ experimental_preconfirmationTime?: number | undefined | undefined;
3981
+ rpcUrls: {
3982
+ readonly default: {
3983
+ readonly http: readonly ["https://rpc.hyperliquid.xyz/evm"];
3984
+ };
3985
+ };
3986
+ sourceId?: number | undefined | undefined;
3987
+ testnet: false;
3988
+ custom?: Record<string, unknown> | undefined;
3989
+ extendSchema?: Record<string, unknown> | undefined;
3990
+ fees?: import("viem").ChainFees<undefined> | undefined;
3991
+ formatters?: undefined;
3992
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3993
+ client: import("viem").Client;
3994
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3995
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3996
+ client: import("viem").Client;
3997
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3998
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3999
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4000
+ }] | undefined;
4001
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
4056
4002
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4057
4003
  } | {
4058
4004
  blockExplorers: {
4059
4005
  readonly default: {
4060
- readonly name: "Blockscout";
4061
- readonly url: "https://optimism-sepolia.blockscout.com";
4062
- readonly apiUrl: "https://optimism-sepolia.blockscout.com/api";
4006
+ readonly name: "Monadscan";
4007
+ readonly url: "https://monadscan.com";
4008
+ readonly apiUrl: "https://api.etherscan.io/v2/api?chainid=143";
4009
+ };
4010
+ readonly monadvision: {
4011
+ readonly name: "MonadVision";
4012
+ readonly url: "https://monadvision.com";
4063
4013
  };
4064
4014
  };
4065
- blockTime: 2000;
4015
+ blockTime: 400;
4066
4016
  contracts: {
4067
- readonly disputeGameFactory: {
4068
- readonly 11155111: {
4069
- readonly address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1";
4070
- };
4017
+ readonly multicall3: {
4018
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
4019
+ readonly blockCreated: 9248132;
4071
4020
  };
4072
- readonly l2OutputOracle: {
4073
- readonly 11155111: {
4074
- readonly address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F";
4075
- };
4021
+ };
4022
+ ensTlds?: readonly string[] | undefined;
4023
+ id: 143;
4024
+ name: "Monad";
4025
+ nativeCurrency: {
4026
+ readonly name: "Monad";
4027
+ readonly symbol: "MON";
4028
+ readonly decimals: 18;
4029
+ };
4030
+ experimental_preconfirmationTime?: number | undefined | undefined;
4031
+ rpcUrls: {
4032
+ readonly default: {
4033
+ readonly http: readonly ["https://rpc.monad.xyz", "https://rpc1.monad.xyz"];
4034
+ readonly webSocket: readonly ["wss://rpc.monad.xyz", "wss://rpc1.monad.xyz"];
4035
+ };
4036
+ };
4037
+ sourceId?: number | undefined | undefined;
4038
+ testnet: false;
4039
+ custom?: Record<string, unknown> | undefined;
4040
+ extendSchema?: Record<string, unknown> | undefined;
4041
+ fees?: import("viem").ChainFees<undefined> | undefined;
4042
+ formatters?: undefined;
4043
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4044
+ client: import("viem").Client;
4045
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4046
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4047
+ client: import("viem").Client;
4048
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4049
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
4050
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4051
+ }] | undefined;
4052
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
4053
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4054
+ } | {
4055
+ blockExplorers: {
4056
+ readonly default: {
4057
+ readonly name: "Uniscan";
4058
+ readonly url: "https://uniscan.xyz";
4059
+ readonly apiUrl: "https://api.uniscan.xyz/api";
4076
4060
  };
4061
+ };
4062
+ blockTime: 1000;
4063
+ contracts: {
4077
4064
  readonly multicall3: {
4078
4065
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4079
- readonly blockCreated: 1620204;
4066
+ readonly blockCreated: 0;
4067
+ };
4068
+ readonly disputeGameFactory: {
4069
+ readonly 1: {
4070
+ readonly address: "0x2F12d621a16e2d3285929C9996f478508951dFe4";
4071
+ };
4080
4072
  };
4081
4073
  readonly portal: {
4082
- readonly 11155111: {
4083
- readonly address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC";
4074
+ readonly 1: {
4075
+ readonly address: "0x0bd48f6B86a26D3a217d0Fa6FfE2B491B956A7a2";
4084
4076
  };
4085
4077
  };
4086
4078
  readonly l1StandardBridge: {
4087
- readonly 11155111: {
4088
- readonly address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1";
4079
+ readonly 1: {
4080
+ readonly address: "0x81014F44b0a345033bB2b3B21C7a1A308B35fEeA";
4089
4081
  };
4090
4082
  };
4091
4083
  readonly gasPriceOracle: {
@@ -4108,21 +4100,21 @@ declare const chains: ({
4108
4100
  };
4109
4101
  };
4110
4102
  ensTlds?: readonly string[] | undefined;
4111
- id: 11155420;
4112
- name: "OP Sepolia";
4103
+ id: 130;
4104
+ name: "Unichain";
4113
4105
  nativeCurrency: {
4114
- readonly name: "Sepolia Ether";
4106
+ readonly name: "Ether";
4115
4107
  readonly symbol: "ETH";
4116
4108
  readonly decimals: 18;
4117
4109
  };
4118
4110
  experimental_preconfirmationTime?: number | undefined | undefined;
4119
4111
  rpcUrls: {
4120
4112
  readonly default: {
4121
- readonly http: readonly ["https://sepolia.optimism.io"];
4113
+ readonly http: readonly ["https://mainnet.unichain.org/"];
4122
4114
  };
4123
4115
  };
4124
- sourceId: 11155111;
4125
- testnet: true;
4116
+ sourceId: 1;
4117
+ testnet?: boolean | undefined | undefined;
4126
4118
  custom?: Record<string, unknown> | undefined;
4127
4119
  extendSchema?: Record<string, unknown> | undefined;
4128
4120
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -4382,53 +4374,8 @@ declare const chains: ({
4382
4374
  } | {
4383
4375
  blockExplorers: {
4384
4376
  readonly default: {
4385
- readonly name: "PlasmaScan";
4386
- readonly url: "https://plasmascan.to";
4387
- };
4388
- };
4389
- blockTime: 1000;
4390
- contracts: {
4391
- readonly multicall3: {
4392
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
4393
- readonly blockCreated: 0;
4394
- };
4395
- };
4396
- ensTlds?: readonly string[] | undefined;
4397
- id: 9745;
4398
- name: "Plasma";
4399
- nativeCurrency: {
4400
- readonly name: "Plasma";
4401
- readonly symbol: "XPL";
4402
- readonly decimals: 18;
4403
- };
4404
- experimental_preconfirmationTime?: number | undefined | undefined;
4405
- rpcUrls: {
4406
- readonly default: {
4407
- readonly http: readonly ["https://rpc.plasma.to"];
4408
- };
4409
- };
4410
- sourceId?: number | undefined | undefined;
4411
- testnet?: boolean | undefined | undefined;
4412
- custom?: Record<string, unknown> | undefined;
4413
- extendSchema?: Record<string, unknown> | undefined;
4414
- fees?: import("viem").ChainFees<undefined> | undefined;
4415
- formatters?: undefined;
4416
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4417
- client: import("viem").Client;
4418
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4419
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4420
- client: import("viem").Client;
4421
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4422
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
4423
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4424
- }] | undefined;
4425
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
4426
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4427
- } | {
4428
- blockExplorers: {
4429
- readonly default: {
4430
- readonly name: "RouteScan";
4431
- readonly url: "https://testnet.plasmascan.to";
4377
+ readonly name: "katana explorer";
4378
+ readonly url: "https://katanascan.com";
4432
4379
  };
4433
4380
  };
4434
4381
  blockTime?: number | undefined | undefined;
@@ -4439,21 +4386,21 @@ declare const chains: ({
4439
4386
  };
4440
4387
  };
4441
4388
  ensTlds?: readonly string[] | undefined;
4442
- id: 9746;
4443
- name: "Plasma Testnet";
4389
+ id: 747474;
4390
+ name: "Katana";
4444
4391
  nativeCurrency: {
4445
- readonly name: "Testnet Plasma";
4446
- readonly symbol: "XPL";
4392
+ readonly name: "Ether";
4393
+ readonly symbol: "ETH";
4447
4394
  readonly decimals: 18;
4448
4395
  };
4449
4396
  experimental_preconfirmationTime?: number | undefined | undefined;
4450
4397
  rpcUrls: {
4451
4398
  readonly default: {
4452
- readonly http: readonly ["https://testnet-rpc.plasma.to"];
4399
+ readonly http: readonly ["https://rpc.katana.network"];
4453
4400
  };
4454
4401
  };
4455
4402
  sourceId?: number | undefined | undefined;
4456
- testnet: true;
4403
+ testnet: false;
4457
4404
  custom?: Record<string, unknown> | undefined;
4458
4405
  extendSchema?: Record<string, unknown> | undefined;
4459
4406
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -4469,33 +4416,33 @@ declare const chains: ({
4469
4416
  }] | undefined;
4470
4417
  serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
4471
4418
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4419
+ readonly network: "katana";
4472
4420
  } | {
4473
4421
  blockExplorers: {
4474
4422
  readonly default: {
4475
- readonly name: "PolygonScan";
4476
- readonly url: "https://polygonscan.com";
4477
- readonly apiUrl: "https://api.etherscan.io/v2/api";
4423
+ readonly name: "Blockscout";
4424
+ readonly url: "https://robinhoodchain.blockscout.com";
4425
+ readonly apiUrl: "https://robinhoodchain.blockscout.com/api";
4478
4426
  };
4479
4427
  };
4480
- blockTime: 2000;
4428
+ blockTime?: number | undefined | undefined;
4481
4429
  contracts: {
4482
4430
  readonly multicall3: {
4483
4431
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4484
- readonly blockCreated: 25770160;
4485
4432
  };
4486
4433
  };
4487
4434
  ensTlds?: readonly string[] | undefined;
4488
- id: 137;
4489
- name: "Polygon";
4435
+ id: 4663;
4436
+ name: "Robinhood Chain";
4490
4437
  nativeCurrency: {
4491
- readonly name: "POL";
4492
- readonly symbol: "POL";
4438
+ readonly name: "Ether";
4439
+ readonly symbol: "ETH";
4493
4440
  readonly decimals: 18;
4494
4441
  };
4495
4442
  experimental_preconfirmationTime?: number | undefined | undefined;
4496
4443
  rpcUrls: {
4497
4444
  readonly default: {
4498
- readonly http: readonly ["https://polygon.drpc.org"];
4445
+ readonly http: readonly ["https://rpc.mainnet.chain.robinhood.com"];
4499
4446
  };
4500
4447
  };
4501
4448
  sourceId?: number | undefined | undefined;
@@ -4518,29 +4465,30 @@ declare const chains: ({
4518
4465
  } | {
4519
4466
  blockExplorers: {
4520
4467
  readonly default: {
4521
- readonly name: "Blockscout";
4522
- readonly url: "https://robinhoodchain.blockscout.com";
4523
- readonly apiUrl: "https://robinhoodchain.blockscout.com/api";
4468
+ readonly name: "SnowTrace";
4469
+ readonly url: "https://snowtrace.io";
4470
+ readonly apiUrl: "https://api.snowtrace.io";
4524
4471
  };
4525
4472
  };
4526
- blockTime?: number | undefined | undefined;
4473
+ blockTime: 1700;
4527
4474
  contracts: {
4528
4475
  readonly multicall3: {
4529
4476
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4477
+ readonly blockCreated: 11907934;
4530
4478
  };
4531
4479
  };
4532
4480
  ensTlds?: readonly string[] | undefined;
4533
- id: 4663;
4534
- name: "Robinhood Chain";
4481
+ id: 43114;
4482
+ name: "Avalanche";
4535
4483
  nativeCurrency: {
4536
- readonly name: "Ether";
4537
- readonly symbol: "ETH";
4538
4484
  readonly decimals: 18;
4485
+ readonly name: "Avalanche";
4486
+ readonly symbol: "AVAX";
4539
4487
  };
4540
4488
  experimental_preconfirmationTime?: number | undefined | undefined;
4541
4489
  rpcUrls: {
4542
4490
  readonly default: {
4543
- readonly http: readonly ["https://rpc.mainnet.chain.robinhood.com"];
4491
+ readonly http: readonly ["https://api.avax.network/ext/bc/C/rpc"];
4544
4492
  };
4545
4493
  };
4546
4494
  sourceId?: number | undefined | undefined;
@@ -4614,38 +4562,36 @@ declare const chains: ({
4614
4562
  blockExplorers: {
4615
4563
  readonly default: {
4616
4564
  readonly name: "Blockscout";
4617
- readonly url: "https://soneium.blockscout.com";
4618
- readonly apiUrl: "https://soneium.blockscout.com/api";
4565
+ readonly url: "https://optimism-sepolia.blockscout.com";
4566
+ readonly apiUrl: "https://optimism-sepolia.blockscout.com/api";
4619
4567
  };
4620
4568
  };
4621
4569
  blockTime: 2000;
4622
4570
  contracts: {
4623
4571
  readonly disputeGameFactory: {
4624
- readonly 1: {
4625
- readonly address: "0x512a3d2c7a43bd9261d2b8e8c9c70d4bd4d503c0";
4572
+ readonly 11155111: {
4573
+ readonly address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1";
4626
4574
  };
4627
4575
  };
4628
4576
  readonly l2OutputOracle: {
4629
- readonly 1: {
4630
- readonly address: "0x0000000000000000000000000000000000000000";
4577
+ readonly 11155111: {
4578
+ readonly address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F";
4631
4579
  };
4632
4580
  };
4581
+ readonly multicall3: {
4582
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4583
+ readonly blockCreated: 1620204;
4584
+ };
4633
4585
  readonly portal: {
4634
- readonly 1: {
4635
- readonly address: "0x88e529a6ccd302c948689cd5156c83d4614fae92";
4636
- readonly blockCreated: 7061266;
4586
+ readonly 11155111: {
4587
+ readonly address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC";
4637
4588
  };
4638
4589
  };
4639
4590
  readonly l1StandardBridge: {
4640
- readonly 1: {
4641
- readonly address: "0xeb9bf100225c214efc3e7c651ebbadcf85177607";
4642
- readonly blockCreated: 7061266;
4591
+ readonly 11155111: {
4592
+ readonly address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1";
4643
4593
  };
4644
4594
  };
4645
- readonly multicall3: {
4646
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
4647
- readonly blockCreated: 1;
4648
- };
4649
4595
  readonly gasPriceOracle: {
4650
4596
  readonly address: "0x420000000000000000000000000000000000000F";
4651
4597
  };
@@ -4666,21 +4612,21 @@ declare const chains: ({
4666
4612
  };
4667
4613
  };
4668
4614
  ensTlds?: readonly string[] | undefined;
4669
- id: 1868;
4670
- name: "Soneium Mainnet";
4615
+ id: 11155420;
4616
+ name: "OP Sepolia";
4671
4617
  nativeCurrency: {
4672
- readonly name: "Ether";
4618
+ readonly name: "Sepolia Ether";
4673
4619
  readonly symbol: "ETH";
4674
4620
  readonly decimals: 18;
4675
4621
  };
4676
4622
  experimental_preconfirmationTime?: number | undefined | undefined;
4677
4623
  rpcUrls: {
4678
4624
  readonly default: {
4679
- readonly http: readonly ["https://rpc.soneium.org"];
4625
+ readonly http: readonly ["https://sepolia.optimism.io"];
4680
4626
  };
4681
4627
  };
4682
- sourceId: 1;
4683
- testnet?: boolean | undefined | undefined;
4628
+ sourceId: 11155111;
4629
+ testnet: true;
4684
4630
  custom?: Record<string, unknown> | undefined;
4685
4631
  extendSchema?: Record<string, unknown> | undefined;
4686
4632
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -4940,77 +4886,39 @@ declare const chains: ({
4940
4886
  } | {
4941
4887
  blockExplorers: {
4942
4888
  readonly default: {
4943
- readonly name: "Sonic Explorer";
4944
- readonly url: "https://sonicscan.org";
4945
- };
4946
- };
4947
- blockTime: 630;
4948
- contracts: {
4949
- readonly multicall3: {
4950
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4951
- readonly blockCreated: 60;
4952
- };
4953
- };
4954
- ensTlds?: readonly string[] | undefined;
4955
- id: 146;
4956
- name: "Sonic";
4957
- nativeCurrency: {
4958
- readonly decimals: 18;
4959
- readonly name: "Sonic";
4960
- readonly symbol: "S";
4961
- };
4962
- experimental_preconfirmationTime?: number | undefined | undefined;
4963
- rpcUrls: {
4964
- readonly default: {
4965
- readonly http: readonly ["https://rpc.soniclabs.com"];
4966
- };
4967
- };
4968
- sourceId?: number | undefined | undefined;
4969
- testnet: false;
4970
- custom?: Record<string, unknown> | undefined;
4971
- extendSchema?: Record<string, unknown> | undefined;
4972
- fees?: import("viem").ChainFees<undefined> | undefined;
4973
- formatters?: undefined;
4974
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4975
- client: import("viem").Client;
4976
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4977
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4978
- client: import("viem").Client;
4979
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4980
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
4981
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4982
- }] | undefined;
4983
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
4984
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4985
- } | {
4986
- blockExplorers: {
4987
- readonly default: {
4988
- readonly name: "Uniscan";
4989
- readonly url: "https://uniscan.xyz";
4990
- readonly apiUrl: "https://api.uniscan.xyz/api";
4889
+ readonly name: "Basescan";
4890
+ readonly url: "https://sepolia.basescan.org";
4891
+ readonly apiUrl: "https://api-sepolia.basescan.org/api";
4991
4892
  };
4992
4893
  };
4993
- blockTime: 1000;
4894
+ blockTime: 2000;
4994
4895
  contracts: {
4995
- readonly multicall3: {
4996
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4997
- readonly blockCreated: 0;
4998
- };
4999
4896
  readonly disputeGameFactory: {
5000
- readonly 1: {
5001
- readonly address: "0x2F12d621a16e2d3285929C9996f478508951dFe4";
4897
+ readonly 11155111: {
4898
+ readonly address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1";
4899
+ };
4900
+ };
4901
+ readonly l2OutputOracle: {
4902
+ readonly 11155111: {
4903
+ readonly address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254";
5002
4904
  };
5003
4905
  };
5004
4906
  readonly portal: {
5005
- readonly 1: {
5006
- readonly address: "0x0bd48f6B86a26D3a217d0Fa6FfE2B491B956A7a2";
4907
+ readonly 11155111: {
4908
+ readonly address: "0x49f53e41452c74589e85ca1677426ba426459e85";
4909
+ readonly blockCreated: 4446677;
5007
4910
  };
5008
4911
  };
5009
4912
  readonly l1StandardBridge: {
5010
- readonly 1: {
5011
- readonly address: "0x81014F44b0a345033bB2b3B21C7a1A308B35fEeA";
4913
+ readonly 11155111: {
4914
+ readonly address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120";
4915
+ readonly blockCreated: 4446677;
5012
4916
  };
5013
4917
  };
4918
+ readonly multicall3: {
4919
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4920
+ readonly blockCreated: 1059647;
4921
+ };
5014
4922
  readonly gasPriceOracle: {
5015
4923
  readonly address: "0x420000000000000000000000000000000000000F";
5016
4924
  };
@@ -5031,21 +4939,21 @@ declare const chains: ({
5031
4939
  };
5032
4940
  };
5033
4941
  ensTlds?: readonly string[] | undefined;
5034
- id: 130;
5035
- name: "Unichain";
4942
+ id: 84532;
4943
+ name: "Base Sepolia";
5036
4944
  nativeCurrency: {
5037
- readonly name: "Ether";
4945
+ readonly name: "Sepolia Ether";
5038
4946
  readonly symbol: "ETH";
5039
4947
  readonly decimals: 18;
5040
4948
  };
5041
4949
  experimental_preconfirmationTime?: number | undefined | undefined;
5042
4950
  rpcUrls: {
5043
4951
  readonly default: {
5044
- readonly http: readonly ["https://mainnet.unichain.org/"];
4952
+ readonly http: readonly ["https://sepolia.base.org"];
5045
4953
  };
5046
4954
  };
5047
- sourceId: 1;
5048
- testnet?: boolean | undefined | undefined;
4955
+ sourceId: 11155111;
4956
+ testnet: true;
5049
4957
  custom?: Record<string, unknown> | undefined;
5050
4958
  extendSchema?: Record<string, unknown> | undefined;
5051
4959
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -5302,6 +5210,98 @@ declare const chains: ({
5302
5210
  readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
5303
5211
  };
5304
5212
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
5213
+ readonly network: "base-sepolia";
5214
+ } | {
5215
+ blockExplorers: {
5216
+ readonly default: {
5217
+ readonly name: "Arbiscan";
5218
+ readonly url: "https://sepolia.arbiscan.io";
5219
+ readonly apiUrl: "https://api-sepolia.arbiscan.io/api";
5220
+ };
5221
+ };
5222
+ blockTime: 250;
5223
+ contracts: {
5224
+ readonly multicall3: {
5225
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
5226
+ readonly blockCreated: 81930;
5227
+ };
5228
+ };
5229
+ ensTlds?: readonly string[] | undefined;
5230
+ id: 421614;
5231
+ name: "Arbitrum Sepolia";
5232
+ nativeCurrency: {
5233
+ readonly name: "Arbitrum Sepolia Ether";
5234
+ readonly symbol: "ETH";
5235
+ readonly decimals: 18;
5236
+ };
5237
+ experimental_preconfirmationTime?: number | undefined | undefined;
5238
+ rpcUrls: {
5239
+ readonly default: {
5240
+ readonly http: readonly ["https://sepolia-rollup.arbitrum.io/rpc"];
5241
+ };
5242
+ };
5243
+ sourceId?: number | undefined | undefined;
5244
+ testnet: true;
5245
+ custom?: Record<string, unknown> | undefined;
5246
+ extendSchema?: Record<string, unknown> | undefined;
5247
+ fees?: import("viem").ChainFees<undefined> | undefined;
5248
+ formatters?: undefined;
5249
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
5250
+ client: import("viem").Client;
5251
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
5252
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
5253
+ client: import("viem").Client;
5254
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
5255
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
5256
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
5257
+ }] | undefined;
5258
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
5259
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
5260
+ } | {
5261
+ blockExplorers: {
5262
+ readonly default: {
5263
+ readonly name: "RouteScan";
5264
+ readonly url: "https://testnet.plasmascan.to";
5265
+ };
5266
+ };
5267
+ blockTime?: number | undefined | undefined;
5268
+ contracts: {
5269
+ readonly multicall3: {
5270
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
5271
+ readonly blockCreated: 0;
5272
+ };
5273
+ };
5274
+ ensTlds?: readonly string[] | undefined;
5275
+ id: 9746;
5276
+ name: "Plasma Testnet";
5277
+ nativeCurrency: {
5278
+ readonly name: "Testnet Plasma";
5279
+ readonly symbol: "XPL";
5280
+ readonly decimals: 18;
5281
+ };
5282
+ experimental_preconfirmationTime?: number | undefined | undefined;
5283
+ rpcUrls: {
5284
+ readonly default: {
5285
+ readonly http: readonly ["https://testnet-rpc.plasma.to"];
5286
+ };
5287
+ };
5288
+ sourceId?: number | undefined | undefined;
5289
+ testnet: true;
5290
+ custom?: Record<string, unknown> | undefined;
5291
+ extendSchema?: Record<string, unknown> | undefined;
5292
+ fees?: import("viem").ChainFees<undefined> | undefined;
5293
+ formatters?: undefined;
5294
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
5295
+ client: import("viem").Client;
5296
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
5297
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
5298
+ client: import("viem").Client;
5299
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
5300
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
5301
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
5302
+ }] | undefined;
5303
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
5304
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
5305
5305
  })[];
5306
5306
  declare enum MainnetNetwork {
5307
5307
  ETHEREUM,