chore(storage): Add error handling on Store::get_forkchoice_store

bin/ethlambda/src/main.rs

@@ -640,7 +640,9 @@ async fn fetch_initial_state(
     // overlaps with what `get_forkchoice_store` already wrote, but it's
     // idempotent and the only path that also stores `BlockSignatures`.
     let anchor_root = signed_block.message.header().hash_tree_root();
-    let mut store = Store::get_forkchoice_store(backend, state, signed_block.message.clone());
+    let mut store = Store::get_forkchoice_store(backend, state, signed_block.message.clone())
+        .inspect_err(|err| error!(%err, "Failed to initialize store from anchor state and block"))
+        .map_err(|_| checkpoint_sync::CheckpointSyncError::AnchorPairingMismatch)?;
     store.insert_signed_block(anchor_root, signed_block);
     Ok(store)
 }

crates/blockchain/tests/forkchoice_spectests.rs

@@ -70,7 +70,8 @@ fn run(path: &Path) -> datatest_stable::Result<()> {
         }
 
         let backend = Arc::new(InMemoryBackend::new());
-        let mut store = Store::get_forkchoice_store(backend, anchor_state, anchor_block);
+        let mut store = Store::get_forkchoice_store(backend, anchor_state, anchor_block)
+            .expect("anchor state and block must match");
 
         // Block registry: maps block labels to their roots
         let mut block_registry: HashMap<String, H256> = HashMap::new();

crates/blockchain/tests/signature_spectests.rs

@@ -42,7 +42,8 @@ fn run(path: &Path) -> datatest_stable::Result<()> {
         // Initialize the store with the anchor state and block
         let genesis_time = anchor_state.config.genesis_time;
         let backend = Arc::new(InMemoryBackend::new());
-        let mut st = Store::get_forkchoice_store(backend, anchor_state, anchor_block);
+        let mut st = Store::get_forkchoice_store(backend, anchor_state, anchor_block)
+            .expect("anchor state and block must match");
 
         // Step 2: Run the state transition function with the block fixture
         let signed_block: SignedBlock = test.signed_block.into();

crates/storage/Cargo.toml

@@ -14,6 +14,7 @@ ethlambda-types.workspace = true
 
 tracing.workspace = true
 rocksdb.workspace = true
+thiserror.workspace = true
 
 libssz.workspace = true
 libssz-derive.workspace = true

crates/storage/src/lib.rs

@@ -3,4 +3,4 @@ pub mod backend;
 mod store;
 
 pub use api::{ALL_TABLES, StorageBackend, StorageReadView, StorageWriteBatch, Table};
-pub use store::{ForkCheckpoints, Store};
+pub use store::{ForkCheckpoints, GetForkchoiceStoreError, Store};

crates/storage/src/store.rs

@@ -20,8 +20,22 @@ use ethlambda_types::{
     state::{ChainConfig, State, anchor_pair_is_consistent},
 };
 use libssz::{SszDecode, SszEncode};
+use thiserror::Error;
 use tracing::info;
 
+/// Errors returned by [`Store::get_forkchoice_store`].
+#[derive(Debug, Error)]
+pub enum GetForkchoiceStoreError {
+    #[error(
+        "anchor block doesn't match anchor state: \
+         state header = {anchor_state:?}, block = {anchor_block:?}"
+    )]
+    AnchorPairInconsistent {
+        anchor_state: Box<State>,
+        anchor_block: Box<Block>,
+    },
+}
+
 /// Checkpoints to update in the forkchoice store.
 ///
 /// Used with `Store::update_checkpoints` to update head and optionally
@@ -470,20 +484,28 @@ impl Store {
     /// The block must match the state's `latest_block_header`.
     /// Named to mirror the spec's `get_forkchoice_store` function.
     ///
-    /// # Panics
+    /// # Errors
     ///
-    /// Panics if [`anchor_pair_is_consistent`] would reject the pair.
+    /// Returns [`GetForkchoiceStoreError::AnchorPairInconsistent`] if the block's header
+    /// doesn't match the state's `latest_block_header` (comparing all fields
+    /// except `state_root`, which is computed internally).
     pub fn get_forkchoice_store(
         backend: Arc<dyn StorageBackend>,
         mut anchor_state: State,
         anchor_block: Block,
-    ) -> Self {
-        assert!(
-            anchor_pair_is_consistent(&mut anchor_state, &anchor_block),
-            "anchor block does not match anchor state"
-        );
+    ) -> Result<Self, GetForkchoiceStoreError> {
+        if !anchor_pair_is_consistent(&mut anchor_state, &anchor_block) {
+            return Err(GetForkchoiceStoreError::AnchorPairInconsistent {
+                anchor_state: Box::new(anchor_state),
+                anchor_block: Box::new(anchor_block),
+            });
+        }
 
-        Self::init_store(backend, anchor_state, Some(anchor_block.body))
+        Ok(Self::init_store(
+            backend,
+            anchor_state,
+            Some(anchor_block.body),
+        ))
     }
 
     /// Internal helper to initialize the store with anchor data.