@rhinestone/shared-configs 1.12.0 → 1.14.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 (14) hide show
  1. package/dist/configs/chains.json +83 -1
  2. package/dist/configs/mainnets.json +6 -0
  3. package/dist/configs/oft.json +3 -0
  4. package/dist/configs/providers.json +3 -0
  5. package/dist/scripts/validation.js +1 -0
  6. package/dist/src/chains.js +87 -1
  7. package/dist/src/generated/contracts.dev.js +21 -0
  8. package/dist/src/generated/contracts.js +21 -0
  9. package/dist/src/generated/networks.d.ts +1299 -655
  10. package/dist/src/generated/networks.js +3 -1
  11. package/dist/src/generated/packageVersion.d.ts +1 -1
  12. package/dist/src/generated/packageVersion.js +1 -1
  13. package/dist/src/types.d.ts +1 -1
  14. package/package.json +1 -1
package/dist/src/generated/networks.d.ts CHANGED
@@ -558,182 +558,26 @@ declare const mainnetChains: ({
558
558
  } | {
559
559
  blockExplorers: {
560
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";
561
+ readonly name: "Blockscout";
562
+ readonly url: "https://explorer.inkonchain.com";
563
+ readonly apiUrl: "https://explorer.inkonchain.com/api/v2";
711
564
  };
712
565
  };
713
566
  blockTime: 2000;
714
567
  contracts: {
715
568
  readonly disputeGameFactory: {
716
569
  readonly 1: {
717
- readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
718
- };
719
- };
720
- readonly l2OutputOracle: {
721
- readonly 1: {
722
- readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
570
+ readonly address: "0x10d7b35078d3baabb96dd45a9143b94be65b12cd";
723
571
  };
724
572
  };
725
- readonly multicall3: {
726
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
727
- readonly blockCreated: 4286263;
728
- };
729
573
  readonly portal: {
730
574
  readonly 1: {
731
- readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
575
+ readonly address: "0x5d66c1782664115999c47c9fa5cd031f495d3e4f";
732
576
  };
733
577
  };
734
578
  readonly l1StandardBridge: {
735
579
  readonly 1: {
736
- readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
580
+ readonly address: "0x88ff1e5b602916615391f55854588efcbb7663f0";
737
581
  };
738
582
  };
739
583
  readonly gasPriceOracle: {
@@ -754,10 +598,14 @@ declare const mainnetChains: ({
754
598
  readonly l2ToL1MessagePasser: {
755
599
  readonly address: "0x4200000000000000000000000000000000000016";
756
600
  };
601
+ readonly multicall3: {
602
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
603
+ readonly blockCreated: 0;
604
+ };
757
605
  };
758
606
  ensTlds?: readonly string[] | undefined;
759
- id: 10;
760
- name: "OP Mainnet";
607
+ id: 57073;
608
+ name: "Ink";
761
609
  nativeCurrency: {
762
610
  readonly name: "Ether";
763
611
  readonly symbol: "ETH";
@@ -766,11 +614,12 @@ declare const mainnetChains: ({
766
614
  experimental_preconfirmationTime?: number | undefined | undefined;
767
615
  rpcUrls: {
768
616
  readonly default: {
769
- readonly http: readonly ["https://mainnet.optimism.io"];
617
+ readonly http: readonly ["https://rpc-gel.inkonchain.com", "https://rpc-qnd.inkonchain.com"];
618
+ readonly webSocket: readonly ["wss://rpc-gel.inkonchain.com", "wss://rpc-qnd.inkonchain.com"];
770
619
  };
771
620
  };
772
621
  sourceId: 1;
773
- testnet?: boolean | undefined | undefined;
622
+ testnet: false;
774
623
  custom?: Record<string, unknown> | undefined;
775
624
  extendSchema?: Record<string, unknown> | undefined;
776
625
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -1030,11 +879,11 @@ declare const mainnetChains: ({
1030
879
  } | {
1031
880
  blockExplorers: {
1032
881
  readonly default: {
1033
- readonly name: "PlasmaScan";
1034
- readonly url: "https://plasmascan.to";
882
+ readonly name: "katana explorer";
883
+ readonly url: "https://katanascan.com";
1035
884
  };
1036
885
  };
1037
- blockTime: 1000;
886
+ blockTime?: number | undefined | undefined;
1038
887
  contracts: {
1039
888
  readonly multicall3: {
1040
889
  readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
@@ -1042,21 +891,21 @@ declare const mainnetChains: ({
1042
891
  };
1043
892
  };
1044
893
  ensTlds?: readonly string[] | undefined;
1045
- id: 9745;
1046
- name: "Plasma";
894
+ id: 747474;
895
+ name: "Katana";
1047
896
  nativeCurrency: {
1048
- readonly name: "Plasma";
1049
- readonly symbol: "XPL";
897
+ readonly name: "Ether";
898
+ readonly symbol: "ETH";
1050
899
  readonly decimals: 18;
1051
900
  };
1052
901
  experimental_preconfirmationTime?: number | undefined | undefined;
1053
902
  rpcUrls: {
1054
903
  readonly default: {
1055
- readonly http: readonly ["https://rpc.plasma.to"];
904
+ readonly http: readonly ["https://rpc.katana.network"];
1056
905
  };
1057
906
  };
1058
907
  sourceId?: number | undefined | undefined;
1059
- testnet?: boolean | undefined | undefined;
908
+ testnet: false;
1060
909
  custom?: Record<string, unknown> | undefined;
1061
910
  extendSchema?: Record<string, unknown> | undefined;
1062
911
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -1072,33 +921,38 @@ declare const mainnetChains: ({
1072
921
  }] | undefined;
1073
922
  serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1074
923
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
924
+ readonly network: "katana";
1075
925
  } | {
1076
926
  blockExplorers: {
1077
927
  readonly default: {
1078
- readonly name: "PolygonScan";
1079
- readonly url: "https://polygonscan.com";
1080
- readonly apiUrl: "https://api.etherscan.io/v2/api";
928
+ readonly name: "Etherscan";
929
+ readonly url: "https://etherscan.io";
930
+ readonly apiUrl: "https://api.etherscan.io/api";
1081
931
  };
1082
932
  };
1083
- blockTime: 2000;
933
+ blockTime: 12000;
1084
934
  contracts: {
935
+ readonly ensUniversalResolver: {
936
+ readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
937
+ readonly blockCreated: 23085558;
938
+ };
1085
939
  readonly multicall3: {
1086
940
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1087
- readonly blockCreated: 25770160;
941
+ readonly blockCreated: 14353601;
1088
942
  };
1089
943
  };
1090
944
  ensTlds?: readonly string[] | undefined;
1091
- id: 137;
1092
- name: "Polygon";
945
+ id: 1;
946
+ name: "Ethereum";
1093
947
  nativeCurrency: {
1094
- readonly name: "POL";
1095
- readonly symbol: "POL";
948
+ readonly name: "Ether";
949
+ readonly symbol: "ETH";
1096
950
  readonly decimals: 18;
1097
951
  };
1098
952
  experimental_preconfirmationTime?: number | undefined | undefined;
1099
953
  rpcUrls: {
1100
954
  readonly default: {
1101
- readonly http: readonly ["https://polygon.drpc.org"];
955
+ readonly http: readonly ["https://eth.merkle.io"];
1102
956
  };
1103
957
  };
1104
958
  sourceId?: number | undefined | undefined;
@@ -1121,33 +975,39 @@ declare const mainnetChains: ({
1121
975
  } | {
1122
976
  blockExplorers: {
1123
977
  readonly default: {
1124
- readonly name: "Blockscout";
1125
- readonly url: "https://robinhoodchain.blockscout.com";
1126
- readonly apiUrl: "https://robinhoodchain.blockscout.com/api";
978
+ readonly name: "Monadscan";
979
+ readonly url: "https://monadscan.com";
980
+ readonly apiUrl: "https://api.etherscan.io/v2/api?chainid=143";
981
+ };
982
+ readonly monadvision: {
983
+ readonly name: "MonadVision";
984
+ readonly url: "https://monadvision.com";
1127
985
  };
1128
986
  };
1129
- blockTime?: number | undefined | undefined;
987
+ blockTime: 400;
1130
988
  contracts: {
1131
989
  readonly multicall3: {
1132
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
990
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
991
+ readonly blockCreated: 9248132;
1133
992
  };
1134
993
  };
1135
994
  ensTlds?: readonly string[] | undefined;
1136
- id: 4663;
1137
- name: "Robinhood Chain";
995
+ id: 143;
996
+ name: "Monad";
1138
997
  nativeCurrency: {
1139
- readonly name: "Ether";
1140
- readonly symbol: "ETH";
998
+ readonly name: "Monad";
999
+ readonly symbol: "MON";
1141
1000
  readonly decimals: 18;
1142
1001
  };
1143
1002
  experimental_preconfirmationTime?: number | undefined | undefined;
1144
1003
  rpcUrls: {
1145
1004
  readonly default: {
1146
- readonly http: readonly ["https://rpc.mainnet.chain.robinhood.com"];
1005
+ readonly http: readonly ["https://rpc.monad.xyz", "https://rpc1.monad.xyz"];
1006
+ readonly webSocket: readonly ["wss://rpc.monad.xyz", "wss://rpc1.monad.xyz"];
1147
1007
  };
1148
1008
  };
1149
1009
  sourceId?: number | undefined | undefined;
1150
- testnet?: boolean | undefined | undefined;
1010
+ testnet: false;
1151
1011
  custom?: Record<string, unknown> | undefined;
1152
1012
  extendSchema?: Record<string, unknown> | undefined;
1153
1013
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -1166,39 +1026,37 @@ declare const mainnetChains: ({
1166
1026
  } | {
1167
1027
  blockExplorers: {
1168
1028
  readonly default: {
1169
- readonly name: "Blockscout";
1170
- readonly url: "https://soneium.blockscout.com";
1171
- readonly apiUrl: "https://soneium.blockscout.com/api";
1029
+ readonly name: "Optimism Explorer";
1030
+ readonly url: "https://optimistic.etherscan.io";
1031
+ readonly apiUrl: "https://api-optimistic.etherscan.io/api";
1172
1032
  };
1173
1033
  };
1174
1034
  blockTime: 2000;
1175
1035
  contracts: {
1176
1036
  readonly disputeGameFactory: {
1177
1037
  readonly 1: {
1178
- readonly address: "0x512a3d2c7a43bd9261d2b8e8c9c70d4bd4d503c0";
1038
+ readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
1179
1039
  };
1180
1040
  };
1181
1041
  readonly l2OutputOracle: {
1182
1042
  readonly 1: {
1183
- readonly address: "0x0000000000000000000000000000000000000000";
1043
+ readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
1184
1044
  };
1185
1045
  };
1186
- readonly portal: {
1187
- readonly 1: {
1188
- readonly address: "0x88e529a6ccd302c948689cd5156c83d4614fae92";
1189
- readonly blockCreated: 7061266;
1046
+ readonly multicall3: {
1047
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1048
+ readonly blockCreated: 4286263;
1049
+ };
1050
+ readonly portal: {
1051
+ readonly 1: {
1052
+ readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
1190
1053
  };
1191
1054
  };
1192
1055
  readonly l1StandardBridge: {
1193
1056
  readonly 1: {
1194
- readonly address: "0xeb9bf100225c214efc3e7c651ebbadcf85177607";
1195
- readonly blockCreated: 7061266;
1057
+ readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
1196
1058
  };
1197
1059
  };
1198
- readonly multicall3: {
1199
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
1200
- readonly blockCreated: 1;
1201
- };
1202
1060
  readonly gasPriceOracle: {
1203
1061
  readonly address: "0x420000000000000000000000000000000000000F";
1204
1062
  };
@@ -1219,8 +1077,8 @@ declare const mainnetChains: ({
1219
1077
  };
1220
1078
  };
1221
1079
  ensTlds?: readonly string[] | undefined;
1222
- id: 1868;
1223
- name: "Soneium Mainnet";
1080
+ id: 10;
1081
+ name: "OP Mainnet";
1224
1082
  nativeCurrency: {
1225
1083
  readonly name: "Ether";
1226
1084
  readonly symbol: "ETH";
@@ -1229,7 +1087,7 @@ declare const mainnetChains: ({
1229
1087
  experimental_preconfirmationTime?: number | undefined | undefined;
1230
1088
  rpcUrls: {
1231
1089
  readonly default: {
1232
- readonly http: readonly ["https://rpc.soneium.org"];
1090
+ readonly http: readonly ["https://mainnet.optimism.io"];
1233
1091
  };
1234
1092
  };
1235
1093
  sourceId: 1;
@@ -1493,33 +1351,79 @@ declare const mainnetChains: ({
1493
1351
  } | {
1494
1352
  blockExplorers: {
1495
1353
  readonly default: {
1496
- readonly name: "Sonic Explorer";
1497
- readonly url: "https://sonicscan.org";
1354
+ readonly name: "PlasmaScan";
1355
+ readonly url: "https://plasmascan.to";
1498
1356
  };
1499
1357
  };
1500
- blockTime: 630;
1358
+ blockTime: 1000;
1359
+ contracts: {
1360
+ readonly multicall3: {
1361
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
1362
+ readonly blockCreated: 0;
1363
+ };
1364
+ };
1365
+ ensTlds?: readonly string[] | undefined;
1366
+ id: 9745;
1367
+ name: "Plasma";
1368
+ nativeCurrency: {
1369
+ readonly name: "Plasma";
1370
+ readonly symbol: "XPL";
1371
+ readonly decimals: 18;
1372
+ };
1373
+ experimental_preconfirmationTime?: number | undefined | undefined;
1374
+ rpcUrls: {
1375
+ readonly default: {
1376
+ readonly http: readonly ["https://rpc.plasma.to"];
1377
+ };
1378
+ };
1379
+ sourceId?: number | undefined | undefined;
1380
+ testnet?: boolean | undefined | undefined;
1381
+ custom?: Record<string, unknown> | undefined;
1382
+ extendSchema?: Record<string, unknown> | undefined;
1383
+ fees?: import("viem").ChainFees<undefined> | undefined;
1384
+ formatters?: undefined;
1385
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1386
+ client: import("viem").Client;
1387
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1388
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1389
+ client: import("viem").Client;
1390
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1391
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
1392
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1393
+ }] | undefined;
1394
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1395
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1396
+ } | {
1397
+ blockExplorers: {
1398
+ readonly default: {
1399
+ readonly name: "PolygonScan";
1400
+ readonly url: "https://polygonscan.com";
1401
+ readonly apiUrl: "https://api.etherscan.io/v2/api";
1402
+ };
1403
+ };
1404
+ blockTime: 2000;
1501
1405
  contracts: {
1502
1406
  readonly multicall3: {
1503
1407
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1504
- readonly blockCreated: 60;
1408
+ readonly blockCreated: 25770160;
1505
1409
  };
1506
1410
  };
1507
1411
  ensTlds?: readonly string[] | undefined;
1508
- id: 146;
1509
- name: "Sonic";
1412
+ id: 137;
1413
+ name: "Polygon";
1510
1414
  nativeCurrency: {
1415
+ readonly name: "POL";
1416
+ readonly symbol: "POL";
1511
1417
  readonly decimals: 18;
1512
- readonly name: "Sonic";
1513
- readonly symbol: "S";
1514
1418
  };
1515
1419
  experimental_preconfirmationTime?: number | undefined | undefined;
1516
1420
  rpcUrls: {
1517
1421
  readonly default: {
1518
- readonly http: readonly ["https://rpc.soniclabs.com"];
1422
+ readonly http: readonly ["https://polygon.drpc.org"];
1519
1423
  };
1520
1424
  };
1521
1425
  sourceId?: number | undefined | undefined;
1522
- testnet: false;
1426
+ testnet?: boolean | undefined | undefined;
1523
1427
  custom?: Record<string, unknown> | undefined;
1524
1428
  extendSchema?: Record<string, unknown> | undefined;
1525
1429
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -1538,32 +1442,84 @@ declare const mainnetChains: ({
1538
1442
  } | {
1539
1443
  blockExplorers: {
1540
1444
  readonly default: {
1541
- readonly name: "Uniscan";
1542
- readonly url: "https://uniscan.xyz";
1543
- readonly apiUrl: "https://api.uniscan.xyz/api";
1445
+ readonly name: "Blockscout";
1446
+ readonly url: "https://robinhoodchain.blockscout.com";
1447
+ readonly apiUrl: "https://robinhoodchain.blockscout.com/api";
1544
1448
  };
1545
1449
  };
1546
- blockTime: 1000;
1450
+ blockTime?: number | undefined | undefined;
1547
1451
  contracts: {
1548
1452
  readonly multicall3: {
1549
1453
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1550
- readonly blockCreated: 0;
1551
1454
  };
1455
+ };
1456
+ ensTlds?: readonly string[] | undefined;
1457
+ id: 4663;
1458
+ name: "Robinhood Chain";
1459
+ nativeCurrency: {
1460
+ readonly name: "Ether";
1461
+ readonly symbol: "ETH";
1462
+ readonly decimals: 18;
1463
+ };
1464
+ experimental_preconfirmationTime?: number | undefined | undefined;
1465
+ rpcUrls: {
1466
+ readonly default: {
1467
+ readonly http: readonly ["https://rpc.mainnet.chain.robinhood.com"];
1468
+ };
1469
+ };
1470
+ sourceId?: number | undefined | undefined;
1471
+ testnet?: boolean | undefined | undefined;
1472
+ custom?: Record<string, unknown> | undefined;
1473
+ extendSchema?: Record<string, unknown> | undefined;
1474
+ fees?: import("viem").ChainFees<undefined> | undefined;
1475
+ formatters?: undefined;
1476
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1477
+ client: import("viem").Client;
1478
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1479
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
1480
+ client: import("viem").Client;
1481
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
1482
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
1483
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
1484
+ }] | undefined;
1485
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
1486
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1487
+ } | {
1488
+ blockExplorers: {
1489
+ readonly default: {
1490
+ readonly name: "Blockscout";
1491
+ readonly url: "https://soneium.blockscout.com";
1492
+ readonly apiUrl: "https://soneium.blockscout.com/api";
1493
+ };
1494
+ };
1495
+ blockTime: 2000;
1496
+ contracts: {
1552
1497
  readonly disputeGameFactory: {
1553
1498
  readonly 1: {
1554
- readonly address: "0x2F12d621a16e2d3285929C9996f478508951dFe4";
1499
+ readonly address: "0x512a3d2c7a43bd9261d2b8e8c9c70d4bd4d503c0";
1500
+ };
1501
+ };
1502
+ readonly l2OutputOracle: {
1503
+ readonly 1: {
1504
+ readonly address: "0x0000000000000000000000000000000000000000";
1555
1505
  };
1556
1506
  };
1557
1507
  readonly portal: {
1558
1508
  readonly 1: {
1559
- readonly address: "0x0bd48f6B86a26D3a217d0Fa6FfE2B491B956A7a2";
1509
+ readonly address: "0x88e529a6ccd302c948689cd5156c83d4614fae92";
1510
+ readonly blockCreated: 7061266;
1560
1511
  };
1561
1512
  };
1562
1513
  readonly l1StandardBridge: {
1563
1514
  readonly 1: {
1564
- readonly address: "0x81014F44b0a345033bB2b3B21C7a1A308B35fEeA";
1515
+ readonly address: "0xeb9bf100225c214efc3e7c651ebbadcf85177607";
1516
+ readonly blockCreated: 7061266;
1565
1517
  };
1566
1518
  };
1519
+ readonly multicall3: {
1520
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
1521
+ readonly blockCreated: 1;
1522
+ };
1567
1523
  readonly gasPriceOracle: {
1568
1524
  readonly address: "0x420000000000000000000000000000000000000F";
1569
1525
  };
@@ -1584,8 +1540,8 @@ declare const mainnetChains: ({
1584
1540
  };
1585
1541
  };
1586
1542
  ensTlds?: readonly string[] | undefined;
1587
- id: 130;
1588
- name: "Unichain";
1543
+ id: 1868;
1544
+ name: "Soneium Mainnet";
1589
1545
  nativeCurrency: {
1590
1546
  readonly name: "Ether";
1591
1547
  readonly symbol: "ETH";
@@ -1594,7 +1550,7 @@ declare const mainnetChains: ({
1594
1550
  experimental_preconfirmationTime?: number | undefined | undefined;
1595
1551
  rpcUrls: {
1596
1552
  readonly default: {
1597
- readonly http: readonly ["https://mainnet.unichain.org/"];
1553
+ readonly http: readonly ["https://rpc.soneium.org"];
1598
1554
  };
1599
1555
  };
1600
1556
  sourceId: 1;
@@ -1855,38 +1811,36 @@ declare const mainnetChains: ({
1855
1811
  readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
1856
1812
  };
1857
1813
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
1858
- })[];
1859
- declare const testnetChains: ({
1814
+ } | {
1860
1815
  blockExplorers: {
1861
1816
  readonly default: {
1862
- readonly name: "Arbiscan";
1863
- readonly url: "https://sepolia.arbiscan.io";
1864
- readonly apiUrl: "https://api-sepolia.arbiscan.io/api";
1817
+ readonly name: "Sonic Explorer";
1818
+ readonly url: "https://sonicscan.org";
1865
1819
  };
1866
1820
  };
1867
- blockTime: 250;
1821
+ blockTime: 630;
1868
1822
  contracts: {
1869
1823
  readonly multicall3: {
1870
1824
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1871
- readonly blockCreated: 81930;
1825
+ readonly blockCreated: 60;
1872
1826
  };
1873
1827
  };
1874
1828
  ensTlds?: readonly string[] | undefined;
1875
- id: 421614;
1876
- name: "Arbitrum Sepolia";
1829
+ id: 146;
1830
+ name: "Sonic";
1877
1831
  nativeCurrency: {
1878
- readonly name: "Arbitrum Sepolia Ether";
1879
- readonly symbol: "ETH";
1880
1832
  readonly decimals: 18;
1833
+ readonly name: "Sonic";
1834
+ readonly symbol: "S";
1881
1835
  };
1882
1836
  experimental_preconfirmationTime?: number | undefined | undefined;
1883
1837
  rpcUrls: {
1884
1838
  readonly default: {
1885
- readonly http: readonly ["https://sepolia-rollup.arbitrum.io/rpc"];
1839
+ readonly http: readonly ["https://rpc.soniclabs.com"];
1886
1840
  };
1887
1841
  };
1888
1842
  sourceId?: number | undefined | undefined;
1889
- testnet: true;
1843
+ testnet: false;
1890
1844
  custom?: Record<string, unknown> | undefined;
1891
1845
  extendSchema?: Record<string, unknown> | undefined;
1892
1846
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -1905,39 +1859,32 @@ declare const testnetChains: ({
1905
1859
  } | {
1906
1860
  blockExplorers: {
1907
1861
  readonly default: {
1908
- readonly name: "Basescan";
1909
- readonly url: "https://sepolia.basescan.org";
1910
- readonly apiUrl: "https://api-sepolia.basescan.org/api";
1862
+ readonly name: "Uniscan";
1863
+ readonly url: "https://uniscan.xyz";
1864
+ readonly apiUrl: "https://api.uniscan.xyz/api";
1911
1865
  };
1912
1866
  };
1913
- blockTime: 2000;
1867
+ blockTime: 1000;
1914
1868
  contracts: {
1915
- readonly disputeGameFactory: {
1916
- readonly 11155111: {
1917
- readonly address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1";
1918
- };
1869
+ readonly multicall3: {
1870
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1871
+ readonly blockCreated: 0;
1919
1872
  };
1920
- readonly l2OutputOracle: {
1921
- readonly 11155111: {
1922
- readonly address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254";
1873
+ readonly disputeGameFactory: {
1874
+ readonly 1: {
1875
+ readonly address: "0x2F12d621a16e2d3285929C9996f478508951dFe4";
1923
1876
  };
1924
1877
  };
1925
1878
  readonly portal: {
1926
- readonly 11155111: {
1927
- readonly address: "0x49f53e41452c74589e85ca1677426ba426459e85";
1928
- readonly blockCreated: 4446677;
1879
+ readonly 1: {
1880
+ readonly address: "0x0bd48f6B86a26D3a217d0Fa6FfE2B491B956A7a2";
1929
1881
  };
1930
1882
  };
1931
1883
  readonly l1StandardBridge: {
1932
- readonly 11155111: {
1933
- readonly address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120";
1934
- readonly blockCreated: 4446677;
1884
+ readonly 1: {
1885
+ readonly address: "0x81014F44b0a345033bB2b3B21C7a1A308B35fEeA";
1935
1886
  };
1936
1887
  };
1937
- readonly multicall3: {
1938
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
1939
- readonly blockCreated: 1059647;
1940
- };
1941
1888
  readonly gasPriceOracle: {
1942
1889
  readonly address: "0x420000000000000000000000000000000000000F";
1943
1890
  };
@@ -1958,21 +1905,21 @@ declare const testnetChains: ({
1958
1905
  };
1959
1906
  };
1960
1907
  ensTlds?: readonly string[] | undefined;
1961
- id: 84532;
1962
- name: "Base Sepolia";
1908
+ id: 130;
1909
+ name: "Unichain";
1963
1910
  nativeCurrency: {
1964
- readonly name: "Sepolia Ether";
1911
+ readonly name: "Ether";
1965
1912
  readonly symbol: "ETH";
1966
1913
  readonly decimals: 18;
1967
1914
  };
1968
1915
  experimental_preconfirmationTime?: number | undefined | undefined;
1969
1916
  rpcUrls: {
1970
1917
  readonly default: {
1971
- readonly http: readonly ["https://sepolia.base.org"];
1918
+ readonly http: readonly ["https://mainnet.unichain.org/"];
1972
1919
  };
1973
1920
  };
1974
- sourceId: 11155111;
1975
- testnet: true;
1921
+ sourceId: 1;
1922
+ testnet?: boolean | undefined | undefined;
1976
1923
  custom?: Record<string, unknown> | undefined;
1977
1924
  extendSchema?: Record<string, unknown> | undefined;
1978
1925
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -2229,41 +2176,89 @@ declare const testnetChains: ({
2229
2176
  readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
2230
2177
  };
2231
2178
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2232
- readonly network: "base-sepolia";
2233
- } | {
2179
+ })[];
2180
+ declare const testnetChains: ({
2234
2181
  blockExplorers: {
2235
2182
  readonly default: {
2236
- readonly name: "Blockscout";
2237
- readonly url: "https://optimism-sepolia.blockscout.com";
2238
- readonly apiUrl: "https://optimism-sepolia.blockscout.com/api";
2183
+ readonly name: "Arbiscan";
2184
+ readonly url: "https://sepolia.arbiscan.io";
2185
+ readonly apiUrl: "https://api-sepolia.arbiscan.io/api";
2239
2186
  };
2240
2187
  };
2241
- blockTime: 2000;
2188
+ blockTime: 250;
2242
2189
  contracts: {
2243
- readonly disputeGameFactory: {
2244
- readonly 11155111: {
2245
- readonly address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1";
2246
- };
2247
- };
2248
- readonly l2OutputOracle: {
2249
- readonly 11155111: {
2250
- readonly address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F";
2251
- };
2252
- };
2253
2190
  readonly multicall3: {
2254
2191
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2255
- readonly blockCreated: 1620204;
2192
+ readonly blockCreated: 81930;
2193
+ };
2194
+ };
2195
+ ensTlds?: readonly string[] | undefined;
2196
+ id: 421614;
2197
+ name: "Arbitrum Sepolia";
2198
+ nativeCurrency: {
2199
+ readonly name: "Arbitrum Sepolia Ether";
2200
+ readonly symbol: "ETH";
2201
+ readonly decimals: 18;
2202
+ };
2203
+ experimental_preconfirmationTime?: number | undefined | undefined;
2204
+ rpcUrls: {
2205
+ readonly default: {
2206
+ readonly http: readonly ["https://sepolia-rollup.arbitrum.io/rpc"];
2207
+ };
2208
+ };
2209
+ sourceId?: number | undefined | undefined;
2210
+ testnet: true;
2211
+ custom?: Record<string, unknown> | undefined;
2212
+ extendSchema?: Record<string, unknown> | undefined;
2213
+ fees?: import("viem").ChainFees<undefined> | undefined;
2214
+ formatters?: undefined;
2215
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2216
+ client: import("viem").Client;
2217
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2218
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2219
+ client: import("viem").Client;
2220
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2221
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2222
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2223
+ }] | undefined;
2224
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2225
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2226
+ } | {
2227
+ blockExplorers: {
2228
+ readonly default: {
2229
+ readonly name: "Basescan";
2230
+ readonly url: "https://sepolia.basescan.org";
2231
+ readonly apiUrl: "https://api-sepolia.basescan.org/api";
2232
+ };
2233
+ };
2234
+ blockTime: 2000;
2235
+ contracts: {
2236
+ readonly disputeGameFactory: {
2237
+ readonly 11155111: {
2238
+ readonly address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1";
2239
+ };
2240
+ };
2241
+ readonly l2OutputOracle: {
2242
+ readonly 11155111: {
2243
+ readonly address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254";
2244
+ };
2256
2245
  };
2257
2246
  readonly portal: {
2258
2247
  readonly 11155111: {
2259
- readonly address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC";
2248
+ readonly address: "0x49f53e41452c74589e85ca1677426ba426459e85";
2249
+ readonly blockCreated: 4446677;
2260
2250
  };
2261
2251
  };
2262
2252
  readonly l1StandardBridge: {
2263
2253
  readonly 11155111: {
2264
- readonly address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1";
2254
+ readonly address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120";
2255
+ readonly blockCreated: 4446677;
2265
2256
  };
2266
2257
  };
2258
+ readonly multicall3: {
2259
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2260
+ readonly blockCreated: 1059647;
2261
+ };
2267
2262
  readonly gasPriceOracle: {
2268
2263
  readonly address: "0x420000000000000000000000000000000000000F";
2269
2264
  };
@@ -2284,8 +2279,8 @@ declare const testnetChains: ({
2284
2279
  };
2285
2280
  };
2286
2281
  ensTlds?: readonly string[] | undefined;
2287
- id: 11155420;
2288
- name: "OP Sepolia";
2282
+ id: 84532;
2283
+ name: "Base Sepolia";
2289
2284
  nativeCurrency: {
2290
2285
  readonly name: "Sepolia Ether";
2291
2286
  readonly symbol: "ETH";
@@ -2294,7 +2289,7 @@ declare const testnetChains: ({
2294
2289
  experimental_preconfirmationTime?: number | undefined | undefined;
2295
2290
  rpcUrls: {
2296
2291
  readonly default: {
2297
- readonly http: readonly ["https://sepolia.optimism.io"];
2292
+ readonly http: readonly ["https://sepolia.base.org"];
2298
2293
  };
2299
2294
  };
2300
2295
  sourceId: 11155111;
@@ -2555,187 +2550,513 @@ declare const testnetChains: ({
2555
2550
  readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
2556
2551
  };
2557
2552
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2553
+ readonly network: "base-sepolia";
2558
2554
  } | {
2559
2555
  blockExplorers: {
2560
2556
  readonly default: {
2561
- readonly name: "RouteScan";
2562
- readonly url: "https://testnet.plasmascan.to";
2557
+ readonly name: "Blockscout";
2558
+ readonly url: "https://optimism-sepolia.blockscout.com";
2559
+ readonly apiUrl: "https://optimism-sepolia.blockscout.com/api";
2563
2560
  };
2564
2561
  };
2565
- blockTime?: number | undefined | undefined;
2562
+ blockTime: 2000;
2566
2563
  contracts: {
2567
- readonly multicall3: {
2568
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
2569
- readonly blockCreated: 0;
2570
- };
2571
- };
2572
- ensTlds?: readonly string[] | undefined;
2573
- id: 9746;
2574
- name: "Plasma Testnet";
2575
- nativeCurrency: {
2576
- readonly name: "Testnet Plasma";
2577
- readonly symbol: "XPL";
2578
- readonly decimals: 18;
2579
- };
2580
- experimental_preconfirmationTime?: number | undefined | undefined;
2581
- rpcUrls: {
2582
- readonly default: {
2583
- readonly http: readonly ["https://testnet-rpc.plasma.to"];
2564
+ readonly disputeGameFactory: {
2565
+ readonly 11155111: {
2566
+ readonly address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1";
2567
+ };
2584
2568
  };
2585
- };
2586
- sourceId?: number | undefined | undefined;
2587
- testnet: true;
2588
- custom?: Record<string, unknown> | undefined;
2589
- extendSchema?: Record<string, unknown> | undefined;
2590
- fees?: import("viem").ChainFees<undefined> | undefined;
2591
- formatters?: undefined;
2592
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2593
- client: import("viem").Client;
2594
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2595
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2596
- client: import("viem").Client;
2597
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2598
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2599
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2600
- }] | undefined;
2601
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2602
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2603
- } | {
2604
- blockExplorers: {
2605
- readonly default: {
2606
- readonly name: "Etherscan";
2607
- readonly url: "https://sepolia.etherscan.io";
2608
- readonly apiUrl: "https://api-sepolia.etherscan.io/api";
2569
+ readonly l2OutputOracle: {
2570
+ readonly 11155111: {
2571
+ readonly address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F";
2572
+ };
2609
2573
  };
2610
- };
2611
- blockTime?: number | undefined | undefined;
2612
- contracts: {
2613
2574
  readonly multicall3: {
2614
2575
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2615
- readonly blockCreated: 751532;
2576
+ readonly blockCreated: 1620204;
2616
2577
  };
2617
- readonly ensUniversalResolver: {
2618
- readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
2619
- readonly blockCreated: 8928790;
2578
+ readonly portal: {
2579
+ readonly 11155111: {
2580
+ readonly address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC";
2581
+ };
2620
2582
  };
2621
- };
2622
- ensTlds?: readonly string[] | undefined;
2623
- id: 11155111;
2624
- name: "Sepolia";
2625
- nativeCurrency: {
2626
- readonly name: "Sepolia Ether";
2627
- readonly symbol: "ETH";
2628
- readonly decimals: 18;
2629
- };
2630
- experimental_preconfirmationTime?: number | undefined | undefined;
2631
- rpcUrls: {
2632
- readonly default: {
2633
- readonly http: readonly ["https://11155111.rpc.thirdweb.com"];
2583
+ readonly l1StandardBridge: {
2584
+ readonly 11155111: {
2585
+ readonly address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1";
2586
+ };
2634
2587
  };
2635
- };
2636
- sourceId?: number | undefined | undefined;
2637
- testnet: true;
2638
- custom?: Record<string, unknown> | undefined;
2639
- extendSchema?: Record<string, unknown> | undefined;
2640
- fees?: import("viem").ChainFees<undefined> | undefined;
2641
- formatters?: undefined;
2642
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2643
- client: import("viem").Client;
2644
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2645
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2646
- client: import("viem").Client;
2647
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2648
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2649
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2650
- }] | undefined;
2651
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2652
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2653
- })[];
2654
- declare const chains: ({
2655
- blockExplorers: {
2656
- readonly default: {
2657
- readonly name: "Arbiscan";
2658
- readonly url: "https://arbiscan.io";
2659
- readonly apiUrl: "https://api.arbiscan.io/api";
2588
+ readonly gasPriceOracle: {
2589
+ readonly address: "0x420000000000000000000000000000000000000F";
2660
2590
  };
2661
- };
2662
- blockTime: 250;
2663
- contracts: {
2664
- readonly multicall3: {
2665
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2666
- readonly blockCreated: 7654707;
2591
+ readonly l1Block: {
2592
+ readonly address: "0x4200000000000000000000000000000000000015";
2667
2593
  };
2668
- };
2669
- ensTlds?: readonly string[] | undefined;
2670
- id: 42161;
2671
- name: "Arbitrum One";
2672
- nativeCurrency: {
2673
- readonly name: "Ether";
2674
- readonly symbol: "ETH";
2675
- readonly decimals: 18;
2676
- };
2677
- experimental_preconfirmationTime?: number | undefined | undefined;
2678
- rpcUrls: {
2679
- readonly default: {
2680
- readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
2594
+ readonly l2CrossDomainMessenger: {
2595
+ readonly address: "0x4200000000000000000000000000000000000007";
2681
2596
  };
2682
- };
2683
- sourceId?: number | undefined | undefined;
2684
- testnet?: boolean | undefined | undefined;
2685
- custom?: Record<string, unknown> | undefined;
2686
- extendSchema?: Record<string, unknown> | undefined;
2687
- fees?: import("viem").ChainFees<undefined> | undefined;
2688
- formatters?: undefined;
2689
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2690
- client: import("viem").Client;
2691
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2692
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2693
- client: import("viem").Client;
2694
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2695
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2696
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2697
- }] | undefined;
2698
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2699
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2700
- } | {
2701
- blockExplorers: {
2702
- readonly default: {
2703
- readonly name: "Arbiscan";
2704
- readonly url: "https://sepolia.arbiscan.io";
2705
- readonly apiUrl: "https://api-sepolia.arbiscan.io/api";
2597
+ readonly l2Erc721Bridge: {
2598
+ readonly address: "0x4200000000000000000000000000000000000014";
2706
2599
  };
2707
- };
2708
- blockTime: 250;
2709
- contracts: {
2710
- readonly multicall3: {
2711
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2712
- readonly blockCreated: 81930;
2600
+ readonly l2StandardBridge: {
2601
+ readonly address: "0x4200000000000000000000000000000000000010";
2602
+ };
2603
+ readonly l2ToL1MessagePasser: {
2604
+ readonly address: "0x4200000000000000000000000000000000000016";
2713
2605
  };
2714
2606
  };
2715
2607
  ensTlds?: readonly string[] | undefined;
2716
- id: 421614;
2717
- name: "Arbitrum Sepolia";
2608
+ id: 11155420;
2609
+ name: "OP Sepolia";
2718
2610
  nativeCurrency: {
2719
- readonly name: "Arbitrum Sepolia Ether";
2611
+ readonly name: "Sepolia Ether";
2720
2612
  readonly symbol: "ETH";
2721
2613
  readonly decimals: 18;
2722
2614
  };
2723
2615
  experimental_preconfirmationTime?: number | undefined | undefined;
2724
2616
  rpcUrls: {
2725
2617
  readonly default: {
2726
- readonly http: readonly ["https://sepolia-rollup.arbitrum.io/rpc"];
2618
+ readonly http: readonly ["https://sepolia.optimism.io"];
2727
2619
  };
2728
2620
  };
2729
- sourceId?: number | undefined | undefined;
2621
+ sourceId: 11155111;
2730
2622
  testnet: true;
2731
2623
  custom?: Record<string, unknown> | undefined;
2732
2624
  extendSchema?: Record<string, unknown> | undefined;
2733
2625
  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: {
2626
+ formatters: {
2627
+ readonly block: {
2628
+ exclude: [] | undefined;
2629
+ format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => {
2630
+ baseFeePerGas: bigint | null;
2631
+ blobGasUsed: bigint;
2632
+ difficulty: bigint;
2633
+ excessBlobGas: bigint;
2634
+ extraData: import("viem").Hex;
2635
+ gasLimit: bigint;
2636
+ gasUsed: bigint;
2637
+ hash: `0x${string}` | null;
2638
+ logsBloom: `0x${string}` | null;
2639
+ miner: import("abitype").Address;
2640
+ mixHash: import("viem").Hash;
2641
+ nonce: `0x${string}` | null;
2642
+ number: bigint | null;
2643
+ parentBeaconBlockRoot?: `0x${string}` | undefined;
2644
+ parentHash: import("viem").Hash;
2645
+ receiptsRoot: import("viem").Hex;
2646
+ sealFields: import("viem").Hex[];
2647
+ sha3Uncles: import("viem").Hash;
2648
+ size: bigint;
2649
+ stateRoot: import("viem").Hash;
2650
+ timestamp: bigint;
2651
+ totalDifficulty: bigint | null;
2652
+ transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
2653
+ transactionsRoot: import("viem").Hash;
2654
+ uncles: import("viem").Hash[];
2655
+ withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
2656
+ withdrawalsRoot?: `0x${string}` | undefined;
2657
+ } & {};
2658
+ type: "block";
2659
+ };
2660
+ readonly transaction: {
2661
+ exclude: [] | undefined;
2662
+ format: (args: import("viem/chains").OpStackRpcTransaction, action?: string | undefined) => ({
2663
+ blockHash: `0x${string}` | null;
2664
+ blockNumber: bigint | null;
2665
+ blockTimestamp?: bigint | undefined;
2666
+ from: import("abitype").Address;
2667
+ gas: bigint;
2668
+ hash: import("viem").Hash;
2669
+ input: import("viem").Hex;
2670
+ nonce: number;
2671
+ r: import("viem").Hex;
2672
+ s: import("viem").Hex;
2673
+ to: import("abitype").Address | null;
2674
+ transactionIndex: number | null;
2675
+ typeHex: import("viem").Hex | null;
2676
+ v: bigint;
2677
+ value: bigint;
2678
+ yParity: number;
2679
+ gasPrice?: undefined | undefined;
2680
+ maxFeePerBlobGas?: undefined | undefined;
2681
+ maxFeePerGas: bigint;
2682
+ maxPriorityFeePerGas: bigint;
2683
+ isSystemTx?: boolean;
2684
+ mint?: bigint | undefined | undefined;
2685
+ sourceHash: import("viem").Hex;
2686
+ type: "deposit";
2687
+ } | {
2688
+ r: import("viem").Hex;
2689
+ s: import("viem").Hex;
2690
+ v: bigint;
2691
+ to: import("abitype").Address | null;
2692
+ from: import("abitype").Address;
2693
+ gas: bigint;
2694
+ nonce: number;
2695
+ value: bigint;
2696
+ blockHash: `0x${string}` | null;
2697
+ blockNumber: bigint | null;
2698
+ blockTimestamp?: bigint | undefined;
2699
+ hash: import("viem").Hash;
2700
+ input: import("viem").Hex;
2701
+ transactionIndex: number | null;
2702
+ typeHex: import("viem").Hex | null;
2703
+ accessList?: undefined | undefined;
2704
+ authorizationList?: undefined | undefined;
2705
+ blobVersionedHashes?: undefined | undefined;
2706
+ chainId?: number | undefined;
2707
+ yParity?: undefined | undefined;
2708
+ type: "legacy";
2709
+ gasPrice: bigint;
2710
+ maxFeePerBlobGas?: undefined | undefined;
2711
+ maxFeePerGas?: undefined | undefined;
2712
+ maxPriorityFeePerGas?: undefined | undefined;
2713
+ isSystemTx?: undefined | undefined;
2714
+ mint?: undefined | undefined;
2715
+ sourceHash?: undefined | undefined;
2716
+ } | {
2717
+ blockHash: `0x${string}` | null;
2718
+ blockNumber: bigint | null;
2719
+ blockTimestamp?: bigint | undefined;
2720
+ from: import("abitype").Address;
2721
+ gas: bigint;
2722
+ hash: import("viem").Hash;
2723
+ input: import("viem").Hex;
2724
+ nonce: number;
2725
+ r: import("viem").Hex;
2726
+ s: import("viem").Hex;
2727
+ to: import("abitype").Address | null;
2728
+ transactionIndex: number | null;
2729
+ typeHex: import("viem").Hex | null;
2730
+ v: bigint;
2731
+ value: bigint;
2732
+ yParity: number;
2733
+ accessList: import("viem").AccessList;
2734
+ authorizationList?: undefined | undefined;
2735
+ blobVersionedHashes?: undefined | undefined;
2736
+ chainId: number;
2737
+ type: "eip2930";
2738
+ gasPrice: bigint;
2739
+ maxFeePerBlobGas?: undefined | undefined;
2740
+ maxFeePerGas?: undefined | undefined;
2741
+ maxPriorityFeePerGas?: undefined | undefined;
2742
+ isSystemTx?: undefined | undefined;
2743
+ mint?: undefined | undefined;
2744
+ sourceHash?: undefined | undefined;
2745
+ } | {
2746
+ blockHash: `0x${string}` | null;
2747
+ blockNumber: bigint | null;
2748
+ blockTimestamp?: bigint | undefined;
2749
+ from: import("abitype").Address;
2750
+ gas: bigint;
2751
+ hash: import("viem").Hash;
2752
+ input: import("viem").Hex;
2753
+ nonce: number;
2754
+ r: import("viem").Hex;
2755
+ s: import("viem").Hex;
2756
+ to: import("abitype").Address | null;
2757
+ transactionIndex: number | null;
2758
+ typeHex: import("viem").Hex | null;
2759
+ v: bigint;
2760
+ value: bigint;
2761
+ yParity: number;
2762
+ accessList: import("viem").AccessList;
2763
+ authorizationList?: undefined | undefined;
2764
+ blobVersionedHashes?: undefined | undefined;
2765
+ chainId: number;
2766
+ type: "eip1559";
2767
+ gasPrice?: undefined | undefined;
2768
+ maxFeePerBlobGas?: undefined | undefined;
2769
+ maxFeePerGas: bigint;
2770
+ maxPriorityFeePerGas: bigint;
2771
+ isSystemTx?: undefined | undefined;
2772
+ mint?: undefined | undefined;
2773
+ sourceHash?: undefined | undefined;
2774
+ } | {
2775
+ blockHash: `0x${string}` | null;
2776
+ blockNumber: bigint | null;
2777
+ blockTimestamp?: bigint | undefined;
2778
+ from: import("abitype").Address;
2779
+ gas: bigint;
2780
+ hash: import("viem").Hash;
2781
+ input: import("viem").Hex;
2782
+ nonce: number;
2783
+ r: import("viem").Hex;
2784
+ s: import("viem").Hex;
2785
+ to: import("abitype").Address | null;
2786
+ transactionIndex: number | null;
2787
+ typeHex: import("viem").Hex | null;
2788
+ v: bigint;
2789
+ value: bigint;
2790
+ yParity: number;
2791
+ accessList: import("viem").AccessList;
2792
+ authorizationList?: undefined | undefined;
2793
+ blobVersionedHashes: readonly import("viem").Hex[];
2794
+ chainId: number;
2795
+ type: "eip4844";
2796
+ gasPrice?: undefined | undefined;
2797
+ maxFeePerBlobGas: bigint;
2798
+ maxFeePerGas: bigint;
2799
+ maxPriorityFeePerGas: bigint;
2800
+ isSystemTx?: undefined | undefined;
2801
+ mint?: undefined | undefined;
2802
+ sourceHash?: undefined | undefined;
2803
+ } | {
2804
+ blockHash: `0x${string}` | null;
2805
+ blockNumber: bigint | null;
2806
+ blockTimestamp?: bigint | undefined;
2807
+ from: import("abitype").Address;
2808
+ gas: bigint;
2809
+ hash: import("viem").Hash;
2810
+ input: import("viem").Hex;
2811
+ nonce: number;
2812
+ r: import("viem").Hex;
2813
+ s: import("viem").Hex;
2814
+ to: import("abitype").Address | null;
2815
+ transactionIndex: number | null;
2816
+ typeHex: import("viem").Hex | null;
2817
+ v: bigint;
2818
+ value: bigint;
2819
+ yParity: number;
2820
+ accessList: import("viem").AccessList;
2821
+ authorizationList: import("viem").SignedAuthorizationList;
2822
+ blobVersionedHashes?: undefined | undefined;
2823
+ chainId: number;
2824
+ type: "eip7702";
2825
+ gasPrice?: undefined | undefined;
2826
+ maxFeePerBlobGas?: undefined | undefined;
2827
+ maxFeePerGas: bigint;
2828
+ maxPriorityFeePerGas: bigint;
2829
+ isSystemTx?: undefined | undefined;
2830
+ mint?: undefined | undefined;
2831
+ sourceHash?: undefined | undefined;
2832
+ }) & {};
2833
+ type: "transaction";
2834
+ };
2835
+ readonly transactionReceipt: {
2836
+ exclude: [] | undefined;
2837
+ format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
2838
+ blobGasPrice?: bigint | undefined;
2839
+ blobGasUsed?: bigint | undefined;
2840
+ blockHash: import("viem").Hash;
2841
+ blockNumber: bigint;
2842
+ blockTimestamp?: bigint | undefined;
2843
+ contractAddress: import("abitype").Address | null | undefined;
2844
+ cumulativeGasUsed: bigint;
2845
+ effectiveGasPrice: bigint;
2846
+ from: import("abitype").Address;
2847
+ gasUsed: bigint;
2848
+ logs: import("viem").Log<bigint, number, false>[];
2849
+ logsBloom: import("viem").Hex;
2850
+ root?: `0x${string}` | undefined;
2851
+ status: "success" | "reverted";
2852
+ to: import("abitype").Address | null;
2853
+ transactionHash: import("viem").Hash;
2854
+ transactionIndex: number;
2855
+ type: import("viem").TransactionType;
2856
+ depositNonce?: bigint | undefined | undefined;
2857
+ depositReceiptVersion?: number | undefined | undefined;
2858
+ l1GasPrice: bigint | null;
2859
+ l1GasUsed: bigint | null;
2860
+ l1Fee: bigint | null;
2861
+ l1FeeScalar: number | null;
2862
+ } & {};
2863
+ type: "transactionReceipt";
2864
+ };
2865
+ };
2866
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2867
+ client: import("viem").Client;
2868
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2869
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2870
+ client: import("viem").Client;
2871
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2872
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2873
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2874
+ }] | undefined;
2875
+ serializers: {
2876
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
2877
+ };
2878
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2879
+ } | {
2880
+ blockExplorers: {
2881
+ readonly default: {
2882
+ readonly name: "RouteScan";
2883
+ readonly url: "https://testnet.plasmascan.to";
2884
+ };
2885
+ };
2886
+ blockTime?: number | undefined | undefined;
2887
+ contracts: {
2888
+ readonly multicall3: {
2889
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
2890
+ readonly blockCreated: 0;
2891
+ };
2892
+ };
2893
+ ensTlds?: readonly string[] | undefined;
2894
+ id: 9746;
2895
+ name: "Plasma Testnet";
2896
+ nativeCurrency: {
2897
+ readonly name: "Testnet Plasma";
2898
+ readonly symbol: "XPL";
2899
+ readonly decimals: 18;
2900
+ };
2901
+ experimental_preconfirmationTime?: number | undefined | undefined;
2902
+ rpcUrls: {
2903
+ readonly default: {
2904
+ readonly http: readonly ["https://testnet-rpc.plasma.to"];
2905
+ };
2906
+ };
2907
+ sourceId?: number | undefined | undefined;
2908
+ testnet: true;
2909
+ custom?: Record<string, unknown> | undefined;
2910
+ extendSchema?: Record<string, unknown> | undefined;
2911
+ fees?: import("viem").ChainFees<undefined> | undefined;
2912
+ formatters?: undefined;
2913
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2914
+ client: import("viem").Client;
2915
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2916
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2917
+ client: import("viem").Client;
2918
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2919
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2920
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2921
+ }] | undefined;
2922
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2923
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2924
+ } | {
2925
+ blockExplorers: {
2926
+ readonly default: {
2927
+ readonly name: "Etherscan";
2928
+ readonly url: "https://sepolia.etherscan.io";
2929
+ readonly apiUrl: "https://api-sepolia.etherscan.io/api";
2930
+ };
2931
+ };
2932
+ blockTime?: number | undefined | undefined;
2933
+ contracts: {
2934
+ readonly multicall3: {
2935
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2936
+ readonly blockCreated: 751532;
2937
+ };
2938
+ readonly ensUniversalResolver: {
2939
+ readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
2940
+ readonly blockCreated: 8928790;
2941
+ };
2942
+ };
2943
+ ensTlds?: readonly string[] | undefined;
2944
+ id: 11155111;
2945
+ name: "Sepolia";
2946
+ nativeCurrency: {
2947
+ readonly name: "Sepolia Ether";
2948
+ readonly symbol: "ETH";
2949
+ readonly decimals: 18;
2950
+ };
2951
+ experimental_preconfirmationTime?: number | undefined | undefined;
2952
+ rpcUrls: {
2953
+ readonly default: {
2954
+ readonly http: readonly ["https://11155111.rpc.thirdweb.com"];
2955
+ };
2956
+ };
2957
+ sourceId?: number | undefined | undefined;
2958
+ testnet: true;
2959
+ custom?: Record<string, unknown> | undefined;
2960
+ extendSchema?: Record<string, unknown> | undefined;
2961
+ fees?: import("viem").ChainFees<undefined> | undefined;
2962
+ formatters?: undefined;
2963
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2964
+ client: import("viem").Client;
2965
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2966
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2967
+ client: import("viem").Client;
2968
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2969
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2970
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2971
+ }] | undefined;
2972
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
2973
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2974
+ })[];
2975
+ declare const chains: ({
2976
+ blockExplorers: {
2977
+ readonly default: {
2978
+ readonly name: "Arbiscan";
2979
+ readonly url: "https://arbiscan.io";
2980
+ readonly apiUrl: "https://api.arbiscan.io/api";
2981
+ };
2982
+ };
2983
+ blockTime: 250;
2984
+ contracts: {
2985
+ readonly multicall3: {
2986
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2987
+ readonly blockCreated: 7654707;
2988
+ };
2989
+ };
2990
+ ensTlds?: readonly string[] | undefined;
2991
+ id: 42161;
2992
+ name: "Arbitrum One";
2993
+ nativeCurrency: {
2994
+ readonly name: "Ether";
2995
+ readonly symbol: "ETH";
2996
+ readonly decimals: 18;
2997
+ };
2998
+ experimental_preconfirmationTime?: number | undefined | undefined;
2999
+ rpcUrls: {
3000
+ readonly default: {
3001
+ readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
3002
+ };
3003
+ };
3004
+ sourceId?: number | undefined | undefined;
3005
+ testnet?: boolean | undefined | undefined;
3006
+ custom?: Record<string, unknown> | undefined;
3007
+ extendSchema?: Record<string, unknown> | undefined;
3008
+ fees?: import("viem").ChainFees<undefined> | undefined;
3009
+ formatters?: undefined;
3010
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3011
+ client: import("viem").Client;
3012
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3013
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3014
+ client: import("viem").Client;
3015
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3016
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3017
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3018
+ }] | undefined;
3019
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3020
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3021
+ } | {
3022
+ blockExplorers: {
3023
+ readonly default: {
3024
+ readonly name: "Arbiscan";
3025
+ readonly url: "https://sepolia.arbiscan.io";
3026
+ readonly apiUrl: "https://api-sepolia.arbiscan.io/api";
3027
+ };
3028
+ };
3029
+ blockTime: 250;
3030
+ contracts: {
3031
+ readonly multicall3: {
3032
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3033
+ readonly blockCreated: 81930;
3034
+ };
3035
+ };
3036
+ ensTlds?: readonly string[] | undefined;
3037
+ id: 421614;
3038
+ name: "Arbitrum Sepolia";
3039
+ nativeCurrency: {
3040
+ readonly name: "Arbitrum Sepolia Ether";
3041
+ readonly symbol: "ETH";
3042
+ readonly decimals: 18;
3043
+ };
3044
+ experimental_preconfirmationTime?: number | undefined | undefined;
3045
+ rpcUrls: {
3046
+ readonly default: {
3047
+ readonly http: readonly ["https://sepolia-rollup.arbitrum.io/rpc"];
3048
+ };
3049
+ };
3050
+ sourceId?: number | undefined | undefined;
3051
+ testnet: true;
3052
+ custom?: Record<string, unknown> | undefined;
3053
+ extendSchema?: Record<string, unknown> | undefined;
3054
+ fees?: import("viem").ChainFees<undefined> | undefined;
3055
+ formatters?: undefined;
3056
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3057
+ client: import("viem").Client;
3058
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3059
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2739
3060
  client: import("viem").Client;
2740
3061
  phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
2741
3062
  }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
@@ -2757,27 +3078,352 @@ declare const chains: ({
2757
3078
  readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2758
3079
  readonly blockCreated: 11907934;
2759
3080
  };
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"];
3081
+ };
3082
+ ensTlds?: readonly string[] | undefined;
3083
+ id: 43114;
3084
+ name: "Avalanche";
3085
+ nativeCurrency: {
3086
+ readonly decimals: 18;
3087
+ readonly name: "Avalanche";
3088
+ readonly symbol: "AVAX";
3089
+ };
3090
+ experimental_preconfirmationTime?: number | undefined | undefined;
3091
+ rpcUrls: {
3092
+ readonly default: {
3093
+ readonly http: readonly ["https://api.avax.network/ext/bc/C/rpc"];
3094
+ };
3095
+ };
3096
+ sourceId?: number | undefined | undefined;
3097
+ testnet?: boolean | undefined | undefined;
3098
+ custom?: Record<string, unknown> | undefined;
3099
+ extendSchema?: Record<string, unknown> | undefined;
3100
+ fees?: import("viem").ChainFees<undefined> | undefined;
3101
+ formatters?: undefined;
3102
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3103
+ client: import("viem").Client;
3104
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3105
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3106
+ client: import("viem").Client;
3107
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3108
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3109
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3110
+ }] | undefined;
3111
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3112
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3113
+ } | {
3114
+ blockExplorers: {
3115
+ readonly default: {
3116
+ readonly name: "Basescan";
3117
+ readonly url: "https://basescan.org";
3118
+ readonly apiUrl: "https://api.basescan.org/api";
3119
+ };
3120
+ };
3121
+ blockTime: 2000;
3122
+ contracts: {
3123
+ readonly disputeGameFactory: {
3124
+ readonly 1: {
3125
+ readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
3126
+ };
3127
+ };
3128
+ readonly l2OutputOracle: {
3129
+ readonly 1: {
3130
+ readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
3131
+ };
3132
+ };
3133
+ readonly multicall3: {
3134
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3135
+ readonly blockCreated: 5022;
3136
+ };
3137
+ readonly portal: {
3138
+ readonly 1: {
3139
+ readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
3140
+ readonly blockCreated: 17482143;
3141
+ };
3142
+ };
3143
+ readonly l1StandardBridge: {
3144
+ readonly 1: {
3145
+ readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
3146
+ readonly blockCreated: 17482143;
3147
+ };
3148
+ };
3149
+ readonly gasPriceOracle: {
3150
+ readonly address: "0x420000000000000000000000000000000000000F";
3151
+ };
3152
+ readonly l1Block: {
3153
+ readonly address: "0x4200000000000000000000000000000000000015";
3154
+ };
3155
+ readonly l2CrossDomainMessenger: {
3156
+ readonly address: "0x4200000000000000000000000000000000000007";
3157
+ };
3158
+ readonly l2Erc721Bridge: {
3159
+ readonly address: "0x4200000000000000000000000000000000000014";
3160
+ };
3161
+ readonly l2StandardBridge: {
3162
+ readonly address: "0x4200000000000000000000000000000000000010";
3163
+ };
3164
+ readonly l2ToL1MessagePasser: {
3165
+ readonly address: "0x4200000000000000000000000000000000000016";
3166
+ };
3167
+ };
3168
+ ensTlds?: readonly string[] | undefined;
3169
+ id: 8453;
3170
+ name: "Base";
3171
+ nativeCurrency: {
3172
+ readonly name: "Ether";
3173
+ readonly symbol: "ETH";
3174
+ readonly decimals: 18;
3175
+ };
3176
+ experimental_preconfirmationTime?: number | undefined | undefined;
3177
+ rpcUrls: {
3178
+ readonly default: {
3179
+ readonly http: readonly ["https://mainnet.base.org"];
3180
+ };
3181
+ };
3182
+ sourceId: 1;
3183
+ testnet?: boolean | undefined | undefined;
3184
+ custom?: Record<string, unknown> | undefined;
3185
+ extendSchema?: Record<string, unknown> | undefined;
3186
+ fees?: import("viem").ChainFees<undefined> | undefined;
3187
+ formatters: {
3188
+ readonly block: {
3189
+ exclude: [] | undefined;
3190
+ format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => {
3191
+ baseFeePerGas: bigint | null;
3192
+ blobGasUsed: bigint;
3193
+ difficulty: bigint;
3194
+ excessBlobGas: bigint;
3195
+ extraData: import("viem").Hex;
3196
+ gasLimit: bigint;
3197
+ gasUsed: bigint;
3198
+ hash: `0x${string}` | null;
3199
+ logsBloom: `0x${string}` | null;
3200
+ miner: import("abitype").Address;
3201
+ mixHash: import("viem").Hash;
3202
+ nonce: `0x${string}` | null;
3203
+ number: bigint | null;
3204
+ parentBeaconBlockRoot?: `0x${string}` | undefined;
3205
+ parentHash: import("viem").Hash;
3206
+ receiptsRoot: import("viem").Hex;
3207
+ sealFields: import("viem").Hex[];
3208
+ sha3Uncles: import("viem").Hash;
3209
+ size: bigint;
3210
+ stateRoot: import("viem").Hash;
3211
+ timestamp: bigint;
3212
+ totalDifficulty: bigint | null;
3213
+ transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
3214
+ transactionsRoot: import("viem").Hash;
3215
+ uncles: import("viem").Hash[];
3216
+ withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
3217
+ withdrawalsRoot?: `0x${string}` | undefined;
3218
+ } & {};
3219
+ type: "block";
3220
+ };
3221
+ readonly transaction: {
3222
+ exclude: [] | undefined;
3223
+ format: (args: import("viem/chains").OpStackRpcTransaction, action?: string | undefined) => ({
3224
+ blockHash: `0x${string}` | null;
3225
+ blockNumber: bigint | null;
3226
+ blockTimestamp?: bigint | undefined;
3227
+ from: import("abitype").Address;
3228
+ gas: bigint;
3229
+ hash: import("viem").Hash;
3230
+ input: import("viem").Hex;
3231
+ nonce: number;
3232
+ r: import("viem").Hex;
3233
+ s: import("viem").Hex;
3234
+ to: import("abitype").Address | null;
3235
+ transactionIndex: number | null;
3236
+ typeHex: import("viem").Hex | null;
3237
+ v: bigint;
3238
+ value: bigint;
3239
+ yParity: number;
3240
+ gasPrice?: undefined | undefined;
3241
+ maxFeePerBlobGas?: undefined | undefined;
3242
+ maxFeePerGas: bigint;
3243
+ maxPriorityFeePerGas: bigint;
3244
+ isSystemTx?: boolean;
3245
+ mint?: bigint | undefined | undefined;
3246
+ sourceHash: import("viem").Hex;
3247
+ type: "deposit";
3248
+ } | {
3249
+ r: import("viem").Hex;
3250
+ s: import("viem").Hex;
3251
+ v: bigint;
3252
+ to: import("abitype").Address | null;
3253
+ from: import("abitype").Address;
3254
+ gas: bigint;
3255
+ nonce: number;
3256
+ value: bigint;
3257
+ blockHash: `0x${string}` | null;
3258
+ blockNumber: bigint | null;
3259
+ blockTimestamp?: bigint | undefined;
3260
+ hash: import("viem").Hash;
3261
+ input: import("viem").Hex;
3262
+ transactionIndex: number | null;
3263
+ typeHex: import("viem").Hex | null;
3264
+ accessList?: undefined | undefined;
3265
+ authorizationList?: undefined | undefined;
3266
+ blobVersionedHashes?: undefined | undefined;
3267
+ chainId?: number | undefined;
3268
+ yParity?: undefined | undefined;
3269
+ type: "legacy";
3270
+ gasPrice: bigint;
3271
+ maxFeePerBlobGas?: undefined | undefined;
3272
+ maxFeePerGas?: undefined | undefined;
3273
+ maxPriorityFeePerGas?: undefined | undefined;
3274
+ isSystemTx?: undefined | undefined;
3275
+ mint?: undefined | undefined;
3276
+ sourceHash?: undefined | undefined;
3277
+ } | {
3278
+ blockHash: `0x${string}` | null;
3279
+ blockNumber: bigint | null;
3280
+ blockTimestamp?: bigint | undefined;
3281
+ from: import("abitype").Address;
3282
+ gas: bigint;
3283
+ hash: import("viem").Hash;
3284
+ input: import("viem").Hex;
3285
+ nonce: number;
3286
+ r: import("viem").Hex;
3287
+ s: import("viem").Hex;
3288
+ to: import("abitype").Address | null;
3289
+ transactionIndex: number | null;
3290
+ typeHex: import("viem").Hex | null;
3291
+ v: bigint;
3292
+ value: bigint;
3293
+ yParity: number;
3294
+ accessList: import("viem").AccessList;
3295
+ authorizationList?: undefined | undefined;
3296
+ blobVersionedHashes?: undefined | undefined;
3297
+ chainId: number;
3298
+ type: "eip2930";
3299
+ gasPrice: bigint;
3300
+ maxFeePerBlobGas?: undefined | undefined;
3301
+ maxFeePerGas?: undefined | undefined;
3302
+ maxPriorityFeePerGas?: undefined | undefined;
3303
+ isSystemTx?: undefined | undefined;
3304
+ mint?: undefined | undefined;
3305
+ sourceHash?: undefined | undefined;
3306
+ } | {
3307
+ blockHash: `0x${string}` | null;
3308
+ blockNumber: bigint | null;
3309
+ blockTimestamp?: bigint | undefined;
3310
+ from: import("abitype").Address;
3311
+ gas: bigint;
3312
+ hash: import("viem").Hash;
3313
+ input: import("viem").Hex;
3314
+ nonce: number;
3315
+ r: import("viem").Hex;
3316
+ s: import("viem").Hex;
3317
+ to: import("abitype").Address | null;
3318
+ transactionIndex: number | null;
3319
+ typeHex: import("viem").Hex | null;
3320
+ v: bigint;
3321
+ value: bigint;
3322
+ yParity: number;
3323
+ accessList: import("viem").AccessList;
3324
+ authorizationList?: undefined | undefined;
3325
+ blobVersionedHashes?: undefined | undefined;
3326
+ chainId: number;
3327
+ type: "eip1559";
3328
+ gasPrice?: undefined | undefined;
3329
+ maxFeePerBlobGas?: undefined | undefined;
3330
+ maxFeePerGas: bigint;
3331
+ maxPriorityFeePerGas: bigint;
3332
+ isSystemTx?: undefined | undefined;
3333
+ mint?: undefined | undefined;
3334
+ sourceHash?: undefined | undefined;
3335
+ } | {
3336
+ blockHash: `0x${string}` | null;
3337
+ blockNumber: bigint | null;
3338
+ blockTimestamp?: bigint | undefined;
3339
+ from: import("abitype").Address;
3340
+ gas: bigint;
3341
+ hash: import("viem").Hash;
3342
+ input: import("viem").Hex;
3343
+ nonce: number;
3344
+ r: import("viem").Hex;
3345
+ s: import("viem").Hex;
3346
+ to: import("abitype").Address | null;
3347
+ transactionIndex: number | null;
3348
+ typeHex: import("viem").Hex | null;
3349
+ v: bigint;
3350
+ value: bigint;
3351
+ yParity: number;
3352
+ accessList: import("viem").AccessList;
3353
+ authorizationList?: undefined | undefined;
3354
+ blobVersionedHashes: readonly import("viem").Hex[];
3355
+ chainId: number;
3356
+ type: "eip4844";
3357
+ gasPrice?: undefined | undefined;
3358
+ maxFeePerBlobGas: bigint;
3359
+ maxFeePerGas: bigint;
3360
+ maxPriorityFeePerGas: bigint;
3361
+ isSystemTx?: undefined | undefined;
3362
+ mint?: undefined | undefined;
3363
+ sourceHash?: undefined | undefined;
3364
+ } | {
3365
+ blockHash: `0x${string}` | null;
3366
+ blockNumber: bigint | null;
3367
+ blockTimestamp?: bigint | undefined;
3368
+ from: import("abitype").Address;
3369
+ gas: bigint;
3370
+ hash: import("viem").Hash;
3371
+ input: import("viem").Hex;
3372
+ nonce: number;
3373
+ r: import("viem").Hex;
3374
+ s: import("viem").Hex;
3375
+ to: import("abitype").Address | null;
3376
+ transactionIndex: number | null;
3377
+ typeHex: import("viem").Hex | null;
3378
+ v: bigint;
3379
+ value: bigint;
3380
+ yParity: number;
3381
+ accessList: import("viem").AccessList;
3382
+ authorizationList: import("viem").SignedAuthorizationList;
3383
+ blobVersionedHashes?: undefined | undefined;
3384
+ chainId: number;
3385
+ type: "eip7702";
3386
+ gasPrice?: undefined | undefined;
3387
+ maxFeePerBlobGas?: undefined | undefined;
3388
+ maxFeePerGas: bigint;
3389
+ maxPriorityFeePerGas: bigint;
3390
+ isSystemTx?: undefined | undefined;
3391
+ mint?: undefined | undefined;
3392
+ sourceHash?: undefined | undefined;
3393
+ }) & {};
3394
+ type: "transaction";
3395
+ };
3396
+ readonly transactionReceipt: {
3397
+ exclude: [] | undefined;
3398
+ format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
3399
+ blobGasPrice?: bigint | undefined;
3400
+ blobGasUsed?: bigint | undefined;
3401
+ blockHash: import("viem").Hash;
3402
+ blockNumber: bigint;
3403
+ blockTimestamp?: bigint | undefined;
3404
+ contractAddress: import("abitype").Address | null | undefined;
3405
+ cumulativeGasUsed: bigint;
3406
+ effectiveGasPrice: bigint;
3407
+ from: import("abitype").Address;
3408
+ gasUsed: bigint;
3409
+ logs: import("viem").Log<bigint, number, false>[];
3410
+ logsBloom: import("viem").Hex;
3411
+ root?: `0x${string}` | undefined;
3412
+ status: "success" | "reverted";
3413
+ to: import("abitype").Address | null;
3414
+ transactionHash: import("viem").Hash;
3415
+ transactionIndex: number;
3416
+ type: import("viem").TransactionType;
3417
+ depositNonce?: bigint | undefined | undefined;
3418
+ depositReceiptVersion?: number | undefined | undefined;
3419
+ l1GasPrice: bigint | null;
3420
+ l1GasUsed: bigint | null;
3421
+ l1Fee: bigint | null;
3422
+ l1FeeScalar: number | null;
3423
+ } & {};
3424
+ type: "transactionReceipt";
2773
3425
  };
2774
3426
  };
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
3427
  prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
2782
3428
  client: import("viem").Client;
2783
3429
  phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
@@ -2787,44 +3433,46 @@ declare const chains: ({
2787
3433
  }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
2788
3434
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
2789
3435
  }] | undefined;
2790
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3436
+ serializers: {
3437
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
3438
+ };
2791
3439
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
2792
3440
  } | {
2793
3441
  blockExplorers: {
2794
3442
  readonly default: {
2795
3443
  readonly name: "Basescan";
2796
- readonly url: "https://basescan.org";
2797
- readonly apiUrl: "https://api.basescan.org/api";
3444
+ readonly url: "https://sepolia.basescan.org";
3445
+ readonly apiUrl: "https://api-sepolia.basescan.org/api";
2798
3446
  };
2799
3447
  };
2800
3448
  blockTime: 2000;
2801
3449
  contracts: {
2802
3450
  readonly disputeGameFactory: {
2803
- readonly 1: {
2804
- readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
3451
+ readonly 11155111: {
3452
+ readonly address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1";
2805
3453
  };
2806
3454
  };
2807
3455
  readonly l2OutputOracle: {
2808
- readonly 1: {
2809
- readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
3456
+ readonly 11155111: {
3457
+ readonly address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254";
2810
3458
  };
2811
3459
  };
2812
- readonly multicall3: {
2813
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
2814
- readonly blockCreated: 5022;
2815
- };
2816
3460
  readonly portal: {
2817
- readonly 1: {
2818
- readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
2819
- readonly blockCreated: 17482143;
3461
+ readonly 11155111: {
3462
+ readonly address: "0x49f53e41452c74589e85ca1677426ba426459e85";
3463
+ readonly blockCreated: 4446677;
2820
3464
  };
2821
3465
  };
2822
3466
  readonly l1StandardBridge: {
2823
- readonly 1: {
2824
- readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
2825
- readonly blockCreated: 17482143;
3467
+ readonly 11155111: {
3468
+ readonly address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120";
3469
+ readonly blockCreated: 4446677;
2826
3470
  };
2827
3471
  };
3472
+ readonly multicall3: {
3473
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3474
+ readonly blockCreated: 1059647;
3475
+ };
2828
3476
  readonly gasPriceOracle: {
2829
3477
  readonly address: "0x420000000000000000000000000000000000000F";
2830
3478
  };
@@ -2845,21 +3493,21 @@ declare const chains: ({
2845
3493
  };
2846
3494
  };
2847
3495
  ensTlds?: readonly string[] | undefined;
2848
- id: 8453;
2849
- name: "Base";
3496
+ id: 84532;
3497
+ name: "Base Sepolia";
2850
3498
  nativeCurrency: {
2851
- readonly name: "Ether";
3499
+ readonly name: "Sepolia Ether";
2852
3500
  readonly symbol: "ETH";
2853
3501
  readonly decimals: 18;
2854
3502
  };
2855
3503
  experimental_preconfirmationTime?: number | undefined | undefined;
2856
3504
  rpcUrls: {
2857
3505
  readonly default: {
2858
- readonly http: readonly ["https://mainnet.base.org"];
3506
+ readonly http: readonly ["https://sepolia.base.org"];
2859
3507
  };
2860
3508
  };
2861
- sourceId: 1;
2862
- testnet?: boolean | undefined | undefined;
3509
+ sourceId: 11155111;
3510
+ testnet: true;
2863
3511
  custom?: Record<string, unknown> | undefined;
2864
3512
  extendSchema?: Record<string, unknown> | undefined;
2865
3513
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -3112,46 +3760,174 @@ declare const chains: ({
3112
3760
  }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3113
3761
  runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3114
3762
  }] | undefined;
3115
- serializers: {
3116
- readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
3763
+ serializers: {
3764
+ readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
3765
+ };
3766
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3767
+ readonly network: "base-sepolia";
3768
+ } | {
3769
+ blockExplorers: {
3770
+ readonly default: {
3771
+ readonly name: "BscScan";
3772
+ readonly url: "https://bscscan.com";
3773
+ readonly apiUrl: "https://api.bscscan.com/api";
3774
+ };
3775
+ };
3776
+ blockTime: 750;
3777
+ contracts: {
3778
+ readonly multicall3: {
3779
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3780
+ readonly blockCreated: 15921452;
3781
+ };
3782
+ };
3783
+ ensTlds?: readonly string[] | undefined;
3784
+ id: 56;
3785
+ name: "BNB Smart Chain";
3786
+ nativeCurrency: {
3787
+ readonly decimals: 18;
3788
+ readonly name: "BNB";
3789
+ readonly symbol: "BNB";
3790
+ };
3791
+ experimental_preconfirmationTime?: number | undefined | undefined;
3792
+ rpcUrls: {
3793
+ readonly default: {
3794
+ readonly http: readonly ["https://56.rpc.thirdweb.com"];
3795
+ };
3796
+ };
3797
+ sourceId?: number | undefined | undefined;
3798
+ testnet?: boolean | undefined | undefined;
3799
+ custom?: Record<string, unknown> | undefined;
3800
+ extendSchema?: Record<string, unknown> | undefined;
3801
+ fees?: import("viem").ChainFees<undefined> | undefined;
3802
+ formatters?: undefined;
3803
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3804
+ client: import("viem").Client;
3805
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3806
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3807
+ client: import("viem").Client;
3808
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3809
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3810
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3811
+ }] | undefined;
3812
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3813
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3814
+ } | {
3815
+ blockExplorers: {
3816
+ readonly default: {
3817
+ readonly name: "Gnosisscan";
3818
+ readonly url: "https://gnosisscan.io";
3819
+ readonly apiUrl: "https://api.gnosisscan.io/api";
3820
+ };
3821
+ };
3822
+ blockTime: 5000;
3823
+ contracts: {
3824
+ readonly multicall3: {
3825
+ readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3826
+ readonly blockCreated: 21022491;
3827
+ };
3828
+ };
3829
+ ensTlds?: readonly string[] | undefined;
3830
+ id: 100;
3831
+ name: "Gnosis";
3832
+ nativeCurrency: {
3833
+ readonly decimals: 18;
3834
+ readonly name: "xDAI";
3835
+ readonly symbol: "XDAI";
3836
+ };
3837
+ experimental_preconfirmationTime?: number | undefined | undefined;
3838
+ rpcUrls: {
3839
+ readonly default: {
3840
+ readonly http: readonly ["https://rpc.gnosischain.com"];
3841
+ readonly webSocket: readonly ["wss://rpc.gnosischain.com/wss"];
3842
+ };
3843
+ };
3844
+ sourceId?: number | undefined | undefined;
3845
+ testnet?: boolean | undefined | undefined;
3846
+ custom?: Record<string, unknown> | undefined;
3847
+ extendSchema?: Record<string, unknown> | undefined;
3848
+ fees?: import("viem").ChainFees<undefined> | undefined;
3849
+ formatters?: undefined;
3850
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3851
+ client: import("viem").Client;
3852
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3853
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3854
+ client: import("viem").Client;
3855
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3856
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3857
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3858
+ }] | undefined;
3859
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3860
+ verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3861
+ } | {
3862
+ blockExplorers: {
3863
+ readonly default: {
3864
+ readonly name: "HyperEVMScan";
3865
+ readonly url: "https://hyperevmscan.io";
3866
+ };
3867
+ };
3868
+ blockTime?: number | undefined | undefined;
3869
+ contracts: {
3870
+ readonly multicall3: {
3871
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
3872
+ readonly blockCreated: 13051;
3873
+ };
3874
+ };
3875
+ ensTlds?: readonly string[] | undefined;
3876
+ id: 999;
3877
+ name: "HyperEVM";
3878
+ nativeCurrency: {
3879
+ readonly name: "HYPE";
3880
+ readonly symbol: "HYPE";
3881
+ readonly decimals: 18;
3882
+ };
3883
+ experimental_preconfirmationTime?: number | undefined | undefined;
3884
+ rpcUrls: {
3885
+ readonly default: {
3886
+ readonly http: readonly ["https://rpc.hyperliquid.xyz/evm"];
3887
+ };
3117
3888
  };
3889
+ sourceId?: number | undefined | undefined;
3890
+ testnet: false;
3891
+ custom?: Record<string, unknown> | undefined;
3892
+ extendSchema?: Record<string, unknown> | undefined;
3893
+ fees?: import("viem").ChainFees<undefined> | undefined;
3894
+ formatters?: undefined;
3895
+ prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3896
+ client: import("viem").Client;
3897
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3898
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3899
+ client: import("viem").Client;
3900
+ phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3901
+ }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3902
+ runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3903
+ }] | undefined;
3904
+ serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3118
3905
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3119
3906
  } | {
3120
3907
  blockExplorers: {
3121
3908
  readonly default: {
3122
- readonly name: "Basescan";
3123
- readonly url: "https://sepolia.basescan.org";
3124
- readonly apiUrl: "https://api-sepolia.basescan.org/api";
3909
+ readonly name: "Blockscout";
3910
+ readonly url: "https://explorer.inkonchain.com";
3911
+ readonly apiUrl: "https://explorer.inkonchain.com/api/v2";
3125
3912
  };
3126
3913
  };
3127
3914
  blockTime: 2000;
3128
3915
  contracts: {
3129
3916
  readonly disputeGameFactory: {
3130
- readonly 11155111: {
3131
- readonly address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1";
3132
- };
3133
- };
3134
- readonly l2OutputOracle: {
3135
- readonly 11155111: {
3136
- readonly address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254";
3917
+ readonly 1: {
3918
+ readonly address: "0x10d7b35078d3baabb96dd45a9143b94be65b12cd";
3137
3919
  };
3138
3920
  };
3139
3921
  readonly portal: {
3140
- readonly 11155111: {
3141
- readonly address: "0x49f53e41452c74589e85ca1677426ba426459e85";
3142
- readonly blockCreated: 4446677;
3922
+ readonly 1: {
3923
+ readonly address: "0x5d66c1782664115999c47c9fa5cd031f495d3e4f";
3143
3924
  };
3144
3925
  };
3145
3926
  readonly l1StandardBridge: {
3146
- readonly 11155111: {
3147
- readonly address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120";
3148
- readonly blockCreated: 4446677;
3927
+ readonly 1: {
3928
+ readonly address: "0x88ff1e5b602916615391f55854588efcbb7663f0";
3149
3929
  };
3150
3930
  };
3151
- readonly multicall3: {
3152
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3153
- readonly blockCreated: 1059647;
3154
- };
3155
3931
  readonly gasPriceOracle: {
3156
3932
  readonly address: "0x420000000000000000000000000000000000000F";
3157
3933
  };
@@ -3170,23 +3946,28 @@ declare const chains: ({
3170
3946
  readonly l2ToL1MessagePasser: {
3171
3947
  readonly address: "0x4200000000000000000000000000000000000016";
3172
3948
  };
3949
+ readonly multicall3: {
3950
+ readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
3951
+ readonly blockCreated: 0;
3952
+ };
3173
3953
  };
3174
3954
  ensTlds?: readonly string[] | undefined;
3175
- id: 84532;
3176
- name: "Base Sepolia";
3955
+ id: 57073;
3956
+ name: "Ink";
3177
3957
  nativeCurrency: {
3178
- readonly name: "Sepolia Ether";
3958
+ readonly name: "Ether";
3179
3959
  readonly symbol: "ETH";
3180
3960
  readonly decimals: 18;
3181
3961
  };
3182
3962
  experimental_preconfirmationTime?: number | undefined | undefined;
3183
3963
  rpcUrls: {
3184
3964
  readonly default: {
3185
- readonly http: readonly ["https://sepolia.base.org"];
3965
+ readonly http: readonly ["https://rpc-gel.inkonchain.com", "https://rpc-qnd.inkonchain.com"];
3966
+ readonly webSocket: readonly ["wss://rpc-gel.inkonchain.com", "wss://rpc-qnd.inkonchain.com"];
3186
3967
  };
3187
3968
  };
3188
- sourceId: 11155111;
3189
- testnet: true;
3969
+ sourceId: 1;
3970
+ testnet: false;
3190
3971
  custom?: Record<string, unknown> | undefined;
3191
3972
  extendSchema?: Record<string, unknown> | undefined;
3192
3973
  fees?: import("viem").ChainFees<undefined> | undefined;
@@ -3443,145 +4224,6 @@ declare const chains: ({
3443
4224
  readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
3444
4225
  };
3445
4226
  verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3446
- readonly network: "base-sepolia";
3447
- } | {
3448
- blockExplorers: {
3449
- readonly default: {
3450
- readonly name: "BscScan";
3451
- readonly url: "https://bscscan.com";
3452
- readonly apiUrl: "https://api.bscscan.com/api";
3453
- };
3454
- };
3455
- blockTime: 750;
3456
- contracts: {
3457
- readonly multicall3: {
3458
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3459
- readonly blockCreated: 15921452;
3460
- };
3461
- };
3462
- ensTlds?: readonly string[] | undefined;
3463
- id: 56;
3464
- name: "BNB Smart Chain";
3465
- nativeCurrency: {
3466
- readonly decimals: 18;
3467
- readonly name: "BNB";
3468
- readonly symbol: "BNB";
3469
- };
3470
- experimental_preconfirmationTime?: number | undefined | undefined;
3471
- rpcUrls: {
3472
- readonly default: {
3473
- readonly http: readonly ["https://56.rpc.thirdweb.com"];
3474
- };
3475
- };
3476
- sourceId?: number | undefined | undefined;
3477
- testnet?: boolean | undefined | undefined;
3478
- custom?: Record<string, unknown> | undefined;
3479
- extendSchema?: Record<string, unknown> | undefined;
3480
- fees?: import("viem").ChainFees<undefined> | undefined;
3481
- formatters?: undefined;
3482
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3483
- client: import("viem").Client;
3484
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3485
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3486
- client: import("viem").Client;
3487
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3488
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3489
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3490
- }] | undefined;
3491
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3492
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3493
- } | {
3494
- blockExplorers: {
3495
- readonly default: {
3496
- readonly name: "Gnosisscan";
3497
- readonly url: "https://gnosisscan.io";
3498
- readonly apiUrl: "https://api.gnosisscan.io/api";
3499
- };
3500
- };
3501
- blockTime: 5000;
3502
- contracts: {
3503
- readonly multicall3: {
3504
- readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
3505
- readonly blockCreated: 21022491;
3506
- };
3507
- };
3508
- ensTlds?: readonly string[] | undefined;
3509
- id: 100;
3510
- name: "Gnosis";
3511
- nativeCurrency: {
3512
- readonly decimals: 18;
3513
- readonly name: "xDAI";
3514
- readonly symbol: "XDAI";
3515
- };
3516
- experimental_preconfirmationTime?: number | undefined | undefined;
3517
- rpcUrls: {
3518
- readonly default: {
3519
- readonly http: readonly ["https://rpc.gnosischain.com"];
3520
- readonly webSocket: readonly ["wss://rpc.gnosischain.com/wss"];
3521
- };
3522
- };
3523
- sourceId?: number | undefined | undefined;
3524
- testnet?: boolean | undefined | undefined;
3525
- custom?: Record<string, unknown> | undefined;
3526
- extendSchema?: Record<string, unknown> | undefined;
3527
- fees?: import("viem").ChainFees<undefined> | undefined;
3528
- formatters?: undefined;
3529
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3530
- client: import("viem").Client;
3531
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3532
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3533
- client: import("viem").Client;
3534
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3535
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3536
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3537
- }] | undefined;
3538
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3539
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3540
- } | {
3541
- blockExplorers: {
3542
- readonly default: {
3543
- readonly name: "HyperEVMScan";
3544
- readonly url: "https://hyperevmscan.io";
3545
- };
3546
- };
3547
- blockTime?: number | undefined | undefined;
3548
- contracts: {
3549
- readonly multicall3: {
3550
- readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
3551
- readonly blockCreated: 13051;
3552
- };
3553
- };
3554
- ensTlds?: readonly string[] | undefined;
3555
- id: 999;
3556
- name: "HyperEVM";
3557
- nativeCurrency: {
3558
- readonly name: "HYPE";
3559
- readonly symbol: "HYPE";
3560
- readonly decimals: 18;
3561
- };
3562
- experimental_preconfirmationTime?: number | undefined | undefined;
3563
- rpcUrls: {
3564
- readonly default: {
3565
- readonly http: readonly ["https://rpc.hyperliquid.xyz/evm"];
3566
- };
3567
- };
3568
- sourceId?: number | undefined | undefined;
3569
- testnet: false;
3570
- custom?: Record<string, unknown> | undefined;
3571
- extendSchema?: Record<string, unknown> | undefined;
3572
- fees?: import("viem").ChainFees<undefined> | undefined;
3573
- formatters?: undefined;
3574
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3575
- client: import("viem").Client;
3576
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3577
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
3578
- client: import("viem").Client;
3579
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
3580
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
3581
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
3582
- }] | undefined;
3583
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
3584
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
3585
4227
  } | {
3586
4228
  blockExplorers: {
3587
4229
  readonly default: {
@@ -5324,7 +5966,8 @@ declare enum MainnetNetwork {
5324
5966
  TRON = 728126428,
5325
5967
  KATANA,
5326
5968
  ROBINHOOD,
5327
- AVALANCHE
5969
+ AVALANCHE,
5970
+ INK
5328
5971
  }
5329
5972
  declare enum TestnetNetwork {
5330
5973
  ETHEREUM_SEPOLIA,
@@ -5338,6 +5981,7 @@ declare enum OPStackChains {
5338
5981
  MAINNET_BASE,
5339
5982
  MAINNET_SONEIUM,
5340
5983
  MAINNET_UNICHAIN,
5984
+ MAINNET_INK,
5341
5985
  TESTNET_OPTIMISM,
5342
5986
  TESTNET_BASE
5343
5987
  }