test: add comprehensive test coverage and E2E integration tests

crates/chainspec/src/constants.rs

@@ -49,3 +49,54 @@ pub const L2_MESSAGE_QUEUE_ADDRESS: Address = address!("530000000000000000000000
 ///
 /// This is slot 33, which stores the Merkle root for L2->L1 messages.
 pub const L2_MESSAGE_QUEUE_WITHDRAW_TRIE_ROOT_SLOT: U256 = U256::from_limbs([33, 0, 0, 0]);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_chain_ids_are_distinct() {
+        assert_ne!(MORPH_MAINNET_CHAIN_ID, MORPH_HOODI_CHAIN_ID);
+    }
+
+    #[test]
+    fn test_chain_id_values() {
+        assert_eq!(MORPH_MAINNET_CHAIN_ID, 2818);
+        assert_eq!(MORPH_HOODI_CHAIN_ID, 2910);
+    }
+
+    #[test]
+    fn test_genesis_hashes_are_distinct() {
+        assert_ne!(MORPH_MAINNET_GENESIS_HASH, MORPH_HOODI_GENESIS_HASH);
+        assert_ne!(
+            MORPH_MAINNET_GENESIS_STATE_ROOT,
+            MORPH_HOODI_GENESIS_STATE_ROOT
+        );
+    }
+
+    #[test]
+    fn test_genesis_hashes_are_nonzero() {
+        assert_ne!(MORPH_MAINNET_GENESIS_HASH, B256::ZERO);
+        assert_ne!(MORPH_HOODI_GENESIS_HASH, B256::ZERO);
+        assert_ne!(MORPH_MAINNET_GENESIS_STATE_ROOT, B256::ZERO);
+        assert_ne!(MORPH_HOODI_GENESIS_STATE_ROOT, B256::ZERO);
+    }
+
+    #[test]
+    fn test_l2_message_queue_address() {
+        assert_eq!(
+            L2_MESSAGE_QUEUE_ADDRESS,
+            address!("5300000000000000000000000000000000000001")
+        );
+    }
+
+    #[test]
+    fn test_withdraw_trie_root_slot() {
+        assert_eq!(L2_MESSAGE_QUEUE_WITHDRAW_TRIE_ROOT_SLOT, U256::from(33));
+    }
+
+    #[test]
+    fn test_base_fee() {
+        assert_eq!(MORPH_BASE_FEE, 1_000_000);
+    }
+}

crates/chainspec/src/hardfork.rs

@@ -297,4 +297,54 @@ mod tests {
         assert_eq!(MorphHardfork::from(SpecId::PRAGUE), MorphHardfork::Viridian);
         assert_eq!(MorphHardfork::from(SpecId::OSAKA), MorphHardfork::Jade);
     }
+
+    #[test]
+    fn test_is_bernoulli() {
+        assert!(MorphHardfork::Bernoulli.is_bernoulli());
+        assert!(MorphHardfork::Curie.is_bernoulli());
+        assert!(MorphHardfork::Morph203.is_bernoulli());
+        assert!(MorphHardfork::Viridian.is_bernoulli());
+        assert!(MorphHardfork::Emerald.is_bernoulli());
+        assert!(MorphHardfork::Jade.is_bernoulli());
+    }
+
+    /// SpecIds below CANCUN should map to Morph203 (the latest CANCUN-level hardfork).
+    #[test]
+    fn test_specid_below_cancun_maps_to_morph203() {
+        assert_eq!(
+            MorphHardfork::from(SpecId::SHANGHAI),
+            MorphHardfork::Morph203
+        );
+        assert_eq!(
+            MorphHardfork::from(SpecId::HOMESTEAD),
+            MorphHardfork::Morph203
+        );
+    }
+
+    /// Verify bidirectional mapping consistency: Hardfork -> SpecId -> Hardfork
+    /// always returns the latest hardfork sharing that SpecId.
+    #[test]
+    fn test_specid_roundtrip_returns_latest_for_spec() {
+        // Bernoulli -> CANCUN -> Morph203 (latest CANCUN hardfork)
+        let spec = SpecId::from(MorphHardfork::Bernoulli);
+        assert_eq!(MorphHardfork::from(spec), MorphHardfork::Morph203);
+
+        // Emerald -> OSAKA -> Jade (latest OSAKA hardfork)
+        let spec = SpecId::from(MorphHardfork::Emerald);
+        assert_eq!(MorphHardfork::from(spec), MorphHardfork::Jade);
+    }
+
+    #[test]
+    fn test_default_hardfork_is_jade() {
+        assert_eq!(MorphHardfork::default(), MorphHardfork::Jade);
+    }
+
+    #[test]
+    fn test_hardfork_ordering() {
+        assert!(MorphHardfork::Bernoulli < MorphHardfork::Curie);
+        assert!(MorphHardfork::Curie < MorphHardfork::Morph203);
+        assert!(MorphHardfork::Morph203 < MorphHardfork::Viridian);
+        assert!(MorphHardfork::Viridian < MorphHardfork::Emerald);
+        assert!(MorphHardfork::Emerald < MorphHardfork::Jade);
+    }
 }