fmt & clippy :)

coins/monero/generators/src/lib.rs

@@ -34,14 +34,15 @@ lazy_static! {
 
   /// Monero's `H` generator multiplied 2^i for each index, i.e. H, 2H, 4H, 8H, ...
   /// used in old range proofs.
-  /// https://github.com/monero-project/monero/blob/94e67bf96bbc010241f29ada6abc89f49a81759c/src/ringct/rctTypes.h#L628
+  /// https://github.com/monero-project/monero/blob/94e67bf96bbc010241f29ada6abc89f49a81759c/src/
+  /// ringct/rctTypes.h#L628
   pub static ref H2: [DalekPoint; 64] = generate_H2();
 }
 
 #[allow(non_snake_case)]
 fn generate_H2() -> [DalekPoint; 64] {
   let mut temp = Vec::with_capacity(64);
-  for i in 0..64 {
+  for i in 0 .. 64 {
     temp.push(Scalar::from(2_u128.pow(i)) * *H)
   }
   temp.try_into().unwrap()

coins/monero/src/ringct/borromean.rs

@@ -3,7 +3,7 @@
 use std::fmt::Debug;
 use std::io::{self, Read, Write};
 
-use curve25519_dalek::edwards::{CompressedEdwardsY, EdwardsPoint};
+use curve25519_dalek::edwards::EdwardsPoint;
 use curve25519_dalek::scalar::Scalar;
 use curve25519_dalek::traits::Identity;
 
@@ -70,7 +70,7 @@ impl RangeSig {
 
     let mut C_temp = EdwardsPoint::identity();
 
-    for i in 0..64 {
+    for i in 0 .. 64 {
       bbs0.push(Scalar::from_bytes_mod_order(self.asig.s0[i]));
       bbs1.push(Scalar::from_bytes_mod_order(self.asig.s1[i]));
 
@@ -85,13 +85,18 @@ impl RangeSig {
     } else {
       verify_borromean(P1, P2, bbee, bbs0, bbs1)
     }
-
   }
 }
 
-fn verify_borromean(P1: Vec<EdwardsPoint>, P2: Vec<EdwardsPoint>, bbee: Scalar, bbs0: Vec<Scalar>, bbs1: Vec<Scalar>) -> bool {
+fn verify_borromean(
+  P1: Vec<EdwardsPoint>,
+  P2: Vec<EdwardsPoint>,
+  bbee: Scalar,
+  bbs0: Vec<Scalar>,
+  bbs1: Vec<Scalar>,
+) -> bool {
   let mut LV: Vec<u8> = Vec::with_capacity(2048);
-  for i in 0..64 {
+  for i in 0 .. 64 {
     let LL = EdwardsPoint::vartime_double_scalar_mul_basepoint(&bbee, &P1[i], &bbs0[i]);
     let chash = hash_to_scalar(LL.compress().as_bytes());
     let LV_temp = EdwardsPoint::vartime_double_scalar_mul_basepoint(&chash, &P2[i], &bbs1[i]);
@@ -99,10 +104,5 @@ fn verify_borromean(P1: Vec<EdwardsPoint>, P2: Vec<EdwardsPoint>, bbee: Scalar,
   }
   let eecomp = hash_to_scalar(&LV);
 
-  if !(eecomp == bbee) {
+  eecomp == bbee
-    false
-  }
-  else {
-    true
-  }
 }

coins/monero/src/ringct/mlsag/mod.rs

@@ -33,28 +33,28 @@ impl Mlsag {
     })
   }
 
-  fn verify(&self, msg: &[u8; 32], ring: &[[EdwardsPoint; 2]], I: &EdwardsPoint) -> bool {
+  pub fn verify(&self, msg: &[u8; 32], ring: &[[EdwardsPoint; 2]], I: &EdwardsPoint) -> bool {
     let mut buf = Vec::with_capacity(32 * 6);
 
-
     let mut ci = self.cc;
 
-    for i in 0..ring.len() {
+    for (i, ring_member) in ring.iter().enumerate() {
       buf.extend_from_slice(msg);
-      buf.extend_from_slice(ring[i][0].compress().as_bytes());
+      buf.extend_from_slice(ring_member[0].compress().as_bytes());
 
-      let L1 = EdwardsPoint::vartime_double_scalar_mul_basepoint(&ci, &ring[i][0], &self.ss[i][0]);
+      let L1 =
+        EdwardsPoint::vartime_double_scalar_mul_basepoint(&ci, &ring_member[0], &self.ss[i][0]);
       buf.extend_from_slice(L1.compress().as_bytes());
 
-      let temp = hash_to_point(ring[i][0]);
+      let temp = hash_to_point(ring_member[0]);
 
       let R = self.ss[i][0] * temp + ci * I;
       buf.extend_from_slice(R.compress().as_bytes());
 
-      buf.extend_from_slice(ring[i][1].compress().as_bytes());
+      buf.extend_from_slice(ring_member[1].compress().as_bytes());
 
-
+      let L2 =
-      let L2 = EdwardsPoint::vartime_double_scalar_mul_basepoint(&ci, &ring[i][1], &self.ss[i][1]);
+        EdwardsPoint::vartime_double_scalar_mul_basepoint(&ci, &ring_member[1], &self.ss[i][1]);
       buf.extend_from_slice(L2.compress().as_bytes());
 
       ci = hash_to_scalar(&buf);

coins/monero/src/transaction.rs

@@ -258,14 +258,16 @@ impl Transaction {
     };
 
     if prefix.version == 1 {
-
       signatures = prefix
         .inputs
         .iter()
         .filter_map(|input| match input {
-          Input::ToKey { key_offsets, .. } => {
+          Input::ToKey { key_offsets, .. } => Some(
-            Some(key_offsets.iter().map(|_| Ok((read_scalar(r)?, read_scalar(r)?))).collect::<Result<_, io::Error>>())
+            key_offsets
-          }
+              .iter()
+              .map(|_| Ok((read_scalar(r)?, read_scalar(r)?)))
+              .collect::<Result<_, io::Error>>(),
+          ),
           _ => None,
         })
         .collect::<Result<_, _>>()?;