Further expand clippy workspace lints

Achieves a notable amount of reduced async and clones.

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

@@ -7,7 +7,7 @@ use std_shims::{
 
 use rand_core::{RngCore, CryptoRng};
 
-use zeroize::Zeroize;
+use zeroize::{Zeroize, Zeroizing};
 
 use curve25519_dalek::edwards::EdwardsPoint;
 use multiexp::BatchVerifier;
@@ -91,7 +91,7 @@ impl Bulletproofs {
       Bulletproofs::Plus(
         AggregateRangeStatement::new(outputs.iter().map(|com| DfgPoint(com.calculate())).collect())
           .unwrap()
-          .prove(rng, AggregateRangeWitness::new(outputs).unwrap())
+          .prove(rng, &Zeroizing::new(AggregateRangeWitness::new(outputs).unwrap()))
           .unwrap(),
       )
     })

coins/monero/src/ringct/bulletproofs/original.rs

@@ -223,7 +223,7 @@ impl OriginalStruct {
     let A = normalize(&self.A);
     let S = normalize(&self.S);
 
-    let commitments = commitments.iter().map(|c| c.mul_by_cofactor()).collect::<Vec<_>>();
+    let commitments = commitments.iter().map(EdwardsPoint::mul_by_cofactor).collect::<Vec<_>>();
 
     // Verify it
     let mut proof = Vec::with_capacity(4 + commitments.len());

coins/monero/src/ringct/bulletproofs/plus/aggregate_range_proof.rs

@@ -2,7 +2,7 @@ use std_shims::vec::Vec;
 
 use rand_core::{RngCore, CryptoRng};
 
-use zeroize::{Zeroize, ZeroizeOnDrop};
+use zeroize::{Zeroize, ZeroizeOnDrop, Zeroizing};
 
 use multiexp::{multiexp, multiexp_vartime, BatchVerifier};
 use group::{
@@ -142,7 +142,7 @@ impl AggregateRangeStatement {
     A_terms.push((y_mn_plus_one, commitment_accum));
     A_terms.push((
       ((y_pows * z) - (d.sum() * y_mn_plus_one * z) - (y_pows * z.square())),
-      generators.g(),
+      Generators::g(),
     ));
 
     (y, d_descending_y, y_mn_plus_one, z, ScalarVector(z_pow), A + multiexp_vartime(&A_terms))
@@ -151,7 +151,7 @@ impl AggregateRangeStatement {
   pub(crate) fn prove<R: RngCore + CryptoRng>(
     self,
     rng: &mut R,
-    witness: AggregateRangeWitness,
+    witness: &AggregateRangeWitness,
   ) -> Option<AggregateRangeProof> {
     // Check for consistency with the witness
     if self.V.len() != witness.values.len() {
@@ -202,7 +202,7 @@ impl AggregateRangeStatement {
     for (i, a_r) in a_r.0.iter().enumerate() {
       A_terms.push((*a_r, generators.generator(GeneratorsList::HBold1, i)));
     }
-    A_terms.push((alpha, generators.h()));
+    A_terms.push((alpha, Generators::h()));
     let mut A = multiexp(&A_terms);
     A_terms.zeroize();
 
@@ -222,7 +222,7 @@ impl AggregateRangeStatement {
     Some(AggregateRangeProof {
       A,
       wip: WipStatement::new(generators, A_hat, y)
-        .prove(rng, transcript, WipWitness::new(a_l, a_r, alpha).unwrap())
+        .prove(rng, transcript, &Zeroizing::new(WipWitness::new(a_l, a_r, alpha).unwrap()))
         .unwrap(),
     })
   }

coins/monero/src/ringct/bulletproofs/plus/mod.rs

@@ -31,8 +31,6 @@ pub(crate) enum GeneratorsList {
 // TODO: Table these
 #[derive(Clone, Debug)]
 pub(crate) struct Generators {
-  g: EdwardsPoint,
-
   g_bold1: &'static [EdwardsPoint],
   h_bold1: &'static [EdwardsPoint],
 }
@@ -47,18 +45,18 @@ impl Generators {
   #[allow(clippy::new_without_default)]
   pub(crate) fn new() -> Self {
     let gens = generators::GENERATORS();
-    Generators { g: dalek_ff_group::EdwardsPoint(crate::H()), g_bold1: &gens.G, h_bold1: &gens.H }
+    Generators { g_bold1: &gens.G, h_bold1: &gens.H }
   }
 
   pub(crate) fn len(&self) -> usize {
     self.g_bold1.len()
   }
 
-  pub(crate) fn g(&self) -> EdwardsPoint {
-    self.g
+  pub(crate) fn g() -> EdwardsPoint {
+    dalek_ff_group::EdwardsPoint(crate::H())
   }
 
-  pub(crate) fn h(&self) -> EdwardsPoint {
+  pub(crate) fn h() -> EdwardsPoint {
     EdwardsPoint::generator()
   }
 
@@ -74,11 +72,7 @@ impl Generators {
     let generators = padded_pow_of_2(generators);
     assert!(generators <= self.g_bold1.len());
 
-    Generators {
-      g: self.g,
-      g_bold1: &self.g_bold1[.. generators],
-      h_bold1: &self.h_bold1[.. generators],
-    }
+    Generators { g_bold1: &self.g_bold1[.. generators], h_bold1: &self.h_bold1[.. generators] }
   }
 }
 

coins/monero/src/ringct/bulletproofs/plus/weighted_inner_product.rs

@@ -189,7 +189,7 @@ impl WipStatement {
     self,
     rng: &mut R,
     mut transcript: Scalar,
-    witness: WipWitness,
+    witness: &WipWitness,
   ) -> Option<WipProof> {
     let WipStatement { generators, P, mut y } = self;
     #[cfg(not(debug_assertions))]
@@ -198,7 +198,7 @@ impl WipStatement {
     if generators.len() != witness.a.len() {
       return None;
     }
-    let (g, h) = (generators.g(), generators.h());
+    let (g, h) = (Generators::g(), Generators::h());
     let mut g_bold = vec![];
     let mut h_bold = vec![];
     for i in 0 .. generators.len() {
@@ -345,7 +345,7 @@ impl WipStatement {
   ) -> bool {
     let WipStatement { generators, P, y } = self;
 
-    let (g, h) = (generators.g(), generators.h());
+    let (g, h) = (Generators::g(), Generators::h());
 
     // Verify the L/R lengths
     {

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

@@ -96,7 +96,7 @@ fn core(
   msg: &[u8; 32],
   D: &EdwardsPoint,
   s: &[Scalar],
-  A_c1: Mode,
+  A_c1: &Mode,
 ) -> ((EdwardsPoint, Scalar, Scalar), Scalar) {
   let n = ring.len();
 
@@ -164,7 +164,7 @@ fn core(
     Mode::Verify(c1) => {
       start = 0;
       end = n;
-      c = c1;
+      c = *c1;
     }
   }
 
@@ -226,7 +226,7 @@ impl Clsag {
       s.push(random_scalar(rng));
     }
     let ((D, p, c), c1) =
-      core(&input.decoys.ring, I, &pseudo_out, msg, &D, &s, Mode::Sign(r, A, AH));
+      core(&input.decoys.ring, I, &pseudo_out, msg, &D, &s, &Mode::Sign(r, A, AH));
 
     (Clsag { D, s, c1 }, pseudo_out, p, c * z)
   }
@@ -301,7 +301,7 @@ impl Clsag {
       Err(ClsagError::InvalidD)?;
     }
 
-    let (_, c1) = core(ring, I, pseudo_out, msg, &D, &self.s, Mode::Verify(self.c1));
+    let (_, c1) = core(ring, I, pseudo_out, msg, &D, &self.s, &Mode::Verify(self.c1));
     if c1 != self.c1 {
       Err(ClsagError::InvalidC1)?;
     }

coins/monero/src/ringct/mod.rs

@@ -104,13 +104,11 @@ impl RctType {
 
   pub fn compact_encrypted_amounts(&self) -> bool {
     match self {
-      RctType::Null => false,
-      RctType::MlsagAggregate => false,
-      RctType::MlsagIndividual => false,
+      RctType::Null |
+      RctType::MlsagAggregate |
+      RctType::MlsagIndividual |
       RctType::Bulletproofs => false,
-      RctType::BulletproofsCompactAmount => true,
-      RctType::Clsag => true,
-      RctType::BulletproofsPlus => true,
+      RctType::BulletproofsCompactAmount | RctType::Clsag | RctType::BulletproofsPlus => true,
     }
   }
 }
@@ -151,9 +149,7 @@ impl RctBase {
       RctType::from_byte(read_byte(r)?).ok_or_else(|| io::Error::other("invalid RCT type"))?;
 
     match rct_type {
-      RctType::Null => {}
-      RctType::MlsagAggregate => {}
-      RctType::MlsagIndividual => {}
+      RctType::Null | RctType::MlsagAggregate | RctType::MlsagIndividual => {}
       RctType::Bulletproofs |
       RctType::BulletproofsCompactAmount |
       RctType::Clsag |
@@ -325,7 +321,7 @@ impl RctPrunable {
       RctPrunable::MlsagBorromean { borromean, .. } => {
         borromean.iter().try_for_each(|rs| rs.write(w))
       }
-      RctPrunable::MlsagBulletproofs { bulletproofs, .. } => bulletproofs.signature_write(w),
+      RctPrunable::MlsagBulletproofs { bulletproofs, .. } |
       RctPrunable::Clsag { bulletproofs, .. } => bulletproofs.signature_write(w),
     }
   }
@@ -386,8 +382,8 @@ impl RctSignatures {
     serialized
   }
 
-  pub fn read<R: Read>(decoys: Vec<usize>, outputs: usize, r: &mut R) -> io::Result<RctSignatures> {
+  pub fn read<R: Read>(decoys: &[usize], outputs: usize, r: &mut R) -> io::Result<RctSignatures> {
     let base = RctBase::read(decoys.len(), outputs, r)?;
-    Ok(RctSignatures { base: base.0, prunable: RctPrunable::read(base.1, &decoys, outputs, r)? })
+    Ok(RctSignatures { base: base.0, prunable: RctPrunable::read(base.1, decoys, outputs, r)? })
   }
 }