feat: new genesis loading API

Author: Evalir

crates/genesis/README.md

@@ -4,11 +4,11 @@ Genesis configuration and utilities for the Signet Node.
 
 This library contains the following:
 
-- `GenesisSpec` - An enum representing different genesis specifications, either
-  Pecorino, Test, or a custom genesis file path, which can be used to load
-  genesis data.
-- `PECORINO_GENESIS` - The Pecorino genesis data.
-- `TEST_GENESIS` - A local test genesis for testing purposes.
+- `GenesisSpec` - An enum representing different genesis specifications (Mainnet,
+  Pecorino, Test, or custom file paths), which can be used to load genesis data.
+- `NetworkGenesis` - A struct containing both rollup and host genesis configurations.
+- `PECORINO_GENESIS` / `PECORINO_HOST_GENESIS` - The Pecorino genesis data.
+- `TEST_GENESIS` / `TEST_HOST_GENESIS` - Local test genesis for testing purposes.
 - `GenesisError` - Errors that can occur when loading or parsing genesis data.
 
 ## Example
@@ -17,6 +17,10 @@ This library contains the following:
 # use signet_genesis::GenesisSpec;
 # fn _main() -> Result<(), Box<dyn std::error::Error>> {
 let genesis = GenesisSpec::Pecorino.load_genesis()?;
