feat(l1): implement eth-config (#4625)

**Motivation**

Achieving full Fusaka implementation before launch.

**Description**

This PR implements [EIP-7910](https://eips.ethereum.org/EIPS/eip-7910).
To summarize, it consists of a new eth method, that returns the fork ID,
chain ID, activation time, active precompiles and system contracts for
the currently activated fork, and when applicable, the next and latest
fork's the client has in its configuration.

As part of implementing the precompiles side of things, the logic of how
we check an address is a precompile was refactored, introducing a method
that returns the precompiles per fork so as to more closely tie the
addresses we return in the `eth-config` method and the way we check a
precompile is active when executing it.

To test this PR, you can follow the instructions in [this
page](https://eest.ethereum.org/main/running_tests/execute/eth_config/).
Keep in mind the tests require to have whichever chain they're being run
on fully synced.

Closes #3711

Author: SDartayet

crates/common/types/genesis.rs

@@ -111,9 +111,9 @@ impl TryFrom<&Path> for Genesis {
 )]
 #[serde(rename_all = "camelCase")]
 pub struct ForkBlobSchedule {
-    pub target: u32,
-    pub max: u32,
     pub base_fee_update_fraction: u64,
+    pub max: u32,
+    pub target: u32,
 }
 
 #[allow(unused)]
@@ -460,6 +460,97 @@ impl ChainConfig {
         self.get_fork(block_timestamp)
     }
 
+    pub fn next_fork(&self, block_timestamp: u64) -> Option<Fork> {
+        let next = if self.is_bpo5_activated(block_timestamp) {
+            None
+        } else if self.is_bpo4_activated(block_timestamp) && self.bpo5_time.is_some() {
+            Some(Fork::BPO5)
+        } else if self.is_bpo3_activated(block_timestamp) && self.bpo4_time.is_some() {
+            Some(Fork::BPO4)
+        } else if self.is_bpo2_activated(block_timestamp) && self.bpo3_time.is_some() {
+            Some(Fork::BPO3)
+        } else if self.is_bpo1_activated(block_timestamp) && self.bpo2_time.is_some() {
+            Some(Fork::BPO2)
+        } else if self.is_osaka_activated(block_timestamp) && self.bpo1_time.is_some() {
+            Some(Fork::BPO1)
+        } else if self.is_prague_activated(block_timestamp) && self.osaka_time.is_some() {
+            Some(Fork::Osaka)
+        } else if self.is_cancun_activated(block_timestamp) && self.prague_time.is_some() {
+            Some(Fork::Prague)
+        } else if self.is_shanghai_activated(block_timestamp) && self.cancun_time.is_some() {
+            Some(Fork::Cancun)
+        } else {
+            None
+        };
+        match next {
+            Some(fork) if fork > self.fork(block_timestamp) => next,
+            _ => None,
+        }
+    }
+
+    pub fn get_last_scheduled_fork(&self) -> Fork {
+        if self.bpo5_time.is_some() {
+            Fork::BPO5
+        } else if self.bpo4_time.is_some() {
+            Fork::BPO4
+        } else if self.bpo3_time.is_some() {
+            Fork::BPO3
+        } else if self.bpo2_time.is_some() {
+            Fork::BPO2
+        } else if self.bpo1_time.is_some() {
+            Fork::BPO1
+        } else if self.osaka_time.is_some() {
+            Fork::Osaka
+        } else if self.prague_time.is_some() {
+            Fork::Prague
+        } else if self.cancun_time.is_some() {
+            Fork::Cancun
+        } else {
+            Fork::Paris
+        }
+    }
+
+    pub fn get_activation_timestamp_for_fork(&self, fork: Fork) -> Option<u64> {
+        match fork {
+            Fork::Cancun => self.cancun_time,
+            Fork::Prague => self.prague_time,
+            Fork::Osaka => self.osaka_time,
+            Fork::BPO1 => self.bpo1_time,
+            Fork::BPO2 => self.bpo2_time,
+            Fork::BPO3 => self.bpo3_time,
+            Fork::BPO4 => self.bpo4_time,
+            Fork::BPO5 => self.bpo5_time,
+            Fork::Homestead => self.homestead_block,
+            Fork::DaoFork => self.dao_fork_block,
+            Fork::Byzantium => self.byzantium_block,
+            Fork::Constantinople => self.constantinople_block,
+            Fork::Petersburg => self.petersburg_block,
+            Fork::Istanbul => self.istanbul_block,
+            Fork::MuirGlacier => self.muir_glacier_block,
+            Fork::Berlin => self.berlin_block,
+            Fork::London => self.london_block,
+            Fork::ArrowGlacier => self.arrow_glacier_block,
+            Fork::GrayGlacier => self.gray_glacier_block,
+            Fork::Paris => self.merge_netsplit_block,
+            Fork::Shanghai => self.shanghai_time,
+            _ => None,
+        }
+    }
+
+    pub fn get_blob_schedule_for_fork(&self, fork: Fork) -> Option<ForkBlobSchedule> {
+        match fork {
+            Fork::Cancun => Some(self.blob_schedule.cancun),
+            Fork::Prague => Some(self.blob_schedule.prague),
+            Fork::Osaka => Some(self.blob_schedule.osaka),
+            Fork::BPO1 => Some(self.blob_schedule.bpo1),
+            Fork::BPO2 => Some(self.blob_schedule.bpo2),
+            Fork::BPO3 => self.blob_schedule.bpo3,
+            Fork::BPO4 => self.blob_schedule.bpo4,
+            Fork::BPO5 => self.blob_schedule.bpo5,
+            _ => None,
+        }
+    }
+
     pub fn gather_forks(&self, genesis_header: BlockHeader) -> (Vec<u64>, Vec<u64>) {
         let mut block_number_based_forks: Vec<u64> = vec![
             self.homestead_block,

crates/networking/rpc/engine/blobs.rs

@@ -44,6 +44,7 @@ impl RpcHandler for BlobsV1Request {
 
     async fn handle(&self, context: RpcApiContext) -> Result<Value, RpcErr> {
         info!("Received new engine request: Requested Blobs");
+
         if self.blob_versioned_hashes.len() >= GET_BLOBS_V1_REQUEST_MAX_SIZE {
             return Err(RpcErr::TooLargeRequest);
         }

crates/networking/rpc/eth/client.rs

@@ -1,4 +1,12 @@
+use std::collections::BTreeMap;
+
+use ethrex_common::H32;
+use ethrex_common::H160;
 use ethrex_common::serde_utils;
+use ethrex_common::types::Fork;
+use ethrex_common::types::ForkBlobSchedule;
+use ethrex_common::types::ForkId;
+use ethrex_vm::{precompiles_for_fork, system_contracts::system_contracts_for_fork};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use tracing::debug;
@@ -62,3 +70,110 @@ impl RpcHandler for Syncing {
         }
     }
 }
+
+pub struct Config;
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct EthConfigObject {
+    activation_time: Option<u64>,
+    blob_schedule: Option<ForkBlobSchedule>,
+    #[serde(with = "serde_utils::u64::hex_str")]
+    chain_id: u64,
+    fork_id: H32,
+    precompiles: BTreeMap<String, H160>,
+    system_contracts: BTreeMap<String, H160>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct EthConfigResponse {
+    current: EthConfigObject,
+    next: Option<EthConfigObject>,
+    last: Option<EthConfigObject>,
+}
+
+impl RpcHandler for Config {
+    fn parse(_params: &Option<Vec<Value>>) -> Result<Self, RpcErr> {
+        Ok(Self {})
+    }
+
+    async fn handle(&self, context: RpcApiContext) -> Result<Value, RpcErr> {
+        let chain_config = context.storage.get_chain_config()?;
+        let Some(latest_block) = context
+            .storage
+            .get_block_by_number(context.storage.get_latest_block_number().await?)
+            .await?
+        else {
+            return Err(RpcErr::Internal("Failed to fetch latest block".to_string()));
+        };
+
+        let latest_block_timestamp = latest_block.header.timestamp;
+        let current_fork = chain_config.get_fork(latest_block_timestamp);
+
+        if current_fork < Fork::Paris {
+            return Err(RpcErr::UnsuportedFork(
+                "eth-config is not supported for forks prior to Paris".to_string(),
+            ));
+        }
+
+        let current = get_config_for_fork(current_fork, &context).await?;
+        let next = if let Some(next_fork) = chain_config.next_fork(latest_block_timestamp) {
+            Some(get_config_for_fork(next_fork, &context).await?)
+        } else {
+            None
+        };
+        let last_fork = chain_config.get_last_scheduled_fork();
+        let last = if last_fork > current_fork {
+            Some(get_config_for_fork(last_fork, &context).await?)
+        } else {
+            None
+        };
+        let response = EthConfigResponse {
+            current,
+            next,
+            last,
+        };
+
+        serde_json::to_value(response).map_err(|error| RpcErr::Internal(error.to_string()))
+    }
+}
+
+async fn get_config_for_fork(
+    fork: Fork,
+    context: &RpcApiContext,
+) -> Result<EthConfigObject, RpcErr> {
+    let chain_config = context.storage.get_chain_config()?;
+    let activation_time = chain_config.get_activation_timestamp_for_fork(fork);
+    let genesis_header = context
+        .storage
+        .get_block_by_number(0)
+        .await?
+        .expect("Failed to get genesis block. This should not happen.")
+        .header;
+    let block_number = context.storage.get_latest_block_number().await?;
+    let fork_id = if let Some(timestamp) = activation_time {
+        ForkId::new(chain_config, genesis_header, timestamp, block_number).fork_hash
+    } else {
+        H32::zero()
+    };
+    let mut system_contracts = BTreeMap::new();
+    for contract in system_contracts_for_fork(fork) {
+        system_contracts.insert(contract.name.to_string(), contract.address);
+    }
+
+    let mut precompiles = BTreeMap::new();
+
+    for precompile in precompiles_for_fork(fork) {
+        precompiles.insert(precompile.name.to_string(), precompile.address);
+    }
+
+    Ok(EthConfigObject {
+        activation_time,
+        blob_schedule: chain_config.get_blob_schedule_for_fork(fork),
+        chain_id: chain_config.chain_id,
+        fork_id,
+        precompiles,
+        system_contracts,
+    })
+}