feat: hexify eth_config types and compute fork_id(#1)

Author: zacksfF

crates/eth-config-api/Cargo.toml

@@ -9,3 +9,4 @@ authors = ["EIP-7910 contributors"]
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
+crc32fast = { workspace = true }

crates/eth-config-api/src/fork_id.rs

@@ -1,20 +1,43 @@
+use crc32fast::Hasher;
 use serde::{Deserialize, Serialize};
 
+use crate::types::HexU64;
+
 /// EIP-6122 fork identifier (hash + next fork block number).
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
 #[serde(rename_all = "camelCase")]
 pub struct ForkId {
     pub hash: String,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub next: Option<u64>,
+    pub next: Option<HexU64>,
 }
 
 impl ForkId {
-    /// Placeholder constructor for scaffolding.
-    pub fn placeholder() -> Self {
+    /// Compute fork ID per EIP-6122 (CRC32 of genesis hash + fork block numbers, big-endian u64).
+    pub fn compute(genesis_hash: [u8; 32], fork_blocks: &[u64], next_fork: Option<u64>) -> Self {
+        let mut hasher = Hasher::new();
+        hasher.update(&genesis_hash);
+        for block in fork_blocks {
+            hasher.update(&block.to_be_bytes());
+        }
+        let hash = hasher.finalize();
         Self {
-            hash: String::from("0x00000000"),
-            next: None,
+            hash: format!("0x{hash:08x}"),
+            next: next_fork.map(HexU64),
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn fork_id_deterministic() {
+        let genesis = [0u8; 32];
+        let forks = [0u64, 9, 30_000_000];
+        let a = ForkId::compute(genesis, &forks, Some(40_000_000));
+        let b = ForkId::compute(genesis, &forks, Some(40_000_000));
+        assert_eq!(a, b);
+    }
+}

crates/eth-config-api/src/lib.rs

@@ -6,4 +6,4 @@ pub mod types;
 pub use fork_id::ForkId;
 pub use precompiles::{PrecompileDescriptor, PrecompileRegistry};
 pub use system_contracts::{SystemContractDescriptor, SystemContractRegistry};
-pub use types::{BlobSchedule, EthConfigResponse, ForkConfig, ForkEntry};
+pub use types::{BlobSchedule, EthConfigResponse, ForkConfig, ForkEntry, HexU64};

crates/eth-config-api/src/types.rs

@@ -1,12 +1,41 @@
 use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+
+use crate::fork_id::ForkId;
+
+/// Hex-encoded quantity helper.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub struct HexU64(pub u64);
+
+impl Serialize for HexU64 {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(&format!("0x{:x}", self.0))
+    }
+}
+
+impl<'de> Deserialize<'de> for HexU64 {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        let s = s.strip_prefix("0x").unwrap_or(&s);
+        u64::from_str_radix(s, 16)
+            .map(HexU64)
+            .map_err(|e| serde::de::Error::custom(format!("invalid hex quantity: {e}")))
+    }
+}
 
 /// Blob gas scheduling parameters (EIP-4844 style).
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
 #[serde(rename_all = "camelCase")]
 pub struct BlobSchedule {
-    pub max_blob_gas_per_block: u64,
-    pub target_blob_gas_per_block: u64,
-    pub blob_gasprice_update_fraction: u64,
+    pub max_blob_gas_per_block: HexU64,
+    pub target_blob_gas_per_block: HexU64,
+    pub blob_gasprice_update_fraction: HexU64,
 }
 
 /// Fork-level configuration object as returned by eth_config.
@@ -15,17 +44,18 @@ pub struct BlobSchedule {
 pub struct ForkConfig {
     /// Human-readable fork name (e.g. "cancun").
     pub name: String,
-    /// Block number at which the fork activates; null in EIP becomes None here.
+    /// Block number at which the fork activates.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub block: Option<u64>,
+    pub block: Option<HexU64>,
     /// Optional blob gas schedule parameters for blob-enabled forks.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub blob_schedule: Option<BlobSchedule>,
     /// List of enabled precompiles at this fork (hex addresses as strings).
-    pub precompiles: Vec<String>,
+    #[serde(default)]
+    pub precompiles: BTreeMap<String, String>,
     /// List of system contracts active at this fork.
     #[serde(default)]
-    pub system_contracts: Vec<SystemContract>,
+    pub system_contracts: BTreeMap<String, SystemContract>,
 }
 
 /// System contract entry in eth_config response.
@@ -50,10 +80,10 @@ pub struct ForkEntry {
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
 #[serde(rename_all = "camelCase")]
 pub struct EthConfigResponse {
-    pub current: ForkEntry,
+    pub current: ForkConfig,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub next: Option<ForkEntry>,
+    pub next: Option<ForkConfig>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub last: Option<ForkEntry>,
-    pub fork_id: crate::fork_id::ForkId,
+    pub last: Option<ForkConfig>,
+    pub fork_id: ForkId,
 }