Fix clippy warnings

Author: nougzarm

src/toolbox/sigma/fiat_shamir.rs

@@ -80,7 +80,7 @@ where
     }
 
     /// Verify a non-interactive serialized proof and returns a Result: `Ok(())` if the proof verifies successfully, `Err(())` otherwise.
-    pub fn verify(&mut self, proof: &Vec<u8>) -> Result<(), ()> {
+    pub fn verify(&mut self, proof: &[u8]) -> Result<(), ()> {
         self.hash_state = C::new(&self.domain_sep);
 
         let (commitment, response) = self.sigmap.deserialize_batchable(proof).unwrap();

src/toolbox/sigma/group_morphism.rs

@@ -34,11 +34,17 @@ pub struct Morphism<G: Group> {
 fn msm_pr<G: Group>(scalars: &[G::Scalar], bases: &[G]) -> G {
     let mut acc = G::identity();
     for (s, p) in scalars.iter().zip(bases.iter()) {
-        acc = acc + (*p * s.clone());
+        acc += *p * s;
     }
     acc
 }
 
+impl<G: Group> Default for Morphism<G> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<G: Group> Morphism<G> {
     /// Creates a new empty Morphism.
     pub fn new() -> Self {
@@ -65,8 +71,8 @@ impl<G: Group> Morphism<G> {
     /// Computes all linear combinations using the provided scalars and returns their group outputs.
     pub fn evaluate(&self, scalars: &[<G as Group>::Scalar]) -> Vec<G> {
         self.linear_combination.iter().map(|lc| {
-            let coefficients: Vec<_> = lc.scalar_indices.iter().map(|&i| scalars[i].clone()).collect();
-            let elements: Vec<_> = lc.element_indices.iter().map(|&i| self.group_elements[i].clone()).collect();
+            let coefficients: Vec<_> = lc.scalar_indices.iter().map(|&i| scalars[i]).collect();
+            let elements: Vec<_> = lc.element_indices.iter().map(|&i| self.group_elements[i]).collect();
             msm_pr(&coefficients, &elements)
         }).collect()
     }
@@ -87,6 +93,15 @@ where
     pub image: Vec<usize>,
 }
 
+impl<G> Default for GroupMorphismPreimage<G>
+where
+    G: Group + GroupEncoding,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<G> GroupMorphismPreimage<G>
 where
     G: Group + GroupEncoding,
@@ -143,15 +158,15 @@ where
     /// Set the value of group elements at a given index, inside the list of allocated group elements.
     pub fn set_elements(&mut self, elements: &[(usize, G)]) {
         for &(i, ref elt) in elements {
-            self.morphism.group_elements[i] = elt.clone();
+            self.morphism.group_elements[i] = *elt;
         }
     }
 
     /// Return the group elements corresponding to the image indices.
     pub fn image(&self) -> Vec<G> {
         let mut result = Vec::new();
         for i in &self.image {
-            result.push(self.morphism.group_elements[*i].clone());
+            result.push(self.morphism.group_elements[*i]);
         }
         result
     }

src/toolbox/sigma/schnorr_proof.rs

@@ -71,11 +71,13 @@ where
         challenge: &Self::Challenge,
         response: &Self::Response,
     ) -> Result<(), ()> {
-        let lhs = self.morphismp.morphism.evaluate(&response);
+        let lhs = self.morphismp.morphism.evaluate(response);
+
         let mut rhs = Vec::new();
-        for i in 0..self.morphismp.morphism.num_scalars {
-            rhs.push(commitment[i] + self.morphismp.morphism.group_elements[self.morphismp.image[i]] * *challenge);
+        for (i, g) in commitment.iter().enumerate().take(self.morphismp.morphism.num_scalars) {
+            rhs.push(*g + self.morphismp.morphism.group_elements[self.morphismp.image[i]] * *challenge);
         }
+
         match lhs == rhs {
             true => Ok(()),
             false => Err(()), 
@@ -90,14 +92,16 @@ where
         response: &Self::Response
     ) -> Vec<u8> {
         let mut bytes = Vec::new();
-        let scalar_nb = self.morphismp.morphism.num_scalars.clone();
+        let scalar_nb = self.morphismp.morphism.num_scalars;
+
         // Serialize commitments
-        for i in 0..scalar_nb {
-            bytes.extend_from_slice(commitment[i].to_bytes().as_ref());
+        for commit in commitment.iter().take(scalar_nb) {
+            bytes.extend_from_slice(commit.to_bytes().as_ref());
         }
+
         // Serialize responses
-        for i in 0..scalar_nb {
-            bytes.extend_from_slice(response[i].to_repr().as_ref());
+        for response in response.iter().take(scalar_nb) {
+            bytes.extend_from_slice(response.to_repr().as_ref());
         }
         bytes
     }

src/toolbox/sigma/trait.rs

@@ -94,8 +94,7 @@ pub trait SigmaProtocol {
 /// Types implementing `SigmaProtocolSimulator` must define:
 /// - `simulate_proof`
 /// - `simulate_transcription`
-pub trait SigmaProtocolSimulator
-where Self: SigmaProtocol {
+pub trait SigmaProtocolSimulator: SigmaProtocol {
 
     /// Simulates a protocol transcript given a challenge.
     ///