chore: Use reference to an array representing a blob instead of an owned KzgBlob (only for peerdas functions)

beacon_node/beacon_chain/src/kzg_utils.rs

@@ -1,12 +1,13 @@
-use kzg::{Blob as KzgBlob, Bytes48, CellRef as KzgCellRef, Error as KzgError, Kzg};
+use kzg::{Bytes48, CellRef as KzgCellRef, Error as KzgError, Kzg, KzgBlobRef};
 use std::sync::Arc;
 use types::data_column_sidecar::Cell;
 use types::{Blob, DataColumnSidecar, EthSpec, Hash256, KzgCommitment, KzgProof};
 
 /// Converts a blob ssz List object to an array to be used with the kzg
 /// crypto library.
-fn ssz_blob_to_crypto_blob<E: EthSpec>(blob: &Blob<E>) -> Result<KzgBlob, KzgError> {
-    KzgBlob::from_bytes(blob.as_ref()).map_err(Into::into)
+fn ssz_blob_to_crypto_blob<E: EthSpec>(blob: &Blob<E>) -> Result<KzgBlobRef, KzgError> {
+    let blob_bytes: &[u8] = blob.as_ref();
+    Ok(blob_bytes.try_into().expect("expected cell to have size {BYTES_PER_BLOB}. This should be guaranteed by the `FixedVector type"))
 }
 
 /// Converts a cell ssz List object to an array to be used with the kzg
@@ -27,7 +28,7 @@ pub fn validate_blob<E: EthSpec>(
 ) -> Result<(), KzgError> {
     let _timer = crate::metrics::start_timer(&crate::metrics::KZG_VERIFICATION_SINGLE_TIMES);
     let kzg_blob = ssz_blob_to_crypto_blob::<E>(blob)?;
-    kzg.verify_blob_kzg_proof(&kzg_blob, kzg_commitment, kzg_proof)
+    kzg.verify_blob_kzg_proof(kzg_blob, kzg_commitment, kzg_proof)
 }
 
 /// Validate a batch of `DataColumnSidecar`.
@@ -97,7 +98,7 @@ pub fn compute_blob_kzg_proof<E: EthSpec>(
     kzg_commitment: KzgCommitment,
 ) -> Result<KzgProof, KzgError> {
     let kzg_blob = ssz_blob_to_crypto_blob::<E>(blob)?;
-    kzg.compute_blob_kzg_proof(&kzg_blob, kzg_commitment)
+    kzg.compute_blob_kzg_proof(kzg_blob, kzg_commitment)
 }
 
 /// Compute the kzg commitment for a given blob.
@@ -106,7 +107,7 @@ pub fn blob_to_kzg_commitment<E: EthSpec>(
     blob: &Blob<E>,
 ) -> Result<KzgCommitment, KzgError> {
     let kzg_blob = ssz_blob_to_crypto_blob::<E>(blob)?;
-    kzg.blob_to_kzg_commitment(&kzg_blob)
+    kzg.blob_to_kzg_commitment(kzg_blob)
 }
 
 /// Compute the kzg proof for a given blob and an evaluation point z.
@@ -117,7 +118,7 @@ pub fn compute_kzg_proof<E: EthSpec>(
 ) -> Result<(KzgProof, Hash256), KzgError> {
     let z = z.0.into();
     let kzg_blob = ssz_blob_to_crypto_blob::<E>(blob)?;
-    kzg.compute_kzg_proof(&kzg_blob, &z)
+    kzg.compute_kzg_proof(kzg_blob, &z)
         .map(|(proof, z)| (proof, Hash256::from_slice(&z.to_vec())))
 }
 

consensus/types/src/data_column_sidecar.rs

@@ -9,7 +9,7 @@ use bls::Signature;
 use derivative::Derivative;
 #[cfg_attr(test, double)]
 use kzg::Kzg;
-use kzg::{Blob as KzgBlob, CellRef as KzgCellRef, Error as KzgError};
+use kzg::{CellRef as KzgCellRef, Error as KzgError};
 use kzg::{KzgCommitment, KzgProof};
 use merkle_proof::verify_merkle_proof;
 #[cfg(test)]
@@ -128,8 +128,11 @@ impl<E: EthSpec> DataColumnSidecar<E> {
         let blob_cells_and_proofs_vec = blobs
             .into_par_iter()
             .map(|blob| {
-                let blob = KzgBlob::from_bytes(blob).map_err(KzgError::from)?;
-                kzg.compute_cells_and_proofs(&blob)
+                let blob = blob
+                    .as_ref()
+                    .try_into()
+                    .expect("blob should have a guaranteed size due to FixedVector");
+                kzg.compute_cells_and_proofs(blob)
             })
             .collect::<Result<Vec<_>, KzgError>>()?;
 

crypto/kzg/src/lib.rs

@@ -20,8 +20,11 @@ pub use peerdas_kzg::{
     Cell, CellIndex as CellID, CellRef, TrustedSetup as PeerDASTrustedSetup,
 };
 use peerdas_kzg::{prover::ProverError, verifier::VerifierError, PeerDASContext};
+
 pub type CellsAndKzgProofs = ([Cell; CELLS_PER_EXT_BLOB], [KzgProof; CELLS_PER_EXT_BLOB]);
 
+pub type KzgBlobRef<'a> = &'a [u8; BYTES_PER_BLOB];
+
 #[derive(Debug)]
 pub enum Error {
     /// An error from the underlying kzg library.
@@ -75,25 +78,29 @@ impl Kzg {
     }
 
     /// Compute the kzg proof given a blob and its kzg commitment.
-    pub fn compute_blob_kzg_proof(
+    #[allow(clippy::needless_lifetimes)]
+    pub fn compute_blob_kzg_proof<'a>(
         &self,
-        blob: &Blob,
+        blob: KzgBlobRef<'a>,
         kzg_commitment: KzgCommitment,
     ) -> Result<KzgProof, Error> {
-        c_kzg::KzgProof::compute_blob_kzg_proof(blob, &kzg_commitment.into(), &self.trusted_setup)
+        let blob = Blob::from_bytes(blob)?;
+        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.
-    pub fn verify_blob_kzg_proof(
+    #[allow(clippy::needless_lifetimes)]
+    pub fn verify_blob_kzg_proof<'a>(
         &self,
-        blob: &Blob,
+        blob: KzgBlobRef<'a>,
         kzg_commitment: KzgCommitment,
         kzg_proof: KzgProof,
     ) -> Result<(), Error> {
+        let blob = Blob::from_bytes(blob)?;
         if !c_kzg::KzgProof::verify_blob_kzg_proof(
-            blob,
+            &blob,
             &kzg_commitment.into(),
             &kzg_proof.into(),
             &self.trusted_setup,
@@ -108,9 +115,10 @@ impl Kzg {
     ///
     /// Note: This method is slightly faster than calling `Self::verify_blob_kzg_proof` in a loop sequentially.
     /// TODO(pawan): test performance against a parallelized rayon impl.
-    pub fn verify_blob_kzg_proof_batch(
+    #[allow(clippy::needless_lifetimes)]
+    pub fn verify_blob_kzg_proof_batch<'a>(
         &self,
-        blobs: &[Blob],
+        blobs: &[KzgBlobRef<'a>],
         kzg_commitments: &[KzgCommitment],
         kzg_proofs: &[KzgProof],
     ) -> Result<(), Error> {
@@ -124,8 +132,12 @@ impl Kzg {
             .map(|proof| Bytes48::from(*proof))
             .collect::<Vec<_>>();
 
+        let blobs = blobs
+            .iter()
+            .map(|blob| Blob::from_bytes(blob.as_slice()))
+            .collect::<Result<Vec<_>, _>>()?;
         if !c_kzg::KzgProof::verify_blob_kzg_proof_batch(
-            blobs,
+            &blobs,
             &commitments_bytes,
             &proofs_bytes,
             &self.trusted_setup,
@@ -137,19 +149,23 @@ impl Kzg {
     }
 
     /// 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)
+    #[allow(clippy::needless_lifetimes)]
+    pub fn blob_to_kzg_commitment<'a>(&self, blob: KzgBlobRef<'a>) -> Result<KzgCommitment, Error> {
+        let blob = Blob::from_bytes(blob)?;
+        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`
-    pub fn compute_kzg_proof(
+    #[allow(clippy::needless_lifetimes)]
+    pub fn compute_kzg_proof<'a>(
         &self,
-        blob: &Blob,
+        blob: KzgBlobRef<'a>,
         z: &Bytes32,
     ) -> Result<(KzgProof, Bytes32), Error> {
-        c_kzg::KzgProof::compute_kzg_proof(blob, z, &self.trusted_setup)
+        let blob = Blob::from_bytes(blob)?;
+        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)
     }
@@ -173,7 +189,11 @@ impl Kzg {
     }
 
     /// Computes the cells and associated proofs for a given `blob` at index `index`.
-    pub fn compute_cells_and_proofs(&self, blob: &Blob) -> Result<CellsAndKzgProofs, Error> {
+    #[allow(clippy::needless_lifetimes)]
+    pub fn compute_cells_and_proofs<'a>(
+        &self,
+        blob: KzgBlobRef<'a>,
+    ) -> Result<CellsAndKzgProofs, Error> {
         let blob_bytes: &[u8; BYTES_PER_BLOB] = blob
             .as_ref()
             .try_into()
@@ -245,11 +265,11 @@ impl Kzg {
 }
 
 pub mod mock {
-    use crate::{Blob, Cell, CellsAndKzgProofs, BYTES_PER_CELL, CELLS_PER_EXT_BLOB};
+    use crate::{Cell, CellsAndKzgProofs, KzgBlobRef, BYTES_PER_CELL, CELLS_PER_EXT_BLOB};
     use crate::{Error, KzgProof};
 
     #[allow(clippy::type_complexity)]
-    pub fn compute_cells_and_proofs(_blob: &Blob) -> Result<CellsAndKzgProofs, Error> {
+    pub fn compute_cells_and_proofs(_blob: KzgBlobRef) -> Result<CellsAndKzgProofs, Error> {
         let empty_cells = vec![Cell::new([0; BYTES_PER_CELL]); CELLS_PER_EXT_BLOB]
             .try_into()
             .expect("expected {CELLS_PER_EXT_BLOB} number of items");

testing/ef_tests/src/cases/kzg_compute_cells_and_kzg_proofs.rs

@@ -1,6 +1,6 @@
 use super::*;
 use crate::case_result::compare_result;
-use kzg::{Blob as KzgBlob, CellsAndKzgProofs};
+use kzg::CellsAndKzgProofs;
 use serde::Deserialize;
 use std::marker::PhantomData;
 
@@ -32,10 +32,10 @@ impl<E: EthSpec> Case for KZGComputeCellsAndKZGProofs<E> {
 
     fn result(&self, _case_index: usize, _fork_name: ForkName) -> Result<(), Error> {
         let cells_and_proofs = parse_blob::<E>(&self.input.blob).and_then(|blob| {
-            let blob = KzgBlob::from_bytes(&blob).map_err(|e| {
+            let blob = blob.as_ref().try_into().map_err(|e| {
                 Error::InternalError(format!("Failed to convert blob to kzg blob: {e:?}"))
             })?;
-            KZG.compute_cells_and_proofs(&blob).map_err(|e| {
+            KZG.compute_cells_and_proofs(blob).map_err(|e| {
                 Error::InternalError(format!("Failed to compute cells and kzg proofs: {e:?}"))
             })
         });