Further expand clippy workspace lints

Achieves a notable amount of reduced async and clones.

crypto/frost/src/tests/literal/dalek.rs

@@ -10,7 +10,7 @@ use crate::{
 fn ristretto_vectors() {
   test_with_vectors::<_, curve::Ristretto, curve::IetfRistrettoHram>(
     &mut OsRng,
-    Vectors::from(
+    &Vectors::from(
       serde_json::from_str::<serde_json::Value>(include_str!(
         "vectors/frost-ristretto255-sha512.json"
       ))
@@ -24,7 +24,7 @@ fn ristretto_vectors() {
 fn ed25519_vectors() {
   test_with_vectors::<_, curve::Ed25519, curve::IetfEd25519Hram>(
     &mut OsRng,
-    Vectors::from(
+    &Vectors::from(
       serde_json::from_str::<serde_json::Value>(include_str!("vectors/frost-ed25519-sha512.json"))
         .unwrap(),
     ),

crypto/frost/src/tests/literal/ed448.rs

@@ -57,7 +57,7 @@ fn ed448_8032_vector() {
 fn ed448_vectors() {
   test_with_vectors::<_, Ed448, IetfEd448Hram>(
     &mut OsRng,
-    Vectors::from(
+    &Vectors::from(
       serde_json::from_str::<serde_json::Value>(include_str!("vectors/frost-ed448-shake256.json"))
         .unwrap(),
     ),

crypto/frost/src/tests/literal/kp256.rs

@@ -13,7 +13,7 @@ use crate::curve::{P256, IetfP256Hram};
 fn secp256k1_vectors() {
   test_with_vectors::<_, Secp256k1, IetfSecp256k1Hram>(
     &mut OsRng,
-    Vectors::from(
+    &Vectors::from(
       serde_json::from_str::<serde_json::Value>(include_str!(
         "vectors/frost-secp256k1-sha256.json"
       ))
@@ -27,7 +27,7 @@ fn secp256k1_vectors() {
 fn p256_vectors() {
   test_with_vectors::<_, P256, IetfP256Hram>(
     &mut OsRng,
-    Vectors::from(
+    &Vectors::from(
       serde_json::from_str::<serde_json::Value>(include_str!("vectors/frost-p256-sha256.json"))
         .unwrap(),
     ),

crypto/frost/src/tests/mod.rs

@@ -39,7 +39,7 @@ pub fn clone_without<K: Clone + core::cmp::Eq + core::hash::Hash, V: Clone>(
 /// Spawn algorithm machines for a random selection of signers, each executing the given algorithm.
 pub fn algorithm_machines<R: RngCore, C: Curve, A: Algorithm<C>>(
   rng: &mut R,
-  algorithm: A,
+  algorithm: &A,
   keys: &HashMap<Participant, ThresholdKeys<C>>,
 ) -> HashMap<Participant, AlgorithmMachine<C, A>> {
   let mut included = vec![];
@@ -167,7 +167,7 @@ pub fn sign_without_caching<R: RngCore + CryptoRng, M: PreprocessMachine>(
 /// successfully.
 pub fn sign<R: RngCore + CryptoRng, M: PreprocessMachine>(
   rng: &mut R,
-  params: <M::SignMachine as SignMachine<M::Signature>>::Params,
+  params: &<M::SignMachine as SignMachine<M::Signature>>::Params,
   mut keys: HashMap<Participant, <M::SignMachine as SignMachine<M::Signature>>::Keys>,
   machines: HashMap<Participant, M>,
   msg: &[u8],
@@ -195,12 +195,12 @@ pub fn sign<R: RngCore + CryptoRng, M: PreprocessMachine>(
 /// Test a basic Schnorr signature with the provided keys.
 pub fn test_schnorr_with_keys<R: RngCore + CryptoRng, C: Curve, H: Hram<C>>(
   rng: &mut R,
-  keys: HashMap<Participant, ThresholdKeys<C>>,
+  keys: &HashMap<Participant, ThresholdKeys<C>>,
 ) {
   const MSG: &[u8] = b"Hello, World!";
 
-  let machines = algorithm_machines(&mut *rng, IetfSchnorr::<C, H>::ietf(), &keys);
-  let sig = sign(&mut *rng, IetfSchnorr::<C, H>::ietf(), keys.clone(), machines, MSG);
+  let machines = algorithm_machines(&mut *rng, &IetfSchnorr::<C, H>::ietf(), keys);
+  let sig = sign(&mut *rng, &IetfSchnorr::<C, H>::ietf(), keys.clone(), machines, MSG);
   let group_key = keys[&Participant::new(1).unwrap()].group_key();
   assert!(sig.verify(group_key, H::hram(&sig.R, &group_key, MSG)));
 }
@@ -208,13 +208,13 @@ pub fn test_schnorr_with_keys<R: RngCore + CryptoRng, C: Curve, H: Hram<C>>(
 /// Test a basic Schnorr signature.
 pub fn test_schnorr<R: RngCore + CryptoRng, C: Curve, H: Hram<C>>(rng: &mut R) {
   let keys = key_gen(&mut *rng);
-  test_schnorr_with_keys::<_, _, H>(&mut *rng, keys)
+  test_schnorr_with_keys::<_, _, H>(&mut *rng, &keys)
 }
 
 /// Test a basic Schnorr signature, yet with MuSig.
 pub fn test_musig_schnorr<R: RngCore + CryptoRng, C: Curve, H: Hram<C>>(rng: &mut R) {
   let keys = musig_key_gen(&mut *rng);
-  test_schnorr_with_keys::<_, _, H>(&mut *rng, keys)
+  test_schnorr_with_keys::<_, _, H>(&mut *rng, &keys)
 }
 
 /// Test an offset Schnorr signature.
@@ -231,8 +231,8 @@ pub fn test_offset_schnorr<R: RngCore + CryptoRng, C: Curve, H: Hram<C>>(rng: &m
     assert_eq!(keys.group_key(), offset_key);
   }
 
-  let machines = algorithm_machines(&mut *rng, IetfSchnorr::<C, H>::ietf(), &keys);
-  let sig = sign(&mut *rng, IetfSchnorr::<C, H>::ietf(), keys.clone(), machines, MSG);
+  let machines = algorithm_machines(&mut *rng, &IetfSchnorr::<C, H>::ietf(), &keys);
+  let sig = sign(&mut *rng, &IetfSchnorr::<C, H>::ietf(), keys.clone(), machines, MSG);
   let group_key = keys[&Participant::new(1).unwrap()].group_key();
   assert!(sig.verify(offset_key, H::hram(&sig.R, &group_key, MSG)));
 }
@@ -242,7 +242,7 @@ pub fn test_schnorr_blame<R: RngCore + CryptoRng, C: Curve, H: Hram<C>>(rng: &mu
   const MSG: &[u8] = b"Hello, World!";
 
   let keys = key_gen(&mut *rng);
-  let machines = algorithm_machines(&mut *rng, IetfSchnorr::<C, H>::ietf(), &keys);
+  let machines = algorithm_machines(&mut *rng, &IetfSchnorr::<C, H>::ietf(), &keys);
 
   let (mut machines, shares) = preprocess_and_shares(&mut *rng, machines, |_, _| {}, MSG);
 

crypto/frost/src/tests/nonces.rs

@@ -154,14 +154,14 @@ impl<C: Curve> Algorithm<C> for MultiNonce<C> {
 // 3) Provide algorithms with nonces which match the group nonces
 pub fn test_multi_nonce<R: RngCore + CryptoRng, C: Curve>(rng: &mut R) {
   let keys = key_gen::<R, C>(&mut *rng);
-  let machines = algorithm_machines(&mut *rng, MultiNonce::<C>::new(), &keys);
-  sign(&mut *rng, MultiNonce::<C>::new(), keys.clone(), machines, &[]);
+  let machines = algorithm_machines(&mut *rng, &MultiNonce::<C>::new(), &keys);
+  sign(&mut *rng, &MultiNonce::<C>::new(), keys.clone(), machines, &[]);
 }
 
 /// Test malleating a commitment for a nonce across generators causes the preprocess to error.
 pub fn test_invalid_commitment<R: RngCore + CryptoRng, C: Curve>(rng: &mut R) {
   let keys = key_gen::<R, C>(&mut *rng);
-  let machines = algorithm_machines(&mut *rng, MultiNonce::<C>::new(), &keys);
+  let machines = algorithm_machines(&mut *rng, &MultiNonce::<C>::new(), &keys);
   let (machines, mut preprocesses) = preprocess(&mut *rng, machines, |_, _| {});
 
   // Select a random participant to give an invalid commitment
@@ -193,7 +193,7 @@ pub fn test_invalid_commitment<R: RngCore + CryptoRng, C: Curve>(rng: &mut R) {
 /// Test malleating the DLEq proof for a preprocess causes it to error.
 pub fn test_invalid_dleq_proof<R: RngCore + CryptoRng, C: Curve>(rng: &mut R) {
   let keys = key_gen::<R, C>(&mut *rng);
-  let machines = algorithm_machines(&mut *rng, MultiNonce::<C>::new(), &keys);
+  let machines = algorithm_machines(&mut *rng, &MultiNonce::<C>::new(), &keys);
   let (machines, mut preprocesses) = preprocess(&mut *rng, machines, |_, _| {});
 
   // Select a random participant to give an invalid DLEq proof

crypto/frost/src/tests/vectors.rs

@@ -143,12 +143,12 @@ fn vectors_to_multisig_keys<C: Curve>(vectors: &Vectors) -> HashMap<Participant,
 /// Test a Ciphersuite with its vectors.
 pub fn test_with_vectors<R: RngCore + CryptoRng, C: Curve, H: Hram<C>>(
   rng: &mut R,
-  vectors: Vectors,
+  vectors: &Vectors,
 ) {
   test_ciphersuite::<R, C, H>(rng);
 
   // Test against the vectors
-  let keys = vectors_to_multisig_keys::<C>(&vectors);
+  let keys = vectors_to_multisig_keys::<C>(vectors);
   {
     let group_key =
       <C as Curve>::read_G::<&[u8]>(&mut hex::decode(&vectors.group_key).unwrap().as_ref())