testgpu

tac0turtle · tac0turtle · commit 79f1c8142465 · 2025-12-16T21:02:53.000-08:00
diff --git a/README.md b/README.md
@@ -456,30 +456,3 @@ This project builds upon the excellent work of:
 
 - [Reth](https://github.com/paradigmxyz/reth) - The Rust Ethereum client
 - [Evolve](https://ev.xyz/) - The modular rollup framework
-
-### Canonical Block Hash Activation
-
-Legacy deployments allowed application-level hashes to flow through the Engine API, which meant
-Reth had to ignore block-hash mismatches and upstream tooling flagged every block as a fork. Newer
-networks can opt-in to canonical keccak block hashes by setting `hashRewireActivationHeight` inside
-the `evolve` section of the chainspec:
-
-Separately, Ethereum clients expect `stateRoot` to be the current block's post-state root (after
-executing this block's transactions on top of the parent). If an integration accidentally supplies
-the parent (height-1) root instead, execution clients can report persistent "forks" that are really
-just state-root mismatches. ev-reth computes and exposes the canonical post-state root so state-root
-validation behaves like standard Ethereum.
-
-```json
-"config": {
-  ...,
-  "evolve": {
-    "hashRewireActivationHeight": 0
-  }
-}
-```
-
-Set the activation height to the first block where canonical hashes should be enforced (use `0` for
-fresh networks). Before the activation height the node continues to bypass hash mismatches so
-existing chains keep working; after activation, the node rejects malformed payloads and the reported
-block hash always matches the standard Engine API expectations.
diff --git a/crates/node/src/config.rs b/crates/node/src/config.rs
@@ -21,32 +21,6 @@ struct ChainspecEvolveConfig {
     /// Block height at which the custom contract size limit activates.
     #[serde(default, rename = "contractSizeLimitActivationHeight")]
     pub contract_size_limit_activation_height: Option<u64>,
-    /// Block height at which canonical block hash enforcement activates.
-    ///
-    /// # Background
-    ///
-    /// Early versions of ev-node passed block hashes from height H-1 instead of H
-    /// when communicating with ev-reth via the Engine API. This caused block hashes
-    /// to not match the canonical Ethereum block hash (keccak256 of RLP-encoded header),
-    /// resulting in block explorers like Blockscout incorrectly displaying every block
-    /// as a fork due to parent hash mismatches.
-    ///
-    /// # Migration Strategy
-    ///
-    /// For existing networks with historical blocks containing non-canonical hashes:
-    /// - Set this to a future block height where the fix will activate
-    /// - Before the activation height: hash mismatches are bypassed (legacy mode)
-    /// - At and after the activation height: canonical hash validation is enforced
-    ///
-    /// This allows nodes to sync from genesis on networks with historical hash
-    /// mismatches while ensuring new blocks use correct canonical hashes.
-    ///
-    /// # Default Behavior
-    ///
-    /// If not set, canonical hash validation is enforced from genesis (block 0).
-    /// This is the correct setting for new networks without legacy data.
-    #[serde(default, rename = "canonicalHashActivationHeight")]
-    pub canonical_hash_activation_height: Option<u64>,
 }
 
 /// Configuration for the Evolve payload builder
@@ -70,32 +44,6 @@ pub struct EvolvePayloadBuilderConfig {
     /// Block height at which the custom contract size limit activates.
     #[serde(default)]
     pub contract_size_limit_activation_height: Option<u64>,
-    /// Block height at which canonical block hash enforcement activates.
-    ///
-    /// # Background
-    ///
-    /// Early versions of ev-node passed block hashes from height H-1 instead of H
-    /// when communicating with ev-reth via the Engine API. This caused block hashes
-    /// to not match the canonical Ethereum block hash (keccak256 of RLP-encoded header),
-    /// resulting in block explorers like Blockscout incorrectly displaying every block
-    /// as a fork due to parent hash mismatches.
-    ///
-    /// # Migration Strategy
-    ///
-    /// For existing networks with historical blocks containing non-canonical hashes:
-    /// - Set this to a future block height where the fix will activate
-    /// - Before the activation height: hash mismatches are bypassed (legacy mode)
-    /// - At and after the activation height: canonical hash validation is enforced
-    ///
-    /// This allows nodes to sync from genesis on networks with historical hash
-    /// mismatches while ensuring new blocks use correct canonical hashes.
-    ///
-    /// # Default Behavior
-    ///
-    /// If not set, canonical hash validation is enforced from genesis (block 0).
-    /// This is the correct setting for new networks without legacy data.
-    #[serde(default)]
-    pub canonical_hash_activation_height: Option<u64>,
 }
 
 impl EvolvePayloadBuilderConfig {
@@ -108,7 +56,6 @@ impl EvolvePayloadBuilderConfig {
             mint_precompile_activation_height: None,
             contract_size_limit: None,
             contract_size_limit_activation_height: None,
-            canonical_hash_activation_height: None,
         }
     }
 
@@ -143,7 +90,6 @@ impl EvolvePayloadBuilderConfig {
             config.contract_size_limit = extras.contract_size_limit;
             config.contract_size_limit_activation_height =
                 extras.contract_size_limit_activation_height;
-            config.canonical_hash_activation_height = extras.canonical_hash_activation_height;
         }
         Ok(config)
     }
@@ -197,29 +143,6 @@ impl EvolvePayloadBuilderConfig {
         self.base_fee_redirect_settings()
             .and_then(|(sink, activation)| (block_number >= activation).then_some(sink))
     }
-
-    /// Returns true if canonical block hash validation should be enforced for the given block.
-    ///
-    /// This method controls whether the validator should reject blocks with hash mismatches
-    /// or bypass the check for legacy compatibility.
-    ///
-    /// # Returns
-    ///
-    /// - `true`: Enforce canonical hash validation (reject mismatches)
-    /// - `false`: Bypass hash validation (legacy mode for historical blocks)
-    ///
-    /// # Logic
-    ///
-    /// - If `canonical_hash_activation_height` is `None`: Always enforce (new networks)
-    /// - If `canonical_hash_activation_height` is `Some(N)`:
-    ///   - `block_number < N`: Don't enforce (legacy mode)
-    ///   - `block_number >= N`: Enforce (canonical mode)
-    pub const fn is_canonical_hash_enforced(&self, block_number: u64) -> bool {
-        match self.canonical_hash_activation_height {
-            Some(activation) => block_number >= activation,
-            None => true, // Default: enforce canonical hashes from genesis
-        }
-    }
 }
 
 /// Errors that can occur during configuration validation
