feat: add custom contract size limit settings with activation height

Author: tac0turtle

crates/ev-revm/src/factory.rs

@@ -73,14 +73,39 @@ impl MintPrecompileSettings {
     }
 }
 
+/// Settings for custom contract size limit with activation height.
+#[derive(Debug, Clone, Copy)]
+pub struct ContractSizeLimitSettings {
+    limit: usize,
+    activation_height: u64,
+}
+
+impl ContractSizeLimitSettings {
+    /// Creates a new settings object.
+    pub const fn new(limit: usize, activation_height: u64) -> Self {
+        Self {
+            limit,
+            activation_height,
+        }
+    }
+
+    const fn activation_height(&self) -> u64 {
+        self.activation_height
+    }
+
+    const fn limit(&self) -> usize {
+        self.limit
+    }
+}
+
 /// Wrapper around an existing `EvmFactory` that produces [`EvEvm`] instances.
 #[derive(Debug, Clone)]
 pub struct EvEvmFactory<F> {
     inner: F,
     redirect: Option<BaseFeeRedirectSettings>,
     mint_precompile: Option<MintPrecompileSettings>,
-    /// Maximum contract code size in bytes. When set, overrides the default EIP-170 limit.
-    limit_contract_code_size: Option<usize>,
+    /// Custom contract size limit with activation height.
+    contract_size_limit: Option<ContractSizeLimitSettings>,
 }
 
 impl<F> EvEvmFactory<F> {
@@ -89,16 +114,26 @@ impl<F> EvEvmFactory<F> {
         inner: F,
         redirect: Option<BaseFeeRedirectSettings>,
         mint_precompile: Option<MintPrecompileSettings>,
-        limit_contract_code_size: Option<usize>,
+        contract_size_limit: Option<ContractSizeLimitSettings>,
     ) -> Self {
         Self {
             inner,
             redirect,
             mint_precompile,
-            limit_contract_code_size,
+            contract_size_limit,
         }
     }
 
+    fn contract_size_limit_for_block(&self, block_number: U256) -> Option<usize> {
+        self.contract_size_limit.and_then(|settings| {
+            if block_number >= U256::from(settings.activation_height()) {
+                Some(settings.limit())
+            } else {
+                None
+            }
+        })
+    }
+
     fn install_mint_precompile(&self, precompiles: &mut PrecompilesMap, block_number: U256) {
         let Some(settings) = self.mint_precompile else {
             return;
@@ -148,8 +183,8 @@ impl EvmFactory for EvEvmFactory<EthEvmFactory> {
         mut evm_env: EvmEnv<Self::Spec, Self::BlockEnv>,
     ) -> Self::Evm<DB, NoOpInspector> {
         let block_number = evm_env.block_env.number;
-        // Apply custom contract size limit if configured
-        if let Some(limit) = self.limit_contract_code_size {
+        // Apply custom contract size limit if configured and active for this block
+        if let Some(limit) = self.contract_size_limit_for_block(block_number) {
             evm_env.cfg_env.limit_contract_code_size = Some(limit);
         }
         let inner = self.inner.create_evm(db, evm_env);
@@ -168,8 +203,8 @@ impl EvmFactory for EvEvmFactory<EthEvmFactory> {
         inspector: I,
     ) -> Self::Evm<DB, I> {
         let block_number = input.block_env.number;
-        // Apply custom contract size limit if configured
-        if let Some(limit) = self.limit_contract_code_size {
+        // Apply custom contract size limit if configured and active for this block
+        if let Some(limit) = self.contract_size_limit_for_block(block_number) {
             input.cfg_env.limit_contract_code_size = Some(limit);
         }
         let inner = self.inner.create_evm_with_inspector(db, input, inspector);
@@ -187,7 +222,7 @@ pub fn with_ev_handler<ChainSpec>(
     config: EthEvmConfig<ChainSpec, EthEvmFactory>,
     redirect: Option<BaseFeeRedirectSettings>,
     mint_precompile: Option<MintPrecompileSettings>,
-    limit_contract_code_size: Option<usize>,
+    contract_size_limit: Option<ContractSizeLimitSettings>,
 ) -> EthEvmConfig<ChainSpec, EvEvmFactory<EthEvmFactory>> {
     let EthEvmConfig {
         executor_factory,
@@ -197,7 +232,7 @@ pub fn with_ev_handler<ChainSpec>(
         *executor_factory.evm_factory(),
         redirect,
         mint_precompile,
-        limit_contract_code_size,
+        contract_size_limit,
     );
     let new_executor_factory = EthBlockExecutorFactory::new(
         *executor_factory.receipt_builder(),

crates/ev-revm/src/lib.rs

@@ -11,5 +11,8 @@ pub use api::EvBuilder;
 pub use base_fee::{BaseFeeRedirect, BaseFeeRedirectError};
 pub use config::{BaseFeeConfig, ConfigError};
 pub use evm::{DefaultEvEvm, EvEvm};
-pub use factory::{with_ev_handler, BaseFeeRedirectSettings, EvEvmFactory, MintPrecompileSettings};
+pub use factory::{
+    with_ev_handler, BaseFeeRedirectSettings, ContractSizeLimitSettings, EvEvmFactory,
+    MintPrecompileSettings,
+};
 pub use handler::EvHandler;

crates/node/src/config.rs

@@ -2,8 +2,8 @@ use alloy_primitives::Address;
 use reth_chainspec::ChainSpec;
 use serde::{Deserialize, Serialize};
 
-/// Default contract size limit in bytes (128KB).
-pub const DEFAULT_CONTRACT_SIZE_LIMIT: usize = 128 * 1024;
+/// Default contract size limit in bytes (24KB per EIP-170).
+pub const DEFAULT_CONTRACT_SIZE_LIMIT: usize = 24 * 1024;
 
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 struct ChainspecEvolveConfig {
@@ -15,9 +15,12 @@ struct ChainspecEvolveConfig {
     pub mint_admin: Option<Address>,
     #[serde(default, rename = "mintPrecompileActivationHeight")]
     pub mint_precompile_activation_height: Option<u64>,
-    /// Maximum contract code size in bytes. Defaults to 128KB if not specified.
+    /// Maximum contract code size in bytes. Defaults to 24KB (EIP-170) if not specified.
     #[serde(default, rename = "contractSizeLimit")]
     pub contract_size_limit: Option<usize>,
+    /// Block height at which the custom contract size limit activates.
+    #[serde(default, rename = "contractSizeLimitActivationHeight")]
+    pub contract_size_limit_activation_height: Option<u64>,
 }
 
 /// Configuration for the Evolve payload builder
@@ -35,9 +38,12 @@ pub struct EvolvePayloadBuilderConfig {
     /// Optional activation height for mint precompile; defaults to 0 when admin set.
     #[serde(default)]
     pub mint_precompile_activation_height: Option<u64>,
-    /// Maximum contract code size in bytes. Defaults to 128KB.
+    /// Maximum contract code size in bytes. Defaults to 24KB (EIP-170).
     #[serde(default)]
     pub contract_size_limit: Option<usize>,
+    /// Block height at which the custom contract size limit activates.
+    #[serde(default)]
+    pub contract_size_limit_activation_height: Option<u64>,
 }
 
 impl EvolvePayloadBuilderConfig {
@@ -49,6 +55,7 @@ impl EvolvePayloadBuilderConfig {
             base_fee_redirect_activation_height: None,
             mint_precompile_activation_height: None,
             contract_size_limit: None,
+            contract_size_limit_activation_height: None,
         }
     }
 
@@ -81,13 +88,32 @@ impl EvolvePayloadBuilderConfig {
             }
 
             config.contract_size_limit = extras.contract_size_limit;
+            config.contract_size_limit_activation_height =
+                extras.contract_size_limit_activation_height;
         }
         Ok(config)
     }
 
-    /// Returns the contract size limit, defaulting to 128KB.
-    pub fn contract_size_limit(&self) -> usize {
-        self.contract_size_limit
+    /// Returns the contract size limit settings (limit, `activation_height`) if configured.
+    /// Returns None if no custom limit is set (uses EIP-170 default).
+    pub fn contract_size_limit_settings(&self) -> Option<(usize, u64)> {
+        self.contract_size_limit.map(|limit| {
+            let activation = self.contract_size_limit_activation_height.unwrap_or(0);
+            (limit, activation)
+        })
+    }
+
+    /// Returns the contract size limit for a given block number.
+    /// Uses the custom limit if configured and active, otherwise returns EIP-170 default.
+    pub fn contract_size_limit_for_block(&self, block_number: u64) -> usize {
+        self.contract_size_limit_settings()
+            .and_then(|(limit, activation)| {
+                if block_number >= activation {
+                    Some(limit)
+                } else {
+                    None
+                }
+            })
             .unwrap_or(DEFAULT_CONTRACT_SIZE_LIMIT)
     }
 
@@ -305,6 +331,7 @@ mod tests {
             base_fee_redirect_activation_height: Some(0),
             mint_precompile_activation_height: Some(0),
             contract_size_limit: None,
+            contract_size_limit_activation_height: None,
         };
         assert!(config_with_sink.validate().is_ok());
     }
@@ -318,6 +345,7 @@ mod tests {
             base_fee_redirect_activation_height: Some(5),
             mint_precompile_activation_height: None,
             contract_size_limit: None,
+            contract_size_limit_activation_height: None,
         };
 
         assert_eq!(config.base_fee_sink_for_block(4), None);
@@ -354,30 +382,72 @@ mod tests {
 
     #[test]
     fn test_contract_size_limit_default() {
-        // Test default contract size limit (128KB)
+        // Test default contract size limit (24KB per EIP-170)
         let config = EvolvePayloadBuilderConfig::new();
         assert_eq!(config.contract_size_limit, None);
-        assert_eq!(config.contract_size_limit(), DEFAULT_CONTRACT_SIZE_LIMIT);
-        assert_eq!(config.contract_size_limit(), 128 * 1024);
+        assert_eq!(config.contract_size_limit_settings(), None);
+        // When no custom limit is set, use EIP-170 default for any block
+        assert_eq!(config.contract_size_limit_for_block(0), DEFAULT_CONTRACT_SIZE_LIMIT);
+        assert_eq!(config.contract_size_limit_for_block(0), 24 * 1024);
     }
 
     #[test]
     fn test_contract_size_limit_from_chainspec() {
-        // Test contract size limit from chainspec
+        // Test contract size limit from chainspec with activation height
+        let extras = json!({
+            "contractSizeLimit": 131072,
+            "contractSizeLimitActivationHeight": 100
+        });
+
+        let chainspec = create_test_chainspec_with_extras(Some(extras));
+        let config = EvolvePayloadBuilderConfig::from_chain_spec(&chainspec).unwrap();
+
+        assert_eq!(config.contract_size_limit, Some(131072));
+        assert_eq!(config.contract_size_limit_activation_height, Some(100));
+        assert_eq!(config.contract_size_limit_settings(), Some((131072, 100)));
+    }
+
+    #[test]
+    fn test_contract_size_limit_respects_activation_height() {
+        // Test that contract size limit respects activation height
+        let extras = json!({
+            "contractSizeLimit": 131072,
+            "contractSizeLimitActivationHeight": 100
+        });
+
+        let chainspec = create_test_chainspec_with_extras(Some(extras));
+        let config = EvolvePayloadBuilderConfig::from_chain_spec(&chainspec).unwrap();
+
+        // Before activation: use EIP-170 default
+        assert_eq!(config.contract_size_limit_for_block(0), DEFAULT_CONTRACT_SIZE_LIMIT);
+        assert_eq!(config.contract_size_limit_for_block(99), DEFAULT_CONTRACT_SIZE_LIMIT);
+
+        // At and after activation: use custom limit
+        assert_eq!(config.contract_size_limit_for_block(100), 131072);
+        assert_eq!(config.contract_size_limit_for_block(1000), 131072);
+    }
+
+    #[test]
+    fn test_contract_size_limit_defaults_activation_to_zero() {
+        // Test that activation height defaults to 0 when limit is set but height is not
         let extras = json!({
-            "contractSizeLimit": 256000
+            "contractSizeLimit": 131072
         });
 
         let chainspec = create_test_chainspec_with_extras(Some(extras));
         let config = EvolvePayloadBuilderConfig::from_chain_spec(&chainspec).unwrap();
 
-        assert_eq!(config.contract_size_limit, Some(256000));
-        assert_eq!(config.contract_size_limit(), 256000);
+        assert_eq!(config.contract_size_limit, Some(131072));
+        assert_eq!(config.contract_size_limit_activation_height, None);
+        // Settings method defaults activation to 0
+        assert_eq!(config.contract_size_limit_settings(), Some((131072, 0)));
+        // Limit is active from block 0
+        assert_eq!(config.contract_size_limit_for_block(0), 131072);
     }
 
     #[test]
     fn test_contract_size_limit_not_set_uses_default() {
-        // Test that missing contractSizeLimit uses default
+        // Test that missing contractSizeLimit uses EIP-170 default
         let extras = json!({
             "baseFeeSink": "0x0000000000000000000000000000000000000001"
         });
@@ -386,6 +456,8 @@ mod tests {
         let config = EvolvePayloadBuilderConfig::from_chain_spec(&chainspec).unwrap();
 
         assert_eq!(config.contract_size_limit, None);
-        assert_eq!(config.contract_size_limit(), DEFAULT_CONTRACT_SIZE_LIMIT);
+        assert_eq!(config.contract_size_limit_settings(), None);
+        assert_eq!(config.contract_size_limit_for_block(0), DEFAULT_CONTRACT_SIZE_LIMIT);
+        assert_eq!(config.contract_size_limit_for_block(1000000), DEFAULT_CONTRACT_SIZE_LIMIT);
     }
 }

crates/node/src/executor.rs

@@ -2,7 +2,8 @@
 
 use alloy_evm::eth::{spec::EthExecutorSpec, EthEvmFactory};
 use ev_revm::{
-    with_ev_handler, BaseFeeRedirect, BaseFeeRedirectSettings, EvEvmFactory, MintPrecompileSettings,
+    with_ev_handler, BaseFeeRedirect, BaseFeeRedirectSettings, ContractSizeLimitSettings,
+    EvEvmFactory, MintPrecompileSettings,
 };
 use reth_chainspec::ChainSpec;
 use reth_ethereum::{
@@ -51,12 +52,17 @@ where
         .mint_precompile_settings()
         .map(|(admin, activation)| MintPrecompileSettings::new(admin, activation));
 
-    let contract_size_limit = Some(evolve_config.contract_size_limit());
-    info!(
-        target = "ev-reth::executor",
-        limit_bytes = contract_size_limit,
-        "Contract size limit configured"
-    );
+    let contract_size_limit = evolve_config
+        .contract_size_limit_settings()
+        .map(|(limit, activation)| {
+            info!(
+                target = "ev-reth::executor",
+                limit_bytes = limit,
+                activation_height = activation,
+                "Custom contract size limit enabled"
+            );
+            ContractSizeLimitSettings::new(limit, activation)
+        });
 
     Ok(with_ev_handler(
         base_config,

crates/tests/src/common.rs

@@ -8,7 +8,10 @@ use std::sync::Arc;
 use alloy_consensus::{transaction::SignerRecoverable, TxLegacy, TypedTransaction};
 use alloy_genesis::Genesis;
 use alloy_primitives::{Address, Bytes, ChainId, Signature, TxKind, B256, U256};
-use ev_revm::{with_ev_handler, BaseFeeRedirect, BaseFeeRedirectSettings, MintPrecompileSettings};
+use ev_revm::{
+    with_ev_handler, BaseFeeRedirect, BaseFeeRedirectSettings, ContractSizeLimitSettings,
+    MintPrecompileSettings,
+};
 use eyre::Result;
 use reth_chainspec::{ChainSpec, ChainSpecBuilder};
 use reth_ethereum_primitives::TransactionSigned;
@@ -137,7 +140,9 @@ impl EvolveTestFixture {
         let mint_precompile = config
             .mint_precompile_settings()
             .map(|(admin, activation)| MintPrecompileSettings::new(admin, activation));
-        let contract_size_limit = Some(config.contract_size_limit());
+        let contract_size_limit = config
+            .contract_size_limit_settings()
+            .map(|(limit, activation)| ContractSizeLimitSettings::new(limit, activation));
         let wrapped_evm = with_ev_handler(
             evm_config,
             base_fee_redirect,