1use alloy_chains::Chain;
7use alloy_rpc_types::BlockNumberOrTag;
8use evm2::SpecId;
9use foundry_compilers::artifacts::EvmVersion;
10use serde::{Deserialize, Serialize};
11use std::{
12 str::FromStr,
13 time::{SystemTime, UNIX_EPOCH},
14};
15
16#[cfg(all(feature = "optimism", not(feature = "base")))]
17use alloy_chains::NamedChain;
18#[cfg(feature = "optimism")]
19use op_evm2::OpSpecId;
20
21pub use alloy_hardforks::EthereumHardfork;
22pub use tempo_hardfork::TempoHardfork;
23
24#[cfg(feature = "base")]
25pub use base_common_genesis::BaseUpgrade;
26#[cfg(feature = "base")]
27pub use base_evm2::BaseSpecId;
28
29#[cfg(feature = "monad")]
30pub use monad_evm2::MonadHardfork;
31
32#[cfg(feature = "optimism")]
33pub use alloy_op_hardforks::OpHardfork;
34
35#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
36#[serde(into = "String")]
37pub enum FoundryHardfork {
38 Ethereum(EthereumHardfork),
39 #[cfg(feature = "optimism")]
40 Optimism(OpHardfork),
41 #[cfg(feature = "base")]
42 Base(BaseUpgrade),
43 Tempo(TempoHardfork),
44 #[cfg(feature = "monad")]
45 Monad(MonadHardfork),
46}
47
48impl From<FoundryHardfork> for String {
49 fn from(fork: FoundryHardfork) -> Self {
50 match fork {
51 FoundryHardfork::Ethereum(h) => format!("{h}"),
52 #[cfg(feature = "optimism")]
53 FoundryHardfork::Optimism(h) => format!("optimism:{h}"),
54 #[cfg(feature = "base")]
55 FoundryHardfork::Base(h) => format!("base:{h}"),
56 FoundryHardfork::Tempo(h) => format!("tempo:{h}"),
57 #[cfg(feature = "monad")]
58 FoundryHardfork::Monad(h) => format!("monad:{h}"),
59 }
60 }
61}
62
63impl<'de> Deserialize<'de> for FoundryHardfork {
64 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
65 where
66 D: serde::Deserializer<'de>,
67 {
68 let s = String::deserialize(deserializer)?;
69 Self::from_str(&s).map_err(serde::de::Error::custom)
70 }
71}
72
73impl FromStr for FoundryHardfork {
74 type Err = String;
75
76 fn from_str(s: &str) -> Result<Self, Self::Err> {
77 let raw = s.trim();
78
79 let Some((ns, fork_raw)) = raw.split_once(':') else {
80 return EthereumHardfork::from_str(raw)
81 .map(Self::Ethereum)
82 .map_err(|_| format!("unknown ethereum hardfork '{raw}'"));
83 };
84
85 let ns = ns.trim().to_ascii_lowercase();
86 let fork = fork_raw.trim().to_ascii_lowercase().replace(['-', ' '], "_");
87
88 match ns.as_str() {
89 "eth" | "ethereum" => EthereumHardfork::from_str(&fork)
90 .map(Self::Ethereum)
91 .map_err(|_| format!("unknown ethereum hardfork '{fork_raw}'")),
92
93 #[cfg(feature = "optimism")]
94 "op" | "optimism" => OpHardfork::from_str(&fork)
95 .map(Self::Optimism)
96 .map_err(|_| format!("unknown optimism hardfork '{fork_raw}'")),
97 #[cfg(not(feature = "optimism"))]
98 "op" | "optimism" => {
99 Err(format!("hardfork namespace '{ns}' requires the `optimism` feature"))
100 }
101
102 #[cfg(feature = "base")]
103 "base" => BaseUpgrade::from_str(&fork)
104 .map(Self::Base)
105 .map_err(|_| format!("unknown base hardfork '{fork_raw}'")),
106 #[cfg(not(feature = "base"))]
107 "base" => Err(format!("hardfork namespace '{ns}' requires the `base` feature")),
108
109 "t" | "tempo" => TempoHardfork::from_str(&fork)
110 .map(Self::Tempo)
111 .map_err(|_| format!("unknown tempo hardfork '{fork_raw}'")),
112
113 #[cfg(feature = "monad")]
114 "m" | "monad" => MonadHardfork::from_str(&fork)
115 .map(Self::Monad)
116 .map_err(|_| format!("unknown monad hardfork '{fork_raw}'")),
117 #[cfg(not(feature = "monad"))]
118 "m" | "monad" => Err(format!("hardfork namespace '{ns}' requires the `monad` feature")),
119
120 _ => Err(format!("unknown hardfork namespace '{ns}'")),
121 }
122 }
123}
124
125impl FoundryHardfork {
126 pub const fn ethereum(h: EthereumHardfork) -> Self {
127 Self::Ethereum(h)
128 }
129
130 #[cfg(feature = "optimism")]
131 pub const fn optimism(h: OpHardfork) -> Self {
132 Self::Optimism(h)
133 }
134
135 #[cfg(feature = "base")]
136 pub const fn base(h: BaseUpgrade) -> Self {
137 Self::Base(h)
138 }
139
140 pub const fn tempo(h: TempoHardfork) -> Self {
141 Self::Tempo(h)
142 }
143
144 #[cfg(feature = "monad")]
145 pub const fn monad(h: MonadHardfork) -> Self {
146 Self::Monad(h)
147 }
148
149 pub fn name(&self) -> String {
151 match self {
152 Self::Ethereum(h) => format!("{h}"),
153 #[cfg(feature = "optimism")]
154 Self::Optimism(h) => format!("{h}"),
155 #[cfg(feature = "base")]
156 Self::Base(h) => format!("{h}"),
157 Self::Tempo(h) => format!("{h}"),
158 #[cfg(feature = "monad")]
159 Self::Monad(h) => format!("{h}"),
160 }
161 }
162
163 pub const fn namespace(&self) -> Option<&'static str> {
167 match self {
168 Self::Ethereum(_) => None,
169 #[cfg(feature = "optimism")]
170 Self::Optimism(_) => Some("optimism"),
171 #[cfg(feature = "base")]
172 Self::Base(_) => Some("base"),
173 Self::Tempo(_) => Some("tempo"),
174 #[cfg(feature = "monad")]
175 Self::Monad(_) => Some("monad"),
176 }
177 }
178
179 pub fn from_chain_and_timestamp(chain_id: u64, timestamp: u64) -> Option<Self> {
183 let chain = Chain::from_id(chain_id);
184 if let Some(fork) = EthereumHardfork::from_chain_and_timestamp(chain, timestamp) {
185 return Some(Self::Ethereum(fork));
186 }
187 #[cfg(feature = "base")]
188 if let Some(fork) = BaseUpgrade::from_chain_and_timestamp(chain_id, timestamp) {
189 return Some(Self::Base(fork));
190 }
191 #[cfg(feature = "optimism")]
192 if let Some(fork) = OpHardfork::from_chain_and_timestamp(chain, timestamp) {
193 return Some(Self::Optimism(fork));
194 }
195 if let Some(fork) = TempoHardfork::from_chain_and_timestamp(chain_id, timestamp) {
196 return Some(Self::Tempo(fork));
197 }
198 #[cfg(feature = "monad")]
199 if let Some(fork) = MonadHardfork::from_chain_and_timestamp(chain_id, timestamp) {
200 return Some(Self::Monad(fork));
201 }
202 None
203 }
204}
205
206impl From<EthereumHardfork> for FoundryHardfork {
207 fn from(value: EthereumHardfork) -> Self {
208 Self::Ethereum(value)
209 }
210}
211
212impl From<FoundryHardfork> for EthereumHardfork {
213 fn from(fork: FoundryHardfork) -> Self {
214 match fork {
215 FoundryHardfork::Ethereum(hardfork) => hardfork,
216 _ => Self::default(),
217 }
218 }
219}
220
221#[cfg(feature = "optimism")]
222impl From<OpHardfork> for FoundryHardfork {
223 fn from(value: OpHardfork) -> Self {
224 Self::Optimism(value)
225 }
226}
227
228#[cfg(feature = "optimism")]
229impl From<FoundryHardfork> for OpHardfork {
230 fn from(fork: FoundryHardfork) -> Self {
231 match fork {
232 FoundryHardfork::Optimism(hardfork) => hardfork,
233 _ => Self::default(),
234 }
235 }
236}
237
238#[cfg(feature = "base")]
239impl From<BaseUpgrade> for FoundryHardfork {
240 fn from(value: BaseUpgrade) -> Self {
241 Self::Base(value)
242 }
243}
244
245#[cfg(feature = "base")]
246impl From<FoundryHardfork> for BaseUpgrade {
247 fn from(fork: FoundryHardfork) -> Self {
248 match fork {
249 FoundryHardfork::Base(upgrade) => upgrade,
250 _ => Self::default(),
251 }
252 }
253}
254
255#[cfg(feature = "base")]
256impl From<FoundryHardfork> for BaseSpecId {
257 fn from(fork: FoundryHardfork) -> Self {
258 match fork {
259 FoundryHardfork::Base(upgrade) => Self::new(upgrade),
260 _ => Self::default(),
261 }
262 }
263}
264
265impl From<TempoHardfork> for FoundryHardfork {
266 fn from(value: TempoHardfork) -> Self {
267 Self::Tempo(value)
268 }
269}
270
271impl From<FoundryHardfork> for TempoHardfork {
272 fn from(fork: FoundryHardfork) -> Self {
273 match fork {
274 FoundryHardfork::Tempo(hardfork) => hardfork,
275 _ => Self::default(),
276 }
277 }
278}
279
280#[cfg(feature = "monad")]
281impl From<MonadHardfork> for FoundryHardfork {
282 fn from(value: MonadHardfork) -> Self {
283 Self::Monad(value)
284 }
285}
286
287#[cfg(feature = "monad")]
288impl From<FoundryHardfork> for MonadHardfork {
289 fn from(fork: FoundryHardfork) -> Self {
290 match fork {
291 FoundryHardfork::Monad(hardfork) => hardfork,
292 _ => Self::default(),
293 }
294 }
295}
296
297impl From<FoundryHardfork> for SpecId {
298 fn from(fork: FoundryHardfork) -> Self {
299 match fork {
300 FoundryHardfork::Ethereum(hardfork) => spec_id_from_ethereum_hardfork(hardfork),
301 #[cfg(feature = "optimism")]
302 FoundryHardfork::Optimism(hardfork) => eth_spec_id_from_optimism_hardfork(hardfork),
303 #[cfg(feature = "base")]
304 FoundryHardfork::Base(hardfork) => BaseSpecId::new(hardfork).into_eth_spec(),
305 FoundryHardfork::Tempo(hardfork) => spec_id_from_tempo_hardfork(hardfork),
306 #[cfg(feature = "monad")]
307 FoundryHardfork::Monad(hardfork) => hardfork.into(),
308 }
309 }
310}
311
312#[cfg(feature = "optimism")]
313impl From<FoundryHardfork> for OpSpecId {
314 fn from(fork: FoundryHardfork) -> Self {
315 match fork {
316 FoundryHardfork::Optimism(hardfork) => spec_id_from_optimism_hardfork(hardfork),
317 _ => Self::default(),
318 }
319 }
320}
321
322pub fn spec_id_from_ethereum_hardfork(hardfork: EthereumHardfork) -> SpecId {
324 match hardfork {
325 EthereumHardfork::Frontier => SpecId::FRONTIER,
326 EthereumHardfork::Homestead => SpecId::HOMESTEAD,
327 EthereumHardfork::Dao => SpecId::HOMESTEAD,
328 EthereumHardfork::Tangerine => SpecId::TANGERINE,
329 EthereumHardfork::SpuriousDragon => SpecId::SPURIOUS_DRAGON,
330 EthereumHardfork::Byzantium => SpecId::BYZANTIUM,
331 EthereumHardfork::Constantinople => SpecId::PETERSBURG,
332 EthereumHardfork::Petersburg => SpecId::PETERSBURG,
333 EthereumHardfork::Istanbul => SpecId::ISTANBUL,
334 EthereumHardfork::MuirGlacier => SpecId::ISTANBUL,
335 EthereumHardfork::Berlin => SpecId::BERLIN,
336 EthereumHardfork::London => SpecId::LONDON,
337 EthereumHardfork::ArrowGlacier => SpecId::LONDON,
338 EthereumHardfork::GrayGlacier => SpecId::LONDON,
339 EthereumHardfork::Paris => SpecId::MERGE,
340 EthereumHardfork::Shanghai => SpecId::SHANGHAI,
341 EthereumHardfork::Cancun => SpecId::CANCUN,
342 EthereumHardfork::Prague => SpecId::PRAGUE,
343 EthereumHardfork::Osaka => SpecId::OSAKA,
344 EthereumHardfork::Bpo1
345 | EthereumHardfork::Bpo2
346 | EthereumHardfork::Bpo3
347 | EthereumHardfork::Bpo4
348 | EthereumHardfork::Bpo5 => SpecId::OSAKA,
349 EthereumHardfork::Amsterdam => SpecId::AMSTERDAM,
350 f => unreachable!("unimplemented {}", f),
351 }
352}
353
354#[cfg(feature = "optimism")]
356pub fn spec_id_from_optimism_hardfork(hardfork: OpHardfork) -> OpSpecId {
357 match hardfork {
358 OpHardfork::Bedrock => OpSpecId::BEDROCK,
359 OpHardfork::Regolith => OpSpecId::REGOLITH,
360 OpHardfork::Canyon => OpSpecId::CANYON,
361 OpHardfork::Ecotone => OpSpecId::ECOTONE,
362 OpHardfork::Fjord => OpSpecId::FJORD,
363 OpHardfork::Granite => OpSpecId::GRANITE,
364 OpHardfork::Holocene => OpSpecId::HOLOCENE,
365 OpHardfork::Isthmus => OpSpecId::ISTHMUS,
366 OpHardfork::Jovian => OpSpecId::JOVIAN,
367 OpHardfork::Karst => OpSpecId::KARST,
368 OpHardfork::Lagoon => OpSpecId::LAGOON,
369 f => unreachable!("unimplemented {}", f),
370 }
371}
372
373#[cfg(feature = "optimism")]
375pub fn eth_spec_id_from_optimism_hardfork(hardfork: OpHardfork) -> SpecId {
376 match hardfork {
377 OpHardfork::Bedrock | OpHardfork::Regolith => SpecId::MERGE,
378 OpHardfork::Canyon => SpecId::SHANGHAI,
379 OpHardfork::Ecotone | OpHardfork::Fjord | OpHardfork::Granite | OpHardfork::Holocene => {
380 SpecId::CANCUN
381 }
382 OpHardfork::Isthmus | OpHardfork::Jovian => SpecId::PRAGUE,
383 OpHardfork::Karst | OpHardfork::Lagoon => SpecId::OSAKA,
384 f => unreachable!("unimplemented {}", f),
385 }
386}
387
388pub const fn spec_id_from_tempo_hardfork(_: TempoHardfork) -> SpecId {
390 SpecId::OSAKA
391}
392
393pub trait FromEvmVersion: From<FoundryHardfork> {
395 fn from_evm_version(version: EvmVersion) -> Self;
396}
397
398pub trait ExecutionSpec: FromEvmVersion {
400 fn evm_version_name(&self) -> String;
402
403 fn from_network_hardfork(_: &str) -> Option<Self> {
405 None
406 }
407
408 fn from_foundry_hardfork(hardfork: FoundryHardfork) -> Option<Self>;
410
411 fn historical_hardfork(chain_id: u64, timestamp: u64) -> Option<FoundryHardfork> {
414 FoundryHardfork::from_chain_and_timestamp(chain_id, timestamp)
415 .filter(|&hardfork| Self::from_foundry_hardfork(hardfork).is_some())
416 }
417
418 fn fork_hardfork(
421 chain_id: u64,
422 timestamp: u64,
423 endpoint_hardfork: Option<FoundryHardfork>,
424 ) -> Option<FoundryHardfork> {
425 endpoint_hardfork
426 .filter(|&hardfork| Self::from_foundry_hardfork(hardfork).is_some())
427 .or_else(|| Self::historical_hardfork(chain_id, timestamp))
428 }
429
430 fn script_fork_hardfork(
433 chain_id: u64,
434 timestamp: u64,
435 endpoint_hardfork: Option<FoundryHardfork>,
436 _configured: Self,
437 ) -> Option<FoundryHardfork> {
438 Self::fork_hardfork(chain_id, timestamp, endpoint_hardfork)
439 }
440
441 fn reported_hardfork(self) -> Option<FoundryHardfork> {
444 None
445 }
446}
447
448impl FromEvmVersion for SpecId {
449 fn from_evm_version(version: EvmVersion) -> Self {
450 match version {
451 EvmVersion::Homestead => Self::HOMESTEAD,
452 EvmVersion::TangerineWhistle => Self::TANGERINE,
453 EvmVersion::SpuriousDragon => Self::SPURIOUS_DRAGON,
454 EvmVersion::Byzantium => Self::BYZANTIUM,
455 EvmVersion::Constantinople => Self::PETERSBURG,
456 EvmVersion::Petersburg => Self::PETERSBURG,
457 EvmVersion::Istanbul => Self::ISTANBUL,
458 EvmVersion::Berlin => Self::BERLIN,
459 EvmVersion::London => Self::LONDON,
460 EvmVersion::Paris => Self::MERGE,
461 EvmVersion::Shanghai => Self::SHANGHAI,
462 EvmVersion::Cancun => Self::CANCUN,
463 EvmVersion::Prague => Self::PRAGUE,
464 EvmVersion::Osaka => Self::OSAKA,
465 EvmVersion::Amsterdam => Self::AMSTERDAM,
466 }
467 }
468}
469
470impl ExecutionSpec for SpecId {
471 fn evm_version_name(&self) -> String {
473 let name = match self {
474 Self::FRONTIER => "Frontier",
475 Self::HOMESTEAD => "Homestead",
476 Self::TANGERINE => "Tangerine",
477 Self::SPURIOUS_DRAGON => "Spurious",
478 Self::BYZANTIUM => "Byzantium",
479 Self::PETERSBURG => "Petersburg",
480 Self::ISTANBUL => "Istanbul",
481 Self::BERLIN => "Berlin",
482 Self::LONDON => "London",
483 Self::MERGE => "Merge",
484 Self::SHANGHAI => "Shanghai",
485 Self::CANCUN => "Cancun",
486 Self::PRAGUE => "Prague",
487 Self::OSAKA => "Osaka",
488 Self::AMSTERDAM => "Amsterdam",
489 spec => return format!("{spec:?}"),
490 };
491 name.to_string()
492 }
493
494 fn from_network_hardfork(hardfork: &str) -> Option<Self> {
496 EthereumHardfork::from_str(hardfork).ok().map(spec_id_from_ethereum_hardfork)
497 }
498
499 fn from_foundry_hardfork(hardfork: FoundryHardfork) -> Option<Self> {
501 match hardfork {
502 FoundryHardfork::Ethereum(hardfork) => Some(spec_id_from_ethereum_hardfork(hardfork)),
503 _ => None,
504 }
505 }
506
507 fn fork_hardfork(
508 _chain_id: u64,
509 _timestamp: u64,
510 _endpoint_hardfork: Option<FoundryHardfork>,
511 ) -> Option<FoundryHardfork> {
512 None
513 }
514
515 fn script_fork_hardfork(
517 chain_id: u64,
518 timestamp: u64,
519 endpoint_hardfork: Option<FoundryHardfork>,
520 configured: Self,
521 ) -> Option<FoundryHardfork> {
522 endpoint_hardfork
523 .filter(|&hardfork| Self::from_foundry_hardfork(hardfork).is_some())
524 .or_else(|| Self::historical_hardfork(chain_id, timestamp))
525 .filter(|&hardfork| {
526 Self::from_foundry_hardfork(hardfork).is_some_and(|spec| spec > configured)
527 })
528 }
529}
530
531#[cfg(feature = "optimism")]
532impl FromEvmVersion for OpSpecId {
533 fn from_evm_version(version: EvmVersion) -> Self {
534 match version {
535 EvmVersion::Homestead
536 | EvmVersion::TangerineWhistle
537 | EvmVersion::SpuriousDragon
538 | EvmVersion::Byzantium
539 | EvmVersion::Constantinople
540 | EvmVersion::Petersburg
541 | EvmVersion::Istanbul
542 | EvmVersion::Berlin
543 | EvmVersion::London
544 | EvmVersion::Paris => Self::BEDROCK,
545 EvmVersion::Shanghai => Self::CANYON,
546 EvmVersion::Cancun => Self::ECOTONE,
547 EvmVersion::Prague => Self::ISTHMUS,
548 EvmVersion::Osaka | EvmVersion::Amsterdam => Self::KARST,
549 }
550 }
551}
552
553#[cfg(feature = "optimism")]
554impl ExecutionSpec for OpSpecId {
555 fn evm_version_name(&self) -> String {
557 let name: &'static str = (*self).into();
558 name.to_string()
559 }
560
561 fn from_network_hardfork(hardfork: &str) -> Option<Self> {
563 OpHardfork::from_str(hardfork).ok().map(spec_id_from_optimism_hardfork)
564 }
565
566 fn from_foundry_hardfork(hardfork: FoundryHardfork) -> Option<Self> {
568 match hardfork {
569 FoundryHardfork::Optimism(hardfork) => Some(spec_id_from_optimism_hardfork(hardfork)),
570 _ => None,
571 }
572 }
573
574 fn fork_hardfork(
575 chain_id: u64,
576 timestamp: u64,
577 endpoint_hardfork: Option<FoundryHardfork>,
578 ) -> Option<FoundryHardfork> {
579 let endpoint_hardfork =
580 endpoint_hardfork.filter(|&hardfork| Self::from_foundry_hardfork(hardfork).is_some());
581 if endpoint_hardfork.is_some() {
582 return endpoint_hardfork;
583 }
584
585 #[cfg(not(feature = "base"))]
588 if matches!(
589 Chain::from_id(chain_id).named(),
590 Some(NamedChain::Base | NamedChain::BaseSepolia)
591 ) {
592 return None;
593 }
594
595 Self::historical_hardfork(chain_id, timestamp)
596 }
597
598 fn historical_hardfork(chain_id: u64, timestamp: u64) -> Option<FoundryHardfork> {
599 OpHardfork::from_chain_and_timestamp(Chain::from_id(chain_id), timestamp)
600 .map(FoundryHardfork::Optimism)
601 }
602}
603
604impl FromEvmVersion for TempoHardfork {
605 fn from_evm_version(_: EvmVersion) -> Self {
606 latest_active_tempo_hardfork()
607 }
608}
609
610impl ExecutionSpec for TempoHardfork {
611 fn evm_version_name(&self) -> String {
613 self.to_string()
614 }
615
616 fn from_network_hardfork(hardfork: &str) -> Option<Self> {
618 Self::from_str(hardfork).ok()
619 }
620
621 fn from_foundry_hardfork(hardfork: FoundryHardfork) -> Option<Self> {
623 match hardfork {
624 FoundryHardfork::Tempo(hardfork) => Some(hardfork),
625 _ => None,
626 }
627 }
628
629 fn reported_hardfork(self) -> Option<FoundryHardfork> {
630 Some(self.into())
631 }
632}
633
634#[cfg(feature = "monad")]
635impl FromEvmVersion for MonadHardfork {
636 fn from_evm_version(_: EvmVersion) -> Self {
637 Self::default()
638 }
639}
640
641#[cfg(feature = "monad")]
642impl ExecutionSpec for MonadHardfork {
643 fn evm_version_name(&self) -> String {
645 self.to_string()
646 }
647
648 fn from_network_hardfork(hardfork: &str) -> Option<Self> {
650 Self::from_str(hardfork).ok()
651 }
652
653 fn from_foundry_hardfork(hardfork: FoundryHardfork) -> Option<Self> {
655 match hardfork {
656 #[cfg(feature = "monad")]
657 FoundryHardfork::Monad(hardfork) => Some(hardfork),
658 _ => None,
659 }
660 }
661
662 fn reported_hardfork(self) -> Option<FoundryHardfork> {
663 Some(self.into())
664 }
665}
666
667#[cfg(feature = "base")]
668impl FromEvmVersion for BaseSpecId {
669 fn from_evm_version(version: EvmVersion) -> Self {
670 let upgrade = match version {
671 EvmVersion::Homestead
672 | EvmVersion::TangerineWhistle
673 | EvmVersion::SpuriousDragon
674 | EvmVersion::Byzantium
675 | EvmVersion::Constantinople
676 | EvmVersion::Petersburg
677 | EvmVersion::Istanbul
678 | EvmVersion::Berlin
679 | EvmVersion::London
680 | EvmVersion::Paris => BaseUpgrade::Bedrock,
681 EvmVersion::Shanghai => BaseUpgrade::Canyon,
682 EvmVersion::Cancun => BaseUpgrade::Ecotone,
683 EvmVersion::Prague => BaseUpgrade::Isthmus,
684 EvmVersion::Osaka | EvmVersion::Amsterdam => BaseUpgrade::Azul,
685 };
686 Self::new(upgrade)
687 }
688}
689
690#[cfg(feature = "base")]
691impl ExecutionSpec for BaseSpecId {
692 fn evm_version_name(&self) -> String {
694 self.to_string()
695 }
696
697 fn from_network_hardfork(hardfork: &str) -> Option<Self> {
699 Self::from_str(hardfork).ok()
700 }
701
702 fn from_foundry_hardfork(hardfork: FoundryHardfork) -> Option<Self> {
704 match hardfork {
705 FoundryHardfork::Base(hardfork) => Some(Self::new(hardfork)),
706 _ => None,
707 }
708 }
709
710 fn reported_hardfork(self) -> Option<FoundryHardfork> {
711 Some(FoundryHardfork::Base(self.upgrade()))
712 }
713}
714
715pub fn evm_spec_id<SPEC: FromEvmVersion>(evm_version: EvmVersion) -> SPEC {
717 SPEC::from_evm_version(evm_version)
718}
719
720pub fn latest_active_tempo_hardfork() -> TempoHardfork {
722 let now = SystemTime::now()
724 .duration_since(UNIX_EPOCH)
725 .map(|duration| duration.as_secs())
726 .unwrap_or(u64::MAX);
727 TempoHardfork::from_chain_and_timestamp(4217, now)
728 .or_else(|| TempoHardfork::from_chain_and_timestamp(42431, now))
729 .unwrap_or_default()
730}
731
732pub fn evm_spec_id_from_str<SPEC: ExecutionSpec>(evm_version: &str) -> Option<SPEC> {
734 let evm_version = evm_version.trim();
735
736 if let Ok(version) = EvmVersion::from_str(evm_version) {
737 return Some(evm_spec_id(version));
738 }
739
740 if let Some(spec) = SPEC::from_network_hardfork(evm_version) {
741 return Some(spec);
742 }
743
744 FoundryHardfork::from_str(evm_version).ok().and_then(SPEC::from_foundry_hardfork)
745}
746
747pub fn ethereum_hardfork_from_block_tag(block: impl Into<BlockNumberOrTag>) -> EthereumHardfork {
749 let num = match block.into() {
750 BlockNumberOrTag::Earliest => 0,
751 BlockNumberOrTag::Number(num) => num,
752 _ => u64::MAX,
753 };
754
755 EthereumHardfork::from_mainnet_block_number(num)
756}
757
758#[cfg(test)]
759mod tests {
760 use super::*;
761 use alloy_hardforks::ethereum::mainnet::*;
762 use tempo_hardfork::constants::{mainnet::*, moderato::*};
763
764 #[test]
765 fn test_ethereum_spec_id_mapping() {
766 for (hardfork, expected) in [
767 (EthereumHardfork::Frontier, SpecId::FRONTIER),
768 (EthereumHardfork::Homestead, SpecId::HOMESTEAD),
769 (EthereumHardfork::Dao, SpecId::HOMESTEAD),
770 (EthereumHardfork::Tangerine, SpecId::TANGERINE),
771 (EthereumHardfork::SpuriousDragon, SpecId::SPURIOUS_DRAGON),
772 (EthereumHardfork::Byzantium, SpecId::BYZANTIUM),
773 (EthereumHardfork::Constantinople, SpecId::PETERSBURG),
774 (EthereumHardfork::Petersburg, SpecId::PETERSBURG),
775 (EthereumHardfork::Istanbul, SpecId::ISTANBUL),
776 (EthereumHardfork::MuirGlacier, SpecId::ISTANBUL),
777 (EthereumHardfork::Berlin, SpecId::BERLIN),
778 (EthereumHardfork::London, SpecId::LONDON),
779 (EthereumHardfork::ArrowGlacier, SpecId::LONDON),
780 (EthereumHardfork::GrayGlacier, SpecId::LONDON),
781 (EthereumHardfork::Paris, SpecId::MERGE),
782 (EthereumHardfork::Shanghai, SpecId::SHANGHAI),
783 (EthereumHardfork::Cancun, SpecId::CANCUN),
784 (EthereumHardfork::Prague, SpecId::PRAGUE),
785 (EthereumHardfork::Osaka, SpecId::OSAKA),
786 (EthereumHardfork::Bpo1, SpecId::OSAKA),
787 (EthereumHardfork::Bpo2, SpecId::OSAKA),
788 (EthereumHardfork::Bpo3, SpecId::OSAKA),
789 (EthereumHardfork::Bpo4, SpecId::OSAKA),
790 (EthereumHardfork::Bpo5, SpecId::OSAKA),
791 (EthereumHardfork::Amsterdam, SpecId::AMSTERDAM),
792 ] {
793 assert_eq!(spec_id_from_ethereum_hardfork(hardfork), expected, "{hardfork}");
794 }
795 }
796
797 #[test]
798 fn test_tempo_spec_id_mapping() {
799 assert_eq!(spec_id_from_tempo_hardfork(TempoHardfork::Genesis), SpecId::OSAKA);
800 assert_eq!(spec_id_from_tempo_hardfork(TempoHardfork::T8), SpecId::OSAKA);
801 }
802
803 #[test]
804 fn test_tempo_evm_version_defaults_to_latest_active_hardfork() {
805 let latest = latest_active_tempo_hardfork();
806 assert_eq!(evm_spec_id::<TempoHardfork>(EvmVersion::Osaka), latest);
807 }
808
809 #[test]
810 #[cfg(feature = "monad")]
811 fn test_monad_hardfork_parsing() {
812 assert_eq!(
813 "monad:MonadNine".parse::<FoundryHardfork>().unwrap(),
814 FoundryHardfork::Monad(MonadHardfork::MonadNine)
815 );
816 assert_eq!(
817 "monad:MonadTen".parse::<FoundryHardfork>().unwrap(),
818 FoundryHardfork::Monad(MonadHardfork::MonadTen)
819 );
820 assert_eq!(
821 "m:MonadNext".parse::<FoundryHardfork>().unwrap(),
822 FoundryHardfork::Monad(MonadHardfork::MonadNext)
823 );
824 }
825
826 #[test]
827 fn test_hardfork_namespace_parsing() {
828 let cases = [
829 ("prague", Ok(FoundryHardfork::Ethereum(EthereumHardfork::Prague))),
830 ("eth:prague", Ok(FoundryHardfork::Ethereum(EthereumHardfork::Prague))),
831 ("ethereum:Osaka", Ok(FoundryHardfork::Ethereum(EthereumHardfork::Osaka))),
832 (" ETH : Prague ", Ok(FoundryHardfork::Ethereum(EthereumHardfork::Prague))),
833 ("t:T5", Ok(FoundryHardfork::Tempo(TempoHardfork::T5))),
834 ("tempo:t5", Ok(FoundryHardfork::Tempo(TempoHardfork::T5))),
835 #[cfg(feature = "optimism")]
836 ("op:Isthmus", Ok(FoundryHardfork::Optimism(OpHardfork::Isthmus))),
837 #[cfg(feature = "optimism")]
838 ("optimism:jovian", Ok(FoundryHardfork::Optimism(OpHardfork::Jovian))),
839 #[cfg(not(feature = "optimism"))]
840 ("op:prague", Err("hardfork namespace 'op' requires the `optimism` feature")),
841 #[cfg(feature = "base")]
842 ("base:azul", Ok(FoundryHardfork::Base(BaseUpgrade::Azul))),
843 #[cfg(not(feature = "base"))]
844 ("base:prague", Err("hardfork namespace 'base' requires the `base` feature")),
845 #[cfg(feature = "monad")]
846 ("m:MonadTen", Ok(FoundryHardfork::Monad(MonadHardfork::MonadTen))),
847 #[cfg(feature = "monad")]
848 ("monad:monadnine", Ok(FoundryHardfork::Monad(MonadHardfork::MonadNine))),
849 #[cfg(not(feature = "monad"))]
850 ("monad:prague", Err("hardfork namespace 'monad' requires the `monad` feature")),
851 ("foo:prague", Err("unknown hardfork namespace 'foo'")),
852 ("Foo:Prague", Err("unknown hardfork namespace 'foo'")),
853 ];
854
855 for (input, expected) in cases {
856 assert_eq!(
857 input.parse::<FoundryHardfork>(),
858 expected.map_err(str::to_string),
859 "{input}"
860 );
861 }
862 }
863
864 #[test]
865 #[cfg(feature = "monad")]
866 fn test_monad_hardfork_serialization() {
867 assert_eq!(
868 String::from(FoundryHardfork::Monad(MonadHardfork::MonadEight)),
869 "monad:MonadEight"
870 );
871 assert_eq!(FoundryHardfork::Monad(MonadHardfork::MonadEight).namespace(), Some("monad"));
872 assert_eq!(FoundryHardfork::Monad(MonadHardfork::MonadEight).name(), "MonadEight");
873 }
874
875 #[test]
876 #[cfg(feature = "monad")]
877 fn test_monad_hardfork_spec_id_mapping() {
878 assert_eq!(SpecId::from(FoundryHardfork::Monad(MonadHardfork::MonadEight)), SpecId::PRAGUE);
879 assert_eq!(SpecId::from(FoundryHardfork::Monad(MonadHardfork::MonadNine)), SpecId::OSAKA);
880 assert_eq!(SpecId::from(FoundryHardfork::Monad(MonadHardfork::MonadTen)), SpecId::OSAKA);
881 assert_eq!(
882 MonadHardfork::from(FoundryHardfork::Monad(MonadHardfork::MonadNext)),
883 MonadHardfork::MonadNext
884 );
885 }
886
887 #[test]
888 fn test_tempo_hardfork_from_chain_and_timestamp() {
889 assert_eq!(
890 FoundryHardfork::from_chain_and_timestamp(4217, u64::MAX),
891 Some(FoundryHardfork::Tempo(TempoHardfork::T14))
892 );
893 assert_eq!(
894 FoundryHardfork::from_chain_and_timestamp(42431, u64::MAX),
895 Some(FoundryHardfork::Tempo(TempoHardfork::T14))
896 );
897 assert_eq!(
898 FoundryHardfork::from_chain_and_timestamp(MAINNET_CHAIN_ID, MAINNET_T14_TIMESTAMP - 1),
899 Some(FoundryHardfork::Tempo(TempoHardfork::T13))
900 );
901 assert_eq!(
902 FoundryHardfork::from_chain_and_timestamp(MAINNET_CHAIN_ID, MAINNET_T14_TIMESTAMP),
903 Some(FoundryHardfork::Tempo(TempoHardfork::T14))
904 );
905 assert_eq!(
906 FoundryHardfork::from_chain_and_timestamp(
907 MODERATO_CHAIN_ID,
908 MODERATO_T14_TIMESTAMP - 1
909 ),
910 Some(FoundryHardfork::Tempo(TempoHardfork::T13))
911 );
912 assert_eq!(
913 FoundryHardfork::from_chain_and_timestamp(MODERATO_CHAIN_ID, MODERATO_T14_TIMESTAMP),
914 Some(FoundryHardfork::Tempo(TempoHardfork::T14))
915 );
916 assert_eq!(
917 FoundryHardfork::from_chain_and_timestamp(MAINNET_CHAIN_ID, MAINNET_T13_TIMESTAMP - 1),
918 Some(FoundryHardfork::Tempo(TempoHardfork::T12))
919 );
920 assert_eq!(
921 FoundryHardfork::from_chain_and_timestamp(MAINNET_CHAIN_ID, MAINNET_T13_TIMESTAMP),
922 Some(FoundryHardfork::Tempo(TempoHardfork::T13))
923 );
924 assert_eq!(
925 FoundryHardfork::from_chain_and_timestamp(
926 MODERATO_CHAIN_ID,
927 MODERATO_T13_TIMESTAMP - 1
928 ),
929 Some(FoundryHardfork::Tempo(TempoHardfork::T12))
930 );
931 assert_eq!(
932 FoundryHardfork::from_chain_and_timestamp(MODERATO_CHAIN_ID, MODERATO_T13_TIMESTAMP),
933 Some(FoundryHardfork::Tempo(TempoHardfork::T13))
934 );
935
936 assert_eq!(
937 FoundryHardfork::from_chain_and_timestamp(MAINNET_CHAIN_ID, MAINNET_T6_TIMESTAMP - 1),
938 Some(FoundryHardfork::Tempo(TempoHardfork::T5))
939 );
940 assert_eq!(
941 FoundryHardfork::from_chain_and_timestamp(MAINNET_CHAIN_ID, MAINNET_T6_TIMESTAMP),
942 Some(FoundryHardfork::Tempo(TempoHardfork::T6))
943 );
944 assert_eq!(
945 FoundryHardfork::from_chain_and_timestamp(MAINNET_CHAIN_ID, MAINNET_T7_TIMESTAMP - 1),
946 Some(FoundryHardfork::Tempo(TempoHardfork::T6))
947 );
948 assert_eq!(
949 FoundryHardfork::from_chain_and_timestamp(MAINNET_CHAIN_ID, MAINNET_T7_TIMESTAMP),
950 Some(FoundryHardfork::Tempo(TempoHardfork::T7))
951 );
952 assert_eq!(
953 FoundryHardfork::from_chain_and_timestamp(MAINNET_CHAIN_ID, MAINNET_T8_TIMESTAMP - 1),
954 Some(FoundryHardfork::Tempo(TempoHardfork::T7))
955 );
956 assert_eq!(
957 FoundryHardfork::from_chain_and_timestamp(MAINNET_CHAIN_ID, MAINNET_T8_TIMESTAMP),
958 Some(FoundryHardfork::Tempo(TempoHardfork::T8))
959 );
960 assert_eq!(
961 FoundryHardfork::from_chain_and_timestamp(MAINNET_CHAIN_ID, MAINNET_T9_TIMESTAMP - 1),
962 Some(FoundryHardfork::Tempo(TempoHardfork::T8))
963 );
964 assert_eq!(
965 FoundryHardfork::from_chain_and_timestamp(MAINNET_CHAIN_ID, MAINNET_T9_TIMESTAMP),
966 Some(FoundryHardfork::Tempo(TempoHardfork::T9))
967 );
968 assert_eq!(
969 FoundryHardfork::from_chain_and_timestamp(MODERATO_CHAIN_ID, MODERATO_T6_TIMESTAMP - 1),
970 Some(FoundryHardfork::Tempo(TempoHardfork::T5))
971 );
972 assert_eq!(
973 FoundryHardfork::from_chain_and_timestamp(MODERATO_CHAIN_ID, MODERATO_T6_TIMESTAMP),
974 Some(FoundryHardfork::Tempo(TempoHardfork::T6))
975 );
976 assert_eq!(
977 FoundryHardfork::from_chain_and_timestamp(MODERATO_CHAIN_ID, MODERATO_T7_TIMESTAMP - 1),
978 Some(FoundryHardfork::Tempo(TempoHardfork::T6))
979 );
980 assert_eq!(
981 FoundryHardfork::from_chain_and_timestamp(MODERATO_CHAIN_ID, MODERATO_T7_TIMESTAMP),
982 Some(FoundryHardfork::Tempo(TempoHardfork::T7))
983 );
984 assert_eq!(
985 FoundryHardfork::from_chain_and_timestamp(MODERATO_CHAIN_ID, MODERATO_T8_TIMESTAMP - 1),
986 Some(FoundryHardfork::Tempo(TempoHardfork::T7))
987 );
988 assert_eq!(
989 FoundryHardfork::from_chain_and_timestamp(MODERATO_CHAIN_ID, MODERATO_T8_TIMESTAMP),
990 Some(FoundryHardfork::Tempo(TempoHardfork::T8))
991 );
992 assert_eq!(
993 FoundryHardfork::from_chain_and_timestamp(MODERATO_CHAIN_ID, MODERATO_T9_TIMESTAMP - 1),
994 Some(FoundryHardfork::Tempo(TempoHardfork::T8))
995 );
996 assert_eq!(
997 FoundryHardfork::from_chain_and_timestamp(MODERATO_CHAIN_ID, MODERATO_T9_TIMESTAMP),
998 Some(FoundryHardfork::Tempo(TempoHardfork::T9))
999 );
1000 }
1001
1002 #[test]
1003 #[cfg(feature = "monad")]
1004 fn test_monad_hardfork_from_chain_and_timestamp() {
1005 let mainnet_ten = MonadHardfork::MonadTen.mainnet_activation_timestamp().unwrap();
1006 let testnet_ten = MonadHardfork::MonadTen.testnet_activation_timestamp().unwrap();
1007
1008 assert_eq!(
1009 FoundryHardfork::from_chain_and_timestamp(
1010 monad_evm2::MONAD_MAINNET_CHAIN_ID,
1011 1_763_648_999,
1012 ),
1013 Some(FoundryHardfork::Monad(MonadHardfork::MonadEight))
1014 );
1015 assert_eq!(
1016 FoundryHardfork::from_chain_and_timestamp(
1017 monad_evm2::MONAD_MAINNET_CHAIN_ID,
1018 1_773_930_600,
1019 ),
1020 Some(FoundryHardfork::Monad(MonadHardfork::MonadNine))
1021 );
1022 assert_eq!(
1023 FoundryHardfork::from_chain_and_timestamp(
1024 monad_evm2::MONAD_MAINNET_CHAIN_ID,
1025 mainnet_ten - 1,
1026 ),
1027 Some(FoundryHardfork::Monad(MonadHardfork::MonadNine))
1028 );
1029 assert_eq!(
1030 FoundryHardfork::from_chain_and_timestamp(
1031 monad_evm2::MONAD_MAINNET_CHAIN_ID,
1032 mainnet_ten,
1033 ),
1034 Some(FoundryHardfork::Monad(MonadHardfork::MonadTen))
1035 );
1036 assert_eq!(
1037 FoundryHardfork::from_chain_and_timestamp(
1038 monad_evm2::MONAD_TESTNET_CHAIN_ID,
1039 1_773_152_999,
1040 ),
1041 Some(FoundryHardfork::Monad(MonadHardfork::MonadEight))
1042 );
1043 assert_eq!(
1044 FoundryHardfork::from_chain_and_timestamp(
1045 monad_evm2::MONAD_TESTNET_CHAIN_ID,
1046 1_773_153_000,
1047 ),
1048 Some(FoundryHardfork::Monad(MonadHardfork::MonadNine))
1049 );
1050 assert_eq!(
1051 FoundryHardfork::from_chain_and_timestamp(
1052 monad_evm2::MONAD_TESTNET_CHAIN_ID,
1053 testnet_ten - 1,
1054 ),
1055 Some(FoundryHardfork::Monad(MonadHardfork::MonadNine))
1056 );
1057 assert_eq!(
1058 FoundryHardfork::from_chain_and_timestamp(
1059 monad_evm2::MONAD_TESTNET_CHAIN_ID,
1060 testnet_ten,
1061 ),
1062 Some(FoundryHardfork::Monad(MonadHardfork::MonadTen))
1063 );
1064 }
1065
1066 #[test]
1067 fn test_evm_spec_id_from_str_parses_network_hardforks() {
1068 assert_eq!(evm_spec_id_from_str::<TempoHardfork>("T3"), Some(TempoHardfork::T3));
1069 assert_eq!(evm_spec_id_from_str::<TempoHardfork>("tempo:T2"), Some(TempoHardfork::T2));
1070 assert_eq!(evm_spec_id_from_str::<TempoHardfork>("tempo:T7"), Some(TempoHardfork::T7));
1071 assert_eq!(evm_spec_id_from_str::<TempoHardfork>("tempo:T8"), Some(TempoHardfork::T8));
1072 assert_eq!(evm_spec_id_from_str::<TempoHardfork>("tempo:T13"), Some(TempoHardfork::T13));
1073 assert_eq!(evm_spec_id_from_str::<TempoHardfork>("T13"), Some(TempoHardfork::T13));
1074 assert_eq!(evm_spec_id_from_str::<TempoHardfork>("tempo:T14"), Some(TempoHardfork::T14));
1075 assert_eq!(evm_spec_id_from_str::<TempoHardfork>("T14"), Some(TempoHardfork::T14));
1076 assert_eq!(evm_spec_id_from_str::<TempoHardfork>("ethereum:prague"), None);
1077
1078 #[cfg(feature = "monad")]
1079 {
1080 assert_eq!(
1081 evm_spec_id_from_str::<MonadHardfork>("MonadNine"),
1082 Some(MonadHardfork::MonadNine)
1083 );
1084 assert_eq!(
1085 evm_spec_id_from_str::<MonadHardfork>("MonadTen"),
1086 Some(MonadHardfork::MonadTen)
1087 );
1088 assert_eq!(
1089 evm_spec_id_from_str::<MonadHardfork>("monad:MonadEight"),
1090 Some(MonadHardfork::MonadEight)
1091 );
1092 assert_eq!(evm_spec_id_from_str::<MonadHardfork>("tempo:T3"), None);
1093 }
1094 }
1095
1096 #[test]
1097 fn test_evm_version_names() {
1098 for (input, spec, name) in [
1099 ("spuriousDragon", SpecId::SPURIOUS_DRAGON, "Spurious"),
1100 ("paris", SpecId::MERGE, "Merge"),
1101 ("cancun", SpecId::CANCUN, "Cancun"),
1102 ("ethereum:prague", SpecId::PRAGUE, "Prague"),
1103 ("Amsterdam", SpecId::AMSTERDAM, "Amsterdam"),
1104 ] {
1105 assert_eq!(evm_spec_id_from_str::<SpecId>(input), Some(spec), "{input}");
1106 assert_eq!(spec.evm_version_name(), name, "{input}");
1107 }
1108 assert_eq!(TempoHardfork::T3.evm_version_name(), "T3");
1109 assert_eq!(
1110 TempoHardfork::T3.reported_hardfork(),
1111 Some(FoundryHardfork::Tempo(TempoHardfork::T3))
1112 );
1113 }
1114
1115 #[test]
1116 fn test_hardfork_from_block_tag_numbers() {
1117 assert_eq!(
1118 ethereum_hardfork_from_block_tag(MAINNET_HOMESTEAD_BLOCK - 1),
1119 EthereumHardfork::Frontier
1120 );
1121 assert_eq!(
1122 ethereum_hardfork_from_block_tag(MAINNET_LONDON_BLOCK + 1),
1123 EthereumHardfork::London
1124 );
1125 }
1126
1127 #[test]
1128 fn test_from_chain_and_timestamp_ethereum_mainnet() {
1129 assert_eq!(
1130 FoundryHardfork::from_chain_and_timestamp(1, 0),
1131 Some(FoundryHardfork::Ethereum(EthereumHardfork::Frontier))
1132 );
1133 assert_eq!(
1135 FoundryHardfork::from_chain_and_timestamp(1, 1_681_338_455),
1136 Some(FoundryHardfork::Ethereum(EthereumHardfork::Shanghai))
1137 );
1138 }
1139
1140 #[test]
1141 fn test_from_chain_and_timestamp_sepolia() {
1142 let sepolia_chain_id = 11155111;
1143 assert!(FoundryHardfork::from_chain_and_timestamp(sepolia_chain_id, u64::MAX).is_some());
1144 }
1145
1146 #[test]
1147 fn test_from_chain_and_timestamp_unknown_chain() {
1148 assert_eq!(FoundryHardfork::from_chain_and_timestamp(999999, 0), None);
1149 }
1150
1151 #[cfg(feature = "base")]
1152 mod base {
1153 use super::*;
1154 use base_common_genesis::UpgradeConfig;
1155
1156 #[test]
1157 fn test_base_hardfork_serialization() {
1158 assert_eq!(String::from(FoundryHardfork::Base(BaseUpgrade::Azul)), "base:Azul");
1159 assert_eq!(FoundryHardfork::Base(BaseUpgrade::Azul).namespace(), Some("base"));
1160 assert_eq!(FoundryHardfork::Base(BaseUpgrade::Azul).name(), "Azul");
1161 }
1162
1163 #[test]
1164 fn test_base_hardfork_spec_id_mapping() {
1165 assert_eq!(SpecId::from(FoundryHardfork::Base(BaseUpgrade::Azul)), SpecId::OSAKA);
1166 assert_eq!(SpecId::from(FoundryHardfork::Base(BaseUpgrade::Jovian)), SpecId::PRAGUE);
1167 assert_eq!(
1168 BaseSpecId::from(FoundryHardfork::Base(BaseUpgrade::Azul)),
1169 BaseSpecId::new(BaseUpgrade::Azul)
1170 );
1171 }
1172
1173 #[test]
1174 fn test_base_hardfork_parsing() {
1175 assert_eq!(
1176 "base:Azul".parse::<FoundryHardfork>().unwrap(),
1177 FoundryHardfork::Base(BaseUpgrade::Azul)
1178 );
1179 assert_eq!(
1180 "base:Beryl".parse::<FoundryHardfork>().unwrap(),
1181 FoundryHardfork::Base(BaseUpgrade::Beryl)
1182 );
1183 }
1184
1185 #[test]
1186 fn test_base_hardfork_from_chain_and_timestamp() {
1187 let mainnet_config = UpgradeConfig::BASE_MAINNET;
1188 let sepolia_config = UpgradeConfig::BASE_SEPOLIA;
1189 assert_eq!(
1190 FoundryHardfork::from_chain_and_timestamp(8453, u64::MAX),
1191 Some(FoundryHardfork::Base(BaseUpgrade::Denim))
1192 );
1193 assert_eq!(
1194 FoundryHardfork::from_chain_and_timestamp(84532, u64::MAX),
1195 Some(FoundryHardfork::Base(BaseUpgrade::Denim))
1196 );
1197 assert_eq!(
1198 FoundryHardfork::from_chain_and_timestamp(8453, mainnet_config.base.azul.unwrap()),
1199 Some(FoundryHardfork::Base(BaseUpgrade::Azul))
1200 );
1201 assert_eq!(
1202 FoundryHardfork::from_chain_and_timestamp(84532, sepolia_config.base.azul.unwrap()),
1203 Some(FoundryHardfork::Base(BaseUpgrade::Azul))
1204 );
1205 assert_eq!(
1206 FoundryHardfork::from_chain_and_timestamp(
1207 8453,
1208 mainnet_config.base.azul.unwrap() - 1
1209 ),
1210 Some(FoundryHardfork::Base(BaseUpgrade::Jovian))
1211 );
1212 assert_eq!(
1213 FoundryHardfork::from_chain_and_timestamp(
1214 84532,
1215 sepolia_config.base.azul.unwrap() - 1
1216 ),
1217 Some(FoundryHardfork::Base(BaseUpgrade::Jovian))
1218 );
1219 }
1220
1221 #[test]
1222 fn test_evm_spec_id_from_str_parses_base_upgrades() {
1223 assert_eq!(
1224 evm_spec_id_from_str::<BaseSpecId>("Azul"),
1225 Some(BaseSpecId::new(BaseUpgrade::Azul))
1226 );
1227 assert_eq!(
1228 evm_spec_id_from_str::<BaseSpecId>("base:Beryl"),
1229 Some(BaseSpecId::new(BaseUpgrade::Beryl))
1230 );
1231 assert_eq!(evm_spec_id_from_str::<BaseSpecId>("tempo:T3"), None);
1232 }
1233 }
1234
1235 #[cfg(feature = "optimism")]
1236 mod optimism {
1237 use super::*;
1238
1239 #[cfg(feature = "base")]
1240 use base_common_genesis::UpgradeConfig;
1241
1242 #[test]
1243 fn test_optimism_spec_id_mapping() {
1244 assert_eq!(spec_id_from_optimism_hardfork(OpHardfork::Bedrock), OpSpecId::BEDROCK);
1245 assert_eq!(spec_id_from_optimism_hardfork(OpHardfork::Regolith), OpSpecId::REGOLITH);
1246
1247 assert_eq!(spec_id_from_optimism_hardfork(OpHardfork::Holocene), OpSpecId::HOLOCENE);
1249 assert_eq!(spec_id_from_optimism_hardfork(OpHardfork::Karst), OpSpecId::KARST);
1250 assert_eq!(spec_id_from_optimism_hardfork(OpHardfork::Lagoon), OpSpecId::LAGOON);
1251 assert_eq!(eth_spec_id_from_optimism_hardfork(OpHardfork::Jovian), SpecId::PRAGUE);
1252 assert_eq!(eth_spec_id_from_optimism_hardfork(OpHardfork::Karst), SpecId::OSAKA);
1253 assert_eq!(eth_spec_id_from_optimism_hardfork(OpHardfork::Lagoon), SpecId::OSAKA);
1254 assert_eq!(evm_spec_id::<OpSpecId>(EvmVersion::Osaka), OpSpecId::KARST);
1255 }
1256
1257 #[test]
1258 fn test_optimism_evm_version_names() {
1259 for (input, spec, name) in [
1260 ("prague", OpSpecId::ISTHMUS, "Isthmus"),
1261 ("isthmus", OpSpecId::ISTHMUS, "Isthmus"),
1262 ("optimism:jovian", OpSpecId::JOVIAN, "Jovian"),
1263 ] {
1264 assert_eq!(evm_spec_id_from_str::<OpSpecId>(input), Some(spec), "{input}");
1265 assert_eq!(spec.evm_version_name(), name, "{input}");
1266 }
1267 }
1268
1269 #[test]
1270 fn test_from_chain_and_timestamp_op_mainnet() {
1271 let op_chain_id = 10;
1272 assert!(matches!(
1273 FoundryHardfork::from_chain_and_timestamp(op_chain_id, u64::MAX),
1274 Some(FoundryHardfork::Optimism(_))
1275 ));
1276 }
1277
1278 #[test]
1279 #[cfg(feature = "base")]
1280 fn test_base_chain_historical_hardfork_is_execution_family_specific() {
1281 let chains = [
1282 (8453, UpgradeConfig::BASE_MAINNET.ecotone_time.unwrap()),
1283 (84532, UpgradeConfig::BASE_SEPOLIA.ecotone_time.unwrap()),
1284 ];
1285
1286 for (chain_id, timestamp) in chains {
1287 assert_eq!(
1288 FoundryHardfork::from_chain_and_timestamp(chain_id, timestamp),
1289 Some(FoundryHardfork::Base(BaseUpgrade::Ecotone))
1290 );
1291 assert_eq!(
1292 BaseSpecId::historical_hardfork(chain_id, timestamp),
1293 Some(FoundryHardfork::Base(BaseUpgrade::Ecotone))
1294 );
1295 assert_eq!(
1296 OpSpecId::historical_hardfork(chain_id, timestamp),
1297 Some(FoundryHardfork::Optimism(OpHardfork::Ecotone))
1298 );
1299 assert_eq!(
1300 OpSpecId::fork_hardfork(chain_id, timestamp, None),
1301 Some(FoundryHardfork::Optimism(OpHardfork::Ecotone))
1302 );
1303 }
1304 }
1305
1306 #[test]
1309 #[cfg(not(feature = "base"))]
1310 fn test_from_chain_and_timestamp_base() {
1311 let base_chain_id = 8453;
1312 assert!(matches!(
1313 FoundryHardfork::from_chain_and_timestamp(base_chain_id, u64::MAX),
1314 Some(FoundryHardfork::Optimism(_))
1315 ));
1316 }
1317 }
1318}