+// Access rollup (L2/Signet) genesis
+let rollup = &genesis.rollup;
+// Access host (L1/Ethereum) genesis
+let host = &genesis.host;
 # Ok(())
 # }
 ```

crates/genesis/src/lib.rs

@@ -33,6 +33,9 @@ pub const PECORINO_HOST_GENESIS_JSON: &str = include_str!("./pecorino.host.genes
 /// Local genesis file for testing purposes.
 pub const TEST_GENESIS_JSON: &str = include_str!("./local.genesis.json");
 
+/// Local host genesis file for testing purposes.
+pub const TEST_HOST_GENESIS_JSON: &str = include_str!("./local.host.genesis.json");
+
 /// Mainnet genesis for the Signet mainnet.
 pub static MAINNET_GENESIS: LazyLock<Genesis> = LazyLock::new(|| {
     serde_json::from_str(MAINNET_GENESIS_JSON).expect("Failed to parse mainnet genesis")
@@ -58,8 +61,16 @@ pub static TEST_GENESIS: LazyLock<Genesis> = LazyLock::new(|| {
     serde_json::from_str(TEST_GENESIS_JSON).expect("Failed to parse test genesis")
 });
 
-/// Environment variable for specifying the genesis JSON file path.
-const GENESIS_JSON_PATH: &str = "GENESIS_JSON_PATH";
+/// Test host genesis for local testing.
+pub static TEST_HOST_GENESIS: LazyLock<Genesis> = LazyLock::new(|| {
+    serde_json::from_str(TEST_HOST_GENESIS_JSON).expect("Failed to parse test host genesis")
+});
+
+/// Environment variable for specifying the rollup genesis JSON file path.
+const ROLLUP_GENESIS_JSON_PATH: &str = "ROLLUP_GENESIS_JSON_PATH";
+
+/// Environment variable for specifying the host genesis JSON file path.
+const HOST_GENESIS_JSON_PATH: &str = "HOST_GENESIS_JSON_PATH";
 
 /// Result type for genesis operations.
 pub type Result<T, E = GenesisError> = std::result::Result<T, E>;
@@ -75,6 +86,24 @@ pub enum GenesisError {
     Json(#[from] serde_json::Error),
 }
 
+/// Genesis configurations for a network, containing both rollup and host chain genesis.
+#[derive(Debug, Clone)]
+pub struct NetworkGenesis {
+    /// The rollup (L2/Signet) genesis configuration.
+    pub rollup: Genesis,
+    /// The host (L1/Ethereum) genesis configuration.
+    pub host: Genesis,
+}
+
+/// Raw genesis JSON strings for a network.
+#[derive(Debug, Clone)]
+pub struct RawNetworkGenesis {
+    /// The rollup (L2/Signet) genesis JSON.
+    pub rollup: Cow<'static, str>,
+    /// The host (L1/Ethereum) genesis JSON.
+    pub host: Cow<'static, str>,
+}
+
 /// Different genesis configurations available.
 #[derive(Debug, Clone, serde::Deserialize)]
 #[serde(untagged)]
@@ -85,49 +114,80 @@ pub enum GenesisSpec {
     Pecorino,
     /// Local testnet.
     Test,
-    /// Custom path to a genesis file.
-    Path(PathBuf),
+    /// Custom paths to genesis files.
+    Custom {
+        /// Path to the rollup genesis file.
+        rollup: PathBuf,
+        /// Path to the host genesis file.
+        host: PathBuf,
+    },
 }
 
 impl GenesisSpec {
-    /// Load the genesis JSON from the specified source.
+    /// Load the raw genesis JSON strings from the specified source.
     ///
-    /// This will alwys return a valid string for [`KnownChains`].
-    pub fn load_raw_genesis(&self) -> Result<Cow<'static, str>> {
+    /// Returns both rollup and host genesis JSON strings.
+    pub fn load_raw_genesis(&self) -> Result<RawNetworkGenesis> {
         match self {
-            GenesisSpec::Mainnet => Ok(Cow::Borrowed(MAINNET_GENESIS_JSON)),
-            GenesisSpec::Pecorino => Ok(Cow::Borrowed(PECORINO_GENESIS_JSON)),
-            GenesisSpec::Test => Ok(Cow::Borrowed(TEST_GENESIS_JSON)),
-            GenesisSpec::Path(path) => {
-                std::fs::read_to_string(path).map(Cow::Owned).map_err(Into::into)
-            }
+            GenesisSpec::Mainnet => Ok(RawNetworkGenesis {
+                rollup: Cow::Borrowed(MAINNET_GENESIS_JSON),
+                host: Cow::Borrowed(MAINNET_HOST_GENESIS_JSON),
+            }),
+            GenesisSpec::Pecorino => Ok(RawNetworkGenesis {
+                rollup: Cow::Borrowed(PECORINO_GENESIS_JSON),
+                host: Cow::Borrowed(PECORINO_HOST_GENESIS_JSON),
+            }),
+            GenesisSpec::Test => Ok(RawNetworkGenesis {
+                rollup: Cow::Borrowed(TEST_GENESIS_JSON),
+                host: Cow::Borrowed(TEST_HOST_GENESIS_JSON),
+            }),
+            GenesisSpec::Custom { rollup, host } => Ok(RawNetworkGenesis {
+                rollup: Cow::Owned(std::fs::read_to_string(rollup)?),
+                host: Cow::Owned(std::fs::read_to_string(host)?),
+            }),
         }
     }
 
-    /// Load the genesis from the specified source.
+    /// Load the genesis configurations from the specified source.
     ///
-    /// This will always return a valid genesis for [`KnownChains`].
-    pub fn load_genesis(&self) -> Result<alloy::genesis::Genesis> {
+    /// Returns both rollup and host genesis configurations.
+    pub fn load_genesis(&self) -> Result<NetworkGenesis> {
         match self {
-            GenesisSpec::Mainnet => Ok(MAINNET_GENESIS.clone()),
-            GenesisSpec::Pecorino => Ok(PECORINO_GENESIS.clone()),
-            GenesisSpec::Test => Ok(TEST_GENESIS.clone()),
-            GenesisSpec::Path(_) => self
-                .load_raw_genesis()
-                .and_then(|raw| serde_json::from_str(&raw).map_err(Into::into)),
+            GenesisSpec::Mainnet => Ok(NetworkGenesis {
+                rollup: MAINNET_GENESIS.clone(),
+                host: MAINNET_HOST_GENESIS.clone(),
+            }),
+            GenesisSpec::Pecorino => Ok(NetworkGenesis {
+                rollup: PECORINO_GENESIS.clone(),
+                host: PECORINO_HOST_GENESIS.clone(),
+            }),
+            GenesisSpec::Test => {
+                Ok(NetworkGenesis { rollup: TEST_GENESIS.clone(), host: TEST_HOST_GENESIS.clone() })
+            }
+            GenesisSpec::Custom { .. } => self.load_raw_genesis().and_then(|genesis| {
+                Ok(NetworkGenesis {
+                    rollup: serde_json::from_str(&genesis.rollup)?,
+                    host: serde_json::from_str(&genesis.host)?,
+                })
+            }),
         }
     }
 }
 
+/// Error returned when parsing an unknown chain name.
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+#[error("unknown chain name: {0}")]
+pub struct UnknownChainError(String);
+
 impl FromStr for GenesisSpec {
-    type Err = <PathBuf as FromStr>::Err;
+    type Err = UnknownChainError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         if let Ok(known) = KnownChains::from_str(s) {
             return Ok(known.into());
         }
 
-        Ok(GenesisSpec::Path(s.parse()?))
+        Err(UnknownChainError(s.to_string()))
     }
 }
 
@@ -150,17 +210,31 @@ impl FromEnv for GenesisSpec {
                 optional: true,
             },
             &EnvItemInfo {
-                var: GENESIS_JSON_PATH,
-                description: "A filepath to the genesis JSON file. Required if CHAIN_NAME is not set.",
+                var: ROLLUP_GENESIS_JSON_PATH,
+                description: "A filepath to the rollup genesis JSON file. Required if CHAIN_NAME is not set.",
+                optional: true,
+            },
+            &EnvItemInfo {
+                var: HOST_GENESIS_JSON_PATH,
+                description: "A filepath to the host genesis JSON file. Required if CHAIN_NAME is not set.",
                 optional: true,
             },
         ]
     }
 
     fn from_env() -> Result<Self, FromEnvErr<Self::Error>> {
-        parse_env_if_present::<KnownChains>("CHAIN_NAME")
-            .map(Into::into)
-            .or_else(|_| parse_env_if_present::<PathBuf>(GENESIS_JSON_PATH).map(Into::into))
+        // First try to parse from CHAIN_NAME
+        if let Ok(spec) = parse_env_if_present::<KnownChains>("CHAIN_NAME").map(Into::into) {
+            return Ok(spec);
+        }
+
+        // Otherwise, try to load from custom paths
+        let rollup = parse_env_if_present::<PathBuf>(ROLLUP_GENESIS_JSON_PATH)
+            .map_err(|_| FromEnvErr::empty(ROLLUP_GENESIS_JSON_PATH))?;
+        let host = parse_env_if_present::<PathBuf>(HOST_GENESIS_JSON_PATH)
+            .map_err(|_| FromEnvErr::empty(HOST_GENESIS_JSON_PATH))?;
+
+        Ok(GenesisSpec::Custom { rollup, host })
     }
 }
 
@@ -172,9 +246,3 @@ impl From<KnownChains> for GenesisSpec {
         }
     }
 }
-
-impl From<PathBuf> for GenesisSpec {
-    fn from(path: PathBuf) -> Self {
-        GenesisSpec::Path(path)
-    }
-}

crates/node-config/src/core.rs

@@ -196,10 +196,10 @@ impl SignetNodeConfig {
         self.ipc_endpoint = Some(endpoint);
     }
 
-    /// Returns the genesis configuration if any has been loaded
+    /// Returns the rollup genesis configuration if any has been loaded.
     pub fn genesis(&self) -> &'static Genesis {
         static ONCE: OnceLock<Genesis> = OnceLock::new();
-        ONCE.get_or_init(|| self.genesis.load_genesis().expect("Failed to load genesis"))
+        ONCE.get_or_init(|| self.genesis.load_genesis().expect("Failed to load genesis").rollup)
     }
 
     /// Create a new chain spec for the Signet Node chain.

crates/node-tests/tests/basic.rs

@@ -70,7 +70,7 @@ async fn test_basic_reorg() {
 async fn test_genesis_allocs() {
     run_test(|ctx| async move {
         let genesis = GenesisSpec::Test.load_genesis().expect("Failed to load genesis");
-        ctx.verify_allocs(&genesis);
+        ctx.verify_allocs(&genesis.rollup);
     })
     .await;
 }