feat(node): consistent genesis

fendermint/app/options/src/genesis.rs

@@ -147,6 +147,28 @@ pub enum GenesisIpcCommands {
     Gateway(GenesisIpcGatewayArgs),
     /// Fetch the genesis parameters of a subnet from the parent.
     FromParent(Box<GenesisFromParentArgs>),
+    /// Seal the genesis state from the genesis parameter file
+    SealState(SealGenesisArgs),
+}
+
+#[derive(Args, Debug, Clone)]
+pub struct SealGenesisArgs {
+    /// The built in actors bundle path
+    #[arg(long, short)]
+    pub builtin_actors_path: PathBuf,
+
+    /// The custom actors bundle path
+    #[arg(long, short)]
+    pub custom_actors_path: PathBuf,
+
+    /// The ipc artifacts output path. If you are using ipc-monorepo, it should be the `out` folder
+    /// of `make build`
+    #[arg(long, short)]
+    pub ipc_artifacts_path: PathBuf,
+
+    /// The sealed, i.e. finalized genesis state CAR file dump path
+    #[arg(long, short)]
+    pub sealed_genesis_path: PathBuf,
 }
 
 #[derive(Args, Debug, Clone)]

fendermint/app/src/app.rs

@@ -42,6 +42,7 @@ use serde::{Deserialize, Serialize};
 use tendermint::abci::request::CheckTxKind;
 use tendermint::abci::{request, response};
 use tracing::instrument;
+use fendermint_vm_interpreter::genesis::read_genesis_car;
 
 use crate::events::{NewBlock, ProposalProcessed};
 use crate::AppExitCode;
@@ -136,8 +137,10 @@ where
     /// Path to the Wasm bundle.
     ///
     /// Only loaded once during genesis; later comes from the [`StateTree`].
+    #[deprecated]
     builtin_actors_bundle: PathBuf,
     /// Path to the custom actor WASM bundle.
+    #[deprecated]
     custom_actors_bundle: PathBuf,
     /// Block height where we should gracefully stop the node
     halt_height: i64,
@@ -447,45 +450,15 @@ where
 
     /// Called once upon genesis.
     async fn init_chain(&self, request: request::InitChain) -> AbciResult<response::InitChain> {
-        let bundle = &self.builtin_actors_bundle;
-        let bundle = std::fs::read(bundle)
-            .map_err(|e| anyhow!("failed to load builtin bundle CAR from {bundle:?}: {e}"))?;
-
-        let custom_actors_bundle = &self.custom_actors_bundle;
-        let custom_actors_bundle = std::fs::read(custom_actors_bundle).map_err(|e| {
-            anyhow!("failed to load custom actor bundle CAR from {custom_actors_bundle:?}: {e}")
-        })?;
-
-        let state = FvmGenesisState::new(
-            self.state_store_clone(),
-            self.multi_engine.clone(),
-            &bundle,
-            &custom_actors_bundle,
-        )
-        .await
-        .context("failed to create genesis state")?;
-
-        tracing::info!(
-            manifest_root = format!("{}", state.manifest_data_cid),
-            "pre-genesis state created"
-        );
-
         let genesis_bytes = request.app_state_bytes.to_vec();
         let genesis_hash =
             fendermint_vm_message::cid(&genesis_bytes).context("failed to compute genesis CID")?;
 
         // Make it easy to spot any discrepancies between nodes.
         tracing::info!(genesis_hash = genesis_hash.to_string(), "genesis");
 
-        let (state, out) = self
-            .interpreter
-            .init(state, genesis_bytes)
-            .await
-            .context("failed to init from genesis")?;
-
-        let state_root = state.commit().context("failed to commit genesis state")?;
-        let validators =
-            to_validator_updates(out.validators).context("failed to convert validators")?;
+        let (validators, state_params) = read_genesis_car(&genesis_bytes, &self.state_store).await?;
+        let validators = to_validator_updates(validators).context("failed to convert validators")?;
 
         // Let's pretend that the genesis state is that of a fictive block at height 0.
         // The record will be stored under height 1, and the record after the application
@@ -502,16 +475,7 @@ where
         let app_state = AppState {
             block_height: height,
             oldest_state_height: height,
-            state_params: FvmStateParams {
-                state_root,
-                timestamp: out.timestamp,
-                network_version: out.network_version,
-                base_fee: out.base_fee,
-                circ_supply: out.circ_supply,
-                chain_id: out.chain_id.into(),
-                power_scale: out.power_scale,
-                app_version: 0,
-            },
+            state_params,
         };
 
         let response = response::InitChain {

fendermint/app/src/cmd/genesis.rs

@@ -14,6 +14,7 @@ use fendermint_vm_genesis::{
     ipc, Account, Actor, ActorMeta, Collateral, Genesis, Multisig, PermissionMode, SignerAddr,
     Validator, ValidatorKey,
 };
+use fendermint_vm_interpreter::genesis::GenesisCreator;
 
 use crate::cmd;
 use crate::options::genesis::*;
@@ -93,6 +94,8 @@ cmd! {
             set_ipc_gateway(&genesis_file, args),
         GenesisIpcCommands::FromParent(args) =>
             new_genesis_from_parent(&genesis_file, args).await,
+        GenesisIpcCommands::SealState(args) =>
+            seal_state(&genesis_file, args).await,
     }
   }
 }
