Skip to main content

foundry_evm_hardforks/
lib.rs

1//! EVM hardfork definitions for Foundry.
2//!
3//! Provides [`FoundryHardfork`], a unified enum over Ethereum, Optimism, Tempo, and Monad hardforks
4//! with `FromStr`/`Serialize`/`Deserialize` support for CLI and config usage.
5
6use 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    /// Returns the hardfork name without a network namespace prefix.
150    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    /// Returns the network namespace for this hardfork, or `None` for plain Ethereum.
164    ///
165    /// Mirrors the namespace prefix used in the `"network:hardfork"` serialization format.
166    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    /// Auto-detect the active hardfork for a given chain at a specific timestamp.
180    ///
181    /// Tries Ethereum, then Optimism, Tempo, and Monad. Returns `None` for unknown chains.
182    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
322/// Map an `EthereumHardfork` enum into its corresponding `SpecId`.
323pub 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/// Map an `OptimismHardfork` enum into its corresponding `OpSpecId`.
355#[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/// Map an `OptimismHardfork` enum into its corresponding Ethereum `SpecId`.
374#[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
388/// Map a `TempoHardfork` enum into its corresponding Ethereum `SpecId`.
389pub const fn spec_id_from_tempo_hardfork(_: TempoHardfork) -> SpecId {
390    SpecId::OSAKA
391}
392
393/// Trait for converting an [`EvmVersion`] into a network-specific spec type.
394pub trait FromEvmVersion: From<FoundryHardfork> {
395    fn from_evm_version(version: EvmVersion) -> Self;
396}
397
398/// Conversion, hardfork scheduling, and trace metadata for a concrete execution spec.
399pub trait ExecutionSpec: FromEvmVersion {
400    // Returns the user-facing name for the active execution spec.
401    fn evm_version_name(&self) -> String;
402
403    // Parses an unnamespaced hardfork name for the active network.
404    fn from_network_hardfork(_: &str) -> Option<Self> {
405        None
406    }
407
408    // Converts a namespaced Foundry hardfork if it belongs to this spec family.
409    fn from_foundry_hardfork(hardfork: FoundryHardfork) -> Option<Self>;
410
411    /// Returns this family's hardfork at a historical source-chain timestamp.
412    /// Unknown source chains return `None`; this never discovers another execution family.
413    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    /// Resolves a local fork's hardfork from compatible endpoint metadata or its source schedule.
419    /// Ethereum overrides this to retain the configured EVM version for local forks.
420    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    /// Resolves the hardfork of a script fork, whose transactions are sent to the source chain.
431    /// Ethereum overrides this to follow the source chain when it is ahead of `configured`.
432    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    /// Returns exact metadata for a directly selected spec, when the family requires it.
442    /// Ethereum and Optimism retain their existing absence of metadata for direct spec overrides.
443    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    // Returns the user-facing name for the active execution spec.
472    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    // Parses an unnamespaced Ethereum hardfork name.
495    fn from_network_hardfork(hardfork: &str) -> Option<Self> {
496        EthereumHardfork::from_str(hardfork).ok().map(spec_id_from_ethereum_hardfork)
497    }
498
499    // Converts only Ethereum namespaced hardforks to an Ethereum spec.
500    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    // Gas limits come from the script simulation, so it must not price below the source chain.
516    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    // Returns the user-facing name for the active execution spec.
556    fn evm_version_name(&self) -> String {
557        let name: &'static str = (*self).into();
558        name.to_string()
559    }
560
561    // Parses an unnamespaced Optimism hardfork name.
562    fn from_network_hardfork(hardfork: &str) -> Option<Self> {
563        OpHardfork::from_str(hardfork).ok().map(spec_id_from_optimism_hardfork)
564    }
565
566    // Converts only Optimism namespaced hardforks to an Optimism spec.
567    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        // Base uses its own upgrade schedule. Without native Base support, retain the configured
586        // EVM version instead of applying the incompatible OP schedule.
587        #[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    // Returns the user-facing name for the active execution spec.
612    fn evm_version_name(&self) -> String {
613        self.to_string()
614    }
615
616    // Parses an unnamespaced Tempo hardfork name.
617    fn from_network_hardfork(hardfork: &str) -> Option<Self> {
618        Self::from_str(hardfork).ok()
619    }
620
621    // Converts only Tempo namespaced hardforks to a Tempo spec.
622    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    // Returns the user-facing name for the active execution spec.
644    fn evm_version_name(&self) -> String {
645        self.to_string()
646    }
647
648    // Parses an unnamespaced Monad hardfork name.
649    fn from_network_hardfork(hardfork: &str) -> Option<Self> {
650        Self::from_str(hardfork).ok()
651    }
652
653    // Converts only Monad namespaced hardforks to a Monad spec.
654    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    // Returns the user-facing name for the active execution spec.
693    fn evm_version_name(&self) -> String {
694        self.to_string()
695    }
696
697    // Parses an unnamespaced Base hardfork name.
698    fn from_network_hardfork(hardfork: &str) -> Option<Self> {
699        Self::from_str(hardfork).ok()
700    }
701
702    // Converts only Base namespaced hardforks to a Base spec.
703    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
715/// Returns the spec id derived from [`EvmVersion`] for a given spec type.
716pub fn evm_spec_id<SPEC: FromEvmVersion>(evm_version: EvmVersion) -> SPEC {
717    SPEC::from_evm_version(evm_version)
718}
719
720/// Returns the latest Tempo hardfork that has an activation on a known Tempo network.
721pub fn latest_active_tempo_hardfork() -> TempoHardfork {
722    // Tempo currently publishes activation timestamps through chain-aware hardfork resolution.
723    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
732// Parses an EVM version or network-specific hardfork into the given spec type.
733pub 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
747/// Convert a `BlockNumberOrTag` into an `EthereumHardfork`.
748pub 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        // Shanghai activated at timestamp 1681338455 on mainnet
1134        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            // Test latest hardforks
1248            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        /// Base is an OP-stack chain, so without the `base` feature its chain IDs must still map
1307        /// to an Optimism hardfork rather than resolving to nothing.
1308        #[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}