feat(l2): implement l1 fee

.github/workflows/main_prover.yaml

@@ -89,6 +89,7 @@ jobs:
           ETHREX_BLOCK_PRODUCER_BASE_FEE_VAULT_ADDRESS=0x000c0d6b7c4516a5b274c51ea331a9410fe69127 \
           ETHREX_BLOCK_PRODUCER_OPERATOR_FEE_VAULT_ADDRESS=0xd5d2a85751b6F158e5b9B8cD509206A865672362 \
           ETHREX_BLOCK_PRODUCER_OPERATOR_FEE_PER_GAS=1000000000 \
+          ETHREX_BLOCK_PRODUCER_L1_FEE_VAULT_ADDRESS=0x45681AE1768a8936FB87aB11453B4755e322ceec \
           docker compose up --build --detach --no-deps ethrex_l2
 
       - name: Copy env to host

.github/workflows/pr-main_l2.yaml

@@ -284,6 +284,7 @@ jobs:
             export ETHREX_BLOCK_PRODUCER_BASE_FEE_VAULT_ADDRESS=0x000c0d6b7c4516a5b274c51ea331a9410fe69127
             export ETHREX_BLOCK_PRODUCER_OPERATOR_FEE_VAULT_ADDRESS=0xd5d2a85751b6F158e5b9B8cD509206A865672362
             export ETHREX_BLOCK_PRODUCER_OPERATOR_FEE_PER_GAS=1000000000
+            export ETHREX_BLOCK_PRODUCER_L1_FEE_VAULT_ADDRESS=0x45681AE1768a8936FB87aB11453B4755e322ceec
           fi
           cd crates/l2
           DOCKER_ETHREX_WORKDIR=/usr/local/bin \
@@ -393,6 +394,7 @@ jobs:
           ETHREX_BLOCK_PRODUCER_BASE_FEE_VAULT_ADDRESS=0x000c0d6b7c4516a5b274c51ea331a9410fe69127 \
           ETHREX_BLOCK_PRODUCER_OPERATOR_FEE_VAULT_ADDRESS=0xd5d2a85751b6F158e5b9B8cD509206A865672362 \
           ETHREX_BLOCK_PRODUCER_OPERATOR_FEE_PER_GAS=1000000000 \
+          ETHREX_BLOCK_PRODUCER_L1_FEE_VAULT_ADDRESS=0x45681AE1768a8936FB87aB11453B4755e322ceec \
           ETHREX_PROOF_COORDINATOR_ADDRESS=0.0.0.0 \
           docker compose -f docker-compose.yaml -f docker-compose-l2-tdx.yaml up --detach --no-deps ethrex_l2
 

cmd/ethrex/cli.rs

@@ -6,8 +6,8 @@ use std::{
 };
 
 use clap::{ArgAction, Parser as ClapParser, Subcommand as ClapSubcommand};
