Add error from verify_kzg_proofs to store Error

eip_7594/Cargo.toml

@@ -15,6 +15,7 @@ kzg = { workspace = true }
 num-traits = { workspace = true }
 ssz = { workspace = true}
 sha2 = { workspace = true }
+thiserror = { workspace = true }
 try_from_iterator = { workspace = true }
 typenum = { workspace = true }
 types = { workspace = true }

eip_7594/src/lib.rs

@@ -1,30 +1,55 @@
 use std::collections::HashMap;
 
-use anyhow::{anyhow, Result};
+use anyhow::{anyhow, ensure, Result};
 use c_kzg::{Blob as CKzgBlob, Bytes48, Cell as CKzgCell, KzgProof as CKzgProof, KzgSettings};
 use hashing::ZERO_HASHES;
 use helper_functions::predicates::{index_at_commitment_depth, is_valid_merkle_branch};
 use kzg::eip_4844::{load_trusted_setup_string, BYTES_PER_G1, BYTES_PER_G2};
 use num_traits::One as _;
 use sha2::{Digest as _, Sha256};
 use ssz::{ByteVector, ContiguousList, ContiguousVector, SszHash, Uint256};
+use thiserror::Error;
 use try_from_iterator::TryFromIterator as _;
 use typenum::Unsigned as _;
 use types::{
     combined::SignedBeaconBlock,
     deneb::primitives::{Blob, BlobIndex, KzgProof},
-    eip7594::{BlobCommitmentsInclusionProof, ColumnIndex, DataColumnSidecar, NumberOfColumns},
+    eip7594::{
+        BlobCommitmentsInclusionProof, ColumnIndex, DataColumnSidecar, NumberOfColumns,
+        DATA_COLUMN_SIDECAR_SUBNET_COUNT,
+    },
     phase0::{containers::SignedBeaconBlockHeader, primitives::NodeId},
+    preset::Preset,
     traits::{BeaconBlock as _, PostDenebBeaconBlockBody},
 };
-use types::{eip7594::DATA_COLUMN_SIDECAR_SUBNET_COUNT, preset::Preset};
 
 const MAX_BLOBS_PER_BLOCK: u64 = 6;
 const MAX_BLOB_COMMITMENTS_PER_BLOCK: usize = 6;
 
 type ExtendedMatrix = [CKzgCell; (MAX_BLOBS_PER_BLOCK * NumberOfColumns::U64) as usize];
 type CellID = u64;
 
+#[derive(Debug, Error)]
+pub enum VerifyKzgProofsError {
+    #[error(
+        "Sidecar index is out of bounds: {index} expected {}",
+        NumberOfColumns::U64
+    )]
+    SidecarIndexOutOfBounds { index: u64 },
+    #[error(
+        "Sidecar column length {column_length} does not match commitment length {commitments_length}"
+    )]
+    SidecarCommitmentsLengthError {
+        column_length: usize,
+        commitments_length: usize,
+    },
+    #[error("Sidecar column length {column_length} does not match proofs length {proofs_length}")]
+    SidecarProofsLengthError {
+        column_length: usize,
+        proofs_length: usize,
+    },
+}
+
 pub fn verify_kzg_proofs<P: Preset>(data_column_sidecar: &DataColumnSidecar<P>) -> Result<bool> {
     let DataColumnSidecar {
         index,
@@ -34,8 +59,26 @@ pub fn verify_kzg_proofs<P: Preset>(data_column_sidecar: &DataColumnSidecar<P>)
         ..
     } = data_column_sidecar;
 
-    assert!(*index < NumberOfColumns::U64);
-    assert!(column.len() == kzg_commitments.len() && column.len() == kzg_proofs.len());
+    ensure!(
+        *index < NumberOfColumns::U64,
+        VerifyKzgProofsError::SidecarIndexOutOfBounds { index: *index }
+    );
+
+    ensure!(
+        column.len() == kzg_commitments.len(),
+        VerifyKzgProofsError::SidecarCommitmentsLengthError {
+            column_length: column.len(),
+            commitments_length: kzg_commitments.len(),
+        }
+    );
+
+    ensure!(
+        column.len() == kzg_proofs.len(),
+        VerifyKzgProofsError::SidecarProofsLengthError {
+            column_length: column.len(),
+            proofs_length: kzg_proofs.len(),
+        }
+    );
 
     let mut row_ids = Vec::new();
     for i in 0..column.len() {

fork_choice_store/src/error.rs

@@ -1,5 +1,6 @@
 use std::sync::Arc;
 
+use anyhow::Error as AnyhowError;
 use static_assertions::assert_eq_size;
 use thiserror::Error;
 use types::{
@@ -81,9 +82,10 @@ pub enum Error<P: Preset> {
     },
     // TODO(feature/deneb): This is vague.
     //                      The validation that fails with this error actually checks commitments.
-    #[error("data_column sidecar is invalid: {data_column_sidecar:?}")]
+    #[error("data_column sidecar is invalid: {data_column_sidecar:?} error: {error}")]
     DataColumnSidecarInvalid {
         data_column_sidecar: Arc<DataColumnSidecar<P>>,
+        error: AnyhowError,
     },
     #[error("data_column sidecar's block's parent is invalid: {data_column_sidecar:?}")]
     DataColumnSidecarInvalidParentOfBlock {

fork_choice_store/src/store.rs

@@ -1856,12 +1856,12 @@ impl<P: Preset> Store<P> {
         );
 
         // [REJECT] The sidecar's column data is valid as verified by verify_data_column_sidecar_kzg_proofs(sidecar).
-        ensure!(
-            verify_kzg_proofs(&data_column_sidecar).unwrap_or(false),
+        verify_kzg_proofs(&data_column_sidecar).map_err(|error| {
             Error::DataColumnSidecarInvalid {
-                data_column_sidecar
+                data_column_sidecar: data_column_sidecar.clone_arc(),
+                error,
             }
-        );
+        })?;
 
         // [REJECT] The sidecar's block's parent (defined by block_header.parent_root) passes validation.
         // Part 1/2:

helper_functions/src/misc.rs

@@ -205,6 +205,7 @@ pub fn compute_subnet_for_blob_sidecar(blob_index: BlobIndex) -> SubnetId {
 }
 
 // source: https://github.com/ethereum/consensus-specs/pull/3574/files/cebf78a83e6fc8fa237daf4264b9ca0fe61473f4#diff-96cf4db15bede3d60f04584fb25339507c35755959159cdbe19d760ca92de109R106
+#[must_use]
 pub fn compute_subnet_for_data_column_sidecar(column_index: ColumnIndex) -> SubnetId {
     (column_index % DATA_COLUMN_SIDECAR_SUBNET_COUNT)
         .try_into()