feat(l1): implement eth-config

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,
+    })
+}