-use ethrex_blockchain::{BlockchainOptions, BlockchainType, error::ChainError};
-use ethrex_common::types::{Block, DEFAULT_BUILDER_GAS_CEIL, Genesis, fee_config::FeeConfig};
+use ethrex_blockchain::{BlockchainOptions, BlockchainType, L2Config, error::ChainError};
+use ethrex_common::types::{Block, DEFAULT_BUILDER_GAS_CEIL, Genesis};
 use ethrex_p2p::{
     discv4::peer_table::TARGET_PEERS, sync::SyncMode, tx_broadcaster::BROADCAST_INTERVAL_MS,
     types::Node,
@@ -402,7 +402,7 @@ impl Subcommand {
                 let network = get_network(opts);
                 let genesis = network.get_genesis()?;
                 let blockchain_type = if l2 {
-                    BlockchainType::L2(FeeConfig::default())
+                    BlockchainType::L2(L2Config::default())
                 } else {
                     BlockchainType::L1
                 };

cmd/ethrex/l2/initializers.rs

@@ -7,8 +7,8 @@ use crate::l2::{L2Options, SequencerOptions};
 use crate::utils::{
     NodeConfigFile, get_client_version, init_datadir, read_jwtsecret_file, store_node_config_file,
 };
-use ethrex_blockchain::{Blockchain, BlockchainType};
-use ethrex_common::types::fee_config::{FeeConfig, OperatorFeeConfig};
+use ethrex_blockchain::{Blockchain, BlockchainType, L2Config};
+use ethrex_common::types::fee_config::{FeeConfig, L1FeeConfig, OperatorFeeConfig};
 use ethrex_common::{Address, types::DEFAULT_BUILDER_GAS_CEIL};
 use ethrex_l2::SequencerConfig;
 use ethrex_p2p::{
@@ -157,18 +157,26 @@ pub async fn init_l2(
     let rollup_store = init_rollup_store(&rollup_store_dir).await;
 
     let operator_fee_config = get_operator_fee_config(&opts.sequencer_opts).await?;
+    let l1_fee_config = get_l1_fee_config(&opts.sequencer_opts);
 
     let fee_config = FeeConfig {
         base_fee_vault: opts
             .sequencer_opts
             .block_producer_opts
             .base_fee_vault_address,
         operator_fee_config,
+        l1_fee_config,
+    };
+
+    // We wrap fee_config in an Arc<RwLock> to let the watcher
+    // update the L1 fee periodically.
+    let l2_config = L2Config {
+        fee_config: Arc::new(tokio::sync::RwLock::new(fee_config)),
     };
 
     let blockchain_opts = ethrex_blockchain::BlockchainOptions {
         max_mempool_size: opts.node_opts.mempool_max_size,
-        r#type: BlockchainType::L2(fee_config),
+        r#type: BlockchainType::L2(l2_config),
         perf_logs_enabled: true,
     };
 
@@ -296,11 +304,25 @@ pub async fn init_l2(
     Ok(())
 }
 
+pub fn get_l1_fee_config(sequencer_opts: &SequencerOptions) -> Option<L1FeeConfig> {
+    if sequencer_opts.based {
+        // If based is enabled, skip L1 fee configuration
+        return None;
+    }
+
+    sequencer_opts
+        .block_producer_opts
+        .l1_fee_vault_address
+        .map(|addr| L1FeeConfig {
+            l1_fee_vault: addr,
+            l1_fee_per_blob_gas: 0, // This is set by the L1 watcher
+}
+
 pub async fn get_operator_fee_config(
     sequencer_opts: &SequencerOptions,
 ) -> eyre::Result<Option<OperatorFeeConfig>> {
     if sequencer_opts.based {
-        // If based is enabled, operator fee is not applicable
+        // If based is enabled, skip operator fee configuration
         return Ok(None);
     }
 

cmd/ethrex/l2/options.rs

@@ -198,6 +198,7 @@ impl TryFrom<SequencerOptions> for SequencerConfig {
                 check_interval_ms: opts.watcher_opts.watch_interval_ms,
                 max_block_step: opts.watcher_opts.max_block_step.into(),
                 watcher_block_delay: opts.watcher_opts.watcher_block_delay,
+                l1_blob_base_fee_update_interval: opts.watcher_opts.l1_fee_update_interval_ms,
             },
             proof_coordinator: ProofCoordinatorConfig {
                 listen_ip: opts.proof_coordinator_opts.listen_ip,
@@ -399,6 +400,14 @@ pub struct WatcherOptions {
         help_heading = "L1 Watcher options"
     )]
     pub watcher_block_delay: u64,
+    #[arg(
+        long = "watcher.l1-fee-update-interval-ms",
+        value_name = "ADDRESS",
+        default_value = "60000",
+        env = "ETHREX_WATCHER_L1_FEE_UPDATE_INTERVAL_MS",
+        help_heading = "Block producer options"
+    )]
+    pub l1_fee_update_interval_ms: u64,
 }
 
 impl Default for WatcherOptions {
@@ -408,6 +417,7 @@ impl Default for WatcherOptions {
             watch_interval_ms: 1000,
             max_block_step: 5000,
             watcher_block_delay: 0,
+            l1_fee_update_interval_ms: 60000,
         }
     }
 }
@@ -453,14 +463,21 @@ pub struct BlockProducerOptions {
     )]
     pub operator_fee_vault_address: Option<Address>,
     #[arg(
-        long,
+        long = "block-producer.operator-fee-per-gas",
         value_name = "UINT64",
         env = "ETHREX_BLOCK_PRODUCER_OPERATOR_FEE_PER_GAS",
         requires = "operator_fee_vault_address",
         help_heading = "Block producer options",
         help = "Fee that the operator will receive for each unit of gas consumed in a block."
     )]
     pub operator_fee_per_gas: Option<u64>,