@@ -409,7 +332,6 @@ mod tests {
             mint_precompile_activation_height: Some(0),
             contract_size_limit: None,
             contract_size_limit_activation_height: None,
-            canonical_hash_activation_height: None,
         };
         assert!(config_with_sink.validate().is_ok());
     }
@@ -424,7 +346,6 @@ mod tests {
             mint_precompile_activation_height: None,
             contract_size_limit: None,
             contract_size_limit_activation_height: None,
-            canonical_hash_activation_height: None,
         };
 
         assert_eq!(config.base_fee_sink_for_block(4), None);
@@ -555,29 +476,4 @@ mod tests {
         );
     }
 
-    #[test]
-    fn test_canonical_hash_activation_from_chainspec() {
-        let extras = json!({
-            "canonicalHashActivationHeight": 500
-        });
-
-        let chainspec = create_test_chainspec_with_extras(Some(extras));
-        let config = EvolvePayloadBuilderConfig::from_chain_spec(&chainspec).unwrap();
-
-        assert_eq!(config.canonical_hash_activation_height, Some(500));
-        // Before activation: legacy mode (not enforced)
-        assert!(!config.is_canonical_hash_enforced(499));
-        // At and after activation: canonical mode (enforced)
-        assert!(config.is_canonical_hash_enforced(500));
-        assert!(config.is_canonical_hash_enforced(600));
-    }
-
-    #[test]
-    fn test_canonical_hash_default_enforces_from_genesis() {
-        // When not configured, canonical hashes should be enforced from genesis
-        let config = EvolvePayloadBuilderConfig::new();
-        assert_eq!(config.canonical_hash_activation_height, None);
-        assert!(config.is_canonical_hash_enforced(0));
-        assert!(config.is_canonical_hash_enforced(1000));
-    }
 }
