chore: remove op-flagged arguments from receipt root calc (#6517)

crates/revm/src/optimism/processor.rs

@@ -1,16 +1,43 @@
-use crate::processor::{verify_receipt, EVMProcessor};
+use crate::processor::{compare_receipts_root_and_logs_bloom, EVMProcessor};
 use reth_interfaces::executor::{
     BlockExecutionError, BlockValidationError, OptimismBlockExecutionError,
 };
 use reth_node_api::ConfigureEvmEnv;
 use reth_primitives::{
-    revm_primitives::ResultAndState, BlockWithSenders, Hardfork, Receipt, TxType, U256,
+    proofs::calculate_receipt_root_optimism, revm_primitives::ResultAndState, BlockWithSenders,
+    Bloom, ChainSpec, Hardfork, Receipt, ReceiptWithBloom, TxType, B256, U256,
 };
 use reth_provider::{BlockExecutor, BlockExecutorStats, BundleStateWithReceipts};
 use revm::DatabaseCommit;
 use std::time::Instant;
 use tracing::{debug, trace};
 
+/// Verify the calculated receipts root against the expected receipts root.
+pub fn verify_receipt_optimism<'a>(
+    expected_receipts_root: B256,
+    expected_logs_bloom: Bloom,
+    receipts: impl Iterator<Item = &'a Receipt> + Clone,
+    chain_spec: &ChainSpec,
+    timestamp: u64,
+) -> Result<(), BlockExecutionError> {
+    // Calculate receipts root.
+    let receipts_with_bloom = receipts.map(|r| r.clone().into()).collect::<Vec<ReceiptWithBloom>>();
+    let receipts_root =
+        calculate_receipt_root_optimism(&receipts_with_bloom, chain_spec, timestamp);
+
+    // Create header log bloom.
+    let logs_bloom = receipts_with_bloom.iter().fold(Bloom::ZERO, |bloom, r| bloom | r.bloom);
+
+    compare_receipts_root_and_logs_bloom(
+        receipts_root,
+        logs_bloom,
+        expected_receipts_root,
+        expected_logs_bloom,
+    )?;
+
+    Ok(())
+}
+
 impl<'a, EvmConfig> BlockExecutor for EVMProcessor<'a, EvmConfig>
 where
     EvmConfig: ConfigureEvmEnv,
@@ -38,7 +65,7 @@ where
         // See more about EIP here: https://eips.ethereum.org/EIPS/eip-658
         if self.chain_spec.fork(Hardfork::Byzantium).active_at_block(block.header.number) {
             let time = Instant::now();
-            if let Err(error) = verify_receipt(
+            if let Err(error) = verify_receipt_optimism(
                 block.header.receipts_root,
                 block.header.logs_bloom,
                 receipts.iter(),

crates/revm/src/processor.rs

@@ -530,35 +530,48 @@ where
     }
 }
 
-/// Verify receipts
+/// Calculate the receipts root, and copmare it against against the expected receipts root and logs
+/// bloom.
 pub fn verify_receipt<'a>(
     expected_receipts_root: B256,
     expected_logs_bloom: Bloom,
     receipts: impl Iterator<Item = &'a Receipt> + Clone,
-    #[cfg(feature = "optimism")] chain_spec: &ChainSpec,
-    #[cfg(feature = "optimism")] timestamp: u64,
 ) -> Result<(), BlockExecutionError> {
-    // Check receipts root.
+    // Calculate receipts root.
     let receipts_with_bloom = receipts.map(|r| r.clone().into()).collect::<Vec<ReceiptWithBloom>>();
-    let receipts_root = reth_primitives::proofs::calculate_receipt_root(
-        &receipts_with_bloom,
-        #[cfg(feature = "optimism")]
-        chain_spec,
-        #[cfg(feature = "optimism")]
-        timestamp,
-    );
-    if receipts_root != expected_receipts_root {
+    let receipts_root = reth_primitives::proofs::calculate_receipt_root(&receipts_with_bloom);
+
+    // Create header log bloom.
+    let logs_bloom = receipts_with_bloom.iter().fold(Bloom::ZERO, |bloom, r| bloom | r.bloom);
+
+    compare_receipts_root_and_logs_bloom(
+        receipts_root,
+        logs_bloom,
+        expected_receipts_root,
+        expected_logs_bloom,
+    )?;
+
+    Ok(())
+}
+
+/// Compare the calculated receipts root with the expected receipts root, also copmare
+/// the calculated logs bloom with the expected logs bloom.
+pub fn compare_receipts_root_and_logs_bloom(
+    calculated_receipts_root: B256,
+    calculated_logs_bloom: Bloom,
+    expected_receipts_root: B256,
+    expected_logs_bloom: Bloom,
+) -> Result<(), BlockExecutionError> {
+    if calculated_receipts_root != expected_receipts_root {
         return Err(BlockValidationError::ReceiptRootDiff(
-            GotExpected { got: receipts_root, expected: expected_receipts_root }.into(),
+            GotExpected { got: calculated_receipts_root, expected: expected_receipts_root }.into(),
         )
         .into())
     }
 
-    // Create header log bloom.
-    let logs_bloom = receipts_with_bloom.iter().fold(Bloom::ZERO, |bloom, r| bloom | r.bloom);
-    if logs_bloom != expected_logs_bloom {
+    if calculated_logs_bloom != expected_logs_bloom {
         return Err(BlockValidationError::BloomLogDiff(
-            GotExpected { got: logs_bloom, expected: expected_logs_bloom }.into(),
+            GotExpected { got: calculated_logs_bloom, expected: expected_logs_bloom }.into(),
         )
         .into())
     }