Correct clippy warnings

Currently intended to be done with:
cargo clippy --features "recommended merlin batch serialize experimental 
ed25519 ristretto p256 secp256k1 multisig" -- -A clippy::type_complexity 
-A dead_code

coins/monero/src/wallet/send/mod.rs

@@ -35,7 +35,7 @@ mod multisig;
 pub use multisig::TransactionMachine;
 
 #[allow(non_snake_case)]
-#[derive(Clone, PartialEq, Debug)]
+#[derive(Clone, PartialEq, Eq, Debug)]
 struct SendOutput {
   R: EdwardsPoint,
   dest: EdwardsPoint,
@@ -61,7 +61,7 @@ impl SendOutput {
         AddressType::Integrated(_) => {
           unimplemented!("SendOutput::new doesn't support Integrated addresses")
         }
-        AddressType::Subaddress => &r * spend,
+        AddressType::Subaddress => r * spend,
       },
       dest: ((&shared_key * &ED25519_BASEPOINT_TABLE) + spend),
       commitment: Commitment::new(commitment_mask(shared_key), output.1),
@@ -113,18 +113,17 @@ async fn prepare_inputs<R: RngCore + CryptoRng>(
   let decoys = Decoys::select(
     rng,
     rpc,
-    rpc.get_height().await.map_err(|e| TransactionError::RpcError(e))? - 10,
+    rpc.get_height().await.map_err(TransactionError::RpcError)? - 10,
     inputs,
   )
   .await
-  .map_err(|e| TransactionError::RpcError(e))?;
+  .map_err(TransactionError::RpcError)?;
 
   for (i, input) in inputs.iter().enumerate() {
     signable.push((
       spend + input.key_offset,
       generate_key_image(spend + input.key_offset),
-      ClsagInput::new(input.commitment, decoys[i].clone())
-        .map_err(|e| TransactionError::ClsagError(e))?,
+      ClsagInput::new(input.commitment, decoys[i].clone()).map_err(TransactionError::ClsagError)?,
     ));
 
     tx.prefix.inputs.push(Input::ToKey {
@@ -158,7 +157,7 @@ impl Fee {
   }
 }
 
-#[derive(Clone, PartialEq, Debug)]
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub struct SignableTransaction {
   inputs: Vec<SpendableOutput>,
   payments: Vec<(Address, u64)>,
@@ -187,10 +186,10 @@ impl SignableTransaction {
       test(change)?;
     }
 
-    if inputs.len() == 0 {
+    if inputs.is_empty() {
       Err(TransactionError::NoInputs)?;
     }
-    if payments.len() == 0 {
+    if payments.is_empty() {
       Err(TransactionError::NoOutputs)?;
     }
 
@@ -339,8 +338,7 @@ impl SignableTransaction {
       RctPrunable::Null => panic!("Signing for RctPrunable::Null"),
       RctPrunable::Clsag { ref mut clsags, ref mut pseudo_outs, .. } => {
         clsags.append(&mut clsag_pairs.iter().map(|clsag| clsag.0.clone()).collect::<Vec<_>>());
-        pseudo_outs
-          .append(&mut clsag_pairs.iter().map(|clsag| clsag.1.clone()).collect::<Vec<_>>());
+        pseudo_outs.append(&mut clsag_pairs.iter().map(|clsag| clsag.1).collect::<Vec<_>>());
       }
     }
     Ok(tx)

coins/monero/src/wallet/send/multisig.rs

@@ -108,7 +108,7 @@ impl SignableTransaction {
       transcript.append_message(b"input_shared_key", &input.key_offset.to_bytes());
     }
     for payment in &self.payments {
-      transcript.append_message(b"payment_address", &payment.0.to_string().as_bytes());
+      transcript.append_message(b"payment_address", payment.0.to_string().as_bytes());
       transcript.append_message(b"payment_amount", &payment.1.to_le_bytes());
     }
 
@@ -125,11 +125,11 @@ impl SignableTransaction {
       clsags.push(
         AlgorithmMachine::new(
           ClsagMultisig::new(transcript.clone(), input.key, inputs[i].clone())
-            .map_err(|e| TransactionError::MultisigError(e))?,
+            .map_err(TransactionError::MultisigError)?,
           Arc::new(offset),
           &included,
         )
-        .map_err(|e| TransactionError::FrostError(e))?,
+        .map_err(TransactionError::FrostError)?,
       );
     }
 
@@ -147,7 +147,7 @@ impl SignableTransaction {
       &self.inputs,
     )
     .await
-    .map_err(|e| TransactionError::RpcError(e))?;
+    .map_err(TransactionError::RpcError)?;
 
     Ok(TransactionMachine {
       signable: self,
@@ -223,7 +223,7 @@ impl SignMachine<Transaction> for TransactionSignMachine {
     mut commitments: HashMap<u16, Re>,
     msg: &[u8],
   ) -> Result<(TransactionSignatureMachine, Vec<u8>), FrostError> {
-    if msg.len() != 0 {
+    if !msg.is_empty() {
       Err(FrostError::InternalError(
         "message was passed to the TransactionMachine when it generates its own",
       ))?;
@@ -237,7 +237,8 @@ impl SignMachine<Transaction> for TransactionSignMachine {
     let mut commitments = (0 .. self.clsags.len())
       .map(|c| {
         let mut buf = [0; CLSAG_LEN];
-        (&self.included)
+        self
+          .included
           .iter()
           .map(|l| {
             // Add all commitments to the transcript for their entropy
@@ -310,7 +311,7 @@ impl SignMachine<Transaction> for TransactionSignMachine {
 
     // Sort the inputs, as expected
     let mut sorted = Vec::with_capacity(self.clsags.len());
-    while self.clsags.len() != 0 {
+    while !self.clsags.is_empty() {
       sorted.push((
         images.swap_remove(0),
         self.signable.inputs.swap_remove(0),
@@ -324,11 +325,11 @@ impl SignMachine<Transaction> for TransactionSignMachine {
 
     let mut rng = ChaCha12Rng::from_seed(self.transcript.rng_seed(b"pseudo_out_masks"));
     let mut sum_pseudo_outs = Scalar::zero();
-    while sorted.len() != 0 {
+    while !sorted.is_empty() {
       let value = sorted.remove(0);
 
       let mut mask = random_scalar(&mut rng);
-      if sorted.len() == 0 {
+      if sorted.is_empty() {
         mask = output_masks - sum_pseudo_outs;
       } else {
         sum_pseudo_outs += mask;