feat(chain): implement genesis block initialization and validation

- Added functionality in ChainActor to initialize the genesis block if it doesn't exist during startup, ensuring all nodes share the same starting state for consensus.
- Introduced a new module for genesis block creation, which queries the execution layer for block #0 and wraps it in a ConsensusBlock.
- Enhanced validation logic to ensure that block #1 references the genesis block correctly, preventing issues with parent hash mismatches.
- Updated handlers to query the genesis block from storage when no chain head is found, improving block production reliability.

Author: michaelgpt

app/src/actors_v2/chain/actor.rs

@@ -517,12 +517,91 @@ impl ChainActor {
 impl Actor for ChainActor {
     type Context = Context<Self>;
 
-    fn started(&mut self, _ctx: &mut Context<Self>) {
+    fn started(&mut self, ctx: &mut Context<Self>) {
         info!(
             "ChainActor V2 started - is_validator: {}",
             self.config.is_validator
         );
         self.record_activity();
+
+        // Initialize genesis block if it doesn't exist
+        // This is critical for consensus - all nodes must share the same genesis
+        let storage = self.storage_actor.clone();
+        let engine = self.engine_actor.clone();
+
+        // Construct ChainSpec from state (Aura has authorities and slot_duration)
+        let chain_spec = crate::spec::ChainSpec {
+            slot_duration: self.state.aura.slot_duration,
+            authorities: self.state.aura.authorities.clone(),
+            federation: self.state.federation.clone(),
+            federation_bitcoin_pubkeys: Vec::new(), // Not needed for genesis
+            bits: self.state.retarget_params.pow_limit,
+            chain_id: self.config.chain_id,
+            max_blocks_without_pow: self.state.max_blocks_without_pow,
+            bitcoin_start_height: 0, // Not relevant for genesis
+            retarget_params: self.state.retarget_params.clone(),
+            is_validator: self.state.is_validator,
+            execution_timeout_length: 8, // Default value
+            required_btc_txn_confirmations: 6, // Default value
+        };
+
+        ctx.spawn(
+            async move {
+                // Check if genesis already exists
+                if let (Some(storage_actor), Some(engine_actor)) = (storage, engine) {
+                    match super::genesis::genesis_exists(&storage_actor).await {
+                        Ok(true) => {
+                            info!("Genesis block already exists in storage");
+                        }
+                        Ok(false) => {
+                            info!("Genesis block not found - creating from execution layer");
+
+                            // Create genesis block from execution layer
+                            match super::genesis::create_genesis_block(&engine_actor, chain_spec)
+                                .await
+                            {
+                                Ok(genesis) => {
+                                    let genesis_hash = genesis.canonical_root();
+                                    info!(
+                                        consensus_hash = %genesis_hash,
+                                        block_number = genesis.message.execution_payload.block_number,
+                                        "Genesis block created successfully"
+                                    );
+
+                                    // Store genesis block
+                                    let store_msg =
+                                        crate::actors_v2::storage::messages::StoreBlockMessage {
+                                            block: genesis.clone(),
+                                            canonical: true, // Genesis is always canonical
+                                            correlation_id: Some(Uuid::new_v4()),
+                                        };
+
+                                    if let Err(e) = storage_actor.send(store_msg).await {
+                                        error!(
+                                            error = ?e,
+                                            "Failed to send genesis block to storage actor"
+                                        );
+                                    } else {
+                                        info!("Genesis block stored successfully");
+                                    }
+                                }
+                                Err(e) => {
+                                    error!(error = ?e, "Failed to create genesis block");
+                                    // Don't panic - this is a recoverable error
+                                    // Node can sync genesis from peers if needed
+                                }
+                            }
+                        }
+                        Err(e) => {
+                            warn!(error = ?e, "Failed to check for genesis block existence");
+                        }
+                    }
+                } else {
+                    warn!("Storage or Engine actor not set - skipping genesis initialization");
+                }
+            }
+            .into_actor(self),
+        );
     }
 
     fn stopped(&mut self, _ctx: &mut Context<Self>) {

app/src/actors_v2/chain/genesis.rs

@@ -0,0 +1,209 @@
+//! Genesis block creation for V2 consensus layer
+//!
+//! This module handles creating the genesis block (height 0) by querying
+//! the execution layer for block #0 and wrapping it in a ConsensusBlock.
+//!
+//! The genesis block serves as the common foundation that all validator nodes
+//! share, ensuring consensus starts from the same state.
+
+use crate::actors_v2::chain::ChainError;
+use crate::actors_v2::engine::EngineActor;
+use crate::block::SignedConsensusBlock;
+use crate::spec::ChainSpec;
+use actix::Addr;
+use lighthouse_wrapper::types::MainnetEthSpec;
+use tracing::{debug, info};
+
+/// Create genesis block by querying execution layer for block #0
+///
+/// This function:
+/// 1. Queries the execution layer (Reth/Geth) for block #0
+/// 2. Wraps the execution payload in a ConsensusBlock structure
+/// 3. Returns a genesis block ready for storage
+///
+/// # Genesis Block Properties
+/// - Height: 0
+/// - Slot: 0
+/// - Parent hash: 0x0000...0000 (genesis has no parent)
+/// - Execution payload: Retrieved from execution layer block #0
+/// - Signature: Empty (genesis is not signed by any authority)
+///
+/// # Determinism
+/// All nodes using the same genesis.json will produce identical genesis blocks
+/// because the execution layer's block #0 is deterministically generated from
+/// the genesis.json configuration.
+///
+/// # Arguments
+/// * `engine_actor` - Address of the EngineActor for querying execution layer
+/// * `chain_spec` - Chain specification (authorities, slot duration, etc.)
+///
+/// # Returns
+/// - `Ok(SignedConsensusBlock)` - Genesis block ready for storage
+/// - `Err(ChainError)` - If execution layer query fails
+///
+/// # Errors
+/// Returns `ChainError::Engine` if:
+/// - Cannot communicate with EngineActor
+/// - Execution layer doesn't have block #0
+/// - Execution payload is invalid
+///
+pub async fn create_genesis_block(
+    engine_actor: &Addr<EngineActor>,
+    chain_spec: ChainSpec,
+) -> Result<SignedConsensusBlock<MainnetEthSpec>, ChainError> {
+    info!("Creating genesis block from execution layer");
+
+    // Query execution layer for block #0
+    // We use the GetPayloadByTag message which accepts "0x0" or "earliest"
+    let get_genesis_msg = crate::actors_v2::engine::messages::EngineMessage::GetPayloadByTag {
+        block_tag: "0x0".to_string(), // Query block #0 (genesis)
+        correlation_id: Some(uuid::Uuid::new_v4()),
+    };
+
+    debug!("Querying execution layer for block #0");
+
+    let execution_payload = match engine_actor.send(get_genesis_msg).await {
+        Ok(Ok(crate::actors_v2::engine::messages::EngineResponse::PayloadByTag { payload })) => {
+            // Extract the Capella payload
+            match payload {
+                lighthouse_wrapper::types::ExecutionPayload::Capella(capella_payload) => {
+                    info!(
+                        block_number = capella_payload.block_number,
+                        block_hash = %capella_payload.block_hash,
+                        "Retrieved execution layer block #0"
+                    );
+                    capella_payload
+                }
+                _ => {
+                    return Err(ChainError::Engine(
+                        "Expected Capella execution payload for genesis".to_string(),
+                    ));
+                }
+            }
+        }
+        Ok(Ok(_)) => {
+            return Err(ChainError::Engine(
+                "Unexpected response type from EngineActor".to_string(),
+            ));
+        }
+        Ok(Err(e)) => {
+            return Err(ChainError::Engine(format!(
+                "Execution layer failed to provide block #0: {}",
+                e
+            )));
+        }
+        Err(e) => {
+            return Err(ChainError::NetworkError(format!(
+                "Failed to communicate with EngineActor: {}",
+                e
+            )));
+        }
+    };
+
+    // Validate that we actually got block #0
+    if execution_payload.block_number != 0 {
+        return Err(ChainError::InvalidBlock(format!(
+            "Expected block #0 from execution layer, got block #{}",
+            execution_payload.block_number
+        )));
+    }
+
+    // Wrap execution payload in a ConsensusBlock
+    let genesis = SignedConsensusBlock::genesis(chain_spec, execution_payload);
+
+    let genesis_hash = genesis.canonical_root();
+    let genesis_exec_hash = genesis.message.execution_payload.block_hash;
+
+    info!(
+        consensus_hash = %genesis_hash,
+        execution_hash = %genesis_exec_hash,
+        "Genesis block created successfully"
+    );
+
+    Ok(genesis)
+}
+
+/// Check if genesis block exists in storage
+///
+/// Helper function to determine if genesis has already been initialized.
+/// Used during ChainActor startup to decide whether to create genesis.
+///
+/// # Arguments
+/// * `storage_actor` - Address of the StorageActor
+///
+/// # Returns
+/// - `Ok(true)` - Genesis block exists in storage
+/// - `Ok(false)` - Genesis block does not exist
+/// - `Err(ChainError)` - Communication or query error
+///
+pub async fn genesis_exists(
+    storage_actor: &Addr<crate::actors_v2::storage::StorageActor>,
+) -> Result<bool, ChainError> {
+    let get_genesis_msg = crate::actors_v2::storage::messages::GetBlockByHeightMessage {
+        height: 0,
+        correlation_id: Some(uuid::Uuid::new_v4()),
+    };
+
+    match storage_actor.send(get_genesis_msg).await {
+        Ok(Ok(Some(_))) => Ok(true),
+        Ok(Ok(None)) => Ok(false),
+        Ok(Err(e)) => Err(ChainError::Storage(format!(
+            "Failed to query genesis from storage: {}",
+            e
+        ))),
+        Err(e) => Err(ChainError::NetworkError(format!(
+            "Failed to communicate with StorageActor: {}",
+            e
+        ))),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::aura::Authority;
+    use lighthouse_wrapper::bls::Keypair;
+
+    #[test]
+    fn test_genesis_has_zero_height() {
+        use crate::block::ConsensusBlock;
+
+        let block = ConsensusBlock::default();
+        let keypair = Keypair::random();
+        let authority = Authority {
+            signer: keypair.clone(),
+            index: 0,
+        };
+
+        // Create a signed block with default values
+        let signed_block = block.sign_block(&authority);
+
+        // Default ConsensusBlock should have height 0
+        assert_eq!(
+            signed_block.message.execution_payload.block_number, 0,
+            "Default block should have height 0"
+        );
+    }
+
+    #[test]
+    fn test_genesis_has_zero_parent_hash() {
+        use crate::block::ConsensusBlock;
+        use ethereum_types::H256;
+
+        let block = ConsensusBlock::default();
+        let keypair = Keypair::random();
+        let authority = Authority {
+            signer: keypair.clone(),
+            index: 0,
+        };
+
+        let signed_block = block.sign_block(&authority);
+
+        // Genesis parent hash should be zero
+        assert_eq!(
+            signed_block.message.parent_hash,
+            H256::zero(),
+            "Genesis block should have zero parent hash"
+        );
+    }
+}

app/src/actors_v2/chain/handlers.rs

@@ -137,8 +137,57 @@ impl Handler<ChainMessage> for ChainActor {
                                             (head_ref.execution_hash, head_ref.hash)
                                         }
                                         Ok(None) => {
-                                            info!(correlation_id = %correlation_id, "No chain head found - producing genesis block (parent_hash will be None for Engine)");
-                                            (lighthouse_wrapper::types::ExecutionBlockHash::zero(), lighthouse_wrapper::types::Hash256::zero())
+                                            info!(correlation_id = %correlation_id, "No chain head found - querying genesis for parent hashes");
+
+                                            // Query genesis block (height 0) to get proper parent hashes
+                                            let get_genesis_msg = crate::actors_v2::storage::messages::GetBlockByHeightMessage {
+                                                height: 0,
+                                                correlation_id: Some(correlation_id),
+                                            };
+
+                                            match storage_actor.send(get_genesis_msg).await {
+                                                Ok(Ok(Some(genesis))) => {
+                                                    let genesis_hash = genesis.canonical_root();
+                                                    let genesis_exec_hash = genesis.message.execution_payload.block_hash;
+
+                                                    info!(
+                                                        correlation_id = %correlation_id,
+                                                        genesis_consensus_hash = %genesis_hash,
+                                                        genesis_execution_hash = %genesis_exec_hash,
+                                                        "Using genesis block as parent for block #1"
+                                                    );
+
+                                                    (genesis_exec_hash, genesis_hash)
+                                                }
+                                                Ok(Ok(None)) => {
+                                                    error!(
+                                                        correlation_id = %correlation_id,
+                                                        "Genesis block not found in storage - cannot produce blocks"
+                                                    );
+                                                    return Err(ChainError::InvalidState(
+                                                        "Cannot produce blocks without genesis - wait for ChainActor genesis initialization".to_string()
+                                                    ));
+                                                }
+                                                Ok(Err(e)) => {
+                                                    error!(
+                                                        correlation_id = %correlation_id,
+                                                        error = ?e,
+                                                        "Failed to query genesis from storage"
+                                                    );
+                                                    return Err(ChainError::Storage(e.to_string()));
+                                                }
+                                                Err(e) => {
+                                                    error!(
+                                                        correlation_id = %correlation_id,
+                                                        error = ?e,
+                                                        "Communication error querying genesis"
+                                                    );
+                                                    return Err(ChainError::NetworkError(format!(
+                                                        "Genesis query communication failed: {}",
+                                                        e
+                                                    )));
+                                                }
+                                            }
                                         }
                                         Err(e) => {
                                             error!(correlation_id = %correlation_id, error = ?e, "Failed to get chain head");

app/src/actors_v2/chain/mod.rs

@@ -28,6 +28,7 @@ pub mod withdrawals;
 // Phase 4 production hardening modules
 pub mod auxpow;
 pub mod fork_choice;
+pub mod genesis;
 pub mod monitoring;
 pub mod recovery;
 pub mod reorganization;