test: add unit tests across all morph-reth crates

Add #[cfg(test)] modules to every crate with comprehensive coverage:
- chainspec: constants, hardfork ordering, chain spec construction
- primitives: header, receipt envelope, transaction encoding/decoding
- revm: error types, EVM config, L1 block fee calculation, precompiles,
  token fee logic, transaction environment
- evm: block assembler, receipt builder, EVM config hardfork mapping
- consensus: header validation, L1 message sequencing, timestamp rules
- txpool: error types, MorphTx validation, transaction type handling
- payload-builder: execution info, builder configuration
- payload-types: attributes, executable/safe L2 data, params
- engine-api: builder state tracker, error types, validator
- rpc: error types, receipt/transaction serialization, request types
- node: CLI args, engine validator

Minor accompanying refactors:
- Remove unused From<MorphConsensusError> for ConsensusError impl
- Remove unused morph-evm dev-dependency from revm crate
- Rename query_erc20_balance to query_balance_via_system_call
- Clean up EIP-4788 trace override imports

Author: panos-xyz

Cargo.lock

@@ -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/constants.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);
+    }
 }

crates/chainspec/src/hardfork.rs

@@ -131,6 +131,10 @@ fn build_hardforks(genesis: &Genesis, chain_info: &MorphGenesisInfo) -> ChainHar
 /// Chains supported by Morph. First value should be used as the default.
 pub const SUPPORTED_CHAINS: &[&str] = &["mainnet", "hoodi"];
 
+// =============================================================================
+// Chain Specification Parser (CLI)
+// =============================================================================
+
 /// Morph chain specification parser.
 #[derive(Debug, Clone, Default)]
 pub struct MorphChainSpecParser;

crates/chainspec/src/spec.rs

@@ -71,9 +71,3 @@ impl From<alloy_rlp::Error> for MorphConsensusError {
         Self::TransactionDecodeError(err.to_string())
     }
 }
-
-impl From<MorphConsensusError> for reth_consensus::ConsensusError {
-    fn from(e: MorphConsensusError) -> Self {
-        Self::Other(e.to_string())
-    }
-}