+    #[arg(
+        long = "block-producer.l1-fee-vault-address",
+        value_name = "ADDRESS",
+        env = "ETHREX_BLOCK_PRODUCER_L1_FEE_VAULT_ADDRESS",
+        help_heading = "Block producer options"
+    )]
+    pub l1_fee_vault_address: Option<Address>,
     #[arg(
         long,
         default_value = "2",
@@ -492,6 +509,7 @@ impl Default for BlockProducerOptions {
             base_fee_vault_address: None,
             operator_fee_vault_address: None,
             operator_fee_per_gas: None,
+            l1_fee_vault_address: None,
             elasticity_multiplier: 2,
             block_gas_limit: DEFAULT_BUILDER_GAS_CEIL,
         }

crates/blockchain/blockchain.rs

@@ -37,7 +37,7 @@ use std::collections::{BTreeMap, HashMap};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::Instant;
-use tokio::sync::Mutex as TokioMutex;
+use tokio::sync::{Mutex as TokioMutex, RwLock};
 use tokio_util::sync::CancellationToken;
 
 use vm::StoreVmDatabase;
@@ -58,7 +58,13 @@ const MAX_MEMPOOL_SIZE_DEFAULT: usize = 10_000;
 pub enum BlockchainType {
     #[default]
     L1,
-    L2(FeeConfig),
+    L2(L2Config),
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct L2Config {
+    /// We use a RwLock because the Watcher updates the L1 fee config periodically
+    pub fee_config: Arc<RwLock<FeeConfig>>,
 }
 
 #[derive(Debug)]
@@ -150,7 +156,7 @@ impl Blockchain {
         validate_block(block, &parent_header, &chain_config, ELASTICITY_MULTIPLIER)?;
 
         let vm_db = StoreVmDatabase::new(self.storage.clone(), block.header.parent_hash);
-        let mut vm = self.new_evm(vm_db)?;
+        let mut vm = self.new_evm(vm_db).await?;
 
         let execution_result = vm.execute_block(block)?;
         let account_updates = vm.get_state_transitions()?;
@@ -185,6 +191,15 @@ impl Blockchain {
     pub async fn generate_witness_for_blocks(
         &self,
         blocks: &[Block],
+    ) -> Result<ExecutionWitness, ChainError> {
+        self.generate_witness_for_blocks_with_fee_configs(blocks, None)
+            .await
+    }
+
+    pub async fn generate_witness_for_blocks_with_fee_configs(
+        &self,
+        blocks: &[Block],
+        fee_configs: Option<&[FeeConfig]>,
     ) -> Result<ExecutionWitness, ChainError> {
         let first_block_header = blocks
             .first()
@@ -215,15 +230,25 @@ impl Blockchain {
         let mut block_hashes = HashMap::new();
         let mut codes = Vec::new();
 
-        for block in blocks {
+        for (i, block) in blocks.iter().enumerate() {
             let parent_hash = block.header.parent_hash;
             let vm_db: DynVmDatabase =
                 Box::new(StoreVmDatabase::new(self.storage.clone(), parent_hash));
             let logger = Arc::new(DatabaseLogger::new(Arc::new(Mutex::new(Box::new(vm_db)))));
-            let mut vm = match self.options.r#type {
+            let mut vm = match &self.options.r#type {
                 BlockchainType::L1 => Evm::new_from_db_for_l1(logger.clone()),
-                BlockchainType::L2(fee_config) => {
-                    Evm::new_from_db_for_l2(logger.clone(), fee_config)
+                BlockchainType::L2(_) => {
+                    let l2_config = match fee_configs {
+                        Some(fee_configs) => {
+                            fee_configs.get(i).ok_or(ChainError::WitnessGeneration(
+                                "FeeConfig not found for witness generation".to_string(),
+                            ))?
+                        }
+                        None => Err(ChainError::WitnessGeneration(
+                            "L2Config not found for witness generation".to_string(),
+                        ))?,
+                    };
+                    Evm::new_from_db_for_l2(logger.clone(), *l2_config)
                 }
             };
 
@@ -540,7 +565,7 @@ impl Blockchain {
             first_block_header.parent_hash,
             block_hash_cache,
         );
-        let mut vm = self.new_evm(vm_db).map_err(|e| (e.into(), None))?;
+        let mut vm = self.new_evm(vm_db).await.map_err(|e| (e.into(), None))?;
 
         let blocks_len = blocks.len();
         let mut all_receipts: Vec<(BlockHash, Vec<Receipt>)> = Vec::with_capacity(blocks_len);
@@ -917,10 +942,12 @@ impl Blockchain {
         Ok(result)
     }
 
-    pub fn new_evm(&self, vm_db: StoreVmDatabase) -> Result<Evm, EvmError> {
-        let evm = match self.options.r#type {
+    pub async fn new_evm(&self, vm_db: StoreVmDatabase) -> Result<Evm, EvmError> {
+        let evm = match &self.options.r#type {
             BlockchainType::L1 => Evm::new_for_l1(vm_db),
-            BlockchainType::L2(fee_config) => Evm::new_for_l2(vm_db, fee_config)?,
+            BlockchainType::L2(l2_config) => {
+                Evm::new_for_l2(vm_db, *l2_config.fee_config.read().await)?
+            }
         };
         Ok(evm)
     }

crates/blockchain/payload.rs

@@ -219,7 +219,7 @@ pub struct PayloadBuildContext {
 }
 
 impl PayloadBuildContext {
-    pub fn new(
+    pub async fn new(
         payload: Block,
         storage: &Store,
         blockchain_type: BlockchainType,
@@ -238,7 +238,9 @@ impl PayloadBuildContext {
         let vm_db = StoreVmDatabase::new(storage.clone(), payload.header.parent_hash);
         let vm = match blockchain_type {
             BlockchainType::L1 => Evm::new_for_l1(vm_db),
-            BlockchainType::L2(fee_config) => Evm::new_for_l2(vm_db, fee_config)?,
+            BlockchainType::L2(l2_config) => {
+                Evm::new_for_l2(vm_db, *l2_config.fee_config.read().await)?
+            }
         };
 
         Ok(PayloadBuildContext {
@@ -392,7 +394,7 @@ impl Blockchain {
         debug!("Building payload");
         let base_fee = payload.header.base_fee_per_gas.unwrap_or_default();
         let mut context =
-            PayloadBuildContext::new(payload, &self.storage, self.options.r#type.clone())?;
+            PayloadBuildContext::new(payload, &self.storage, self.options.r#type.clone()).await?;
 
         if let BlockchainType::L1 = self.options.r#type {
             self.apply_system_operations(&mut context)?;

crates/blockchain/tracing.rs

@@ -107,7 +107,7 @@ impl Blockchain {
             parent_hash,
             block_hash_cache,
         );
-        let mut vm = self.new_evm(vm_db)?;
+        let mut vm = self.new_evm(vm_db).await?;
         // Run parents to rebuild pre-state
         for block in blocks_to_re_execute.iter().rev() {
             vm.rerun_block(block, None)?;

crates/common/types/l2.rs

@@ -1,2 +1,3 @@
+pub mod account_diff;
 pub mod batch;
 pub mod fee_config;