small fixes

README.md

@@ -5,7 +5,7 @@ Nova is a high-speed recursive SNARK (a SNARK is type cryptographic proof system
 This repository provides `libnova,` a Rust library library implementation of Nova. The current release implements the core building blocks in Nova, and future releases will use cycles of elliptic curves to support recursive composition of proofs.
 
 To run tests, run:
-```rust
+```text
 cargo test
 ```
 

src/lib.rs

@@ -65,7 +65,7 @@ impl StepSNARK {
     let W = W1.fold(W2, &T, &r)?;
 
     // return the folded instance and witness
-    return Ok((StepSNARK { comm_T }, (U, W)));
+    Ok((StepSNARK { comm_T }, (U, W)))
   }
 
   /// Takes as input two relaxed R1CS instances `U1` and `U2`
@@ -92,7 +92,7 @@ impl StepSNARK {
     let U = U1.fold(U2, &self.comm_T, &r)?;
 
     // return the folded instance and witness
-    return Ok(U);
+    Ok(U)
   }
 }
 

src/r1cs.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::type_complexity)]
 use super::commitments::Scalar;
 use super::commitments::{CommitGens, CommitTrait, Commitment, CompressedCommitment};
 use super::errors::NovaError;
@@ -50,21 +51,19 @@ impl R1CSShape {
     num_cons: usize,
     num_vars: usize,
     num_inputs: usize,
-    A: &Vec<(usize, usize, Scalar)>,
-    B: &Vec<(usize, usize, Scalar)>,
-    C: &Vec<(usize, usize, Scalar)>,
+    A: &[(usize, usize, Scalar)],
+    B: &[(usize, usize, Scalar)],
+    C: &[(usize, usize, Scalar)],
   ) -> Result<R1CSShape, NovaError> {
     let is_valid = |num_cons: usize,
                     num_vars: usize,
                     num_io: usize,
-                    M: &Vec<(usize, usize, Scalar)>|
+                    M: &[(usize, usize, Scalar)]|
      -> Result<(), NovaError> {
       let res = (0..num_cons)
         .map(|i| {
           let (row, col, _val) = M[i];
-          if row >= num_cons {
-            Err(NovaError::InvalidIndex)
-          } else if col >= num_io + num_vars + 1 {
+          if row >= num_cons || col > num_io + num_vars {
             Err(NovaError::InvalidIndex)
           } else {
             Ok(())
@@ -79,9 +78,9 @@ impl R1CSShape {
       }
     };
 
-    let res_A = is_valid(num_cons, num_vars, num_inputs, &A);
-    let res_B = is_valid(num_cons, num_vars, num_inputs, &B);
-    let res_C = is_valid(num_cons, num_vars, num_inputs, &C);
+    let res_A = is_valid(num_cons, num_vars, num_inputs, A);
+    let res_B = is_valid(num_cons, num_vars, num_inputs, B);
+    let res_C = is_valid(num_cons, num_vars, num_inputs, C);
 
     if res_A.is_err() || res_B.is_err() || res_C.is_err() {
       return Err(NovaError::InvalidIndex);
@@ -91,9 +90,9 @@ impl R1CSShape {
       num_cons,
       num_vars,
       num_inputs,
-      A: A.clone(),
-      B: B.clone(),
-      C: C.clone(),
+      A: A.to_owned(),
+      B: B.to_owned(),
+      C: C.to_owned(),
     };
 
     Ok(shape)
@@ -226,13 +225,13 @@ impl R1CSShape {
 }
 
 impl R1CSWitness {
-  pub fn new(S: &R1CSShape, W: &Vec<Scalar>, E: &Vec<Scalar>) -> Result<R1CSWitness, NovaError> {
+  pub fn new(S: &R1CSShape, W: &[Scalar], E: &[Scalar]) -> Result<R1CSWitness, NovaError> {
     if S.num_vars != W.len() || S.num_cons != E.len() {
       Err(NovaError::InvalidWitnessLength)
     } else {
       Ok(R1CSWitness {
-        W: W.clone(),
-        E: E.clone(),
+        W: W.to_owned(),
+        E: E.to_owned(),
       })
     }
   }
@@ -241,12 +240,7 @@ impl R1CSWitness {
     (self.W.commit(&gens.gens_W), self.E.commit(&gens.gens_E))
   }
 
-  pub fn fold(
-    &self,
-    W2: &R1CSWitness,
-    T: &Vec<Scalar>,
-    r: &Scalar,
-  ) -> Result<R1CSWitness, NovaError> {
+  pub fn fold(&self, W2: &R1CSWitness, T: &[Scalar], r: &Scalar) -> Result<R1CSWitness, NovaError> {
     let (W1, E1) = (&self.W, &self.E);
     let (W2, E2) = (&W2.W, &W2.E);
 
@@ -274,7 +268,7 @@ impl R1CSInstance {
     S: &R1CSShape,
     comm_W: &Commitment,
     comm_E: &Commitment,
-    X: &Vec<Scalar>,
+    X: &[Scalar],
     u: &Scalar,
   ) -> Result<R1CSInstance, NovaError> {
     if S.num_inputs != X.len() {
@@ -283,7 +277,7 @@ impl R1CSInstance {
       Ok(R1CSInstance {
         comm_W: comm_W.clone(),
         comm_E: comm_E.clone(),
-        X: X.clone(),
+        X: X.to_owned(),
         u: *u,
       })
     }