feat(l2-withdrawals): consensus rules

crates/consensus/consensus/src/lib.rs

@@ -450,6 +450,9 @@ pub enum ConsensusError {
         /// The block's timestamp.
         timestamp: u64,
     },
+    /// Other, likely an L2 error.
+    #[display("other, search logs for l2 error")]
+    Other,
 }
 
 impl ConsensusError {

crates/optimism/consensus/Cargo.toml

@@ -18,6 +18,9 @@ reth-consensus-common.workspace = true
 reth-consensus.workspace = true
 reth-primitives.workspace = true
 reth-primitives-traits.workspace = true
+reth-storage-api.workspace = true
+reth-trie.workspace = true
+reth-storage-errors.workspace = true
 
 # op-reth
 reth-optimism-forks.workspace = true
@@ -30,11 +33,21 @@ alloy-eips.workspace = true
 alloy-primitives.workspace = true
 alloy-consensus.workspace = true
 alloy-trie.workspace = true
+revm.workspace = true
 op-alloy-consensus.workspace = true
 
+# misc
+derive_more = { workspace = true, features = ["display", "error"] }
 tracing.workspace = true
 
 [dev-dependencies]
+reth-provider = { workspace = true, features = ["test-utils"] }
+reth-trie-db.workspace = true
+reth-db-common.workspace = true
+reth-optimism-node.workspace = true
+reth-revm.workspace = true
+op-alloy-consensus.workspace = true
+alloy-chains.workspace = true
 alloy-primitives.workspace = true
 reth-optimism-chainspec.workspace = true
 
@@ -49,10 +62,20 @@ std = [
     "reth-optimism-forks/std",
     "reth-optimism-chainspec/std",
     "reth-optimism-primitives/std",
+    "reth-storage-api/std",
+    "alloy-chains/std",
     "alloy-eips/std",
     "alloy-primitives/std",
     "alloy-consensus/std",
     "alloy-trie/std",
     "op-alloy-consensus/std",
+    "reth-revm/std",
+    "revm/std",
+    "derive_more/std",
+    "tracing/std",
+]
+optimism = [
+    "reth-optimism-primitives/optimism",
+    "reth-optimism-node/optimism",
+    "revm/optimism",
 ]
-optimism = ["reth-optimism-primitives/optimism"]

crates/optimism/consensus/src/error.rs

@@ -0,0 +1,33 @@
+//! Optimism consensus errors
+
+use alloy_primitives::B256;
+use derive_more::{Display, Error, From};
+use reth_consensus::ConsensusError;
+use reth_storage_errors::provider::ProviderError;
+
+/// Optimism consensus error.
+#[derive(Debug, Clone, Display, Error, From)]
+pub enum OpConsensusError {
+    /// Block body has non-empty withdrawals list (l1 withdrawals).
+    #[display("non-empty block body withdrawals list")]
+    WithdrawalsNonEmpty,
+    /// Failed to compute L2 withdrawals storage root.
+    #[display("compute L2 withdrawals root failed: {_0}")]
+    #[from]
+    L2WithdrawalsRootCalculationFail(ProviderError),
+    /// L2 withdrawals root missing in block header.
+    #[display("L2 withdrawals root missing from block header")]
+    L2WithdrawalsRootMissing,
+    /// L2 withdrawals root in block header, doesn't match local storage root of predeploy.
+    #[display("L2 withdrawals root mismatch, header: {header}, exec_res: {exec_res}")]
+    L2WithdrawalsRootMismatch {
+        /// Storage root of pre-deploy in block.
+        header: B256,
+        /// Storage root of pre-deploy loaded from local state.
+        exec_res: B256,
+    },
+    /// L1 [`ConsensusError`], that also occurs on L2.
+    #[display("{_0}")]
+    #[from]
+    Eth(ConsensusError),
+}

crates/optimism/consensus/src/lib.rs

@@ -25,21 +25,25 @@ use reth_consensus_common::validation::{
     validate_against_parent_4844, validate_against_parent_eip1559_base_fee,
     validate_against_parent_hash_number, validate_against_parent_timestamp,
     validate_body_against_header, validate_cancun_gas, validate_header_base_fee,
-    validate_header_extra_data, validate_header_gas, validate_shanghai_withdrawals,
+    validate_header_extra_data, validate_header_gas,
 };
 use reth_optimism_forks::OpHardforks;
 use reth_optimism_primitives::DepositReceipt;
 use reth_primitives::{GotExpected, NodePrimitives, RecoveredBlock, SealedHeader};
+use tracing::trace;
 
 mod proof;
 pub use proof::calculate_receipt_root_no_memo_optimism;
 use reth_primitives_traits::{Block, BlockBody, BlockHeader, SealedBlock};
 
-mod validation;
+pub mod validation;
 pub use validation::{
-    decode_holocene_base_fee, next_block_base_fee, validate_block_post_execution,
+    canyon, decode_holocene_base_fee, isthmus, next_block_base_fee, validate_block_post_execution,
 };
 
+pub mod error;
+pub use error::OpConsensusError;
+
 /// Optimism consensus implementation.
 ///
 /// Provides basic checks as outlined in the execution specs.
@@ -99,13 +103,42 @@ impl<ChainSpec: EthChainSpec + OpHardforks, B: Block> Consensus<B>
             return Err(ConsensusError::BodyTransactionRootDiff(error.into()))
         }
 
-        // EIP-4895: Beacon chain push withdrawals as operations
-        if self.chain_spec.is_shanghai_active_at_timestamp(block.timestamp()) {
-            validate_shanghai_withdrawals(block)?;
+        // Check empty shanghai-withdrawals
+        if self.chain_spec.is_canyon_active_at_timestamp(block.timestamp()) {
+            canyon::verify_empty_shanghai_withdrawals(block.body()).map_err(|err| {
+                trace!(target: "op::consensus",
+                    block_number=block.number(),
+                    %err,
+                    "block failed validation",
+                );
+
+                ConsensusError::Other
+            })?;
+        } else {
+            return Ok(())
         }
 
         if self.chain_spec.is_cancun_active_at_timestamp(block.timestamp()) {
             validate_cancun_gas(block)?;
+        } else {
+            return Ok(())
+        }
+
+        // Check withdrawals root field in header
+        if self.chain_spec.is_isthmus_active_at_timestamp(block.timestamp()) {
+            // storage root of withdrawals pre-deploy is verified post-execution
+            isthmus::verify_withdrawals_storage_root_is_some(block.header()).map_err(|err| {
+                trace!(target: "op::consensus",
+                    block_number=block.number(),
+                    %err,
+                    "block failed validation",
+                );
+
+                ConsensusError::Other
+            })?
+        } else {
+            // canyon is active, else would have returned already
+            canyon::verify_empty_withdrawals_root(block.header())?
         }
 
         Ok(())