feat(l2): config eth client through .toml

cmd/ethrex/l2/options.rs

@@ -49,6 +49,7 @@ impl From<SequencerOptions> for SequencerConfig {
             block_producer: BlockProducerConfig {
                 block_time_ms: opts.proposer_opts.block_time_ms,
                 coinbase_address: opts.proposer_opts.coinbase_address,
+                elasticity_multiplier: opts.proposer_opts.elasticity_multiplier,
             },
             l1_committer: CommitterConfig {
                 on_chain_proposer_address: opts.committer_opts.on_chain_proposer_address,
@@ -63,6 +64,10 @@ impl From<SequencerOptions> for SequencerConfig {
             },
             eth: EthConfig {
                 rpc_url: opts.eth_opts.rpc_url,
+                max_number_of_retries: opts.eth_opts.max_number_of_retries,
+                backoff_factor: opts.eth_opts.backoff_factor,
+                min_retry_delay: opts.eth_opts.min_retry_delay,
+                max_retry_delay: opts.eth_opts.max_retry_delay,
                 maximum_allowed_max_fee_per_gas: opts.eth_opts.maximum_allowed_max_fee_per_gas,
                 maximum_allowed_max_fee_per_blob_gas: opts
                     .eth_opts
@@ -115,6 +120,38 @@ pub struct EthOptions {
         help_heading = "Eth options"
     )]
     pub maximum_allowed_max_fee_per_blob_gas: u64,
+    #[arg(
+        long = "eth-max-number-of-retries",
+        default_value = "10",
+        value_name = "UINT64",
+        env = "ETHREX_MAX_NUMBER_OF_RETRIES",
+        help_heading = "Eth options"
+    )]
+    pub max_number_of_retries: u64,
+    #[arg(
+        long = "eth-backoff-factor",
+        default_value = "2",
+        value_name = "UINT64",
+        env = "ETHREX_BACKOFF_FACTOR",
+        help_heading = "Eth options"
+    )]
+    pub backoff_factor: u64,
+    #[arg(
+        long = "eth-min-retry-delay",
+        default_value = "96",
+        value_name = "UINT64",
+        env = "ETHREX_MIN_RETRY_DELAY",
+        help_heading = "Eth options"
+    )]
+    pub min_retry_delay: u64,
+    #[arg(
+        long = "eth-max-retry-delay",
+        default_value = "1800",
+        value_name = "UINT64",
+        env = "ETHREX_MAX_RETRY_DELAY",
+        help_heading = "Eth options"
+    )]
+    pub max_retry_delay: u64,
 }
 
 #[derive(Parser)]
@@ -187,6 +224,14 @@ pub struct ProposerOptions {
         help_heading = "Proposer options"
     )]
     pub coinbase_address: Address,
+    #[arg(
+        long,
+        default_value = "2",
+        value_name = "UINT64",
+        env = "ETHREX_PROPOSER_ELASTICITY_MULTIPLIER",
+        help_heading = "Proposer options"
+    )]
+    pub elasticity_multiplier: u64,
 }
 
 #[derive(Parser)]

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;
@@ -75,7 +75,7 @@ impl Blockchain {
         let chain_config = self.storage.get_chain_config()?;
 
         // 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,
@@ -102,7 +102,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)?;
 
@@ -560,9 +560,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/contracts/bin/deployer/cli.rs

@@ -42,6 +42,38 @@ pub struct DeployerOptions {
         help = "Private key corresponding of a funded account that will be used for L1 contract deployment.",
     )]
     pub private_key: SecretKey,
+    #[arg(
+        long,
+        default_value = "10",
+        value_name = "UINT64",
+        env = "ETHREX_ETH_MAX_NUMBER_OF_RETRIES",
+        help_heading = "Eth options"
+    )]
+    pub max_number_of_retries: u64,
+    #[arg(
+        long,
+        default_value = "2",
+        value_name = "UINT64",
+        env = "ETHREX_ETH_BACKOFF_FACTOR",
+        help_heading = "Eth options"
+    )]
+    pub backoff_factor: u64,
+    #[arg(
+        long,
+        default_value = "96",
+        value_name = "UINT64",
+        env = "ETHREX_ETH_MIN_RETRY_DELAY",
+        help_heading = "Eth options"
+    )]
+    pub min_retry_delay: u64,
+    #[arg(
+        long,
+        default_value = "1800",
+        value_name = "UINT64",
+        env = "ETHREX_ETH_MAX_RETRY_DELAY",
+        help_heading = "Eth options"
+    )]
+    pub max_retry_delay: u64,
     #[arg(
         long,
         value_name = "PATH",
