Merge remote-tracking branch 'origin/unstable' into tree-states

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