@rhinestone/shared-configs 1.7.17 → 1.9.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 (19) hide show
  1. package/dist/configs/chains.json +235 -0
  2. package/dist/scripts/__tests__/validation.test.js +83 -0
  3. package/dist/scripts/generate.js +10 -2
  4. package/dist/scripts/validation.d.ts +46 -0
  5. package/dist/scripts/validation.d.ts.map +1 -1
  6. package/dist/scripts/validation.js +170 -0
  7. package/dist/src/chains.d.ts +5 -1
  8. package/dist/src/chains.d.ts.map +1 -1
  9. package/dist/src/chains.js +235 -0
  10. package/dist/src/generated/networks.d.ts +1281 -1281
  11. package/dist/src/generated/networks.d.ts.map +1 -1
  12. package/dist/src/generated/packageVersion.d.ts +1 -1
  13. package/dist/src/generated/packageVersion.d.ts.map +1 -1
  14. package/dist/src/generated/packageVersion.js +1 -1
  15. package/dist/src/index.d.ts +2 -2
  16. package/dist/src/index.d.ts.map +1 -1
  17. package/dist/src/types.d.ts +36 -1
  18. package/dist/src/types.d.ts.map +1 -1
  19. package/package.json +1 -1
package/dist/src/generated/networks.d.ts CHANGED
@@ -1,25 +1,21 @@
1
1
  declare const mainnetChains: ({
2
2
  blockExplorers: {
3
3
  readonly default: {
4
- readonly name: "Etherscan";
5
- readonly url: "https://etherscan.io";
6
- readonly apiUrl: "https://api.etherscan.io/api";
4
+ readonly name: "Arbiscan";
5
+ readonly url: "https://arbiscan.io";
6
+ readonly apiUrl: "https://api.arbiscan.io/api";
7
7
  };
8
8
  };
9
- blockTime: 12000;
9
+ blockTime: 250;
10
10
  contracts: {
11
- readonly ensUniversalResolver: {
12
- readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
13
- readonly blockCreated: 23085558;
14
- };
15
11
  readonly multicall3: {
16
12
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
17
- readonly blockCreated: 14353601;
13
+ readonly blockCreated: 7654707;
18
14
  };
19
15
  };
20
16
  ensTlds?: readonly string[] | undefined;
21
- id: 1;
22
- name: "Ethereum";
17
+ id: 42161;
18
+ name: "Arbitrum One";
23
19
  nativeCurrency: {
24
20
  readonly name: "Ether";
25
21
  readonly symbol: "ETH";
@@ -28,7 +24,7 @@ declare const mainnetChains: ({
28
24
  experimental_preconfirmationTime?: number | undefined | undefined;
29
25
  rpcUrls: {
30
26
  readonly default: {
31
- readonly http: readonly ["https://eth.merkle.io"];
27
+ readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
32
28
  };
33
29
  };
34
30
  sourceId?: number | undefined | undefined;
@@ -51,35 +47,83 @@ declare const mainnetChains: ({
51
47
  } | {
52
48
  blockExplorers: {
53
49
  readonly default: {
54
- readonly name: "Optimism Explorer";
55
- readonly url: "https://optimistic.etherscan.io";
56
- readonly apiUrl: "https://api-optimistic.etherscan.io/api";
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"];
74
+ };
75
+ };
76
+ sourceId?: number | undefined | undefined;
77
+ testnet?: boolean | undefined | undefined;
78
+ custom?: Record<string, unknown> | undefined;
79
+ extendSchema?: Record<string, unknown> | undefined;
80
+ fees?: import("viem").ChainFees<undefined> | undefined;
81
+ formatters?: undefined;
82
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
83
+ client: import("viem").Client;
84
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
85
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
86
+ client: import("viem").Client;
87
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
88
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
89
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
90
+ }] | undefined;
91
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
92
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
93
+ } | {
94
+ blockExplorers: {
95
+ readonly default: {
96
+ readonly name: "Basescan";
97
+ readonly url: "https://basescan.org";
98
+ readonly apiUrl: "https://api.basescan.org/api";
57
99
  };
58
100
  };
59
101
  blockTime: 2000;
60
102
  contracts: {
61
103
  readonly disputeGameFactory: {
62
104
  readonly 1: {
63
- readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
105
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
64
106
  };
65
107
  };
66
108
  readonly l2OutputOracle: {
67
109
  readonly 1: {
68
- readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
110
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
69
111
  };
70
112
  };
71
113
  readonly multicall3: {
72
114
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
73
- readonly blockCreated: 4286263;
115
+ readonly blockCreated: 5022;
74
116
  };
75
117
  readonly portal: {
76
118
  readonly 1: {
77
- readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
119
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
120
+ readonly blockCreated: 17482143;
78
121
  };
79
122
  };
80
123
  readonly l1StandardBridge: {
81
124
  readonly 1: {
82
- readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
125
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
126
+ readonly blockCreated: 17482143;
83
127
  };
84
128
  };
85
129
  readonly gasPriceOracle: {
@@ -102,8 +146,8 @@ declare const mainnetChains: ({
102
146
  };
103
147
  };
104
148
  ensTlds?: readonly string[] | undefined;
105
- id: 10;
106
- name: "OP Mainnet";
149
+ id: 8453;
150
+ name: "Base";
107
151
  nativeCurrency: {
108
152
  readonly name: "Ether";
109
153
  readonly symbol: "ETH";
@@ -112,7 +156,7 @@ declare const mainnetChains: ({
112
156
  experimental_preconfirmationTime?: number | undefined | undefined;
113
157
  rpcUrls: {
114
158
  readonly default: {
115
- readonly http: readonly ["https://mainnet.optimism.io"];
159
+ readonly http: readonly ["https://mainnet.base.org"];
116
160
  };
117
161
  };
118
162
  sourceId: 1;
@@ -376,99 +420,382 @@ declare const mainnetChains: ({
376
420
  } | {
377
421
  blockExplorers: {
378
422
  readonly default: {
379
- readonly name: "Basescan";
380
- readonly url: "https://basescan.org";
381
- readonly apiUrl: "https://api.basescan.org/api";
423
+ readonly name: "BscScan";
424
+ readonly url: "https://bscscan.com";
425
+ readonly apiUrl: "https://api.bscscan.com/api";
382
426
  };
383
427
  };
384
- blockTime: 2000;
428
+ blockTime: 750;
385
429
  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
- };
396
430
  readonly multicall3: {
397
431
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
398
- readonly blockCreated: 5022;
399
- };
400
- readonly portal: {
401
- readonly 1: {
402
- readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
403
- readonly blockCreated: 17482143;
404
- };
405
- };
406
- readonly l1StandardBridge: {
407
- readonly 1: {
408
- readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
409
- readonly blockCreated: 17482143;
410
- };
432
+ readonly blockCreated: 15921452;
411
433
  };
412
- readonly gasPriceOracle: {
413
- readonly address: "0x420000000000000000000000000000000000000F";
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"];
414
447
  };
415
- readonly l1Block: {
416
- readonly address: "0x4200000000000000000000000000000000000015";
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";
417
472
  };
418
- readonly l2CrossDomainMessenger: {
419
- readonly address: "0x4200000000000000000000000000000000000007";
473
+ };
474
+ blockTime: 5000;
475
+ contracts: {
476
+ readonly multicall3: {
477
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
478
+ readonly blockCreated: 21022491;
420
479
  };
421
- readonly l2Erc721Bridge: {
422
- readonly address: "0x4200000000000000000000000000000000000014";
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"];
423
494
  };
424
- readonly l2StandardBridge: {
425
- readonly address: "0x4200000000000000000000000000000000000010";
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";
426
518
  };
427
- readonly l2ToL1MessagePasser: {
428
- readonly address: "0x4200000000000000000000000000000000000016";
519
+ };
520
+ blockTime?: number | undefined | undefined;
521
+ contracts: {
522
+ readonly multicall3: {
523
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
524
+ readonly blockCreated: 13051;
429
525
  };
430
526
  };
431
527
  ensTlds?: readonly string[] | undefined;
432
- id: 8453;
433
- name: "Base";
528
+ id: 999;
529
+ name: "HyperEVM";
434
530
  nativeCurrency: {
435
- readonly name: "Ether";
436
- readonly symbol: "ETH";
531
+ readonly name: "HYPE";
532
+ readonly symbol: "HYPE";
437
533
  readonly decimals: 18;
438
534
  };
439
535
  experimental_preconfirmationTime?: number | undefined | undefined;
440
536
  rpcUrls: {
441
537
  readonly default: {
442
- readonly http: readonly ["https://mainnet.base.org"];
538
+ readonly http: readonly ["https://rpc.hyperliquid.xyz/evm"];
443
539
  };
444
540
  };
445
- sourceId: 1;
446
- testnet?: boolean | undefined | undefined;
541
+ sourceId?: number | undefined | undefined;
542
+ testnet: false;
447
543
  custom?: Record<string, unknown> | undefined;
448
544
  extendSchema?: Record<string, unknown> | undefined;
449
545
  fees?: import("viem").ChainFees<undefined> | undefined;
450
- formatters: {
451
- readonly block: {
452
- exclude: [] | undefined;
453
- format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => {
454
- baseFeePerGas: bigint | null;
455
- blobGasUsed: bigint;
456
- difficulty: bigint;
457
- excessBlobGas: bigint;
458
- extraData: import("viem").Hex;
459
- gasLimit: bigint;
460
- gasUsed: bigint;
461
- hash: `0x${string}` | null;
462
- logsBloom: `0x${string}` | null;
463
- miner: import("abitype").Address;
464
- mixHash: import("viem").Hash;
465
- nonce: `0x${string}` | null;
466
- number: bigint | null;
467
- parentBeaconBlockRoot?: `0x${string}` | undefined;
468
- parentHash: import("viem").Hash;
469
- receiptsRoot: import("viem").Hex;
470
- sealFields: import("viem").Hex[];
471
- sha3Uncles: import("viem").Hash;
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;
774
+ custom?: Record<string, unknown> | undefined;
775
+ extendSchema?: Record<string, unknown> | undefined;
776
+ fees?: import("viem").ChainFees<undefined> | undefined;
777
+ formatters: {
778
+ readonly block: {
779
+ exclude: [] | undefined;
780
+ format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => {
781
+ baseFeePerGas: bigint | null;
782
+ blobGasUsed: bigint;
783
+ difficulty: bigint;
784
+ excessBlobGas: bigint;
785
+ extraData: import("viem").Hex;
786
+ gasLimit: bigint;
787
+ gasUsed: bigint;
788
+ hash: `0x${string}` | null;
789
+ logsBloom: `0x${string}` | null;
790
+ miner: import("abitype").Address;
791
+ mixHash: import("viem").Hash;
792
+ nonce: `0x${string}` | null;
793
+ number: bigint | null;
794
+ parentBeaconBlockRoot?: `0x${string}` | undefined;
795
+ parentHash: import("viem").Hash;
796
+ receiptsRoot: import("viem").Hex;
797
+ sealFields: import("viem").Hex[];
798
+ sha3Uncles: import("viem").Hash;
472
799
  size: bigint;
473
800
  stateRoot: import("viem").Hash;
474
801
  timestamp: bigint;
@@ -703,30 +1030,29 @@ declare const mainnetChains: ({
703
1030
  } | {
704
1031
  blockExplorers: {
705
1032
  readonly default: {
706
- readonly name: "Arbiscan";
707
- readonly url: "https://arbiscan.io";
708
- readonly apiUrl: "https://api.arbiscan.io/api";
1033
+ readonly name: "PlasmaScan";
1034
+ readonly url: "https://plasmascan.to";
709
1035
  };
710
1036
  };
711
- blockTime: 250;
1037
+ blockTime: 1000;
712
1038
  contracts: {
713
1039
  readonly multicall3: {
714
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
715
- readonly blockCreated: 7654707;
1040
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
1041
+ readonly blockCreated: 0;
716
1042
  };
717
1043
  };
718
1044
  ensTlds?: readonly string[] | undefined;
719
- id: 42161;
720
- name: "Arbitrum One";
1045
+ id: 9745;
1046
+ name: "Plasma";
721
1047
  nativeCurrency: {
722
- readonly name: "Ether";
723
- readonly symbol: "ETH";
1048
+ readonly name: "Plasma";
1049
+ readonly symbol: "XPL";
724
1050
  readonly decimals: 18;
725
1051
  };
726
1052
  experimental_preconfirmationTime?: number | undefined | undefined;
727
1053
  rpcUrls: {
728
1054
  readonly default: {
729
- readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
1055
+ readonly http: readonly ["https://rpc.plasma.to"];
730
1056
  };
731
1057
  };
732
1058
  sourceId?: number | undefined | undefined;
@@ -792,6 +1118,51 @@ declare const mainnetChains: ({
792
1118
  }] | undefined;
793
1119
  serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
794
1120
  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;
795
1166
  } | {
796
1167
  blockExplorers: {
797
1168
  readonly default: {
@@ -1167,301 +1538,67 @@ declare const mainnetChains: ({
1167
1538
  } | {
1168
1539
  blockExplorers: {
1169
1540
  readonly default: {
1170
- readonly name: "PlasmaScan";
1171
- readonly url: "https://plasmascan.to";
1541
+ readonly name: "Uniscan";
1542
+ readonly url: "https://uniscan.xyz";
1543
+ readonly apiUrl: "https://api.uniscan.xyz/api";
1172
1544
  };
1173
1545
  };
1174
1546
  blockTime: 1000;
1175
1547
  contracts: {
1176
1548
  readonly multicall3: {
1177
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
1549
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1178
1550
  readonly blockCreated: 0;
1179
1551
  };
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"];
1552
+ readonly disputeGameFactory: {
1553
+ readonly 1: {
1554
+ readonly address: "0x2F12d621a16e2d3285929C9996f478508951dFe4";
1555
+ };
1193
1556
  };
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";
1557
+ readonly portal: {
1558
+ readonly 1: {
1559
+ readonly address: "0x0bd48f6B86a26D3a217d0Fa6FfE2B491B956A7a2";
1560
+ };
1218
1561
  };
1219
- };
1220
- blockTime: 5000;
1221
- contracts: {
1222
- readonly multicall3: {
1223
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1224
- readonly blockCreated: 21022491;
1562
+ readonly l1StandardBridge: {
1563
+ readonly 1: {
1564
+ readonly address: "0x81014F44b0a345033bB2b3B21C7a1A308B35fEeA";
1565
+ };
1225
1566
  };
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"];
1567
+ readonly gasPriceOracle: {
1568
+ readonly address: "0x420000000000000000000000000000000000000F";
1240
1569
  };
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";
1570
+ readonly l1Block: {
1571
+ readonly address: "0x4200000000000000000000000000000000000015";
1265
1572
  };
1266
- };
1267
- blockTime: 750;
1268
- contracts: {
1269
- readonly multicall3: {
1270
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1271
- readonly blockCreated: 15921452;
1573
+ readonly l2CrossDomainMessenger: {
1574
+ readonly address: "0x4200000000000000000000000000000000000007";
1272
1575
  };
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"];
1576
+ readonly l2Erc721Bridge: {
1577
+ readonly address: "0x4200000000000000000000000000000000000014";
1286
1578
  };
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";
1579
+ readonly l2StandardBridge: {
1580
+ readonly address: "0x4200000000000000000000000000000000000010";
1310
1581
  };
1311
- };
1312
- blockTime?: number | undefined | undefined;
1313
- contracts: {
1314
- readonly multicall3: {
1315
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
1316
- readonly blockCreated: 13051;
1582
+ readonly l2ToL1MessagePasser: {
1583
+ readonly address: "0x4200000000000000000000000000000000000016";
1317
1584
  };
1318
1585
  };
1319
1586
  ensTlds?: readonly string[] | undefined;
1320
- id: 999;
1321
- name: "HyperEVM";
1587
+ id: 130;
1588
+ name: "Unichain";
1322
1589
  nativeCurrency: {
1323
- readonly name: "HYPE";
1324
- readonly symbol: "HYPE";
1590
+ readonly name: "Ether";
1591
+ readonly symbol: "ETH";
1325
1592
  readonly decimals: 18;
1326
1593
  };
1327
1594
  experimental_preconfirmationTime?: number | undefined | undefined;
1328
1595
  rpcUrls: {
1329
1596
  readonly default: {
1330
- readonly http: readonly ["https://rpc.hyperliquid.xyz/evm"];
1597
+ readonly http: readonly ["https://mainnet.unichain.org/"];
1331
1598
  };
1332
1599
  };
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;
1349
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1350
- } | {
1351
- blockExplorers: {
1352
- readonly default: {
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";
1360
- };
1361
- };
1362
- blockTime: 400;
1363
- contracts: {
1364
- readonly multicall3: {
1365
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
1366
- readonly blockCreated: 9248132;
1367
- };
1368
- };
1369
- ensTlds?: readonly string[] | undefined;
1370
- id: 143;
1371
- name: "Monad";
1372
- nativeCurrency: {
1373
- readonly name: "Monad";
1374
- readonly symbol: "MON";
1375
- readonly decimals: 18;
1376
- };
1377
- experimental_preconfirmationTime?: number | undefined | undefined;
1378
- rpcUrls: {
1379
- readonly default: {
1380
- readonly http: readonly ["https://rpc.monad.xyz", "https://rpc1.monad.xyz"];
1381
- readonly webSocket: readonly ["wss://rpc.monad.xyz", "wss://rpc1.monad.xyz"];
1382
- };
1383
- };
1384
- sourceId?: number | undefined | undefined;
1385
- testnet: false;
1386
- custom?: Record<string, unknown> | undefined;
1387
- extendSchema?: Record<string, unknown> | undefined;
1388
- fees?: import("viem").ChainFees<undefined> | undefined;
1389
- formatters?: undefined;
1390
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1391
- client: import("viem").Client;
1392
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1393
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1394
- client: import("viem").Client;
1395
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1396
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
1397
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1398
- }] | undefined;
1399
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1400
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1401
- } | {
1402
- blockExplorers: {
1403
- readonly default: {
1404
- readonly name: "Uniscan";
1405
- readonly url: "https://uniscan.xyz";
1406
- readonly apiUrl: "https://api.uniscan.xyz/api";
1407
- };
1408
- };
1409
- blockTime: 1000;
1410
- contracts: {
1411
- readonly multicall3: {
1412
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1413
- readonly blockCreated: 0;
1414
- };
1415
- readonly disputeGameFactory: {
1416
- readonly 1: {
1417
- readonly address: "0x2F12d621a16e2d3285929C9996f478508951dFe4";
1418
- };
1419
- };
1420
- readonly portal: {
1421
- readonly 1: {
1422
- readonly address: "0x0bd48f6B86a26D3a217d0Fa6FfE2B491B956A7a2";
1423
- };
1424
- };
1425
- readonly l1StandardBridge: {
1426
- readonly 1: {
1427
- readonly address: "0x81014F44b0a345033bB2b3B21C7a1A308B35fEeA";
1428
- };
1429
- };
1430
- readonly gasPriceOracle: {
1431
- readonly address: "0x420000000000000000000000000000000000000F";
1432
- };
1433
- readonly l1Block: {
1434
- readonly address: "0x4200000000000000000000000000000000000015";
1435
- };
1436
- readonly l2CrossDomainMessenger: {
1437
- readonly address: "0x4200000000000000000000000000000000000007";
1438
- };
1439
- readonly l2Erc721Bridge: {
1440
- readonly address: "0x4200000000000000000000000000000000000014";
1441
- };
1442
- readonly l2StandardBridge: {
1443
- readonly address: "0x4200000000000000000000000000000000000010";
1444
- };
1445
- readonly l2ToL1MessagePasser: {
1446
- readonly address: "0x4200000000000000000000000000000000000016";
1447
- };
1448
- };
1449
- ensTlds?: readonly string[] | undefined;
1450
- id: 130;
1451
- name: "Unichain";
1452
- nativeCurrency: {
1453
- readonly name: "Ether";
1454
- readonly symbol: "ETH";
1455
- readonly decimals: 18;
1456
- };
1457
- experimental_preconfirmationTime?: number | undefined | undefined;
1458
- rpcUrls: {
1459
- readonly default: {
1460
- readonly http: readonly ["https://mainnet.unichain.org/"];
1461
- };
1462
- };
1463
- sourceId: 1;
1464
- testnet?: boolean | undefined | undefined;
1600
+ sourceId: 1;
1601
+ testnet?: boolean | undefined | undefined;
1465
1602
  custom?: Record<string, unknown> | undefined;
1466
1603
  extendSchema?: Record<string, unknown> | undefined;
1467
1604
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -1718,36 +1855,38 @@ declare const mainnetChains: ({
1718
1855
  readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
1719
1856
  };
1720
1857
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1721
- } | {
1858
+ })[];
1859
+ declare const testnetChains: ({
1722
1860
  blockExplorers: {
1723
1861
  readonly default: {
1724
- readonly name: "katana explorer";
1725
- readonly url: "https://katanascan.com";
1862
+ readonly name: "Arbiscan";
1863
+ readonly url: "https://sepolia.arbiscan.io";
1864
+ readonly apiUrl: "https://api-sepolia.arbiscan.io/api";
1726
1865
  };
1727
1866
  };
1728
- blockTime?: number | undefined | undefined;
1867
+ blockTime: 250;
1729
1868
  contracts: {
1730
1869
  readonly multicall3: {
1731
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
1732
- readonly blockCreated: 0;
1870
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1871
+ readonly blockCreated: 81930;
1733
1872
  };
1734
1873
  };
1735
1874
  ensTlds?: readonly string[] | undefined;
1736
- id: 747474;
1737
- name: "Katana";
1875
+ id: 421614;
1876
+ name: "Arbitrum Sepolia";
1738
1877
  nativeCurrency: {
1739
- readonly name: "Ether";
1878
+ readonly name: "Arbitrum Sepolia Ether";
1740
1879
  readonly symbol: "ETH";
1741
1880
  readonly decimals: 18;
1742
1881
  };
1743
1882
  experimental_preconfirmationTime?: number | undefined | undefined;
1744
1883
  rpcUrls: {
1745
1884
  readonly default: {
1746
- readonly http: readonly ["https://rpc.katana.network"];
1885
+ readonly http: readonly ["https://sepolia-rollup.arbitrum.io/rpc"];
1747
1886
  };
1748
1887
  };
1749
1888
  sourceId?: number | undefined | undefined;
1750
- testnet: false;
1889
+ testnet: true;
1751
1890
  custom?: Record<string, unknown> | undefined;
1752
1891
  extendSchema?: Record<string, unknown> | undefined;
1753
1892
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -1763,218 +1902,77 @@ declare const mainnetChains: ({
1763
1902
  }] | undefined;
1764
1903
  serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1765
1904
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1766
- readonly network: "katana";
1767
1905
  } | {
1768
1906
  blockExplorers: {
1769
1907
  readonly default: {
1770
- readonly name: "Blockscout";
1771
- readonly url: "https://robinhoodchain.blockscout.com";
1772
- readonly apiUrl: "https://robinhoodchain.blockscout.com/api";
1908
+ readonly name: "Basescan";
1909
+ readonly url: "https://sepolia.basescan.org";
1910
+ readonly apiUrl: "https://api-sepolia.basescan.org/api";
1773
1911
  };
1774
1912
  };
1775
- blockTime?: number | undefined | undefined;
1913
+ blockTime: 2000;
1776
1914
  contracts: {
1777
- readonly multicall3: {
1778
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1915
+ readonly disputeGameFactory: {
1916
+ readonly 11155111: {
1917
+ readonly address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1";
1918
+ };
1779
1919
  };
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"];
1920
+ readonly l2OutputOracle: {
1921
+ readonly 11155111: {
1922
+ readonly address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254";
1923
+ };
1793
1924
  };
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";
1925
+ readonly portal: {
1926
+ readonly 11155111: {
1927
+ readonly address: "0x49f53e41452c74589e85ca1677426ba426459e85";
1928
+ readonly blockCreated: 4446677;
1929
+ };
1930
+ };
1931
+ readonly l1StandardBridge: {
1932
+ readonly 11155111: {
1933
+ readonly address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120";
1934
+ readonly blockCreated: 4446677;
1935
+ };
1818
1936
  };
1819
- };
1820
- blockTime: 1700;
1821
- contracts: {
1822
1937
  readonly multicall3: {
1823
1938
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1824
- readonly blockCreated: 11907934;
1939
+ readonly blockCreated: 1059647;
1940
+ };
1941
+ readonly gasPriceOracle: {
1942
+ readonly address: "0x420000000000000000000000000000000000000F";
1943
+ };
1944
+ readonly l1Block: {
1945
+ readonly address: "0x4200000000000000000000000000000000000015";
1946
+ };
1947
+ readonly l2CrossDomainMessenger: {
1948
+ readonly address: "0x4200000000000000000000000000000000000007";
1949
+ };
1950
+ readonly l2Erc721Bridge: {
1951
+ readonly address: "0x4200000000000000000000000000000000000014";
1952
+ };
1953
+ readonly l2StandardBridge: {
1954
+ readonly address: "0x4200000000000000000000000000000000000010";
1955
+ };
1956
+ readonly l2ToL1MessagePasser: {
1957
+ readonly address: "0x4200000000000000000000000000000000000016";
1825
1958
  };
1826
1959
  };
1827
1960
  ensTlds?: readonly string[] | undefined;
1828
- id: 43114;
1829
- name: "Avalanche";
1961
+ id: 84532;
1962
+ name: "Base Sepolia";
1830
1963
  nativeCurrency: {
1964
+ readonly name: "Sepolia Ether";
1965
+ readonly symbol: "ETH";
1831
1966
  readonly decimals: 18;
1832
- readonly name: "Avalanche";
1833
- readonly symbol: "AVAX";
1834
1967
  };
1835
1968
  experimental_preconfirmationTime?: number | undefined | undefined;
1836
1969
  rpcUrls: {
1837
1970
  readonly default: {
1838
- readonly http: readonly ["https://api.avax.network/ext/bc/C/rpc"];
1971
+ readonly http: readonly ["https://sepolia.base.org"];
1839
1972
  };
1840
1973
  };
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
- })[];
1859
- declare const testnetChains: ({
1860
- blockExplorers: {
1861
- readonly default: {
1862
- readonly name: "Etherscan";
1863
- readonly url: "https://sepolia.etherscan.io";
1864
- readonly apiUrl: "https://api-sepolia.etherscan.io/api";
1865
- };
1866
- };
1867
- blockTime?: number | undefined | undefined;
1868
- contracts: {
1869
- readonly multicall3: {
1870
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1871
- readonly blockCreated: 751532;
1872
- };
1873
- readonly ensUniversalResolver: {
1874
- readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
1875
- readonly blockCreated: 8928790;
1876
- };
1877
- };
1878
- ensTlds?: readonly string[] | undefined;
1879
- id: 11155111;
1880
- name: "Sepolia";
1881
- nativeCurrency: {
1882
- readonly name: "Sepolia Ether";
1883
- readonly symbol: "ETH";
1884
- readonly decimals: 18;
1885
- };
1886
- experimental_preconfirmationTime?: number | undefined | undefined;
1887
- rpcUrls: {
1888
- readonly default: {
1889
- readonly http: readonly ["https://11155111.rpc.thirdweb.com"];
1890
- };
1891
- };
1892
- sourceId?: number | undefined | undefined;
1893
- testnet: true;
1894
- custom?: Record<string, unknown> | undefined;
1895
- extendSchema?: Record<string, unknown> | undefined;
1896
- fees?: import("viem").ChainFees<undefined> | undefined;
1897
- formatters?: undefined;
1898
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1899
- client: import("viem").Client;
1900
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1901
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1902
- client: import("viem").Client;
1903
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1904
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
1905
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1906
- }] | undefined;
1907
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1908
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1909
- } | {
1910
- blockExplorers: {
1911
- readonly default: {
1912
- readonly name: "Blockscout";
1913
- readonly url: "https://optimism-sepolia.blockscout.com";
1914
- readonly apiUrl: "https://optimism-sepolia.blockscout.com/api";
1915
- };
1916
- };
1917
- blockTime: 2000;
1918
- contracts: {
1919
- readonly disputeGameFactory: {
1920
- readonly 11155111: {
1921
- readonly address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1";
1922
- };
1923
- };
1924
- readonly l2OutputOracle: {
1925
- readonly 11155111: {
1926
- readonly address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F";
1927
- };
1928
- };
1929
- readonly multicall3: {
1930
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1931
- readonly blockCreated: 1620204;
1932
- };
1933
- readonly portal: {
1934
- readonly 11155111: {
1935
- readonly address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC";
1936
- };
1937
- };
1938
- readonly l1StandardBridge: {
1939
- readonly 11155111: {
1940
- readonly address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1";
1941
- };
1942
- };
1943
- readonly gasPriceOracle: {
1944
- readonly address: "0x420000000000000000000000000000000000000F";
1945
- };
1946
- readonly l1Block: {
1947
- readonly address: "0x4200000000000000000000000000000000000015";
1948
- };
1949
- readonly l2CrossDomainMessenger: {
1950
- readonly address: "0x4200000000000000000000000000000000000007";
1951
- };
1952
- readonly l2Erc721Bridge: {
1953
- readonly address: "0x4200000000000000000000000000000000000014";
1954
- };
1955
- readonly l2StandardBridge: {
1956
- readonly address: "0x4200000000000000000000000000000000000010";
1957
- };
1958
- readonly l2ToL1MessagePasser: {
1959
- readonly address: "0x4200000000000000000000000000000000000016";
1960
- };
1961
- };
1962
- ensTlds?: readonly string[] | undefined;
1963
- id: 11155420;
1964
- name: "OP Sepolia";
1965
- nativeCurrency: {
1966
- readonly name: "Sepolia Ether";
1967
- readonly symbol: "ETH";
1968
- readonly decimals: 18;
1969
- };
1970
- experimental_preconfirmationTime?: number | undefined | undefined;
1971
- rpcUrls: {
1972
- readonly default: {
1973
- readonly http: readonly ["https://sepolia.optimism.io"];
1974
- };
1975
- };
1976
- sourceId: 11155111;
1977
- testnet: true;
1974
+ sourceId: 11155111;
1975
+ testnet: true;
1978
1976
  custom?: Record<string, unknown> | undefined;
1979
1977
  extendSchema?: Record<string, unknown> | undefined;
1980
1978
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -2231,42 +2229,41 @@ declare const testnetChains: ({
2231
2229
  readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
2232
2230
  };
2233
2231
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2232
+ readonly network: "base-sepolia";
2234
2233
  } | {
2235
2234
  blockExplorers: {
2236
2235
  readonly default: {
2237
- readonly name: "Basescan";
2238
- readonly url: "https://sepolia.basescan.org";
2239
- readonly apiUrl: "https://api-sepolia.basescan.org/api";
2236
+ readonly name: "Blockscout";
2237
+ readonly url: "https://optimism-sepolia.blockscout.com";
2238
+ readonly apiUrl: "https://optimism-sepolia.blockscout.com/api";
2240
2239
  };
2241
2240
  };
2242
2241
  blockTime: 2000;
2243
2242
  contracts: {
2244
2243
  readonly disputeGameFactory: {
2245
2244
  readonly 11155111: {
2246
- readonly address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1";
2245
+ readonly address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1";
2247
2246
  };
2248
2247
  };
2249
2248
  readonly l2OutputOracle: {
2250
2249
  readonly 11155111: {
2251
- readonly address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254";
2250
+ readonly address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F";
2252
2251
  };
2253
2252
  };
2253
+ readonly multicall3: {
2254
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2255
+ readonly blockCreated: 1620204;
2256
+ };
2254
2257
  readonly portal: {
2255
2258
  readonly 11155111: {
2256
- readonly address: "0x49f53e41452c74589e85ca1677426ba426459e85";
2257
- readonly blockCreated: 4446677;
2259
+ readonly address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC";
2258
2260
  };
2259
2261
  };
2260
2262
  readonly l1StandardBridge: {
2261
2263
  readonly 11155111: {
2262
- readonly address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120";
2263
- readonly blockCreated: 4446677;
2264
+ readonly address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1";
2264
2265
  };
2265
2266
  };
2266
- readonly multicall3: {
2267
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2268
- readonly blockCreated: 1059647;
2269
- };
2270
2267
  readonly gasPriceOracle: {
2271
2268
  readonly address: "0x420000000000000000000000000000000000000F";
2272
2269
  };
@@ -2287,8 +2284,8 @@ declare const testnetChains: ({
2287
2284
  };
2288
2285
  };
2289
2286
  ensTlds?: readonly string[] | undefined;
2290
- id: 84532;
2291
- name: "Base Sepolia";
2287
+ id: 11155420;
2288
+ name: "OP Sepolia";
2292
2289
  nativeCurrency: {
2293
2290
  readonly name: "Sepolia Ether";
2294
2291
  readonly symbol: "ETH";
@@ -2297,7 +2294,7 @@ declare const testnetChains: ({
2297
2294
  experimental_preconfirmationTime?: number | undefined | undefined;
2298
2295
  rpcUrls: {
2299
2296
  readonly default: {
2300
- readonly http: readonly ["https://sepolia.base.org"];
2297
+ readonly http: readonly ["https://sepolia.optimism.io"];
2301
2298
  };
2302
2299
  };
2303
2300
  sourceId: 11155111;
@@ -2558,34 +2555,32 @@ declare const testnetChains: ({
2558
2555
  readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
2559
2556
  };
2560
2557
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2561
- readonly network: "base-sepolia";
2562
2558
  } | {
2563
2559
  blockExplorers: {
2564
2560
  readonly default: {
2565
- readonly name: "Arbiscan";
2566
- readonly url: "https://sepolia.arbiscan.io";
2567
- readonly apiUrl: "https://api-sepolia.arbiscan.io/api";
2561
+ readonly name: "RouteScan";
2562
+ readonly url: "https://testnet.plasmascan.to";
2568
2563
  };
2569
2564
  };
2570
- blockTime: 250;
2565
+ blockTime?: number | undefined | undefined;
2571
2566
  contracts: {
2572
2567
  readonly multicall3: {
2573
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2574
- readonly blockCreated: 81930;
2568
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
2569
+ readonly blockCreated: 0;
2575
2570
  };
2576
2571
  };
2577
2572
  ensTlds?: readonly string[] | undefined;
2578
- id: 421614;
2579
- name: "Arbitrum Sepolia";
2573
+ id: 9746;
2574
+ name: "Plasma Testnet";
2580
2575
  nativeCurrency: {
2581
- readonly name: "Arbitrum Sepolia Ether";
2582
- readonly symbol: "ETH";
2576
+ readonly name: "Testnet Plasma";
2577
+ readonly symbol: "XPL";
2583
2578
  readonly decimals: 18;
2584
2579
  };
2585
2580
  experimental_preconfirmationTime?: number | undefined | undefined;
2586
2581
  rpcUrls: {
2587
2582
  readonly default: {
2588
- readonly http: readonly ["https://sepolia-rollup.arbitrum.io/rpc"];
2583
+ readonly http: readonly ["https://testnet-rpc.plasma.to"];
2589
2584
  };
2590
2585
  };
2591
2586
  sourceId?: number | undefined | undefined;
@@ -2608,29 +2603,34 @@ declare const testnetChains: ({
2608
2603
  } | {
2609
2604
  blockExplorers: {
2610
2605
  readonly default: {
2611
- readonly name: "RouteScan";
2612
- readonly url: "https://testnet.plasmascan.to";
2606
+ readonly name: "Etherscan";
2607
+ readonly url: "https://sepolia.etherscan.io";
2608
+ readonly apiUrl: "https://api-sepolia.etherscan.io/api";
2613
2609
  };
2614
2610
  };
2615
2611
  blockTime?: number | undefined | undefined;
2616
2612
  contracts: {
2617
2613
  readonly multicall3: {
2618
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
2619
- readonly blockCreated: 0;
2614
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2615
+ readonly blockCreated: 751532;
2616
+ };
2617
+ readonly ensUniversalResolver: {
2618
+ readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
2619
+ readonly blockCreated: 8928790;
2620
2620
  };
2621
2621
  };
2622
2622
  ensTlds?: readonly string[] | undefined;
2623
- id: 9746;
2624
- name: "Plasma Testnet";
2623
+ id: 11155111;
2624
+ name: "Sepolia";
2625
2625
  nativeCurrency: {
2626
- readonly name: "Testnet Plasma";
2627
- readonly symbol: "XPL";
2626
+ readonly name: "Sepolia Ether";
2627
+ readonly symbol: "ETH";
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://testnet-rpc.plasma.to"];
2633
+ readonly http: readonly ["https://11155111.rpc.thirdweb.com"];
2634
2634
  };
2635
2635
  };
2636
2636
  sourceId?: number | undefined | undefined;
@@ -2654,25 +2654,21 @@ declare const testnetChains: ({
2654
2654
  declare const chains: ({
2655
2655
  blockExplorers: {
2656
2656
  readonly default: {
2657
- readonly name: "Etherscan";
2658
- readonly url: "https://etherscan.io";
2659
- readonly apiUrl: "https://api.etherscan.io/api";
2657
+ readonly name: "Arbiscan";
2658
+ readonly url: "https://arbiscan.io";
2659
+ readonly apiUrl: "https://api.arbiscan.io/api";
2660
2660
  };
2661
2661
  };
2662
- blockTime: 12000;
2662
+ blockTime: 250;
2663
2663
  contracts: {
2664
- readonly ensUniversalResolver: {
2665
- readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
2666
- readonly blockCreated: 23085558;
2667
- };
2668
2664
  readonly multicall3: {
2669
2665
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2670
- readonly blockCreated: 14353601;
2666
+ readonly blockCreated: 7654707;
2671
2667
  };
2672
2668
  };
2673
2669
  ensTlds?: readonly string[] | undefined;
2674
- id: 1;
2675
- name: "Ethereum";
2670
+ id: 42161;
2671
+ name: "Arbitrum One";
2676
2672
  nativeCurrency: {
2677
2673
  readonly name: "Ether";
2678
2674
  readonly symbol: "ETH";
@@ -2681,7 +2677,7 @@ declare const chains: ({
2681
2677
  experimental_preconfirmationTime?: number | undefined | undefined;
2682
2678
  rpcUrls: {
2683
2679
  readonly default: {
2684
- readonly http: readonly ["https://eth.merkle.io"];
2680
+ readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
2685
2681
  };
2686
2682
  };
2687
2683
  sourceId?: number | undefined | undefined;
@@ -2704,36 +2700,130 @@ declare const chains: ({
2704
2700
  } | {
2705
2701
  blockExplorers: {
2706
2702
  readonly default: {
2707
- readonly name: "Optimism Explorer";
2708
- readonly url: "https://optimistic.etherscan.io";
2709
- readonly apiUrl: "https://api-optimistic.etherscan.io/api";
2703
+ readonly name: "Arbiscan";
2704
+ readonly url: "https://sepolia.arbiscan.io";
2705
+ readonly apiUrl: "https://api-sepolia.arbiscan.io/api";
2710
2706
  };
2711
2707
  };
2712
- blockTime: 2000;
2708
+ blockTime: 250;
2713
2709
  contracts: {
2714
- readonly disputeGameFactory: {
2715
- readonly 1: {
2716
- readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
2717
- };
2718
- };
2719
- readonly l2OutputOracle: {
2720
- readonly 1: {
2721
- readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
2722
- };
2723
- };
2724
2710
  readonly multicall3: {
2725
2711
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2726
- readonly blockCreated: 4286263;
2727
- };
2728
- readonly portal: {
2729
- readonly 1: {
2730
- readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
2731
- };
2712
+ readonly blockCreated: 81930;
2732
2713
  };
2733
- readonly l1StandardBridge: {
2734
- readonly 1: {
2735
- readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
2736
- };
2714
+ };
2715
+ ensTlds?: readonly string[] | undefined;
2716
+ id: 421614;
2717
+ name: "Arbitrum Sepolia";
2718
+ nativeCurrency: {
2719
+ readonly name: "Arbitrum Sepolia Ether";
2720
+ readonly symbol: "ETH";
2721
+ readonly decimals: 18;
2722
+ };
2723
+ experimental_preconfirmationTime?: number | undefined | undefined;
2724
+ rpcUrls: {
2725
+ 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"];
2773
+ };
2774
+ };
2775
+ sourceId?: number | undefined | undefined;
2776
+ testnet?: boolean | undefined | undefined;
2777
+ custom?: Record<string, unknown> | undefined;
2778
+ extendSchema?: Record<string, unknown> | undefined;
2779
+ fees?: import("viem").ChainFees<undefined> | undefined;
2780
+ formatters?: undefined;
2781
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2782
+ client: import("viem").Client;
2783
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2784
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2785
+ client: import("viem").Client;
2786
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2787
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2788
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2789
+ }] | undefined;
2790
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2791
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2792
+ } | {
2793
+ blockExplorers: {
2794
+ readonly default: {
2795
+ readonly name: "Basescan";
2796
+ readonly url: "https://basescan.org";
2797
+ readonly apiUrl: "https://api.basescan.org/api";
2798
+ };
2799
+ };
2800
+ blockTime: 2000;
2801
+ contracts: {
2802
+ readonly disputeGameFactory: {
2803
+ readonly 1: {
2804
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
2805
+ };
2806
+ };
2807
+ readonly l2OutputOracle: {
2808
+ readonly 1: {
2809
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
2810
+ };
2811
+ };
2812
+ readonly multicall3: {
2813
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2814
+ readonly blockCreated: 5022;
2815
+ };
2816
+ readonly portal: {
2817
+ readonly 1: {
2818
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
2819
+ readonly blockCreated: 17482143;
2820
+ };
2821
+ };
2822
+ readonly l1StandardBridge: {
2823
+ readonly 1: {
2824
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
2825
+ readonly blockCreated: 17482143;
2826
+ };
2737
2827
  };
2738
2828
  readonly gasPriceOracle: {
2739
2829
  readonly address: "0x420000000000000000000000000000000000000F";
@@ -2755,8 +2845,8 @@ declare const chains: ({
2755
2845
  };
2756
2846
  };
2757
2847
  ensTlds?: readonly string[] | undefined;
2758
- id: 10;
2759
- name: "OP Mainnet";
2848
+ id: 8453;
2849
+ name: "Base";
2760
2850
  nativeCurrency: {
2761
2851
  readonly name: "Ether";
2762
2852
  readonly symbol: "ETH";
@@ -2765,7 +2855,7 @@ declare const chains: ({
2765
2855
  experimental_preconfirmationTime?: number | undefined | undefined;
2766
2856
  rpcUrls: {
2767
2857
  readonly default: {
2768
- readonly http: readonly ["https://mainnet.optimism.io"];
2858
+ readonly http: readonly ["https://mainnet.base.org"];
2769
2859
  };
2770
2860
  };
2771
2861
  sourceId: 1;
@@ -3030,38 +3120,38 @@ declare const chains: ({
3030
3120
  blockExplorers: {
3031
3121
  readonly default: {
3032
3122
  readonly name: "Basescan";
3033
- readonly url: "https://basescan.org";
3034
- readonly apiUrl: "https://api.basescan.org/api";
3123
+ readonly url: "https://sepolia.basescan.org";
3124
+ readonly apiUrl: "https://api-sepolia.basescan.org/api";
3035
3125
  };
3036
3126
  };
3037
3127
  blockTime: 2000;
3038
3128
  contracts: {
3039
3129
  readonly disputeGameFactory: {
3040
- readonly 1: {
3041
- readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
3130
+ readonly 11155111: {
3131
+ readonly address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1";
3042
3132
  };
3043
3133
  };
3044
3134
  readonly l2OutputOracle: {
3045
- readonly 1: {
3046
- readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
3135
+ readonly 11155111: {
3136
+ readonly address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254";
3047
3137
  };
3048
3138
  };
3049
- readonly multicall3: {
3050
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3051
- readonly blockCreated: 5022;
3052
- };
3053
3139
  readonly portal: {
3054
- readonly 1: {
3055
- readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
3056
- readonly blockCreated: 17482143;
3140
+ readonly 11155111: {
3141
+ readonly address: "0x49f53e41452c74589e85ca1677426ba426459e85";
3142
+ readonly blockCreated: 4446677;
3057
3143
  };
3058
3144
  };
3059
3145
  readonly l1StandardBridge: {
3060
- readonly 1: {
3061
- readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
3062
- readonly blockCreated: 17482143;
3146
+ readonly 11155111: {
3147
+ readonly address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120";
3148
+ readonly blockCreated: 4446677;
3063
3149
  };
3064
3150
  };
3151
+ readonly multicall3: {
3152
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3153
+ readonly blockCreated: 1059647;
3154
+ };
3065
3155
  readonly gasPriceOracle: {
3066
3156
  readonly address: "0x420000000000000000000000000000000000000F";
3067
3157
  };
@@ -3082,21 +3172,21 @@ declare const chains: ({
3082
3172
  };
3083
3173
  };
3084
3174
  ensTlds?: readonly string[] | undefined;
3085
- id: 8453;
3086
- name: "Base";
3175
+ id: 84532;
3176
+ name: "Base Sepolia";
3087
3177
  nativeCurrency: {
3088
- readonly name: "Ether";
3178
+ readonly name: "Sepolia Ether";
3089
3179
  readonly symbol: "ETH";
3090
3180
  readonly decimals: 18;
3091
3181
  };
3092
3182
  experimental_preconfirmationTime?: number | undefined | undefined;
3093
3183
  rpcUrls: {
3094
3184
  readonly default: {
3095
- readonly http: readonly ["https://mainnet.base.org"];
3185
+ readonly http: readonly ["https://sepolia.base.org"];
3096
3186
  };
3097
3187
  };
3098
- sourceId: 1;
3099
- testnet?: boolean | undefined | undefined;
3188
+ sourceId: 11155111;
3189
+ testnet: true;
3100
3190
  custom?: Record<string, unknown> | undefined;
3101
3191
  extendSchema?: Record<string, unknown> | undefined;
3102
3192
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -3353,33 +3443,34 @@ declare const chains: ({
3353
3443
  readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
3354
3444
  };
3355
3445
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3446
+ readonly network: "base-sepolia";
3356
3447
  } | {
3357
3448
  blockExplorers: {
3358
3449
  readonly default: {
3359
- readonly name: "Arbiscan";
3360
- readonly url: "https://arbiscan.io";
3361
- readonly apiUrl: "https://api.arbiscan.io/api";
3450
+ readonly name: "BscScan";
3451
+ readonly url: "https://bscscan.com";
3452
+ readonly apiUrl: "https://api.bscscan.com/api";
3362
3453
  };
3363
3454
  };
3364
- blockTime: 250;
3455
+ blockTime: 750;
3365
3456
  contracts: {
3366
3457
  readonly multicall3: {
3367
3458
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3368
- readonly blockCreated: 7654707;
3459
+ readonly blockCreated: 15921452;
3369
3460
  };
3370
3461
  };
3371
3462
  ensTlds?: readonly string[] | undefined;
3372
- id: 42161;
3373
- name: "Arbitrum One";
3463
+ id: 56;
3464
+ name: "BNB Smart Chain";
3374
3465
  nativeCurrency: {
3375
- readonly name: "Ether";
3376
- readonly symbol: "ETH";
3377
3466
  readonly decimals: 18;
3467
+ readonly name: "BNB";
3468
+ readonly symbol: "BNB";
3378
3469
  };
3379
3470
  experimental_preconfirmationTime?: number | undefined | undefined;
3380
3471
  rpcUrls: {
3381
3472
  readonly default: {
3382
- readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
3473
+ readonly http: readonly ["https://56.rpc.thirdweb.com"];
3383
3474
  };
3384
3475
  };
3385
3476
  sourceId?: number | undefined | undefined;
@@ -3402,30 +3493,31 @@ declare const chains: ({
3402
3493
  } | {
3403
3494
  blockExplorers: {
3404
3495
  readonly default: {
3405
- readonly name: "PolygonScan";
3406
- readonly url: "https://polygonscan.com";
3407
- readonly apiUrl: "https://api.etherscan.io/v2/api";
3496
+ readonly name: "Gnosisscan";
3497
+ readonly url: "https://gnosisscan.io";
3498
+ readonly apiUrl: "https://api.gnosisscan.io/api";
3408
3499
  };
3409
3500
  };
3410
- blockTime: 2000;
3501
+ blockTime: 5000;
3411
3502
  contracts: {
3412
3503
  readonly multicall3: {
3413
3504
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3414
- readonly blockCreated: 25770160;
3505
+ readonly blockCreated: 21022491;
3415
3506
  };
3416
3507
  };
3417
3508
  ensTlds?: readonly string[] | undefined;
3418
- id: 137;
3419
- name: "Polygon";
3509
+ id: 100;
3510
+ name: "Gnosis";
3420
3511
  nativeCurrency: {
3421
- readonly name: "POL";
3422
- readonly symbol: "POL";
3423
3512
  readonly decimals: 18;
3513
+ readonly name: "xDAI";
3514
+ readonly symbol: "XDAI";
3424
3515
  };
3425
3516
  experimental_preconfirmationTime?: number | undefined | undefined;
3426
3517
  rpcUrls: {
3427
3518
  readonly default: {
3428
- readonly http: readonly ["https://polygon.drpc.org"];
3519
+ readonly http: readonly ["https://rpc.gnosischain.com"];
3520
+ readonly webSocket: readonly ["wss://rpc.gnosischain.com/wss"];
3429
3521
  };
3430
3522
  };
3431
3523
  sourceId?: number | undefined | undefined;
@@ -3448,78 +3540,268 @@ declare const chains: ({
3448
3540
  } | {
3449
3541
  blockExplorers: {
3450
3542
  readonly default: {
3451
- readonly name: "Blockscout";
3452
- readonly url: "https://soneium.blockscout.com";
3453
- readonly apiUrl: "https://soneium.blockscout.com/api";
3543
+ readonly name: "HyperEVMScan";
3544
+ readonly url: "https://hyperevmscan.io";
3454
3545
  };
3455
3546
  };
3456
- blockTime: 2000;
3547
+ blockTime?: number | undefined | undefined;
3457
3548
  contracts: {
3458
- readonly disputeGameFactory: {
3459
- readonly 1: {
3460
- readonly address: "0x512a3d2c7a43bd9261d2b8e8c9c70d4bd4d503c0";
3461
- };
3462
- };
3463
- readonly l2OutputOracle: {
3464
- readonly 1: {
3465
- readonly address: "0x0000000000000000000000000000000000000000";
3466
- };
3467
- };
3468
- readonly portal: {
3469
- readonly 1: {
3470
- readonly address: "0x88e529a6ccd302c948689cd5156c83d4614fae92";
3471
- readonly blockCreated: 7061266;
3472
- };
3473
- };
3474
- readonly l1StandardBridge: {
3475
- readonly 1: {
3476
- readonly address: "0xeb9bf100225c214efc3e7c651ebbadcf85177607";
3477
- readonly blockCreated: 7061266;
3478
- };
3479
- };
3480
3549
  readonly multicall3: {
3481
3550
  readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
3482
- readonly blockCreated: 1;
3483
- };
3484
- readonly gasPriceOracle: {
3485
- readonly address: "0x420000000000000000000000000000000000000F";
3486
- };
3487
- readonly l1Block: {
3488
- readonly address: "0x4200000000000000000000000000000000000015";
3489
- };
3490
- readonly l2CrossDomainMessenger: {
3491
- readonly address: "0x4200000000000000000000000000000000000007";
3492
- };
3493
- readonly l2Erc721Bridge: {
3494
- readonly address: "0x4200000000000000000000000000000000000014";
3495
- };
3496
- readonly l2StandardBridge: {
3497
- readonly address: "0x4200000000000000000000000000000000000010";
3498
- };
3499
- readonly l2ToL1MessagePasser: {
3500
- readonly address: "0x4200000000000000000000000000000000000016";
3551
+ readonly blockCreated: 13051;
3501
3552
  };
3502
3553
  };
3503
3554
  ensTlds?: readonly string[] | undefined;
3504
- id: 1868;
3505
- name: "Soneium Mainnet";
3555
+ id: 999;
3556
+ name: "HyperEVM";
3506
3557
  nativeCurrency: {
3507
- readonly name: "Ether";
3508
- readonly symbol: "ETH";
3558
+ readonly name: "HYPE";
3559
+ readonly symbol: "HYPE";
3509
3560
  readonly decimals: 18;
3510
3561
  };
3511
3562
  experimental_preconfirmationTime?: number | undefined | undefined;
3512
3563
  rpcUrls: {
3513
3564
  readonly default: {
3514
- readonly http: readonly ["https://rpc.soneium.org"];
3565
+ readonly http: readonly ["https://rpc.hyperliquid.xyz/evm"];
3515
3566
  };
3516
3567
  };
3517
- sourceId: 1;
3518
- testnet?: boolean | undefined | undefined;
3568
+ sourceId?: number | undefined | undefined;
3569
+ testnet: false;
3519
3570
  custom?: Record<string, unknown> | undefined;
3520
3571
  extendSchema?: Record<string, unknown> | undefined;
3521
3572
  fees?: import("viem").ChainFees<undefined> | undefined;
3522
- formatters: {
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"];
3611
+ };
3612
+ };
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
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3620
+ client: import("viem").Client;
3621
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3622
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3623
+ client: import("viem").Client;
3624
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3625
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3626
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3627
+ }] | undefined;
3628
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3629
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3630
+ readonly network: "katana";
3631
+ } | {
3632
+ blockExplorers: {
3633
+ readonly default: {
3634
+ readonly name: "Etherscan";
3635
+ readonly url: "https://etherscan.io";
3636
+ readonly apiUrl: "https://api.etherscan.io/api";
3637
+ };
3638
+ };
3639
+ blockTime: 12000;
3640
+ contracts: {
3641
+ readonly ensUniversalResolver: {
3642
+ readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
3643
+ readonly blockCreated: 23085558;
3644
+ };
3645
+ readonly multicall3: {
3646
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3647
+ readonly blockCreated: 14353601;
3648
+ };
3649
+ };
3650
+ ensTlds?: readonly string[] | undefined;
3651
+ id: 1;
3652
+ name: "Ethereum";
3653
+ nativeCurrency: {
3654
+ readonly name: "Ether";
3655
+ readonly symbol: "ETH";
3656
+ readonly decimals: 18;
3657
+ };
3658
+ experimental_preconfirmationTime?: number | undefined | undefined;
3659
+ rpcUrls: {
3660
+ readonly default: {
3661
+ readonly http: readonly ["https://eth.merkle.io"];
3662
+ };
3663
+ };
3664
+ sourceId?: number | undefined | undefined;
3665
+ testnet?: boolean | undefined | undefined;
3666
+ custom?: Record<string, unknown> | undefined;
3667
+ extendSchema?: Record<string, unknown> | undefined;
3668
+ fees?: import("viem").ChainFees<undefined> | undefined;
3669
+ formatters?: undefined;
3670
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3671
+ client: import("viem").Client;
3672
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3673
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3674
+ client: import("viem").Client;
3675
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3676
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3677
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3678
+ }] | undefined;
3679
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3680
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3681
+ } | {
3682
+ blockExplorers: {
3683
+ 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";
3691
+ };
3692
+ };
3693
+ blockTime: 400;
3694
+ contracts: {
3695
+ readonly multicall3: {
3696
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
3697
+ readonly blockCreated: 9248132;
3698
+ };
3699
+ };
3700
+ ensTlds?: readonly string[] | undefined;
3701
+ id: 143;
3702
+ name: "Monad";
3703
+ nativeCurrency: {
3704
+ readonly name: "Monad";
3705
+ readonly symbol: "MON";
3706
+ readonly decimals: 18;
3707
+ };
3708
+ experimental_preconfirmationTime?: number | undefined | undefined;
3709
+ rpcUrls: {
3710
+ 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"];
3713
+ };
3714
+ };
3715
+ sourceId?: number | undefined | undefined;
3716
+ testnet: false;
3717
+ custom?: Record<string, unknown> | undefined;
3718
+ extendSchema?: Record<string, unknown> | undefined;
3719
+ fees?: import("viem").ChainFees<undefined> | undefined;
3720
+ formatters?: undefined;
3721
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3722
+ client: import("viem").Client;
3723
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3724
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3725
+ client: import("viem").Client;
3726
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3727
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3728
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3729
+ }] | undefined;
3730
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3731
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3732
+ } | {
3733
+ blockExplorers: {
3734
+ readonly default: {
3735
+ readonly name: "Optimism Explorer";
3736
+ readonly url: "https://optimistic.etherscan.io";
3737
+ readonly apiUrl: "https://api-optimistic.etherscan.io/api";
3738
+ };
3739
+ };
3740
+ blockTime: 2000;
3741
+ contracts: {
3742
+ readonly disputeGameFactory: {
3743
+ readonly 1: {
3744
+ readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
3745
+ };
3746
+ };
3747
+ readonly l2OutputOracle: {
3748
+ readonly 1: {
3749
+ readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
3750
+ };
3751
+ };
3752
+ readonly multicall3: {
3753
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3754
+ readonly blockCreated: 4286263;
3755
+ };
3756
+ readonly portal: {
3757
+ readonly 1: {
3758
+ readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
3759
+ };
3760
+ };
3761
+ readonly l1StandardBridge: {
3762
+ readonly 1: {
3763
+ readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
3764
+ };
3765
+ };
3766
+ readonly gasPriceOracle: {
3767
+ readonly address: "0x420000000000000000000000000000000000000F";
3768
+ };
3769
+ readonly l1Block: {
3770
+ readonly address: "0x4200000000000000000000000000000000000015";
3771
+ };
3772
+ readonly l2CrossDomainMessenger: {
3773
+ readonly address: "0x4200000000000000000000000000000000000007";
3774
+ };
3775
+ readonly l2Erc721Bridge: {
3776
+ readonly address: "0x4200000000000000000000000000000000000014";
3777
+ };
3778
+ readonly l2StandardBridge: {
3779
+ readonly address: "0x4200000000000000000000000000000000000010";
3780
+ };
3781
+ readonly l2ToL1MessagePasser: {
3782
+ readonly address: "0x4200000000000000000000000000000000000016";
3783
+ };
3784
+ };
3785
+ ensTlds?: readonly string[] | undefined;
3786
+ id: 10;
3787
+ name: "OP Mainnet";
3788
+ nativeCurrency: {
3789
+ readonly name: "Ether";
3790
+ readonly symbol: "ETH";
3791
+ readonly decimals: 18;
3792
+ };
3793
+ experimental_preconfirmationTime?: number | undefined | undefined;
3794
+ rpcUrls: {
3795
+ readonly default: {
3796
+ readonly http: readonly ["https://mainnet.optimism.io"];
3797
+ };
3798
+ };
3799
+ sourceId: 1;
3800
+ testnet?: boolean | undefined | undefined;
3801
+ custom?: Record<string, unknown> | undefined;
3802
+ extendSchema?: Record<string, unknown> | undefined;
3803
+ fees?: import("viem").ChainFees<undefined> | undefined;
3804
+ formatters: {
3523
3805
  readonly block: {
3524
3806
  exclude: [] | undefined;
3525
3807
  format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => {
@@ -3685,310 +3967,80 @@ declare const chains: ({
3685
3967
  value: bigint;
3686
3968
  yParity: number;
3687
3969
  accessList: import("viem").AccessList;
3688
- authorizationList?: undefined | undefined;
3689
- blobVersionedHashes: readonly import("viem").Hex[];
3690
- chainId: number;
3691
- type: "eip4844";
3692
- gasPrice?: undefined | undefined;
3693
- maxFeePerBlobGas: bigint;
3694
- maxFeePerGas: bigint;
3695
- maxPriorityFeePerGas: bigint;
3696
- isSystemTx?: undefined | undefined;
3697
- mint?: undefined | undefined;
3698
- sourceHash?: undefined | undefined;
3699
- } | {
3700
- blockHash: `0x${string}` | null;
3701
- blockNumber: bigint | null;
3702
- blockTimestamp?: bigint | undefined;
3703
- from: import("abitype").Address;
3704
- gas: bigint;
3705
- hash: import("viem").Hash;
3706
- input: import("viem").Hex;
3707
- nonce: number;
3708
- r: import("viem").Hex;
3709
- s: import("viem").Hex;
3710
- to: import("abitype").Address | null;
3711
- transactionIndex: number | null;
3712
- typeHex: import("viem").Hex | null;
3713
- v: bigint;
3714
- value: bigint;
3715
- yParity: number;
3716
- accessList: import("viem").AccessList;
3717
- authorizationList: import("viem").SignedAuthorizationList;
3718
- blobVersionedHashes?: undefined | undefined;
3719
- chainId: number;
3720
- type: "eip7702";
3721
- gasPrice?: undefined | undefined;
3722
- maxFeePerBlobGas?: undefined | undefined;
3723
- maxFeePerGas: bigint;
3724
- maxPriorityFeePerGas: bigint;
3725
- isSystemTx?: undefined | undefined;
3726
- mint?: undefined | undefined;
3727
- sourceHash?: undefined | undefined;
3728
- }) & {};
3729
- type: "transaction";
3730
- };
3731
- readonly transactionReceipt: {
3732
- exclude: [] | undefined;
3733
- format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
3734
- blobGasPrice?: bigint | undefined;
3735
- blobGasUsed?: bigint | undefined;
3736
- blockHash: import("viem").Hash;
3737
- blockNumber: bigint;
3738
- blockTimestamp?: bigint | undefined;
3739
- contractAddress: import("abitype").Address | null | undefined;
3740
- cumulativeGasUsed: bigint;
3741
- effectiveGasPrice: bigint;
3742
- from: import("abitype").Address;
3743
- gasUsed: bigint;
3744
- logs: import("viem").Log<bigint, number, false>[];
3745
- logsBloom: import("viem").Hex;
3746
- root?: `0x${string}` | undefined;
3747
- status: "success" | "reverted";
3748
- to: import("abitype").Address | null;
3749
- transactionHash: import("viem").Hash;
3750
- transactionIndex: number;
3751
- type: import("viem").TransactionType;
3752
- depositNonce?: bigint | undefined | undefined;
3753
- depositReceiptVersion?: number | undefined | undefined;
3754
- l1GasPrice: bigint | null;
3755
- l1GasUsed: bigint | null;
3756
- l1Fee: bigint | null;
3757
- l1FeeScalar: number | null;
3758
- } & {};
3759
- type: "transactionReceipt";
3760
- };
3761
- };
3762
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3763
- client: import("viem").Client;
3764
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3765
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3766
- client: import("viem").Client;
3767
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3768
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3769
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3770
- }] | undefined;
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
+ authorizationList?: undefined | undefined;
3971
+ blobVersionedHashes: readonly import("viem").Hex[];
3972
+ chainId: number;
3973
+ type: "eip4844";
3974
+ gasPrice?: undefined | undefined;
3975
+ maxFeePerBlobGas: bigint;
3976
+ maxFeePerGas: bigint;
3977
+ maxPriorityFeePerGas: bigint;
3978
+ isSystemTx?: undefined | undefined;
3979
+ mint?: undefined | undefined;
3980
+ sourceHash?: undefined | undefined;
3981
+ } | {
3982
+ blockHash: `0x${string}` | null;
3983
+ blockNumber: bigint | null;
3984
+ blockTimestamp?: bigint | undefined;
3985
+ from: import("abitype").Address;
3986
+ gas: bigint;
3987
+ hash: import("viem").Hash;
3988
+ input: import("viem").Hex;
3989
+ nonce: number;
3990
+ r: import("viem").Hex;
3991
+ s: import("viem").Hex;
3992
+ to: import("abitype").Address | null;
3993
+ transactionIndex: number | null;
3994
+ typeHex: import("viem").Hex | null;
3995
+ v: bigint;
3996
+ value: bigint;
3997
+ yParity: number;
3998
+ accessList: import("viem").AccessList;
3999
+ authorizationList: import("viem").SignedAuthorizationList;
4000
+ blobVersionedHashes?: undefined | undefined;
4001
+ chainId: number;
4002
+ type: "eip7702";
4003
+ gasPrice?: undefined | undefined;
4004
+ maxFeePerBlobGas?: undefined | undefined;
4005
+ maxFeePerGas: bigint;
4006
+ maxPriorityFeePerGas: bigint;
4007
+ isSystemTx?: undefined | undefined;
4008
+ mint?: undefined | undefined;
4009
+ sourceHash?: undefined | undefined;
4010
+ }) & {};
4011
+ type: "transaction";
3970
4012
  };
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"];
4013
+ readonly transactionReceipt: {
4014
+ exclude: [] | undefined;
4015
+ format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
4016
+ blobGasPrice?: bigint | undefined;
4017
+ blobGasUsed?: bigint | undefined;
4018
+ blockHash: import("viem").Hash;
4019
+ blockNumber: bigint;
4020
+ blockTimestamp?: bigint | undefined;
4021
+ contractAddress: import("abitype").Address | null | undefined;
4022
+ cumulativeGasUsed: bigint;
4023
+ effectiveGasPrice: bigint;
4024
+ from: import("abitype").Address;
4025
+ gasUsed: bigint;
4026
+ logs: import("viem").Log<bigint, number, false>[];
4027
+ logsBloom: import("viem").Hex;
4028
+ root?: `0x${string}` | undefined;
4029
+ status: "success" | "reverted";
4030
+ to: import("abitype").Address | null;
4031
+ transactionHash: import("viem").Hash;
4032
+ transactionIndex: number;
4033
+ type: import("viem").TransactionType;
4034
+ depositNonce?: bigint | undefined | undefined;
4035
+ depositReceiptVersion?: number | undefined | undefined;
4036
+ l1GasPrice: bigint | null;
4037
+ l1GasUsed: bigint | null;
4038
+ l1Fee: bigint | null;
4039
+ l1FeeScalar: number | null;
4040
+ } & {};
4041
+ type: "transactionReceipt";
3984
4042
  };
3985
4043
  };
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
4044
  prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3993
4045
  client: import("viem").Client;
3994
4046
  phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
@@ -3998,86 +4050,42 @@ declare const chains: ({
3998
4050
  }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3999
4051
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4000
4052
  }] | undefined;
4001
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
4053
+ serializers: {
4054
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
4055
+ };
4002
4056
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4003
4057
  } | {
4004
4058
  blockExplorers: {
4005
4059
  readonly default: {
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";
4060
+ readonly name: "Blockscout";
4061
+ readonly url: "https://optimism-sepolia.blockscout.com";
4062
+ readonly apiUrl: "https://optimism-sepolia.blockscout.com/api";
4013
4063
  };
4014
4064
  };
4015
- blockTime: 400;
4065
+ blockTime: 2000;
4016
4066
  contracts: {
4017
- readonly multicall3: {
4018
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
4019
- readonly blockCreated: 9248132;
4020
- };
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"];
4067
+ readonly disputeGameFactory: {
4068
+ readonly 11155111: {
4069
+ readonly address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1";
4070
+ };
4035
4071
  };
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";
4072
+ readonly l2OutputOracle: {
4073
+ readonly 11155111: {
4074
+ readonly address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F";
4075
+ };
4060
4076
  };
4061
- };
4062
- blockTime: 1000;
4063
- contracts: {
4064
4077
  readonly multicall3: {
4065
4078
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4066
- readonly blockCreated: 0;
4067
- };
4068
- readonly disputeGameFactory: {
4069
- readonly 1: {
4070
- readonly address: "0x2F12d621a16e2d3285929C9996f478508951dFe4";
4071
- };
4079
+ readonly blockCreated: 1620204;
4072
4080
  };
4073
4081
  readonly portal: {
4074
- readonly 1: {
4075
- readonly address: "0x0bd48f6B86a26D3a217d0Fa6FfE2B491B956A7a2";
4082
+ readonly 11155111: {
4083
+ readonly address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC";
4076
4084
  };
4077
4085
  };
4078
4086
  readonly l1StandardBridge: {
4079
- readonly 1: {
4080
- readonly address: "0x81014F44b0a345033bB2b3B21C7a1A308B35fEeA";
4087
+ readonly 11155111: {
4088
+ readonly address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1";
4081
4089
  };
4082
4090
  };
4083
4091
  readonly gasPriceOracle: {
@@ -4100,21 +4108,21 @@ declare const chains: ({
4100
4108
  };
4101
4109
  };
4102
4110
  ensTlds?: readonly string[] | undefined;
4103
- id: 130;
4104
- name: "Unichain";
4111
+ id: 11155420;
4112
+ name: "OP Sepolia";
4105
4113
  nativeCurrency: {
4106
- readonly name: "Ether";
4114
+ readonly name: "Sepolia Ether";
4107
4115
  readonly symbol: "ETH";
4108
4116
  readonly decimals: 18;
4109
4117
  };
4110
4118
  experimental_preconfirmationTime?: number | undefined | undefined;
4111
4119
  rpcUrls: {
4112
4120
  readonly default: {
4113
- readonly http: readonly ["https://mainnet.unichain.org/"];
4121
+ readonly http: readonly ["https://sepolia.optimism.io"];
4114
4122
  };
4115
4123
  };
4116
- sourceId: 1;
4117
- testnet?: boolean | undefined | undefined;
4124
+ sourceId: 11155111;
4125
+ testnet: true;
4118
4126
  custom?: Record<string, unknown> | undefined;
4119
4127
  extendSchema?: Record<string, unknown> | undefined;
4120
4128
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -4374,11 +4382,11 @@ declare const chains: ({
4374
4382
  } | {
4375
4383
  blockExplorers: {
4376
4384
  readonly default: {
4377
- readonly name: "katana explorer";
4378
- readonly url: "https://katanascan.com";
4385
+ readonly name: "PlasmaScan";
4386
+ readonly url: "https://plasmascan.to";
4379
4387
  };
4380
4388
  };
4381
- blockTime?: number | undefined | undefined;
4389
+ blockTime: 1000;
4382
4390
  contracts: {
4383
4391
  readonly multicall3: {
4384
4392
  readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
@@ -4386,21 +4394,21 @@ declare const chains: ({
4386
4394
  };
4387
4395
  };
4388
4396
  ensTlds?: readonly string[] | undefined;
4389
- id: 747474;
4390
- name: "Katana";
4397
+ id: 9745;
4398
+ name: "Plasma";
4391
4399
  nativeCurrency: {
4392
- readonly name: "Ether";
4393
- readonly symbol: "ETH";
4400
+ readonly name: "Plasma";
4401
+ readonly symbol: "XPL";
4394
4402
  readonly decimals: 18;
4395
4403
  };
4396
4404
  experimental_preconfirmationTime?: number | undefined | undefined;
4397
4405
  rpcUrls: {
4398
4406
  readonly default: {
4399
- readonly http: readonly ["https://rpc.katana.network"];
4407
+ readonly http: readonly ["https://rpc.plasma.to"];
4400
4408
  };
4401
4409
  };
4402
4410
  sourceId?: number | undefined | undefined;
4403
- testnet: false;
4411
+ testnet?: boolean | undefined | undefined;
4404
4412
  custom?: Record<string, unknown> | undefined;
4405
4413
  extendSchema?: Record<string, unknown> | undefined;
4406
4414
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -4416,33 +4424,78 @@ declare const chains: ({
4416
4424
  }] | undefined;
4417
4425
  serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
4418
4426
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4419
- readonly network: "katana";
4420
4427
  } | {
4421
4428
  blockExplorers: {
4422
4429
  readonly default: {
4423
- readonly name: "Blockscout";
4424
- readonly url: "https://robinhoodchain.blockscout.com";
4425
- readonly apiUrl: "https://robinhoodchain.blockscout.com/api";
4430
+ readonly name: "RouteScan";
4431
+ readonly url: "https://testnet.plasmascan.to";
4426
4432
  };
4427
4433
  };
4428
4434
  blockTime?: number | undefined | undefined;
4435
+ contracts: {
4436
+ readonly multicall3: {
4437
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
4438
+ readonly blockCreated: 0;
4439
+ };
4440
+ };
4441
+ ensTlds?: readonly string[] | undefined;
4442
+ id: 9746;
4443
+ name: "Plasma Testnet";
4444
+ nativeCurrency: {
4445
+ readonly name: "Testnet Plasma";
4446
+ readonly symbol: "XPL";
4447
+ readonly decimals: 18;
4448
+ };
4449
+ experimental_preconfirmationTime?: number | undefined | undefined;
4450
+ rpcUrls: {
4451
+ readonly default: {
4452
+ readonly http: readonly ["https://testnet-rpc.plasma.to"];
4453
+ };
4454
+ };
4455
+ sourceId?: number | undefined | undefined;
4456
+ testnet: true;
4457
+ custom?: Record<string, unknown> | undefined;
4458
+ extendSchema?: Record<string, unknown> | undefined;
4459
+ fees?: import("viem").ChainFees<undefined> | undefined;
4460
+ formatters?: undefined;
4461
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4462
+ client: import("viem").Client;
4463
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4464
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
4465
+ client: import("viem").Client;
4466
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
4467
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
4468
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
4469
+ }] | undefined;
4470
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
4471
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
4472
+ } | {
4473
+ blockExplorers: {
4474
+ readonly default: {
4475
+ readonly name: "PolygonScan";
4476
+ readonly url: "https://polygonscan.com";
4477
+ readonly apiUrl: "https://api.etherscan.io/v2/api";
4478
+ };
4479
+ };
4480
+ blockTime: 2000;
4429
4481
  contracts: {
4430
4482
  readonly multicall3: {
4431
4483
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4484
+ readonly blockCreated: 25770160;
4432
4485
  };
4433
4486
  };
4434
4487
  ensTlds?: readonly string[] | undefined;
4435
- id: 4663;
4436
- name: "Robinhood Chain";
4488
+ id: 137;
4489
+ name: "Polygon";
4437
4490
  nativeCurrency: {
4438
- readonly name: "Ether";
4439
- readonly symbol: "ETH";
4491
+ readonly name: "POL";
4492
+ readonly symbol: "POL";
4440
4493
  readonly decimals: 18;
4441
4494
  };
4442
4495
  experimental_preconfirmationTime?: number | undefined | undefined;
4443
4496
  rpcUrls: {
4444
4497
  readonly default: {
4445
- readonly http: readonly ["https://rpc.mainnet.chain.robinhood.com"];
4498
+ readonly http: readonly ["https://polygon.drpc.org"];
4446
4499
  };
4447
4500
  };
4448
4501
  sourceId?: number | undefined | undefined;
@@ -4465,30 +4518,29 @@ declare const chains: ({
4465
4518
  } | {
4466
4519
  blockExplorers: {
4467
4520
  readonly default: {
4468
- readonly name: "SnowTrace";
4469
- readonly url: "https://snowtrace.io";
4470
- readonly apiUrl: "https://api.snowtrace.io";
4521
+ readonly name: "Blockscout";
4522
+ readonly url: "https://robinhoodchain.blockscout.com";
4523
+ readonly apiUrl: "https://robinhoodchain.blockscout.com/api";
4471
4524
  };
4472
4525
  };
4473
- blockTime: 1700;
4526
+ blockTime?: number | undefined | undefined;
4474
4527
  contracts: {
4475
4528
  readonly multicall3: {
4476
4529
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4477
- readonly blockCreated: 11907934;
4478
4530
  };
4479
4531
  };
4480
4532
  ensTlds?: readonly string[] | undefined;
4481
- id: 43114;
4482
- name: "Avalanche";
4533
+ id: 4663;
4534
+ name: "Robinhood Chain";
4483
4535
  nativeCurrency: {
4536
+ readonly name: "Ether";
4537
+ readonly symbol: "ETH";
4484
4538
  readonly decimals: 18;
4485
- readonly name: "Avalanche";
4486
- readonly symbol: "AVAX";
4487
4539
  };
4488
4540
  experimental_preconfirmationTime?: number | undefined | undefined;
4489
4541
  rpcUrls: {
4490
4542
  readonly default: {
4491
- readonly http: readonly ["https://api.avax.network/ext/bc/C/rpc"];
4543
+ readonly http: readonly ["https://rpc.mainnet.chain.robinhood.com"];
4492
4544
  };
4493
4545
  };
4494
4546
  sourceId?: number | undefined | undefined;
@@ -4562,36 +4614,38 @@ declare const chains: ({
4562
4614
  blockExplorers: {
4563
4615
  readonly default: {
4564
4616
  readonly name: "Blockscout";
4565
- readonly url: "https://optimism-sepolia.blockscout.com";
4566
- readonly apiUrl: "https://optimism-sepolia.blockscout.com/api";
4617
+ readonly url: "https://soneium.blockscout.com";
4618
+ readonly apiUrl: "https://soneium.blockscout.com/api";
4567
4619
  };
4568
4620
  };
4569
4621
  blockTime: 2000;
4570
4622
  contracts: {
4571
4623
  readonly disputeGameFactory: {
4572
- readonly 11155111: {
4573
- readonly address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1";
4624
+ readonly 1: {
4625
+ readonly address: "0x512a3d2c7a43bd9261d2b8e8c9c70d4bd4d503c0";
4574
4626
  };
4575
4627
  };
4576
4628
  readonly l2OutputOracle: {
4577
- readonly 11155111: {
4578
- readonly address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F";
4629
+ readonly 1: {
4630
+ readonly address: "0x0000000000000000000000000000000000000000";
4579
4631
  };
4580
4632
  };
4581
- readonly multicall3: {
4582
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4583
- readonly blockCreated: 1620204;
4584
- };
4585
4633
  readonly portal: {
4586
- readonly 11155111: {
4587
- readonly address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC";
4634
+ readonly 1: {
4635
+ readonly address: "0x88e529a6ccd302c948689cd5156c83d4614fae92";
4636
+ readonly blockCreated: 7061266;
4588
4637
  };
4589
4638
  };
4590
4639
  readonly l1StandardBridge: {
4591
- readonly 11155111: {
4592
- readonly address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1";
4640
+ readonly 1: {
4641
+ readonly address: "0xeb9bf100225c214efc3e7c651ebbadcf85177607";
4642
+ readonly blockCreated: 7061266;
4593
4643
  };
4594
4644
  };
4645
+ readonly multicall3: {
4646
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
4647
+ readonly blockCreated: 1;
4648
+ };
4595
4649
  readonly gasPriceOracle: {
4596
4650
  readonly address: "0x420000000000000000000000000000000000000F";
4597
4651
  };
@@ -4612,21 +4666,21 @@ declare const chains: ({
4612
4666
  };
4613
4667
  };
4614
4668
  ensTlds?: readonly string[] | undefined;
4615
- id: 11155420;
4616
- name: "OP Sepolia";
4669
+ id: 1868;
4670
+ name: "Soneium Mainnet";
4617
4671
  nativeCurrency: {
4618
- readonly name: "Sepolia Ether";
4672
+ readonly name: "Ether";
4619
4673
  readonly symbol: "ETH";
4620
4674
  readonly decimals: 18;
4621
4675
  };
4622
4676
  experimental_preconfirmationTime?: number | undefined | undefined;
4623
4677
  rpcUrls: {
4624
4678
  readonly default: {
4625
- readonly http: readonly ["https://sepolia.optimism.io"];
4679
+ readonly http: readonly ["https://rpc.soneium.org"];
4626
4680
  };
4627
4681
  };
4628
- sourceId: 11155111;
4629
- testnet: true;
4682
+ sourceId: 1;
4683
+ testnet?: boolean | undefined | undefined;
4630
4684
  custom?: Record<string, unknown> | undefined;
4631
4685
  extendSchema?: Record<string, unknown> | undefined;
4632
4686
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -4886,39 +4940,77 @@ declare const chains: ({
4886
4940
  } | {
4887
4941
  blockExplorers: {
4888
4942
  readonly default: {
4889
- readonly name: "Basescan";
4890
- readonly url: "https://sepolia.basescan.org";
4891
- readonly apiUrl: "https://api-sepolia.basescan.org/api";
4943
+ readonly name: "Sonic Explorer";
4944
+ readonly url: "https://sonicscan.org";
4892
4945
  };
4893
4946
  };
4894
- blockTime: 2000;
4947
+ blockTime: 630;
4895
4948
  contracts: {
4896
- readonly disputeGameFactory: {
4897
- readonly 11155111: {
4898
- readonly address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1";
4899
- };
4949
+ readonly multicall3: {
4950
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4951
+ readonly blockCreated: 60;
4900
4952
  };
4901
- readonly l2OutputOracle: {
4902
- readonly 11155111: {
4903
- readonly address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254";
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";
4991
+ };
4992
+ };
4993
+ blockTime: 1000;
4994
+ contracts: {
4995
+ readonly multicall3: {
4996
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4997
+ readonly blockCreated: 0;
4998
+ };
4999
+ readonly disputeGameFactory: {
5000
+ readonly 1: {
5001
+ readonly address: "0x2F12d621a16e2d3285929C9996f478508951dFe4";
4904
5002
  };
4905
5003
  };
4906
5004
  readonly portal: {
4907
- readonly 11155111: {
4908
- readonly address: "0x49f53e41452c74589e85ca1677426ba426459e85";
4909
- readonly blockCreated: 4446677;
5005
+ readonly 1: {
5006
+ readonly address: "0x0bd48f6B86a26D3a217d0Fa6FfE2B491B956A7a2";
4910
5007
  };
4911
5008
  };
4912
5009
  readonly l1StandardBridge: {
4913
- readonly 11155111: {
4914
- readonly address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120";
4915
- readonly blockCreated: 4446677;
5010
+ readonly 1: {
5011
+ readonly address: "0x81014F44b0a345033bB2b3B21C7a1A308B35fEeA";
4916
5012
  };
4917
5013
  };
4918
- readonly multicall3: {
4919
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
4920
- readonly blockCreated: 1059647;
4921
- };
4922
5014
  readonly gasPriceOracle: {
4923
5015
  readonly address: "0x420000000000000000000000000000000000000F";
4924
5016
  };
@@ -4939,21 +5031,21 @@ declare const chains: ({
4939
5031
  };
4940
5032
  };
4941
5033
  ensTlds?: readonly string[] | undefined;
4942
- id: 84532;
4943
- name: "Base Sepolia";
5034
+ id: 130;
5035
+ name: "Unichain";
4944
5036
  nativeCurrency: {
4945
- readonly name: "Sepolia Ether";
5037
+ readonly name: "Ether";
4946
5038
  readonly symbol: "ETH";
4947
5039
  readonly decimals: 18;
4948
5040
  };
4949
5041
  experimental_preconfirmationTime?: number | undefined | undefined;
4950
5042
  rpcUrls: {
4951
5043
  readonly default: {
4952
- readonly http: readonly ["https://sepolia.base.org"];
5044
+ readonly http: readonly ["https://mainnet.unichain.org/"];
4953
5045
  };
4954
5046
  };
4955
- sourceId: 11155111;
4956
- testnet: true;
5047
+ sourceId: 1;
5048
+ testnet?: boolean | undefined | undefined;
4957
5049
  custom?: Record<string, unknown> | undefined;
4958
5050
  extendSchema?: Record<string, unknown> | undefined;
4959
5051
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -5210,98 +5302,6 @@ declare const chains: ({
5210
5302
  readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
5211
5303
  };
5212
5304
  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,