@@ -181,6 +213,10 @@ impl Default for DeployerOptions {
             rpc_url: "http://localhost:8545".to_string(),
             maximum_allowed_max_fee_per_gas: 10_000_000_000,
             maximum_allowed_max_fee_per_blob_gas: 10_000_000_000,
+            max_number_of_retries: 10,
+            backoff_factor: 2,
+            min_retry_delay: 96,
+            max_retry_delay: 1800,
             #[allow(clippy::unwrap_used)]
             private_key: SecretKey::from_slice(
                 H256([

crates/l2/contracts/bin/deployer/main.rs

@@ -35,10 +35,14 @@ const BRIDGE_INITIALIZER_SIGNATURE: &str = "initialize(address)";
 async fn main() -> Result<(), DeployerError> {
     let opts = DeployerOptions::parse();
 
-    let eth_client = EthClient::new_with_maximum_fees(
+    let eth_client = EthClient::new_with_config(
         &opts.rpc_url,
-        opts.maximum_allowed_max_fee_per_gas,
-        opts.maximum_allowed_max_fee_per_blob_gas,
+        opts.max_number_of_retries,
+        opts.backoff_factor,
+        opts.min_retry_delay,
+        opts.max_retry_delay,
+        Some(opts.maximum_allowed_max_fee_per_gas),
+        Some(opts.maximum_allowed_max_fee_per_blob_gas),
     );
 
     download_contract_deps(&opts)?;

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

@@ -42,6 +42,7 @@ fn execution_program(input: ProgramInput) -> Result<ProgramOutput, Box<dyn std::
         blocks,
         parent_block_header,
         mut db,
+        elasticity_multiplier,
     } = input;
 
     // Tries used for validating initial and final state root
@@ -63,7 +64,12 @@ fn execution_program(input: ProgramInput) -> Result<ProgramOutput, Box<dyn std::
 
     for block in blocks {
         // Validate the block
-        validate_block(&block, &parent_header, &db.chain_config)?;
+        validate_block(
+            &block,
+            &parent_header,
+            &db.chain_config,
+            elasticity_multiplier,
+        )?;
 
         // Execute block
         let mut vm = Evm::from_execution_db(db.clone());

crates/l2/prover/src/prover.rs

@@ -83,7 +83,8 @@ impl Prover {
                         input:  ProgramInput {
                             blocks: input.blocks,
                             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 {
         blocks: vec![block_to_prove.clone()],
         parent_block_header,
         db,
+        elasticity_multiplier,
     };
     (input, block_to_prove.clone())
 }

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

@@ -5,6 +5,7 @@ use pico_sdk::io::{commit, read_as};
 use ethrex_blockchain::{validate_block, validate_gas_used};
 use ethrex_common::Address;
 use ethrex_storage::AccountUpdate;
+use ethrex_vm::backends::revm::{db::EvmState, REVM};
 use ethrex_vm::Evm;
 use std::collections::HashMap;
 use zkvm_interface::{
@@ -19,6 +20,7 @@ pub fn main() {
         blocks,
         parent_block_header,
         mut db,
+        elasticity_multiplier,
     } = read_as();
     // Tries used for validating initial and final state root
     let (mut state_trie, mut storage_tries) = db
@@ -41,7 +43,13 @@ pub fn main() {
 
     for block in blocks {
         // Validate the block
-        validate_block(&block, &parent_header, &db.chain_config).expect("invalid block");
+        validate_block(
+            &block,
+            &parent_header,
+            &db.chain_config,
+            elasticity_multiplier,
+        )
+        .expect("invalid block");
 
         // Execute block
         let mut vm = Evm::from_execution_db(db.clone());

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

@@ -17,6 +17,7 @@ pub fn main() {
         blocks,
         parent_block_header,
         mut db,
+        elasticity_multiplier,
     } = sp1_zkvm::io::read::<ProgramInput>();
     // Tries used for validating initial and final state root
     let (mut state_trie, mut storage_tries) = db
@@ -41,7 +42,13 @@ pub fn main() {
 
     for block in blocks {
         // Validate the block
-        validate_block(&block, &parent_header, &db.chain_config).expect("invalid block");
+        validate_block(
+            &block,
+            &parent_header,
+            &db.chain_config,
+            elasticity_multiplier,
+        )
+        .expect("invalid block");
 
         // Execute block
         let mut vm = Evm::from_execution_db(db.clone());