chore: Updated clippy - fix merge conflicts

Layr-Labs · Jun 2, 2024 · 3d1398e · 3d1398e
2 parents 2f5bbb3 + 8d92ba6
commit 3d1398e
Show file tree

Hide file tree

Showing 15 changed files with 491 additions and 196 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -30,11 +30,13 @@ num-traits = "0.2"
 byteorder = "1.4"
 ark-poly = "0.4.2"
 crossbeam-channel = "0.5"
-num_cpus = "^1.16.0"
+num_cpus = "1.13.0"
 
 [dev-dependencies]
 criterion = "0.5"
 lazy_static = "1.4"
+tracing = { version = "^0.1.34", features = ["log"] }
+tracing-subscriber = "0.3.18"
 
 [[test]]
 name = "kzg"

diff --git a/benches/bench_kzg_commit.rs b/benches/bench_kzg_commit.rs
@@ -1,6 +1,6 @@
 use criterion::{criterion_group, criterion_main, Criterion};
 use rand::Rng;
-use rust_kzg_bn254::{blob::Blob, kzg::Kzg};
+use rust_kzg_bn254::{blob::Blob, kzg::Kzg, polynomial::PolynomialFormat};
 use std::time::Duration;
 
 fn bench_kzg_commit(c: &mut Criterion) {
@@ -17,7 +17,7 @@ fn bench_kzg_commit(c: &mut Criterion) {
     c.bench_function("bench_kzg_commit_10000", |b| {
         let random_blob: Vec<u8> = (0..10000).map(|_| rng.gen_range(32..=126) as u8).collect();
         let input = Blob::from_bytes_and_pad(&random_blob);
-        let input_poly = input.to_polynomial().unwrap();
+        let input_poly = input.to_polynomial(PolynomialFormat::InCoefficientForm).unwrap();
         kzg.data_setup_custom(1, input.len().try_into().unwrap())
             .unwrap();
         b.iter(|| kzg.commit(&input_poly).unwrap());
@@ -26,7 +26,7 @@ fn bench_kzg_commit(c: &mut Criterion) {
     c.bench_function("bench_kzg_commit_30000", |b| {
         let random_blob: Vec<u8> = (0..30000).map(|_| rng.gen_range(32..=126) as u8).collect();
         let input = Blob::from_bytes_and_pad(&random_blob);
-        let input_poly = input.to_polynomial().unwrap();
+        let input_poly = input.to_polynomial(PolynomialFormat::InCoefficientForm).unwrap();
         kzg.data_setup_custom(1, input.len().try_into().unwrap())
             .unwrap();
         b.iter(|| kzg.commit(&input_poly).unwrap());
@@ -35,7 +35,7 @@ fn bench_kzg_commit(c: &mut Criterion) {
     c.bench_function("bench_kzg_commit_50000", |b| {
         let random_blob: Vec<u8> = (0..50000).map(|_| rng.gen_range(32..=126) as u8).collect();
         let input = Blob::from_bytes_and_pad(&random_blob);
-        let input_poly = input.to_polynomial().unwrap();
+        let input_poly = input.to_polynomial(PolynomialFormat::InCoefficientForm).unwrap();
         kzg.data_setup_custom(1, input.len().try_into().unwrap())
             .unwrap();
         b.iter(|| kzg.commit(&input_poly).unwrap());

diff --git a/benches/bench_kzg_proof.rs b/benches/bench_kzg_proof.rs
@@ -1,6 +1,6 @@
 use criterion::{criterion_group, criterion_main, Criterion};
 use rand::Rng;
-use rust_kzg_bn254::{blob::Blob, kzg::Kzg};
+use rust_kzg_bn254::{blob::Blob, kzg::Kzg, polynomial::PolynomialFormat};
 use std::time::Duration;
 
 fn bench_kzg_proof(c: &mut Criterion) {
@@ -17,7 +17,7 @@ fn bench_kzg_proof(c: &mut Criterion) {
     c.bench_function("bench_kzg_proof_10000", |b| {
         let random_blob: Vec<u8> = (0..10000).map(|_| rng.gen_range(32..=126) as u8).collect();
         let input = Blob::from_bytes_and_pad(&random_blob);
-        let input_poly = input.to_polynomial().unwrap();
+        let input_poly = input.to_polynomial(PolynomialFormat::InCoefficientForm).unwrap();
         kzg.data_setup_custom(1, input.len().try_into().unwrap())
             .unwrap();
         let index =
@@ -31,7 +31,7 @@ fn bench_kzg_proof(c: &mut Criterion) {
     c.bench_function("bench_kzg_proof_30000", |b| {
         let random_blob: Vec<u8> = (0..30000).map(|_| rng.gen_range(32..=126) as u8).collect();
         let input = Blob::from_bytes_and_pad(&random_blob);
-        let input_poly = input.to_polynomial().unwrap();
+        let input_poly = input.to_polynomial(PolynomialFormat::InCoefficientForm).unwrap();
         kzg.data_setup_custom(1, input.len().try_into().unwrap())
             .unwrap();
         let index =
@@ -45,7 +45,7 @@ fn bench_kzg_proof(c: &mut Criterion) {
     c.bench_function("bench_kzg_proof_50000", |b| {
         let random_blob: Vec<u8> = (0..50000).map(|_| rng.gen_range(32..=126) as u8).collect();
         let input = Blob::from_bytes_and_pad(&random_blob);
-        let input_poly = input.to_polynomial().unwrap();
+        let input_poly = input.to_polynomial(PolynomialFormat::InCoefficientForm).unwrap();
         kzg.data_setup_custom(1, input.len().try_into().unwrap())
             .unwrap();
         let index =

diff --git a/benches/bench_kzg_verify.rs b/benches/bench_kzg_verify.rs
@@ -1,6 +1,6 @@
 use criterion::{criterion_group, criterion_main, Criterion};
 use rand::Rng;
-use rust_kzg_bn254::{blob::Blob, kzg::Kzg};
+use rust_kzg_bn254::{blob::Blob, kzg::Kzg, polynomial::PolynomialFormat};
 use std::time::Duration;
 
 fn bench_kzg_verify(c: &mut Criterion) {
@@ -17,7 +17,7 @@ fn bench_kzg_verify(c: &mut Criterion) {
     c.bench_function("bench_kzg_verify_10000", |b| {
         let random_blob: Vec<u8> = (0..10000).map(|_| rng.gen_range(32..=126) as u8).collect();
         let input = Blob::from_bytes_and_pad(&random_blob);
-        let input_poly = input.to_polynomial().unwrap();
+        let input_poly = input.to_polynomial(PolynomialFormat::InCoefficientForm).unwrap();
         kzg.data_setup_custom(1, input.len().try_into().unwrap())
             .unwrap();
         let index =
@@ -34,7 +34,7 @@ fn bench_kzg_verify(c: &mut Criterion) {
     c.bench_function("bench_kzg_verify_30000", |b| {
         let random_blob: Vec<u8> = (0..30000).map(|_| rng.gen_range(32..=126) as u8).collect();
         let input = Blob::from_bytes_and_pad(&random_blob);
-        let input_poly = input.to_polynomial().unwrap();
+        let input_poly = input.to_polynomial(PolynomialFormat::InCoefficientForm).unwrap();
         kzg.data_setup_custom(1, input.len().try_into().unwrap())
             .unwrap();
         let index =
@@ -51,7 +51,7 @@ fn bench_kzg_verify(c: &mut Criterion) {
     c.bench_function("bench_kzg_verify_50000", |b| {
         let random_blob: Vec<u8> = (0..50000).map(|_| rng.gen_range(32..=126) as u8).collect();
         let input = Blob::from_bytes_and_pad(&random_blob);
-        let input_poly = input.to_polynomial().unwrap();
+        let input_poly = input.to_polynomial(PolynomialFormat::InCoefficientForm).unwrap();
         kzg.data_setup_custom(1, input.len().try_into().unwrap())
             .unwrap();
         let index =

diff --git a/rust-toolchain b/rust-toolchain
@@ -1,5 +1,5 @@
 [toolchain]
-channel = 'nightly-2024-04-29'
+channel = '1.74'
 profile = 'minimal'
 components = ['clippy', 'rustfmt']
-targets = ["x86_64-unknown-linux-gnu", "x86_64-pc-windows-gnu", "wasm32-unknown-unknown"]
+targets = ["x86_64-unknown-linux-gnu", "x86_64-pc-windows-gnu", "wasm32-unknown-unknown", "aarch64-apple-darwin"]
diff --git a/src/blob.rs b/src/blob.rs
@@ -1,4 +1,8 @@
-use crate::{errors::BlobError, helpers, polynomial::Polynomial};
+use crate::{
+    errors::BlobError,
+    helpers,
+    polynomial::{Polynomial, PolynomialFormat},
+};
 
 /// A blob which is Eigen DA spec aligned.
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -39,6 +43,22 @@ impl Blob {
         }
     }
 
+    /// Creates a new `Blob` from the provided byte slice and assumes it's
+    /// already padded according to DA specs.
+    /// WARNING: This function does not check if the bytes are modulo bn254
+    /// if the data has 32 byte segments exceeding the modulo of the field
+    /// then the bytes will be modded by the order of the field and the data
+    /// will be transformed incorrectly
+    pub fn from_padded_bytes_unchecked(input: &[u8]) -> Self {
+        let length_after_padding = input.len();
+
+        Blob {
+            blob_data: input.to_vec(),
+            is_padded: true,
+            length_after_padding,
+        }
+    }
+
     /// Returns the blob data
     pub fn get_blob_data(&self) -> Vec<u8> {
         self.blob_data.clone()
@@ -49,7 +69,7 @@ impl Blob {
         self.blob_data.len()
     }
 
-    /// Returns true if the blob is empty.
+    /// Checks if the blob data is empty.
     pub fn is_empty(&self) -> bool {
         self.blob_data.is_empty()
     }
@@ -71,20 +91,21 @@ impl Blob {
         if !self.is_padded {
             Err(BlobError::NotPaddedError)
         } else {
-            self.blob_data = helpers::remove_empty_byte_from_padded_bytes(&self.blob_data);
+            self.blob_data =
+                helpers::remove_empty_byte_from_padded_bytes_unchecked(&self.blob_data);
             self.is_padded = false;
             self.length_after_padding = 0;
             Ok(())
         }
     }
 
     /// Converts the blob data to a `Polynomial` if the data is padded.
-    pub fn to_polynomial(&self) -> Result<Polynomial, BlobError> {
+    pub fn to_polynomial(&self, form: PolynomialFormat) -> Result<Polynomial, BlobError> {
         if !self.is_padded {
             Err(BlobError::NotPaddedError)
         } else {
             let fr_vec = helpers::to_fr_array(&self.blob_data);
-            let poly = Polynomial::new(&fr_vec, self.length_after_padding)
+            let poly = Polynomial::new(&fr_vec, self.length_after_padding, form)
                 .map_err(|err| BlobError::GenericError(err.to_string()))?;
             Ok(poly)
         }

diff --git a/src/errors.rs b/src/errors.rs
@@ -24,6 +24,8 @@ pub enum PolynomialError {
     SerializationFromStringError,
     CommitError(String),
     GenericError(String),
+    FFTError(String),
+    IncorrectFormError(String),
 }
 
 impl fmt::Display for PolynomialError {
@@ -33,7 +35,11 @@ impl fmt::Display for PolynomialError {
                 write!(f, "couldn't load string to fr vector")
             },
             PolynomialError::CommitError(ref msg) => write!(f, "Commitment error: {}", msg),
+            PolynomialError::FFTError(ref msg) => write!(f, "FFT error: {}", msg),
             PolynomialError::GenericError(ref msg) => write!(f, "generic error: {}", msg),
+            PolynomialError::IncorrectFormError(ref msg) => {
+                write!(f, "Incorrect form error: {}", msg)
+            },
         }
     }
 }
@@ -60,112 +66,3 @@ impl fmt::Display for KzgError {
 }
 
 impl Error for KzgError {}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_polynomial_error_serialization_from_string() {
-        let error = PolynomialError::SerializationFromStringError;
-        assert_eq!(format!("{}", error), "couldn't load string to fr vector");
-    }
-
-    #[test]
-    fn test_polynomial_error_commit() {
-        let msg = String::from("test commit error");
-        let error = PolynomialError::CommitError(msg.clone());
-        assert_eq!(format!("{}", error), format!("Commitment error: {}", msg));
-    }
-
-    #[test]
-    fn test_polynomial_error_generic() {
-        let msg = String::from("test generic error");
-        let error = PolynomialError::GenericError(msg.clone());
-        assert_eq!(format!("{}", error), format!("generic error: {}", msg));
-    }
-
-    #[test]
-    fn test_polynomial_error_equality() {
-        let error1 = PolynomialError::SerializationFromStringError;
-        let error2 = PolynomialError::SerializationFromStringError;
-        let error3 = PolynomialError::CommitError(String::from("error"));
-        assert_eq!(error1, error2);
-        assert_ne!(error1, error3);
-    }
-
-    // KzgError tests
-    #[test]
-    fn test_kzg_error_commit() {
-        let msg = String::from("test commit error");
-        let error = KzgError::CommitError(msg.clone());
-        assert_eq!(format!("{}", error), format!("Commitment error: {}", msg));
-    }
-
-    #[test]
-    fn test_kzg_error_serialization() {
-        let msg = String::from("test serialization error");
-        let error = KzgError::SerializationError(msg.clone());
-        assert_eq!(
-            format!("{}", error),
-            format!("Serialization error: {}", msg)
-        );
-    }
-
-    #[test]
-    fn test_kzg_error_fft() {
-        let msg = String::from("test fft error");
-        let error = KzgError::FftError(msg.clone());
-        assert_eq!(format!("{}", error), format!("FFT error: {}", msg));
-    }
-
-    #[test]
-    fn test_kzg_error_generic() {
-        let msg = String::from("test generic error");
-        let error = KzgError::GenericError(msg.clone());
-        assert_eq!(format!("{}", error), format!("Generic error: {}", msg));
-    }
-
-    #[test]
-    fn test_kzg_error_equality() {
-        let error1 = KzgError::CommitError(String::from("error"));
-        let error2 = KzgError::CommitError(String::from("error"));
-        let error3 = KzgError::SerializationError(String::from("different error"));
-        assert_eq!(error1, error2);
-        assert_ne!(error1, error3);
-    }
-
-    #[test]
-    fn test_not_padded_error_display() {
-        let error = BlobError::NotPaddedError;
-        assert_eq!(format!("{}", error), "tried to execute on non padded blob");
-    }
-
-    #[test]
-    fn test_already_padded_error_display() {
-        let error = BlobError::AlreadyPaddedError;
-        assert_eq!(
-            format!("{}", error),
-            "tried to execute on already padded blob"
-        );
-    }
-
-    #[test]
-    fn test_blob_error_equality() {
-        let error1 = BlobError::NotPaddedError;
-        let error2 = BlobError::NotPaddedError;
-        let error3 = BlobError::AlreadyPaddedError;
-
-        assert_eq!(error1, error2);
-        assert_ne!(error1, error3);
-    }
-
-    #[test]
-    fn test_blob_generic_error() {
-        let error1 = BlobError::GenericError(String::from("error"));
-        let error3 = BlobError::GenericError(String::from("error"));
-        let error2 = BlobError::NotPaddedError;
-        assert_eq!(error1, error3);
-        assert_ne!(error1, error2);
-    }
-}