nymcoconut: fix clippy

common/nymcoconut/benches/benchmarks.rs

@@ -14,12 +14,14 @@ use rand::seq::SliceRandom;
 use std::ops::Neg;
 use std::time::Duration;
 
+#[allow(unused)]
 fn double_pairing(g11: &G1Affine, g21: &G2Affine, g12: &G1Affine, g22: &G2Affine) {
-    let gt1 = bls12_381::pairing(&g11, &g21);
-    let gt2 = bls12_381::pairing(&g12, &g22);
+    let gt1 = bls12_381::pairing(g11, g21);
+    let gt2 = bls12_381::pairing(g12, g22);
     assert_eq!(gt1, gt2)
 }
 
+#[allow(unused)]
 fn multi_miller_pairing_affine(g11: &G1Affine, g21: &G2Affine, g12: &G1Affine, g22: &G2Affine) {
     let miller_loop_result = multi_miller_loop(&[
         (g11, &G2Prepared::from(*g21)),
@@ -30,19 +32,21 @@ fn multi_miller_pairing_affine(g11: &G1Affine, g21: &G2Affine, g12: &G1Affine, g
     ))
 }
 
+#[allow(unused)]
 fn multi_miller_pairing_with_prepared(
     g11: &G1Affine,
     g21: &G2Prepared,
     g12: &G1Affine,
     g22: &G2Prepared,
 ) {
-    let miller_loop_result = multi_miller_loop(&[(g11, &g21), (&g12.neg(), &g22)]);
+    let miller_loop_result = multi_miller_loop(&[(g11, g21), (&g12.neg(), g22)]);
     assert!(bool::from(
         miller_loop_result.final_exponentiation().is_identity()
     ))
 }
 
 // the case of being able to prepare G2 generator
+#[allow(unused)]
 fn multi_miller_pairing_with_semi_prepared(
     g11: &G1Affine,
     g21: &G2Affine,
@@ -50,12 +54,13 @@ fn multi_miller_pairing_with_semi_prepared(
     g22: &G2Prepared,
 ) {
     let miller_loop_result =
-        multi_miller_loop(&[(g11, &G2Prepared::from(*g21)), (&g12.neg(), &g22)]);
+        multi_miller_loop(&[(g11, &G2Prepared::from(*g21)), (&g12.neg(), g22)]);
     assert!(bool::from(
         miller_loop_result.final_exponentiation().is_identity()
     ))
 }
 
+#[allow(clippy::too_many_arguments)]
 fn unblind_and_aggregate(
     params: &Parameters,
     blinded_signatures: &[BlindedSignature],
@@ -73,12 +78,12 @@ fn unblind_and_aggregate(
         .map(|(signature, partial_verification_key)| {
             signature
                 .unblind(
-                    &params,
-                    &partial_verification_key,
-                    &private_attributes,
-                    &public_attributes,
-                    &commitment_hash,
-                    &pedersen_commitments_openings,
+                    params,
+                    partial_verification_key,
+                    private_attributes,
+                    public_attributes,
+                    commitment_hash,
+                    pedersen_commitments_openings,
                 )
                 .unwrap()
         })
@@ -94,8 +99,8 @@ fn unblind_and_aggregate(
     attributes.extend_from_slice(private_attributes);
     attributes.extend_from_slice(public_attributes);
     aggregate_signature_shares(
-        &params,
-        &verification_key,
+        params,
+        verification_key,
         &attributes,
         &unblinded_signature_shares,
     )
@@ -119,6 +124,7 @@ impl BenchCase {
     }
 }
 
+#[allow(unused)]
 fn bench_pairings(c: &mut Criterion) {
     let mut rng = rand::thread_rng();
 
@@ -162,14 +168,14 @@ fn bench_coconut(c: &mut Criterion) {
         num_private_attrs: 2,
     };
 
-    let params = setup((case.num_public_attrs + case.num_private_attrs)).unwrap();
+    let params = setup(case.num_public_attrs + case.num_private_attrs).unwrap();
 
     let public_attributes = params.n_random_scalars(case.num_public_attrs as usize);
     let serial_number = params.random_scalar();
     let binding_number = params.random_scalar();
     let private_attributes = vec![serial_number, binding_number];
 
-    let elgamal_keypair = elgamal_keygen(&params);
+    let _elgamal_keypair = elgamal_keygen(&params);
 
     // The prepare blind sign is performed by the user
     let (pedersen_commitments_openings, blind_sign_request) =

common/nymcoconut/src/proofs/mod.rs

@@ -524,7 +524,7 @@ mod tests {
     fn proof_cm_cs_bytes_roundtrip() {
         let mut rng = thread_rng();
 
-        let mut params = setup(1).unwrap();
+        let params = setup(1).unwrap();
         let cm = G1Projective::random(&mut rng);
         let r = params.random_scalar();
         let cms: [G1Projective; 1] = [G1Projective::random(&mut rng)];
@@ -532,12 +532,12 @@ mod tests {
         let private_attributes = params.n_random_scalars(1);
 
         // 0 public 1 private
-        let pi_s = ProofCmCs::construct(&mut params, &cm, &r, &cms, &rs, &private_attributes);
+        let pi_s = ProofCmCs::construct(&params, &cm, &r, &cms, &rs, &private_attributes);
 
         let bytes = pi_s.to_bytes();
         assert_eq!(ProofCmCs::from_bytes(&bytes).unwrap(), pi_s);
 
-        let mut params = setup(2).unwrap();
+        let params = setup(2).unwrap();
         let cm = G1Projective::random(&mut rng);
         let r = params.random_scalar();
         let cms: [G1Projective; 2] = [
@@ -548,7 +548,7 @@ mod tests {
         let private_attributes = params.n_random_scalars(2);
 
         // 0 public 2 privates
-        let pi_s = ProofCmCs::construct(&mut params, &cm, &r, &cms, &rs, &private_attributes);
+        let pi_s = ProofCmCs::construct(&params, &cm, &r, &cms, &rs, &private_attributes);
 
         let bytes = pi_s.to_bytes();
         assert_eq!(ProofCmCs::from_bytes(&bytes).unwrap(), pi_s);

common/nymcoconut/src/scheme/mod.rs

@@ -251,7 +251,7 @@ mod tests {
     #[test]
     fn unblind_returns_error_if_integrity_check_on_commitment_hash_fails() {
         let params = Parameters::new(2).unwrap();
-        let private_attributes = params.n_random_scalars(2 as usize);
+        let private_attributes = params.n_random_scalars(2_usize);
 
         let (_commitments_openings, lambda) =
             prepare_blind_sign(&params, &private_attributes, &[]).unwrap();

common/nymcoconut/src/tests/e2e.rs

@@ -49,7 +49,7 @@ fn main() -> Result<(), CoconutError> {
             .map(|(s, vk)| {
                 s.unblind(
                     &params,
-                    &vk,
+                    vk,
                     &private_attributes,
                     &public_attributes,
                     &blind_sign_request.get_commitment_hash(),