Merge branch 'main' into Withdrawals-alloy

paradigmxyz · Nov 9, 2024 · dfb7bfa · dfb7bfa
2 parents 8325b0c + 7a65cce
commit dfb7bfa
Show file tree

Hide file tree

Showing 31 changed files with 437 additions and 198 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -175,6 +175,7 @@ branches_sharing_code = "warn"
 clear_with_drain = "warn"
 cloned_instead_of_copied = "warn"
 collection_is_never_read = "warn"
+dbg_macro = "warn"
 derive_partial_eq_without_eq = "warn"
 doc_markdown = "warn"
 empty_line_after_doc_comments = "warn"

diff --git a/clippy.toml b/clippy.toml
@@ -15,3 +15,4 @@ doc-valid-idents = [
     "WAL",
     "MessagePack",
 ]
+allow-dbg-in-tests = true
diff --git a/crates/cli/commands/src/test_vectors/tables.rs b/crates/cli/commands/src/test_vectors/tables.rs
@@ -51,7 +51,7 @@ pub fn generate_vectors(mut tables: Vec<String>) -> Result<()> {
             for table in tables {
                 match table.as_str() {
                     $(
-                        stringify!($table_type$(<$($generic),+>)?) => {
+                        stringify!($table_type) => {
                             println!("Generating test vectors for {} <{}>.", stringify!($table_or_dup), tables::$table_type$(::<$($generic),+>)?::NAME);
 
                             generate_vector!($table_type$(<$($generic),+>)?, $per_table, $table_or_dup);

diff --git a/crates/node/core/src/args/payload_builder.rs b/crates/node/core/src/args/payload_builder.rs
@@ -86,7 +86,7 @@ impl TypedValueParser for ExtradataValueParser {
     ) -> Result<Self::Value, clap::Error> {
         let val =
             value.to_str().ok_or_else(|| clap::Error::new(clap::error::ErrorKind::InvalidUtf8))?;
-        if val.as_bytes().len() > MAXIMUM_EXTRA_DATA_SIZE {
+        if val.len() > MAXIMUM_EXTRA_DATA_SIZE {
             return Err(clap::Error::raw(
                 clap::error::ErrorKind::InvalidValue,
                 format!(

diff --git a/crates/node/core/src/version.rs b/crates/node/core/src/version.rs
@@ -144,9 +144,6 @@ mod tests {
     #[test]
     fn assert_extradata_less_32bytes() {
         let extradata = default_extradata();
-        assert!(
-            extradata.as_bytes().len() <= 32,
-            "extradata must be less than 32 bytes: {extradata}"
-        )
+        assert!(extradata.len() <= 32, "extradata must be less than 32 bytes: {extradata}")
     }
 }
diff --git a/crates/optimism/chainspec/src/base.rs b/crates/optimism/chainspec/src/base.rs
@@ -6,7 +6,7 @@ use alloy_chains::Chain;
 use alloy_primitives::{b256, U256};
 use reth_chainspec::{once_cell_set, BaseFeeParams, BaseFeeParamsKind, ChainSpec};
 use reth_ethereum_forks::EthereumHardfork;
-use reth_optimism_forks::OptimismHardfork;
+use reth_optimism_forks::OpHardfork;
 
 use crate::{LazyLock, OpChainSpec};
 
@@ -21,11 +21,11 @@ pub static BASE_MAINNET: LazyLock<Arc<OpChainSpec>> = LazyLock::new(|| {
                 "f712aa9241cc24369b143cf6dce85f0902a9731e70d66818a3a5845b296c73dd"
             )),
             paris_block_and_final_difficulty: Some((0, U256::from(0))),
-            hardforks: OptimismHardfork::base_mainnet(),
+            hardforks: OpHardfork::base_mainnet(),
             base_fee_params: BaseFeeParamsKind::Variable(
                 vec![
                     (EthereumHardfork::London.boxed(), BaseFeeParams::optimism()),
-                    (OptimismHardfork::Canyon.boxed(), BaseFeeParams::optimism_canyon()),
+                    (OpHardfork::Canyon.boxed(), BaseFeeParams::optimism_canyon()),
                 ]
                 .into(),
             ),

diff --git a/crates/optimism/chainspec/src/base_sepolia.rs b/crates/optimism/chainspec/src/base_sepolia.rs
@@ -6,7 +6,7 @@ use alloy_chains::Chain;
 use alloy_primitives::{b256, U256};
 use reth_chainspec::{once_cell_set, BaseFeeParams, BaseFeeParamsKind, ChainSpec};
 use reth_ethereum_forks::EthereumHardfork;
-use reth_optimism_forks::OptimismHardfork;
+use reth_optimism_forks::OpHardfork;
 
 use crate::{LazyLock, OpChainSpec};
 
@@ -21,11 +21,11 @@ pub static BASE_SEPOLIA: LazyLock<Arc<OpChainSpec>> = LazyLock::new(|| {
                 "0dcc9e089e30b90ddfc55be9a37dd15bc551aeee999d2e2b51414c54eaf934e4"
             )),
             paris_block_and_final_difficulty: Some((0, U256::from(0))),
-            hardforks: OptimismHardfork::base_sepolia(),
+            hardforks: OpHardfork::base_sepolia(),
             base_fee_params: BaseFeeParamsKind::Variable(
                 vec![
                     (EthereumHardfork::London.boxed(), BaseFeeParams::base_sepolia()),
-                    (OptimismHardfork::Canyon.boxed(), BaseFeeParams::base_sepolia_canyon()),
+                    (OpHardfork::Canyon.boxed(), BaseFeeParams::base_sepolia_canyon()),
                 ]
                 .into(),
             ),

diff --git a/crates/optimism/chainspec/src/lib.rs b/crates/optimism/chainspec/src/lib.rs
@@ -96,27 +96,25 @@ impl OpChainSpecBuilder {
     }
 
     /// Remove the given fork from the spec.
-    pub fn without_fork(mut self, fork: reth_optimism_forks::OptimismHardfork) -> Self {
+    pub fn without_fork(mut self, fork: reth_optimism_forks::OpHardfork) -> Self {
         self.inner = self.inner.without_fork(fork);
         self
     }
 
     /// Enable Bedrock at genesis
     pub fn bedrock_activated(mut self) -> Self {
         self.inner = self.inner.paris_activated();
-        self.inner = self
-            .inner
-            .with_fork(reth_optimism_forks::OptimismHardfork::Bedrock, ForkCondition::Block(0));
+        self.inner =
+            self.inner.with_fork(reth_optimism_forks::OpHardfork::Bedrock, ForkCondition::Block(0));
         self
     }
 
     /// Enable Regolith at genesis
     pub fn regolith_activated(mut self) -> Self {
         self = self.bedrock_activated();
-        self.inner = self.inner.with_fork(
-            reth_optimism_forks::OptimismHardfork::Regolith,
-            ForkCondition::Timestamp(0),
-        );
+        self.inner = self
+            .inner
+            .with_fork(reth_optimism_forks::OpHardfork::Regolith, ForkCondition::Timestamp(0));
         self
     }
 
@@ -127,7 +125,7 @@ impl OpChainSpecBuilder {
         self.inner = self.inner.with_fork(EthereumHardfork::Shanghai, ForkCondition::Timestamp(0));
         self.inner = self
             .inner
-            .with_fork(reth_optimism_forks::OptimismHardfork::Canyon, ForkCondition::Timestamp(0));
+            .with_fork(reth_optimism_forks::OpHardfork::Canyon, ForkCondition::Timestamp(0));
         self
     }
 
@@ -137,7 +135,7 @@ impl OpChainSpecBuilder {
         self.inner = self.inner.with_fork(EthereumHardfork::Cancun, ForkCondition::Timestamp(0));
         self.inner = self
             .inner
-            .with_fork(reth_optimism_forks::OptimismHardfork::Ecotone, ForkCondition::Timestamp(0));
+            .with_fork(reth_optimism_forks::OpHardfork::Ecotone, ForkCondition::Timestamp(0));
         self
     }
 
@@ -146,7 +144,7 @@ impl OpChainSpecBuilder {
         self = self.ecotone_activated();
         self.inner = self
             .inner
-            .with_fork(reth_optimism_forks::OptimismHardfork::Fjord, ForkCondition::Timestamp(0));
+            .with_fork(reth_optimism_forks::OpHardfork::Fjord, ForkCondition::Timestamp(0));
         self
     }
 
@@ -155,17 +153,16 @@ impl OpChainSpecBuilder {
         self = self.fjord_activated();
         self.inner = self
             .inner
-            .with_fork(reth_optimism_forks::OptimismHardfork::Granite, ForkCondition::Timestamp(0));
+            .with_fork(reth_optimism_forks::OpHardfork::Granite, ForkCondition::Timestamp(0));
         self
     }
 
     /// Enable Holocene at genesis
     pub fn holocene_activated(mut self) -> Self {
         self = self.granite_activated();
-        self.inner = self.inner.with_fork(
-            reth_optimism_forks::OptimismHardfork::Holocene,
-            ForkCondition::Timestamp(0),
-        );
+        self.inner = self
+            .inner
+            .with_fork(reth_optimism_forks::OpHardfork::Holocene, ForkCondition::Timestamp(0));
         self
     }
 
@@ -194,10 +191,9 @@ impl OpChainSpec {
         parent: &Header,
         timestamp: u64,
     ) -> Result<U256, DecodeError> {
-        let is_holocene_activated = self.inner.is_fork_active_at_timestamp(
-            reth_optimism_forks::OptimismHardfork::Holocene,
-            timestamp,
-        );
+        let is_holocene_activated = self
+            .inner
+            .is_fork_active_at_timestamp(reth_optimism_forks::OpHardfork::Holocene, timestamp);
         // If we are in the Holocene, we need to use the base fee params
         // from the parent block's extra data.
         // Else, use the base fee params (default values) from chainspec
@@ -344,7 +340,7 @@ impl OptimismHardforks for OpChainSpec {}
 
 impl From<Genesis> for OpChainSpec {
     fn from(genesis: Genesis) -> Self {
-        use reth_optimism_forks::OptimismHardfork;
+        use reth_optimism_forks::OpHardfork;
         let optimism_genesis_info = OpGenesisInfo::extract_from(&genesis);
         let genesis_info =
             optimism_genesis_info.optimism_chain_info.genesis_info.unwrap_or_default();
@@ -363,7 +359,7 @@ impl From<Genesis> for OpChainSpec {
             (EthereumHardfork::London.boxed(), genesis.config.london_block),
             (EthereumHardfork::ArrowGlacier.boxed(), genesis.config.arrow_glacier_block),
             (EthereumHardfork::GrayGlacier.boxed(), genesis.config.gray_glacier_block),
-            (OptimismHardfork::Bedrock.boxed(), genesis_info.bedrock_block),
+            (OpHardfork::Bedrock.boxed(), genesis_info.bedrock_block),
         ];
         let mut block_hardforks = hardfork_opts
             .into_iter()
@@ -391,11 +387,11 @@ impl From<Genesis> for OpChainSpec {
             (EthereumHardfork::Shanghai.boxed(), genesis.config.shanghai_time),
             (EthereumHardfork::Cancun.boxed(), genesis.config.cancun_time),
             (EthereumHardfork::Prague.boxed(), genesis.config.prague_time),
-            (OptimismHardfork::Regolith.boxed(), genesis_info.regolith_time),
-            (OptimismHardfork::Canyon.boxed(), genesis_info.canyon_time),
-            (OptimismHardfork::Ecotone.boxed(), genesis_info.ecotone_time),
-            (OptimismHardfork::Fjord.boxed(), genesis_info.fjord_time),
-            (OptimismHardfork::Granite.boxed(), genesis_info.granite_time),
+            (OpHardfork::Regolith.boxed(), genesis_info.regolith_time),
+            (OpHardfork::Canyon.boxed(), genesis_info.canyon_time),
+            (OpHardfork::Ecotone.boxed(), genesis_info.ecotone_time),
+            (OpHardfork::Fjord.boxed(), genesis_info.fjord_time),
+            (OpHardfork::Granite.boxed(), genesis_info.granite_time),
         ];
 
         let mut time_hardforks = time_hardfork_opts
@@ -408,7 +404,7 @@ impl From<Genesis> for OpChainSpec {
         block_hardforks.append(&mut time_hardforks);
 
         // Ordered Hardforks
-        let mainnet_hardforks = OptimismHardfork::op_mainnet();
+        let mainnet_hardforks = OpHardfork::op_mainnet();
         let mainnet_order = mainnet_hardforks.forks_iter();
 
         let mut ordered_hardforks = Vec::with_capacity(block_hardforks.len());
@@ -464,7 +460,7 @@ impl OpGenesisInfo {
                                 BaseFeeParams::new(denominator as u128, elasticity as u128),
                             ),
                             (
-                                reth_optimism_forks::OptimismHardfork::Canyon.boxed(),
+                                reth_optimism_forks::OpHardfork::Canyon.boxed(),
                                 BaseFeeParams::new(canyon_denominator as u128, elasticity as u128),
                             ),
                         ]
@@ -490,7 +486,7 @@ mod tests {
     use alloy_primitives::b256;
     use reth_chainspec::{test_fork_ids, BaseFeeParams, BaseFeeParamsKind};
     use reth_ethereum_forks::{EthereumHardfork, ForkCondition, ForkHash, ForkId, Head};
-    use reth_optimism_forks::{OptimismHardfork, OptimismHardforks};
+    use reth_optimism_forks::{OpHardfork, OptimismHardforks};
 
     use crate::*;
 
@@ -763,19 +759,19 @@ mod tests {
             BaseFeeParamsKind::Constant(BaseFeeParams::new(70, 60))
         );
 
-        assert!(!chain_spec.is_fork_active_at_block(OptimismHardfork::Bedrock, 0));
-        assert!(!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Regolith, 0));
-        assert!(!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Canyon, 0));
-        assert!(!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Ecotone, 0));
-        assert!(!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Fjord, 0));
-        assert!(!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Granite, 0));
-
-        assert!(chain_spec.is_fork_active_at_block(OptimismHardfork::Bedrock, 10));
-        assert!(chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Regolith, 20));
-        assert!(chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Canyon, 30));
-        assert!(chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Ecotone, 40));
-        assert!(chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Fjord, 50));
-        assert!(chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Granite, 51));
+        assert!(!chain_spec.is_fork_active_at_block(OpHardfork::Bedrock, 0));
+        assert!(!chain_spec.is_fork_active_at_timestamp(OpHardfork::Regolith, 0));
+        assert!(!chain_spec.is_fork_active_at_timestamp(OpHardfork::Canyon, 0));
+        assert!(!chain_spec.is_fork_active_at_timestamp(OpHardfork::Ecotone, 0));
+        assert!(!chain_spec.is_fork_active_at_timestamp(OpHardfork::Fjord, 0));
+        assert!(!chain_spec.is_fork_active_at_timestamp(OpHardfork::Granite, 0));
+
+        assert!(chain_spec.is_fork_active_at_block(OpHardfork::Bedrock, 10));
+        assert!(chain_spec.is_fork_active_at_timestamp(OpHardfork::Regolith, 20));
+        assert!(chain_spec.is_fork_active_at_timestamp(OpHardfork::Canyon, 30));
+        assert!(chain_spec.is_fork_active_at_timestamp(OpHardfork::Ecotone, 40));
+        assert!(chain_spec.is_fork_active_at_timestamp(OpHardfork::Fjord, 50));
+        assert!(chain_spec.is_fork_active_at_timestamp(OpHardfork::Granite, 51));
     }
 
     #[test]
@@ -829,25 +825,25 @@ mod tests {
             BaseFeeParamsKind::Variable(
                 vec![
                     (EthereumHardfork::London.boxed(), BaseFeeParams::new(70, 60)),
-                    (OptimismHardfork::Canyon.boxed(), BaseFeeParams::new(80, 60)),
+                    (OpHardfork::Canyon.boxed(), BaseFeeParams::new(80, 60)),
                 ]
                 .into()
             )
         );
 
-        assert!(!chain_spec.is_fork_active_at_block(OptimismHardfork::Bedrock, 0));
-        assert!(!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Regolith, 0));
-        assert!(!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Canyon, 0));
-        assert!(!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Ecotone, 0));
-        assert!(!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Fjord, 0));
-        assert!(!chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Granite, 0));
-
-        assert!(chain_spec.is_fork_active_at_block(OptimismHardfork::Bedrock, 10));
-        assert!(chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Regolith, 20));
-        assert!(chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Canyon, 30));
-        assert!(chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Ecotone, 40));
-        assert!(chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Fjord, 50));
-        assert!(chain_spec.is_fork_active_at_timestamp(OptimismHardfork::Granite, 51));
+        assert!(!chain_spec.is_fork_active_at_block(OpHardfork::Bedrock, 0));
+        assert!(!chain_spec.is_fork_active_at_timestamp(OpHardfork::Regolith, 0));
+        assert!(!chain_spec.is_fork_active_at_timestamp(OpHardfork::Canyon, 0));
+        assert!(!chain_spec.is_fork_active_at_timestamp(OpHardfork::Ecotone, 0));
+        assert!(!chain_spec.is_fork_active_at_timestamp(OpHardfork::Fjord, 0));
+        assert!(!chain_spec.is_fork_active_at_timestamp(OpHardfork::Granite, 0));
+
+        assert!(chain_spec.is_fork_active_at_block(OpHardfork::Bedrock, 10));
+        assert!(chain_spec.is_fork_active_at_timestamp(OpHardfork::Regolith, 20));
+        assert!(chain_spec.is_fork_active_at_timestamp(OpHardfork::Canyon, 30));
+        assert!(chain_spec.is_fork_active_at_timestamp(OpHardfork::Ecotone, 40));
+        assert!(chain_spec.is_fork_active_at_timestamp(OpHardfork::Fjord, 50));
+        assert!(chain_spec.is_fork_active_at_timestamp(OpHardfork::Granite, 51));
     }
 
     #[test]
