Sidecar inclusion proof (#4900)

* Refactor BlobSidecar to new type

* Fix some compile errors

* Gossip verification compiles

* Fix http api types take 1

* Fix another round of compile errors

* Beacon node crate compiles

* EF tests compile

* Remove all blob signing from VC

* fmt

* Tests compile

* Fix some tests

* Fix more http tests

* get compiling

* Fix gossip conditions and tests

* Add basic proof generation and verification

* remove unnecessary ssz decode

* add back build_sidecar

* remove default at fork for blobs

* fix beacon chain tests

* get relase tests compiling

* fix lints

* fix existing spec tests

* add new ef tests

* fix gossip duplicate rule

* lints

* add back sidecar signature check in gossip

* add finalized descendant check to blob sidecar gossip

* fix error conversion

* fix release tests

* sidecar inclusion self review cleanup

* Add proof verification and computation metrics

* Remove accidentally committed file

* Unify some block and blob errors; add slashing conditions for sidecars

* Address review comment

* Clean up re-org tests (#4957)

* Address more review comments

* Add Comments & Eliminate Unnecessary Clones

* update names

* Update beacon_node/beacon_chain/src/metrics.rs

Co-authored-by: Jimmy Chen <jchen.tc@gmail.com>

* Update beacon_node/network/src/network_beacon_processor/tests.rs

Co-authored-by: Jimmy Chen <jchen.tc@gmail.com>

* pr feedback

* fix test compile

* Sidecar Inclusion proof small refactor and updates (#4967)

* Update some comments, variables and small cosmetic fixes.

* Couple blobs and proofs into a tuple in `PayloadAndBlobs` for simplicity and safety.

* Update function comment.

* Update testing/ef_tests/src/cases/merkle_proof_validity.rs

Co-authored-by: Jimmy Chen <jchen.tc@gmail.com>

* Rename the block and blob wrapper types used in the beacon API interfaces.

* make sure gossip invalid blobs are passed to the slasher (#4970)

* Add blob headers to slasher before adding to DA checker

* Replace Vec with HashSet in BlockQueue

* fmt

* Rename gindex -> index

* Simplify gossip condition

---------

Co-authored-by: realbigsean <seananderson33@gmail.com>
Co-authored-by: realbigsean <sean@sigmaprime.io>
Co-authored-by: Michael Sproul <michael@sigmaprime.io>
Co-authored-by: Mark Mackey <mark@sigmaprime.io>
Co-authored-by: Jimmy Chen <jchen.tc@gmail.com>

crypto/kzg/src/lib.rs

@@ -6,10 +6,24 @@ use std::fmt::Debug;
 
 pub use crate::{kzg_commitment::KzgCommitment, kzg_proof::KzgProof, trusted_setup::TrustedSetup};
 pub use c_kzg::{
-    Blob, Bytes32, Bytes48, Error, KzgSettings, BYTES_PER_BLOB, BYTES_PER_COMMITMENT,
+    Blob, Bytes32, Bytes48, KzgSettings, BYTES_PER_BLOB, BYTES_PER_COMMITMENT,
     BYTES_PER_FIELD_ELEMENT, BYTES_PER_PROOF, FIELD_ELEMENTS_PER_BLOB,
 };
 
+#[derive(Debug)]
+pub enum Error {
+    /// An error from the underlying kzg library.
+    Kzg(c_kzg::Error),
+    /// The kzg verification failed
+    KzgVerificationFailed,
+}
+
+impl From<c_kzg::Error> for Error {
+    fn from(value: c_kzg::Error) -> Self {
+        Error::Kzg(value)
+    }
+}
+
 /// A wrapper over a kzg library that holds the trusted setup parameters.
 #[derive(Debug)]
 pub struct Kzg {
@@ -35,6 +49,7 @@ impl Kzg {
     ) -> Result<KzgProof, Error> {
         c_kzg::KzgProof::compute_blob_kzg_proof(blob, &kzg_commitment.into(), &self.trusted_setup)
             .map(|proof| KzgProof(proof.to_bytes().into_inner()))
+            .map_err(Into::into)
     }
 
     /// Verify a kzg proof given the blob, kzg commitment and kzg proof.
@@ -43,13 +58,17 @@ impl Kzg {
         blob: &Blob,
         kzg_commitment: KzgCommitment,
         kzg_proof: KzgProof,
-    ) -> Result<bool, Error> {
-        c_kzg::KzgProof::verify_blob_kzg_proof(
+    ) -> Result<(), Error> {
+        if !c_kzg::KzgProof::verify_blob_kzg_proof(
             blob,
             &kzg_commitment.into(),
             &kzg_proof.into(),
             &self.trusted_setup,
-        )
+        )? {
+            Err(Error::KzgVerificationFailed)
+        } else {
+            Ok(())
+        }
     }
 
     /// Verify a batch of blob commitment proof triplets.
@@ -61,7 +80,7 @@ impl Kzg {
         blobs: &[Blob],
         kzg_commitments: &[KzgCommitment],
         kzg_proofs: &[KzgProof],
-    ) -> Result<bool, Error> {
+    ) -> Result<(), Error> {
         let commitments_bytes = kzg_commitments
             .iter()
             .map(|comm| Bytes48::from(*comm))
@@ -72,18 +91,23 @@ impl Kzg {
             .map(|proof| Bytes48::from(*proof))
             .collect::<Vec<_>>();
 
-        c_kzg::KzgProof::verify_blob_kzg_proof_batch(
+        if !c_kzg::KzgProof::verify_blob_kzg_proof_batch(
             blobs,
             &commitments_bytes,
             &proofs_bytes,
             &self.trusted_setup,
-        )
+        )? {
+            Err(Error::KzgVerificationFailed)
+        } else {
+            Ok(())
+        }
     }
 
     /// Converts a blob to a kzg commitment.
     pub fn blob_to_kzg_commitment(&self, blob: &Blob) -> Result<KzgCommitment, Error> {
         c_kzg::KzgCommitment::blob_to_kzg_commitment(blob, &self.trusted_setup)
             .map(|commitment| KzgCommitment(commitment.to_bytes().into_inner()))
+            .map_err(Into::into)
     }
 
     /// Computes the kzg proof for a given `blob` and an evaluation point `z`
@@ -94,6 +118,7 @@ impl Kzg {
     ) -> Result<(KzgProof, Bytes32), Error> {
         c_kzg::KzgProof::compute_kzg_proof(blob, z, &self.trusted_setup)
             .map(|(proof, y)| (KzgProof(proof.to_bytes().into_inner()), y))
+            .map_err(Into::into)
     }
 
     /// Verifies a `kzg_proof` for a `kzg_commitment` that evaluating a polynomial at `z` results in `y`
@@ -111,5 +136,6 @@ impl Kzg {
             &kzg_proof.into(),
             &self.trusted_setup,
         )
+        .map_err(Into::into)
     }
 }