chore: clippy

Author: kevaundray

Cargo.toml

@@ -35,3 +35,6 @@ kzg_multi_open = { package = "crate_crypto_kzg_multi_open_fk20", version = "0.3.
 c_peerdas_kzg = { version = "0.3.0", path = "bindings/c" }
 hex = "0.4.3"
 rayon = "1.10.0"
+
+[profile.release]
+lto = true

bindings/c/build.rs

@@ -22,5 +22,5 @@ fn main() {
         .with_language(cbindgen::Language::C)
         .generate()
         .unwrap()
-        .write_to_file(&output_file);
+        .write_to_file(output_file);
 }

bindings/c/src/blob_to_kzg_commitment.rs

@@ -8,7 +8,7 @@ pub(crate) fn _blob_to_kzg_commitment(
     blob: *const u8,
     out: *mut u8,
 ) -> Result<(), CResult> {
-    assert!(ctx.is_null() == false, "context pointer is null");
+    assert!(!ctx.is_null(), "context pointer is null");
 
     // Dereference the input pointers
     //
@@ -22,7 +22,7 @@ pub(crate) fn _blob_to_kzg_commitment(
         .map_err(|err| CResult::with_error(&format!("{:?}", err)))?;
 
     assert!(
-        commitment.len() == BYTES_PER_COMMITMENT as usize,
+        commitment.len() == BYTES_PER_COMMITMENT,
         "This is a library bug. commitment.len() != BYTES_PER_COMMITMENT, {} != {}",
         commitment.len(),
         BYTES_PER_COMMITMENT

bindings/c/src/compute_cells_and_kzg_proofs.rs

@@ -8,7 +8,7 @@ pub(crate) fn _compute_cells_and_kzg_proofs(
     out_cells: *mut *mut u8,
     out_proofs: *mut *mut u8,
 ) -> Result<(), CResult> {
-    assert!(ctx.is_null() == false, "context pointer is null");
+    assert!(!ctx.is_null(), "context pointer is null");
 
     // Pointer checks
     //

bindings/c/src/lib.rs

@@ -52,14 +52,16 @@ pub struct PeerDASContext {
     verifier_ctx: eip7594_VerifierContext,
 }
 
-impl PeerDASContext {
-    pub fn new() -> Self {
+impl Default for PeerDASContext {
+    fn default() -> Self {
         PeerDASContext {
             prover_ctx: eip7594_ProverContext::new(),
             verifier_ctx: eip7594_VerifierContext::new(),
         }
     }
+}
 
+impl PeerDASContext {
     pub fn prover_ctx(&self) -> &eip7594_ProverContext {
         &self.prover_ctx
     }
@@ -77,7 +79,7 @@ impl PeerDASContext {
 /// by calling `peerdas_context_free`.
 #[no_mangle]
 pub extern "C" fn peerdas_context_new() -> *mut PeerDASContext {
-    let ctx = Box::new(PeerDASContext::new());
+    let ctx = Box::<PeerDASContext>::default();
     Box::into_raw(ctx)
 }
 
@@ -94,6 +96,7 @@ pub extern "C" fn peerdas_context_new() -> *mut PeerDASContext {
 ///
 /// - Since the `ctx` is created in Rust, we can only get undefined behavior, if the caller passes in
 /// a pointer that was not created by `peerdas_context_new`.
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
 pub extern "C" fn peerdas_context_free(ctx: *mut PeerDASContext) {
     if ctx.is_null() {
@@ -156,7 +159,7 @@ impl CResult {
 /// - The caller must ensure that the pointer is valid. If the pointer is null, this method will return early.
 /// - The caller should also avoid a double-free by setting the pointer to null after calling this method.
 #[no_mangle]
-pub extern "C" fn free_error_message(c_message: *mut std::os::raw::c_char) {
+pub unsafe extern "C" fn free_error_message(c_message: *mut std::os::raw::c_char) {
     // check if the pointer is null
     if c_message.is_null() {
         return;
@@ -190,7 +193,7 @@ pub extern "C" fn blob_to_kzg_commitment(
 ) -> CResult {
     match _blob_to_kzg_commitment(ctx, blob, out) {
         Ok(_) => CResult::with_ok(),
-        Err(err) => return err,
+        Err(err) => err,
     }
 }
 
@@ -220,8 +223,8 @@ pub extern "C" fn compute_cells_and_kzg_proofs(
     out_proofs: *mut *mut u8,
 ) -> CResult {
     match _compute_cells_and_kzg_proofs(ctx, blob, out_cells, out_proofs) {
-        Ok(_) => return CResult::with_ok(),
-        Err(err) => return err,
+        Ok(_) => CResult::with_ok(),
+        Err(err) => err,
     }
 }
 
@@ -250,8 +253,8 @@ pub extern "C" fn verify_cell_kzg_proof(
     verified: *mut bool,
 ) -> CResult {
     match _verify_cell_kzg_proof(ctx, cell, commitment, cell_id, proof, verified) {
-        Ok(_) => return CResult::with_ok(),
-        Err(err) => return err,
+        Ok(_) => CResult::with_ok(),
+        Err(err) => err,
     }
 }
 
@@ -330,8 +333,8 @@ pub extern "C" fn verify_cell_kzg_proof_batch(
         proofs,
         verified,
     ) {
-        Ok(_) => return CResult::with_ok(),
-        Err(err) => return err,
+        Ok(_) => CResult::with_ok(),
+        Err(err) => err,
     }
 }
 

bindings/c/src/pointer_utils.rs

@@ -36,7 +36,7 @@ pub(crate) fn ptr_ptr_to_vec_slice_const<'a>(
     let mut result: Vec<&[u8]> = Vec::with_capacity(outer_len);
 
     // Convert each inner pointer to a slice of u8
-    for ptr in vec_slice.into_iter() {
+    for ptr in vec_slice.iter() {
         result.push(create_slice_view(*ptr, inner_len));
     }
 
@@ -57,7 +57,7 @@ pub(crate) fn write_to_2d_slice<T: Copy, const N: usize>(
 ) {
     let out_cells = ptr_ptr_to_slice_slice_mut(ptr, N);
 
-    for (out_cell, result) in out_cells.into_iter().zip(data) {
+    for (out_cell, result) in out_cells.iter_mut().zip(data) {
         write_to_slice(*out_cell, result.as_ref());
     }
 }

bindings/c/src/recover_cells_and_kzg_proofs.rs

@@ -13,7 +13,7 @@ pub(crate) fn _recover_all_cells_and_proofs(
     out_cells: *mut *mut u8,
     out_proofs: *mut *mut u8,
 ) -> Result<(), CResult> {
-    assert!(ctx.is_null() == false, "context pointer is null");
+    assert!(!ctx.is_null(), "context pointer is null");
 
     // Dereference the input pointers
     //

bindings/c/src/verify_cells_and_kzg_proofs.rs

@@ -13,7 +13,7 @@ pub(crate) fn _verify_cell_kzg_proof(
     proof: *const u8,
     verified: *mut bool,
 ) -> Result<(), CResult> {
-    assert!(ctx.is_null() == false, "context pointer is null");
+    assert!(!ctx.is_null(), "context pointer is null");
 
     // Dereference the input pointers
     //

bindings/c/src/verify_cells_and_kzg_proofs_batch.rs

@@ -2,6 +2,7 @@ use crate::pointer_utils::{create_slice_view, deref_const, deref_mut, ptr_ptr_to
 use crate::{verification_result_to_bool_cresult, CResult, PeerDASContext};
 use eip7594::constants::{BYTES_PER_CELL, BYTES_PER_COMMITMENT};
 
+#[allow(clippy::too_many_arguments)]
 pub(crate) fn _verify_cell_kzg_proof_batch(
     ctx: *const PeerDASContext,
 
@@ -22,7 +23,7 @@ pub(crate) fn _verify_cell_kzg_proof_batch(
 
     verified: *mut bool,
 ) -> Result<(), CResult> {
-    assert!(ctx.is_null() == false, "context pointer is null");
+    assert!(!ctx.is_null(), "context pointer is null");
 
     // When the arrays are empty in the caller language, the pointer might be null
     // This was witnessed in csharp.

bindings/java/rust_code/src/errors.rs

@@ -1,8 +1,8 @@
 #[derive(Debug)]
 pub enum Error {
     Jni(jni::errors::Error),
-    ProverError(eip7594::prover::ProverError),
-    VerifierError(eip7594::verifier::VerifierError),
+    Prover(eip7594::prover::ProverError),
+    Verifier(eip7594::verifier::VerifierError),
 }
 
 impl From<jni::errors::Error> for Error {
@@ -13,6 +13,6 @@ impl From<jni::errors::Error> for Error {
 
 impl From<eip7594::prover::ProverError> for Error {
     fn from(err: eip7594::prover::ProverError) -> Self {
-        Error::ProverError(err)
+        Error::Prover(err)
     }
 }

bindings/java/rust_code/src/lib.rs

@@ -9,15 +9,15 @@ mod errors;
 use errors::Error;
 
 #[no_mangle]
-pub unsafe extern "system" fn Java_ethereum_cryptography_LibPeerDASKZG_peerDASContextNew(
+pub extern "system" fn Java_ethereum_cryptography_LibPeerDASKZG_peerDASContextNew(
     _env: JNIEnv,
     _class: JClass,
 ) -> jlong {
     c_peerdas_kzg::peerdas_context_new() as jlong
 }
 
 #[no_mangle]
-pub unsafe extern "system" fn Java_ethereum_cryptography_LibPeerDASKZG_peerDASContextDestroy(
+pub extern "system" fn Java_ethereum_cryptography_LibPeerDASKZG_peerDASContextDestroy(
     _env: JNIEnv,
     _class: JClass,
     ctx_ptr: jlong,
@@ -26,20 +26,18 @@ pub unsafe extern "system" fn Java_ethereum_cryptography_LibPeerDASKZG_peerDASCo
 }
 
 #[no_mangle]
-pub unsafe extern "system" fn Java_ethereum_cryptography_LibPeerDASKZG_computeCellsAndKZGProofs<
-    'local,
->(
+pub extern "system" fn Java_ethereum_cryptography_LibPeerDASKZG_computeCellsAndKZGProofs<'local>(
     mut env: JNIEnv<'local>,
     _class: JClass,
     ctx_ptr: jlong,
     blob: JByteArray<'local>,
 ) -> JObject<'local> {
-    let ctx = &*(ctx_ptr as *const PeerDASContext);
+    let ctx = unsafe { &*(ctx_ptr as *const PeerDASContext) };
     match compute_cells_and_kzg_proofs(&mut env, ctx, blob) {
         Ok(cells_and_proofs) => cells_and_proofs,
         Err(err) => {
             throw_on_error(&mut env, err, "computeCellsAndKZGProofs");
-            return JObject::default();
+            JObject::default()
         }
     }
 }
@@ -54,20 +52,18 @@ fn compute_cells_and_kzg_proofs<'local>(
 }
 
 #[no_mangle]
-pub unsafe extern "system" fn Java_ethereum_cryptography_LibPeerDASKZG_blobToKZGCommitment<
-    'local,
->(
+pub extern "system" fn Java_ethereum_cryptography_LibPeerDASKZG_blobToKZGCommitment<'local>(
     mut env: JNIEnv<'local>,
     _class: JClass,
     ctx_ptr: jlong,
     blob: JByteArray<'local>,
 ) -> JByteArray<'local> {
-    let ctx = &*(ctx_ptr as *const PeerDASContext);
+    let ctx = unsafe { &*(ctx_ptr as *const PeerDASContext) };
     match blob_to_kzg_commitment(&mut env, ctx, blob) {
         Ok(commitment) => commitment,
         Err(err) => {
             throw_on_error(&mut env, err, "blobToKZGCommitment");
-            return JByteArray::default();
+            JByteArray::default()
         }
     }
 }
@@ -82,9 +78,7 @@ fn blob_to_kzg_commitment<'local>(
 }
 
 #[no_mangle]
-pub unsafe extern "system" fn Java_ethereum_cryptography_LibPeerDASKZG_verifyCellKZGProof<
-    'local,
->(
+pub extern "system" fn Java_ethereum_cryptography_LibPeerDASKZG_verifyCellKZGProof<'local>(
     mut env: JNIEnv<'local>,
     _class: JClass,
     ctx_ptr: jlong,
@@ -93,13 +87,13 @@ pub unsafe extern "system" fn Java_ethereum_cryptography_LibPeerDASKZG_verifyCel
     cell: JByteArray<'local>,
     proof_bytes: JByteArray<'local>,
 ) -> jboolean {
-    let ctx = &*(ctx_ptr as *const PeerDASContext);
+    let ctx = unsafe { &*(ctx_ptr as *const PeerDASContext) };
 
     match verify_cell_kzg_proof(&mut env, ctx, commitment_bytes, cell_id, cell, proof_bytes) {
         Ok(result) => result,
         Err(err) => {
             throw_on_error(&mut env, err, "verifyCellKZGProof");
-            return jboolean::default();
+            jboolean::default()
         }
     }
 }
@@ -122,14 +116,12 @@ fn verify_cell_kzg_proof(
     {
         Ok(_) => Ok(jboolean::from(true)),
         Err(VerifierError::InvalidProof) => Ok(jboolean::from(false)),
-        Err(err) => Err(Error::VerifierError(err)),
+        Err(err) => Err(Error::Verifier(err)),
     }
 }
 
 #[no_mangle]
-pub unsafe extern "system" fn Java_ethereum_cryptography_LibPeerDASKZG_verifyCellKZGProofBatch<
-    'local,
->(
+pub extern "system" fn Java_ethereum_cryptography_LibPeerDASKZG_verifyCellKZGProofBatch<'local>(
     mut env: JNIEnv<'local>,
     _class: JClass,
     ctx_ptr: jlong,
@@ -139,7 +131,7 @@ pub unsafe extern "system" fn Java_ethereum_cryptography_LibPeerDASKZG_verifyCel
     cells: JObjectArray<'local>,
     proofs: JObjectArray<'local>,
 ) -> jboolean {
-    let ctx = &*(ctx_ptr as *const PeerDASContext);
+    let ctx = unsafe { &*(ctx_ptr as *const PeerDASContext) };
 
     match verify_cell_kzg_proof_batch(
         &mut env,
@@ -153,7 +145,7 @@ pub unsafe extern "system" fn Java_ethereum_cryptography_LibPeerDASKZG_verifyCel
         Ok(result) => result,
         Err(err) => {
             throw_on_error(&mut env, err, "verifyCellKZGProofBatch");
-            return jboolean::default();
+            jboolean::default()
         }
     }
 }
@@ -181,27 +173,25 @@ fn verify_cell_kzg_proof_batch<'local>(
     ) {
         Ok(_) => Ok(jboolean::from(true)),
         Err(VerifierError::InvalidProof) => Ok(jboolean::from(false)),
-        Err(err) => Err(Error::VerifierError(err)),
+        Err(err) => Err(Error::Verifier(err)),
     }
 }
 
 #[no_mangle]
-pub unsafe extern "system" fn Java_ethereum_cryptography_LibPeerDASKZG_recoverCellsAndProof<
-    'local,
->(
+pub extern "system" fn Java_ethereum_cryptography_LibPeerDASKZG_recoverCellsAndProof<'local>(
     mut env: JNIEnv<'local>,
     _class: JClass,
     ctx_ptr: jlong,
     cell_ids: JLongArray,
     cells: JObjectArray<'local>,
 ) -> JObject<'local> {
-    let ctx = &*(ctx_ptr as *const PeerDASContext);
+    let ctx = unsafe { &*(ctx_ptr as *const PeerDASContext) };
 
     match recover_cells_and_kzg_proofs(&mut env, ctx, cell_ids, cells) {
         Ok(cells_and_proofs) => cells_and_proofs,
         Err(err) => {
             throw_on_error(&mut env, err, "recoverCellsAndProof");
-            return JObject::default();
+            JObject::default()
         }
     }
 }
@@ -288,7 +278,7 @@ fn cells_and_proofs_to_jobject<'local>(
         env.new_byte_array(0)?,
     )?;
 
-    for (i, cell) in cells.into_iter().enumerate() {
+    for (i, cell) in cells.iter().enumerate() {
         let cell_array = env.byte_array_from_slice(cell.as_ref())?;
         env.set_object_array_element(&cells_array, i as i32, cell_array)?;
     }
@@ -300,7 +290,7 @@ fn cells_and_proofs_to_jobject<'local>(
         env.new_byte_array(0)?,
     )?;
 
-    for (i, proof) in proofs.into_iter().enumerate() {
+    for (i, proof) in proofs.iter().enumerate() {
         let proof_array = env.byte_array_from_slice(proof.as_ref())?;
         env.set_object_array_element(&proofs_array, i as i32, proof_array)?;
     }
@@ -319,8 +309,8 @@ fn cells_and_proofs_to_jobject<'local>(
 fn throw_on_error(env: &mut JNIEnv, err: Error, func_name: &'static str) {
     let reason = match err {
         Error::Jni(err) => format!("{:?}", err),
-        Error::ProverError(err) => format!("{:?}", err),
-        Error::VerifierError(err) => format!("{:?}", err),
+        Error::Prover(err) => format!("{:?}", err),
+        Error::Verifier(err) => format!("{:?}", err),
     };
     let msg = format!(
         "function {} has thrown an exception, with reason: {}",

bindings/nim/rust_code/build.rs

@@ -22,7 +22,7 @@ fn main() {
         .with_crate(path_to_c_crate)
         .generate()
         .unwrap()
-        .write_to_file(&output_file);
+        .write_to_file(output_file);
 }
 
 fn path_to_bindings_folder() -> PathBuf {