@@ -921,14 +917,14 @@ mod tests {
             })
         );
 
-        assert!(chainspec.is_fork_active_at_block(OptimismHardfork::Bedrock, 0));
+        assert!(chainspec.is_fork_active_at_block(OpHardfork::Bedrock, 0));
 
-        assert!(chainspec.is_fork_active_at_timestamp(OptimismHardfork::Regolith, 20));
+        assert!(chainspec.is_fork_active_at_timestamp(OpHardfork::Regolith, 20));
     }
 
     #[test]
     fn test_fork_order_optimism_mainnet() {
-        use reth_optimism_forks::OptimismHardfork;
+        use reth_optimism_forks::OpHardfork;
 
         let genesis = Genesis {
             config: ChainConfig {
@@ -984,14 +980,14 @@ mod tests {
             EthereumHardfork::ArrowGlacier.boxed(),
             EthereumHardfork::GrayGlacier.boxed(),
             EthereumHardfork::Paris.boxed(),
-            OptimismHardfork::Bedrock.boxed(),
-            OptimismHardfork::Regolith.boxed(),
+            OpHardfork::Bedrock.boxed(),
+            OpHardfork::Regolith.boxed(),
             EthereumHardfork::Shanghai.boxed(),
-            OptimismHardfork::Canyon.boxed(),
+            OpHardfork::Canyon.boxed(),
             EthereumHardfork::Cancun.boxed(),
-            OptimismHardfork::Ecotone.boxed(),
-            OptimismHardfork::Fjord.boxed(),
-            OptimismHardfork::Granite.boxed(),
+            OpHardfork::Ecotone.boxed(),
+            OpHardfork::Fjord.boxed(),
+            OpHardfork::Granite.boxed(),
         ];
 
         assert!(expected_hardforks
@@ -1022,8 +1018,8 @@ mod tests {
     }
 
     fn holocene_chainspec() -> Arc<OpChainSpec> {
-        let mut hardforks = OptimismHardfork::base_sepolia();
-        hardforks.insert(OptimismHardfork::Holocene.boxed(), ForkCondition::Timestamp(1800000000));
+        let mut hardforks = OpHardfork::base_sepolia();
+        hardforks.insert(OpHardfork::Holocene.boxed(), ForkCondition::Timestamp(1800000000));
         Arc::new(OpChainSpec {
             inner: ChainSpec {
                 chain: BASE_SEPOLIA.inner.chain,
-Original file line number
+Diff line change
@@ Expand Up / @@ -15,3 +15,4 @@ doc-valid-idents = [ @@
         "WAL",
         "MessagePack",
     ]
+    allow-dbg-in-tests = true