feat(l2): config eth client through .toml

crates/blockchain/blockchain.rs

@@ -16,7 +16,7 @@ use ethrex_common::types::{
     validate_prague_header_fields, validate_pre_cancun_header_fields, Block, BlockHash,
     BlockHeader, BlockNumber, ChainConfig, EIP4844Transaction, Receipt, Transaction,
 };
-use ethrex_common::types::{BlobsBundle, Fork};
+use ethrex_common::types::{BlobsBundle, Fork, ELASTICITY_MULTIPLIER};
 
 use ethrex_common::{Address, H256};
 use mempool::Mempool;
@@ -76,7 +76,7 @@ impl Blockchain {
         let fork = chain_config.fork(block.header.timestamp);
 
         // Validate the block pre-execution
-        validate_block(block, &parent_header, &chain_config)?;
+        validate_block(block, &parent_header, &chain_config, ELASTICITY_MULTIPLIER)?;
 
         let mut vm = Evm::new(
             self.evm_engine,
@@ -103,7 +103,7 @@ impl Blockchain {
         vm: &mut Evm,
     ) -> Result<BlockExecutionResult, ChainError> {
         // Validate the block pre-execution
-        validate_block(block, parent_header, chain_config)?;
+        validate_block(block, parent_header, chain_config, ELASTICITY_MULTIPLIER)?;
 
         let execution_result = vm.execute_block(block)?;
 
@@ -561,9 +561,11 @@ pub fn validate_block(
     block: &Block,
     parent_header: &BlockHeader,
     chain_config: &ChainConfig,
+    elasticity_multiplier: u64,
 ) -> Result<(), ChainError> {
     // Verify initial header validity against parent
-    validate_block_header(&block.header, parent_header).map_err(InvalidBlockError::from)?;
+    validate_block_header(&block.header, parent_header, elasticity_multiplier)
+        .map_err(InvalidBlockError::from)?;
 
     if chain_config.is_prague_activated(block.header.timestamp) {
         validate_prague_header_fields(&block.header, parent_header, chain_config)

crates/blockchain/payload.rs

@@ -49,6 +49,7 @@ pub struct BuildPayloadArgs {
     pub withdrawals: Option<Vec<Withdrawal>>,
     pub beacon_root: Option<H256>,
     pub version: u8,
+    pub elasticity_multiplier: u64,
 }
 
 impl BuildPayloadArgs {
@@ -111,6 +112,7 @@ pub fn create_payload(args: &BuildPayloadArgs, storage: &Store) -> Result<Block,
             parent_block.gas_limit,
             parent_block.gas_used,
             parent_block.base_fee_per_gas.unwrap_or_default(),
+            args.elasticity_multiplier,
         ),
         withdrawals_root: chain_config
             .is_shanghai_activated(args.timestamp)

crates/blockchain/smoke_test.rs

@@ -11,7 +11,7 @@ mod blockchain_integration_test {
     };
 
     use ethrex_common::{
-        types::{Block, BlockHeader},
+        types::{Block, BlockHeader, ELASTICITY_MULTIPLIER},
         H160, H256,
     };
     use ethrex_storage::{EngineType, Store};
@@ -301,6 +301,7 @@ mod blockchain_integration_test {
             withdrawals: Some(Vec::new()),
             beacon_root: Some(H256::random()),
             version: 1,
+            elasticity_multiplier: ELASTICITY_MULTIPLIER,
         };
 
         // Create blockchain

crates/common/types/block.rs

@@ -1,6 +1,6 @@
 use super::{
-    ChainConfig, BASE_FEE_MAX_CHANGE_DENOMINATOR, ELASTICITY_MULTIPLIER,
-    GAS_LIMIT_ADJUSTMENT_FACTOR, GAS_LIMIT_MINIMUM, INITIAL_BASE_FEE,
+    ChainConfig, BASE_FEE_MAX_CHANGE_DENOMINATOR, GAS_LIMIT_ADJUSTMENT_FACTOR, GAS_LIMIT_MINIMUM,
+    INITIAL_BASE_FEE,
 };
 use crate::{
     constants::{GAS_PER_BLOB, MIN_BASE_FEE_PER_BLOB_GAS},
@@ -432,14 +432,15 @@ pub fn calculate_base_fee_per_gas(
     parent_gas_limit: u64,
     parent_gas_used: u64,
     parent_base_fee_per_gas: u64,
+    elasticity_multiplier: u64,
 ) -> Option<u64> {
     // Check gas limit, if the check passes we can also rest assured that none of the
     // following divisions will have zero as a divider
     if !check_gas_limit(block_gas_limit, parent_gas_limit) {
         return None;
     }
 
-    let parent_gas_target = parent_gas_limit / ELASTICITY_MULTIPLIER;
+    let parent_gas_target = parent_gas_limit / elasticity_multiplier;
 
     Some(match parent_gas_used.cmp(&parent_gas_target) {
         Ordering::Equal => parent_base_fee_per_gas,
@@ -513,6 +514,7 @@ pub enum InvalidBlockHeaderError {
 pub fn validate_block_header(
     header: &BlockHeader,
     parent_header: &BlockHeader,
+    elasticity_multiplier: u64,
 ) -> Result<(), InvalidBlockHeaderError> {
     if header.gas_used > header.gas_limit {
         return Err(InvalidBlockHeaderError::GasUsedGreaterThanGasLimit);
@@ -523,6 +525,7 @@ pub fn validate_block_header(
         parent_header.gas_limit,
         parent_header.gas_used,
         parent_header.base_fee_per_gas.unwrap_or(INITIAL_BASE_FEE),
+        elasticity_multiplier,
     ) {
         base_fee
     } else {
@@ -669,7 +672,7 @@ pub fn calc_excess_blob_gas(
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::types::EMPTY_KECCACK_HASH;
+    use crate::types::{ELASTICITY_MULTIPLIER, EMPTY_KECCACK_HASH};
     use ethereum_types::H160;
     use hex_literal::hex;
     use std::str::FromStr;
@@ -787,7 +790,7 @@ mod test {
             parent_beacon_block_root: Some(H256::zero()),
             requests_hash: Some(*EMPTY_KECCACK_HASH),
         };
-        assert!(validate_block_header(&block, &parent_block).is_ok())
+        assert!(validate_block_header(&block, &parent_block, ELASTICITY_MULTIPLIER).is_ok())
     }
 
     #[test]

crates/l2/configs/sequencer_config_example.toml

@@ -18,6 +18,10 @@ salt_is_zero = true
 
 [eth]
 rpc_url = "http://localhost:8545"
+max_number_of_retries = 10
+backoff_factor = 2
+min_retry_delay = 96
+max_retry_delay = 1800
 
 [watcher]
 bridge_address = "0x266ffef34e21a7c4ce2e0e42dc780c2c273ca440"
@@ -28,6 +32,7 @@ l2_proposer_private_key = "0x385c546456b6a603a1cfcaa9ec9494ba4832da08dd6bcf4de9a
 [proposer]
 block_time_ms = 5000
 coinbase_address = "0x0007a881CD95B1484fca47615B64803dad620C8d"
+elasticity_multiplier = 2
 
 [committer]
 # Address of a funded account that the sequencer will use to send commit txs to the L1.

crates/l2/contracts/deployer.rs

@@ -3,6 +3,7 @@ use colored::Colorize;
 use ethereum_types::{Address, H160, H256};
 use ethrex_common::U256;
 use ethrex_l2::utils::config::errors;
+use ethrex_l2::utils::config::eth::EthConfig;
 use ethrex_l2::utils::config::{
     read_env_as_lines_by_config, read_env_file_by_config, toml_parser::parse_configs,
     write_env_file_by_config, ConfigMode,
@@ -165,7 +166,14 @@ async fn main() -> Result<(), DeployError> {
 fn setup() -> Result<SetupResult, DeployError> {
     read_env_file_by_config(ConfigMode::Sequencer)?;
 
-    let eth_client = EthClient::new(&read_env_var("ETH_RPC_URL")?);
+    let eth_config = EthConfig::from_env().map_err(DeployError::ConfigError)?;
+    let eth_client = EthClient::new_with_config(
+        &eth_config.rpc_url,
+        eth_config.max_number_of_retries,
+        eth_config.backoff_factor,
+        eth_config.min_retry_delay,
+        eth_config.max_retry_delay,
+    );
 
     let deployer_address = parse_env_var("DEPLOYER_L1_ADDRESS")?;
     let deployer_private_key = SecretKey::from_slice(

crates/l2/docs/sequencer.md

@@ -80,6 +80,7 @@ The following environment variables are available to configure the Proposer cons
   - `l1_private_key`: Its private key.
   - `commit_time_ms`: Sleep time after sending the commit transaction.
   - `on_chain_proposer_address`: Address of the on-chain committer.
+  - `elasticity_multiplier`: Value used to set the gas limit of a block. This value is multiplied by the gas target value of the block.
 
 - Under the `[prover_server]` section:
 
@@ -90,6 +91,14 @@ The following environment variables are available to configure the Proposer cons
   - `listen_port`: Port to listen for proof data requests.
   - `dev_mode`: Whether `dev_mode` is activated or not.
 
+- Under the `[eth]` section:
+
+  - `rpc_url`: The URL for interacting with the RPC endpoint from the client.
+  - `max_number_of_retries`: Value to set how many times are you willing to bump the gas in order to send the transaction.
+  - `backoff_factor`: Base of the exponential used to calculate the backoff for the wait time when bumping the gas.
+  - `min_retry_delay`: Minimum wait time for expecting to receive the receipt of the transaction. If not received, bump the transaction
+  - `max_retry_delay`: Maximum wait time to before expecting the transaction's receipt. This prevents from long wait times.
+
 If you want to use a different configuration file, you can set the:
 
 - `CONFIGS_PATH`: The path where the `SEQUENCER_CONFIG_FILE` is located at.

crates/l2/prover/src/backends/exec.rs

@@ -39,9 +39,16 @@ fn execution_program(input: ProgramInput) -> Result<ProgramOutput, Box<dyn std::
         block,
         parent_block_header,
         db,
+        elasticity_multiplier,
     } = input;
+
     // Validate the block
-    validate_block(&block, &parent_block_header, &db.chain_config)?;
+    validate_block(
+        &block,
+        &parent_block_header,
+        &db.chain_config,
+        elasticity_multiplier,
+    )?;
 
     // Tries used for validating initial and final state root
     let (mut state_trie, mut storage_tries) = db.get_tries()?;

crates/l2/prover/src/prover.rs

@@ -83,7 +83,8 @@ impl Prover {
                         input:  ProgramInput {
                             block: input.block,
                             parent_block_header: input.parent_block_header,
-                            db: input.db
+                            db: input.db,
+                            elasticity_multiplier: input.elasticity_multiplier,
                         }
                     };
                     Ok(prover_data)

crates/l2/prover/tests/perf_zkvm.rs

@@ -1,7 +1,7 @@
 #![allow(clippy::expect_used)]
 #![allow(clippy::unwrap_used)]
 use ethrex_blockchain::Blockchain;
-use ethrex_common::types::Block;
+use ethrex_common::types::{Block, ELASTICITY_MULTIPLIER};
 use ethrex_prover_lib::execute;
 use ethrex_storage::{EngineType, Store};
 use ethrex_vm::Evm;
@@ -16,7 +16,6 @@ async fn test_performance_zkvm() {
     let (input, block_to_prove) = setup().await;
 
     let start = std::time::Instant::now();
-
     // this is only executing because these tests run as a CI job and should be fast
     // TODO: create a test for actual proving
     execute(input).unwrap();
@@ -69,10 +68,14 @@ async fn setup() -> (ProgramInput, Block) {
         .await
         .unwrap();
 
+    // This is just a test, so we can use the default value for the elasticity multiplier.
+    let elasticity_multiplier = ELASTICITY_MULTIPLIER;
+
     let input = ProgramInput {
         block: block_to_prove.clone(),
         parent_block_header,
         db,
+        elasticity_multiplier,
     };
     (input, block_to_prove.clone())
 }

crates/l2/prover/zkvm/interface/pico/src/main.rs

@@ -3,7 +3,7 @@
 use pico_sdk::io::{commit, read_as};
 
 use ethrex_blockchain::{validate_block, validate_gas_used};
-use ethrex_vm::backends::revm::{REVM, db::EvmState};
+use ethrex_vm::backends::revm::{db::EvmState, REVM};
 use zkvm_interface::{
     io::{ProgramInput, ProgramOutput},
     trie::{update_tries, verify_db},
@@ -16,14 +16,21 @@ pub fn main() {
         block,
         parent_block_header,
         db,
+        elasticity_multiplier,
     } = read_as();
     let mut state = EvmState::from(db.clone());
     let chain_config = state
         .chain_config()
         .expect("Failed to get chain config from state");
 
     // Validate the block
-    validate_block(&block, &parent_block_header, &chain_config).expect("invalid block");
+    validate_block(
+        &block,
+        &parent_block_header,
+        &chain_config,
+        elasticity_multiplier,
+    )
+    .expect("invalid block");
 
     // Tries used for validating initial and final state root
     let (mut state_trie, mut storage_tries) = db

crates/l2/prover/zkvm/interface/sp1/src/main.rs

@@ -14,9 +14,17 @@ pub fn main() {
         block,
         parent_block_header,
         db,
+        elasticity_multiplier,
     } = sp1_zkvm::io::read::<ProgramInput>();
+
     // Validate the block
-    validate_block(&block, &parent_block_header, &db.chain_config).expect("invalid block");
+    validate_block(
+        &block,
+        &parent_block_header,
+        &db.chain_config,
+        elasticity_multiplier,
+    )
+    .expect("invalid block");
 
     // Tries used for validating initial and final state root
     let (mut state_trie, mut storage_tries) = db

crates/l2/prover/zkvm/interface/src/lib.rs

@@ -40,6 +40,8 @@ pub mod io {
         pub parent_block_header: BlockHeader,
         /// database containing only the data necessary to execute
         pub db: ExecutionDB,
+        /// value used to calculate base fee
+        pub elasticity_multiplier: u64,
     }
 
     /// Public output variables exposed by the zkVM execution program. Some of these are part of

crates/l2/sequencer/block_producer.rs

@@ -24,6 +24,7 @@ use super::{errors::BlockProducerError, execution_cache::ExecutionCache};
 pub struct BlockProducer {
     block_time_ms: u64,
     coinbase_address: Address,
+    elasticity_multiplier: u64,
 }
 
 pub async fn start_block_producer(
@@ -45,10 +46,12 @@ impl BlockProducer {
         let BlockProducerConfig {
             block_time_ms,
             coinbase_address,
+            elasticity_multiplier,
         } = config;
         Ok(Self {
             block_time_ms,
             coinbase_address,
+            elasticity_multiplier,
         })
     }
 
@@ -101,6 +104,7 @@ impl BlockProducer {
             withdrawals: Default::default(),
             beacon_root: Some(head_beacon_block_root),
             version,
+            elasticity_multiplier: self.elasticity_multiplier,
         };
         let payload = create_payload(&args, &store)?;
 
@@ -114,7 +118,12 @@ impl BlockProducer {
         // Blockchain stores block
         let block = payload_build_result.payload;
         let chain_config = store.get_chain_config()?;
-        validate_block(&block, &head_header, &chain_config)?;
+        validate_block(
+            &block,
+            &head_header,
+            &chain_config,
+            self.elasticity_multiplier,
+        )?;
 
         let account_updates = payload_build_result.account_updates;
 

crates/l2/sequencer/l1_committer.rs

@@ -66,7 +66,13 @@ impl Committer {
         execution_cache: Arc<ExecutionCache>,
     ) -> Self {
         Self {
-            eth_client: EthClient::new(&eth_config.rpc_url),
+            eth_client: EthClient::new_with_config(
+                &eth_config.rpc_url,
+                eth_config.max_number_of_retries,
+                eth_config.backoff_factor,
+                eth_config.min_retry_delay,
+                eth_config.max_retry_delay,
+            ),
             on_chain_proposer_address: committer_config.on_chain_proposer_address,
             store,
             l1_address: committer_config.l1_address,