Fix benchmarks & format code

bindings/rust/Cargo.toml

@@ -50,8 +50,3 @@ glob = "0.3"
 [[bench]]
 name = "kzg_benches"
 harness = false
-
-# The benchmarks crash on Windows with Rust 1.70. This is a band-aid fix for
-# that. Refer to #318 for more details. This should be removed if fixed.
-[profile.bench]
-opt-level = 0

bindings/rust/benches/kzg_benches.rs

@@ -12,15 +12,15 @@ fn generate_random_field_element(rng: &mut ThreadRng) -> Bytes32 {
     arr.into()
 }
 
-fn generate_random_blob(rng: &mut ThreadRng) -> Blob {
+fn generate_random_blob(rng: &mut ThreadRng) -> Box<Blob> {
     let mut arr = [0u8; BYTES_PER_BLOB];
     rng.fill(&mut arr[..]);
     // Ensure that the blob is canonical by ensuring that
     // each field element contained in the blob is < BLS_MODULUS
     for i in 0..FIELD_ELEMENTS_PER_BLOB {
         arr[i * BYTES_PER_FIELD_ELEMENT] = 0;
     }
-    arr.into()
+    Box::new(arr.into())
 }
 
 pub fn criterion_benchmark(c: &mut Criterion) {
@@ -30,7 +30,7 @@ pub fn criterion_benchmark(c: &mut Criterion) {
     assert!(trusted_setup_file.exists());
     let kzg_settings = Arc::new(KzgSettings::load_trusted_setup_file(trusted_setup_file).unwrap());
 
-    let blobs: Vec<Blob> = (0..max_count)
+    let blobs: Vec<Box<Blob>> = (0..max_count)
         .map(|_| generate_random_blob(&mut rng))
         .collect();
     let commitments: Vec<Bytes48> = blobs
@@ -109,7 +109,9 @@ pub fn criterion_benchmark(c: &mut Criterion) {
         group.bench_with_input(BenchmarkId::from_parameter(count), &count, |b, &count| {
             b.iter_batched_ref(
                 || {
-                    let blobs_subset = blobs.clone().into_iter().take(count).collect::<Vec<Blob>>();
+                    let blobs_subset: Vec<Blob> =
+                        blobs.iter().take(count).map(|b| (**b).clone()).collect();
+
                     let commitments_subset = commitments
                         .clone()
                         .into_iter()
@@ -125,7 +127,7 @@ pub fn criterion_benchmark(c: &mut Criterion) {
                 },
                 |(blobs_subset, commitments_subset, proofs_subset)| {
                     KzgProof::verify_blob_kzg_proof_batch(
-                        &blobs_subset,
+                        Box::new(&blobs_subset),
                         &commitments_subset,
                         &proofs_subset,
                         &kzg_settings,

bindings/rust/src/bindings/mod.rs

@@ -430,7 +430,10 @@ impl KZGCommitment {
         hex::encode(self.bytes)
     }
 
-    pub fn blob_to_kzg_commitment(blob: Box<Blob>, kzg_settings: &KZGSettings) -> Result<Self, Error> {
+    pub fn blob_to_kzg_commitment(
+        blob: Box<Blob>,
+        kzg_settings: &KZGSettings,
+    ) -> Result<Self, Error> {
         let mut kzg_commitment: MaybeUninit<KZGCommitment> = MaybeUninit::uninit();
         unsafe {
             let res = blob_to_kzg_commitment(
@@ -571,22 +574,24 @@ mod tests {
 
         let commitments: Vec<Bytes48> = blobs
             .iter()
-            .map(|blob| KZGCommitment::blob_to_kzg_commitment((*blob).clone(), &kzg_settings).unwrap())
+            .map(|blob| {
+                KZGCommitment::blob_to_kzg_commitment((*blob).clone(), &kzg_settings).unwrap()
+            })
             .map(|commitment| commitment.to_bytes())
             .collect();
 
         let proofs: Vec<Bytes48> = blobs
             .iter()
             .zip(commitments.iter())
             .map(|(blob, commitment)| {
-                KZGProof::compute_blob_kzg_proof((*blob).clone(), *commitment, &kzg_settings).unwrap()
+                KZGProof::compute_blob_kzg_proof((*blob).clone(), *commitment, &kzg_settings)
+                    .unwrap()
             })
             .map(|proof| proof.to_bytes())
             .collect();
 
         let blobs_copy: Vec<Blob> = blobs.iter().map(|b| (**b).clone()).collect();
-        let blobs_slice: &[Blob] = &blobs_copy;
-        let blobs_boxed_slice: Box<&[Blob]> = Box::new(blobs_slice);
+        let blobs_boxed_slice: Box<&[Blob]> = Box::new(&blobs_copy);
         assert!(KZGProof::verify_blob_kzg_proof_batch(
             blobs_boxed_slice,
             &commitments,
@@ -598,19 +603,21 @@ mod tests {
         blobs.pop();
 
         let blobs_copy: Vec<Blob> = blobs.iter().map(|b| (**b).clone()).collect();
-        let blobs_slice: &[Blob] = &blobs_copy;
-        let blobs_boxed_slice: Box<&[Blob]> = Box::new(blobs_slice);
-        let error =
-            KZGProof::verify_blob_kzg_proof_batch(blobs_boxed_slice, &commitments, &proofs, &kzg_settings)
-                .unwrap_err();
+        let blobs_boxed_slice: Box<&[Blob]> = Box::new(&blobs_copy);
+        let error = KZGProof::verify_blob_kzg_proof_batch(
+            blobs_boxed_slice,
+            &commitments,
+            &proofs,
+            &kzg_settings,
+        )
+        .unwrap_err();
         assert!(matches!(error, Error::MismatchLength(_)));
 
         let incorrect_blob = generate_random_blob(&mut rng);
         blobs.push(incorrect_blob);
 
         let blobs_copy: Vec<Blob> = blobs.iter().map(|b| (**b).clone()).collect();
-        let blobs_slice: &[Blob] = &blobs_copy;
-        let blobs_boxed_slice: Box<&[Blob]> = Box::new(blobs_slice);
+        let blobs_boxed_slice: Box<&[Blob]> = Box::new(&blobs_copy);
         assert!(!KZGProof::verify_blob_kzg_proof_batch(
             blobs_boxed_slice,
             &commitments,
@@ -812,8 +819,7 @@ mod tests {
             };
 
             let blobs_copy: Vec<Blob> = blobs.iter().map(|b| (**b).clone()).collect();
-            let blobs_slice: &[Blob] = &blobs_copy;
-            let blobs_boxed_slice: Box<&[Blob]> = Box::new(blobs_slice);
+            let blobs_boxed_slice: Box<&[Blob]> = Box::new(&blobs_copy);
 
             match KZGProof::verify_blob_kzg_proof_batch(
                 blobs_boxed_slice,

bindings/rust/src/lib.rs

@@ -7,8 +7,8 @@ pub use bindings::{
 };
 // Expose the constants.
 pub use bindings::{
-    BYTES_PER_BLOB, BYTES_PER_COMMITMENT, BYTES_PER_FIELD_ELEMENT, BYTES_PER_PROOF,
-    FIELD_ELEMENTS_PER_BLOB, BYTES_PER_G1_POINT, BYTES_PER_G2_POINT
+    BYTES_PER_BLOB, BYTES_PER_COMMITMENT, BYTES_PER_FIELD_ELEMENT, BYTES_PER_G1_POINT,
+    BYTES_PER_G2_POINT, BYTES_PER_PROOF, FIELD_ELEMENTS_PER_BLOB,
 };
 // Expose the remaining relevant types.
 pub use bindings::{Blob, Bytes32, Bytes48, Error};