diff --git a/crates/node/src/validator.rs b/crates/node/src/validator.rs
@@ -16,38 +16,24 @@ use reth_ethereum::{
     },
 };
 use reth_ethereum_payload_builder::EthereumExecutionPayloadValidator;
-use reth_primitives_traits::{Block as _, RecoveredBlock};
+use reth_primitives_traits::RecoveredBlock;
 use tracing::info;
 
-use crate::{
-    attributes::EvolveEnginePayloadAttributes, config::EvolvePayloadBuilderConfig,
-    node::EvolveEngineTypes,
-};
+use crate::{attributes::EvolveEnginePayloadAttributes, node::EvolveEngineTypes};
 
 /// Evolve engine validator that handles custom payload validation.
 ///
-/// This validator extends the standard Ethereum payload validation with support for
-/// legacy block hash compatibility. See [`EvolvePayloadBuilderConfig::canonical_hash_activation_height`]
-/// for details on the migration strategy.
-///
-/// # Block Hash Validation
-///
-/// Early versions of ev-node passed block hashes from height H-1 instead of H,
-/// causing block explorers (e.g., Blockscout) to show all blocks as forks. This
-/// validator can bypass hash mismatch errors for historical blocks while enforcing
-/// canonical validation for new blocks, controlled by `canonical_hash_activation_height`.
+/// This validator delegates to the standard Ethereum payload validation.
 #[derive(Debug, Clone)]
 pub struct EvolveEngineValidator {
     inner: EthereumExecutionPayloadValidator<ChainSpec>,
-    config: EvolvePayloadBuilderConfig,
 }
 
 impl EvolveEngineValidator {
     /// Instantiates a new validator.
-    pub const fn new(chain_spec: Arc<ChainSpec>, config: EvolvePayloadBuilderConfig) -> Self {
+    pub const fn new(chain_spec: Arc<ChainSpec>) -> Self {
         Self {
             inner: EthereumExecutionPayloadValidator::new(chain_spec),
-            config,
         }
     }
 
@@ -67,56 +53,13 @@ impl PayloadValidator<EvolveEngineTypes> for EvolveEngineValidator {
     ) -> Result<RecoveredBlock<Self::Block>, NewPayloadError> {
         info!("Evolve engine validator: validating payload");
 
-        match self.inner.ensure_well_formed_payload(payload.clone()) {
-            Ok(sealed_block) => {
-                info!("Evolve engine validator: payload validation succeeded");
-                sealed_block
-                    .try_recover()
-                    .map_err(|e| NewPayloadError::Other(e.into()))
-            }
-            Err(err) => {
-                tracing::debug!("Evolve payload validation error: {:?}", err);
-
-                // Handle block hash mismatch errors specially for legacy compatibility.
-                //
-                // Background: Early versions of ev-node passed block hashes from height H-1
-                // instead of H when communicating with ev-reth via the Engine API. This caused
-                // block hashes to not match the canonical Ethereum block hash (keccak256 of
-                // RLP-encoded header), resulting in block explorers like Blockscout incorrectly
-                // displaying every block as a fork due to parent hash mismatches.
-                //
-                // For existing networks with historical blocks containing these non-canonical
-                // hashes, we need to bypass this validation to allow nodes to sync from genesis.
-                // The `canonical_hash_activation_height` config controls when to start enforcing
-                // canonical hashes for new blocks.
-                if matches!(err, alloy_rpc_types::engine::PayloadError::BlockHash { .. }) {
-                    let block_number = payload.payload.block_number();
-
-                    // If canonical hash enforcement is active for this block, reject the mismatch
-                    if self.config.is_canonical_hash_enforced(block_number) {
-                        tracing::warn!(
-                            block_number,
-                            "canonical hash enforcement active; rejecting mismatched block hash"
-                        );
-                        return Err(NewPayloadError::Eth(err));
-                    }
-
-                    // Legacy mode: bypass hash mismatch to allow syncing historical blocks.
-                    // Re-seal the block with the correct canonical hash (keccak256 of header).
-                    info!(
-                        block_number,
-                        "bypassing block hash mismatch (legacy mode before activation height)"
-                    );
-                    let ExecutionData { payload, sidecar } = payload;
-                    let sealed_block = payload.try_into_block_with_sidecar(&sidecar)?.seal_slow();
-                    sealed_block
-                        .try_recover()
-                        .map_err(|e| NewPayloadError::Other(e.into()))
-                } else {
-                    Err(NewPayloadError::Eth(err))
-                }
-            }
-        }
+        // Directly delegate to the inner Ethereum validator without any bypass logic.
+        // This will fail if block hashes don't match, allowing us to see if the error actually occurs.
+        let sealed_block = self.inner.ensure_well_formed_payload(payload)?;
+        info!("Evolve engine validator: payload validation succeeded");
+        sealed_block
+            .try_recover()
+            .map_err(|e| NewPayloadError::Other(e.into()))
     }
 
     fn validate_payload_attributes_against_header(
@@ -181,8 +124,7 @@ where
     type Validator = EvolveEngineValidator;
 
     async fn build(self, ctx: &AddOnsContext<'_, N>) -> eyre::Result<Self::Validator> {
-        let config = EvolvePayloadBuilderConfig::from_chain_spec(ctx.config.chain.as_ref())?;
-        Ok(EvolveEngineValidator::new(ctx.config.chain.clone(), config))
+        Ok(EvolveEngineValidator::new(ctx.config.chain.clone()))
     }
 }
 
@@ -193,11 +135,9 @@ mod tests {
     use reth_chainspec::ChainSpecBuilder;
     use reth_primitives::{Block, SealedBlock};
 
-    fn validator_with_activation(activation_height: Option<u64>) -> EvolveEngineValidator {
+    fn create_validator() -> EvolveEngineValidator {
         let chain_spec = Arc::new(ChainSpecBuilder::mainnet().build());
-        let mut config = EvolvePayloadBuilderConfig::new();
-        config.canonical_hash_activation_height = activation_height;
-        EvolveEngineValidator::new(chain_spec, config)
+        EvolveEngineValidator::new(chain_spec)
     }
 
     fn mismatched_payload() -> ExecutionData {
@@ -210,35 +150,9 @@ mod tests {
     }
 
     #[test]
-    fn test_legacy_mode_bypasses_hash_mismatch() {
-        // When activation height is set in the future, legacy mode should bypass hash mismatches
-        let validator = validator_with_activation(Some(1000));
-        let payload = mismatched_payload();
-
-        validator
-            .ensure_well_formed_payload(payload)
-            .expect("hash mismatch should be bypassed in legacy mode");
-    }
-
-    #[test]
-    fn test_canonical_mode_rejects_hash_mismatch() {
-        // When activation height is 0 (or in the past), canonical mode should reject mismatches
-        let validator = validator_with_activation(Some(0));
-        let payload = mismatched_payload();
-
-        let result = validator.ensure_well_formed_payload(payload);
-        assert!(matches!(
-            result,
-            Err(NewPayloadError::Eth(
-                alloy_rpc_types::engine::PayloadError::BlockHash { .. }
-            ))
-        ));
-    }
-
-    #[test]
-    fn test_default_enforces_canonical_hash() {
-        // When no activation height is set, canonical validation should be enforced (default)
-        let validator = validator_with_activation(None);
+    fn test_hash_mismatch_is_rejected() {
+        // Hash mismatches should be rejected
+        let validator = create_validator();
         let payload = mismatched_payload();
 
         let result = validator.ensure_well_formed_payload(payload);
