chore(storage): Add error handling on Store::get_forkchoice_store (lambdaclass#362)

## 🗒️ Description / Motivation
Replace the assert_eq! in Store::get_forkchoice_store with a typed
Result so callers see a descriptive error instead of a panic. The
previous message ("block header doesn't match state's
latest_block_header") gave no insight into which field actually
differed, which made misconfigured anchor state/block pairs hard to
diagnose. PR closes lambdaclass#360.

## What Changed
- `crates/storage/Cargo.toml` — add `thiserror` dependency.
- `crates/storage/src/store.rs` — introduce `pub enum
GetForkchoiceStoreError` with a `HeaderMismatch { state_header,
block_header }` variant; change `Store::get_forkchoice_store` to return
`Result<Self, GetForkchoiceStoreError>`; replace the assertion with an
explicit comparison that returns `Err`; update the doc comment (`#
Panics` → `# Errors`).
- `bin/ethlambda/src/main.rs` — added error handling to
`Store::forkchoice_store` to return
`CheckpointSyncError::AnchorPairingMismatch` if there is a mismatch.

## Correctness / Behavior Guarantees
- The validation rule is unchanged: anchor block header must equal the
state's `latest_block_header` after zeroing `state_root`. Mismatches
that previously aborted via assert_eq! now return `Err(HeaderMismatch {
… })`, surfacing both full headers (boxed to keep the variant small) for
diff-friendly debugging.
- `Store::from_anchor_state` is untouched. Internal panics in
`init_store` (`state_root` mismatch and storage backend operations) are
intentionally left as-is — they represent infrastructure invariants
shared between both constructors and are out of scope for this change.

## Tests Added / Run
- No new tests; the type change is enforced by the compiler and existing
fork-choice / signature spec suites continue to exercise the success
path.
- Ran `make fmt`, `make lint`, `cargo test --workspace --release` (unit
tests pass; spec tests require `make leanSpec/fixtures` for fixture
generation)
- Also ran `make test`

## Related Issues / PRs
- Closes lambdaclass#360 

## ✅ Verification Checklist

- [x] Ran `make fmt` — clean
- [x] Ran `make lint` (clippy with `-D warnings`) — clean
- [x] Ran `cargo test --workspace --release` — all passing

---------

Co-authored-by: Pablo Deymonnaz <pdeymon@fi.uba.ar>

Author: Aliemeka

Cargo.lock

@@ -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)
 }

bin/ethlambda/src/main.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/forkchoice_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/blockchain/tests/signature_spectests.rs

@@ -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/Cargo.toml

@@ -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/lib.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.