@@ -279,6 +282,19 @@ fn set_ipc_gateway(genesis_file: &PathBuf, args: &GenesisIpcGatewayArgs) -> anyh
     })
 }
 
+async fn seal_state(genesis_file: &PathBuf, args: &SealGenesisArgs) -> anyhow::Result<()> {
+    let genesis = read_genesis(genesis_file)?;
+
+    let genesis_creator = GenesisCreator::new(
+        args.builtin_actors_path.clone(),
+        args.custom_actors_path.clone(),
+        args.ipc_artifacts_path.clone(),
+        args.sealed_genesis_path.clone(),
+    );
+
+    genesis_creator.create(genesis).await
+}
+
 async fn new_genesis_from_parent(
     genesis_file: &PathBuf,
     args: &GenesisFromParentArgs,

fendermint/app/src/lib.rs

@@ -1,3 +1,5 @@
+extern crate core;
+
 // Copyright 2022-2024 Protocol Labs
 // SPDX-License-Identifier: Apache-2.0, MIT
 mod app;

fendermint/vm/genesis/src/lib.rs

@@ -7,6 +7,7 @@ use anyhow::anyhow;
 use fvm_shared::bigint::{BigInt, Integer};
 use serde::{Deserialize, Serialize};
 use serde_with::serde_as;
+use std::path::PathBuf;
 
 use fendermint_actor_eam::PermissionModeParams;
 use fvm_shared::version::NetworkVersion;

fendermint/vm/interpreter/src/fvm/state/genesis.rs

@@ -177,6 +177,17 @@ where
         }
     }
 
+    /// Flush the data to the block store. Returns the state root cid and the underlying state store.
+    pub fn finalize(self) -> anyhow::Result<(Cid, DB)> {
+        match self.stage {
+            Stage::Tree(_) => Err(anyhow!("invalid finalize state")),
+            Stage::Exec(exec_state) => match exec_state.commit()? {
+                (_, _, true) => bail!("FVM parameters are not expected to be updated in genesis"),
+                (cid, _, _) => Ok((cid, self.store)),
+            },
+        }
+    }
+
     /// Replaces the built in actor with custom actor. This assumes the system actor is already
     /// created, else it would throw an error.
     pub fn replace_builtin_actor(

fendermint/vm/interpreter/src/fvm/state/snapshot.rs

@@ -213,7 +213,7 @@ where
 }
 
 #[pin_project::pin_project]
-struct StateTreeStreamer<BS> {
+pub(crate) struct StateTreeStreamer<BS> {
     /// The list of cids to pull from the blockstore
     #[pin]
     dfs: VecDeque<Cid>,
@@ -286,7 +286,7 @@ fn walk_ipld_cids(ipld: Ipld, dfs: &mut VecDeque<Cid>) {
     }
 }
 
-fn derive_cid<T: Serialize>(t: &T) -> anyhow::Result<(Cid, Vec<u8>)> {
+pub(crate) fn derive_cid<T: Serialize>(t: &T) -> anyhow::Result<(Cid, Vec<u8>)> {
     let bytes = fvm_ipld_encoding::to_vec(&t)?;
     let cid = Cid::new_v1(DAG_CBOR, Code::Blake2b256.digest(&bytes));
     Ok((cid, bytes))