Apply an initial set of rustfmt rules

crypto/dleq/src/tests/cross_group/aos.rs

@@ -6,7 +6,7 @@ use multiexp::BatchVerifier;
 
 use crate::{
   cross_group::aos::{Re, Aos},
-  tests::cross_group::{G0, G1, transcript, generators}
+  tests::cross_group::{G0, G1, transcript, generators},
 };
 
 #[allow(non_snake_case)]
@@ -26,10 +26,8 @@ fn test_aos<const RING_LEN: usize>(default: Re<G0, G1>) {
   #[allow(deprecated)]
   let mut ring = [(G0::identity(), G1::identity()); RING_LEN];
   for i in 0 .. RING_LEN {
-    ring_keys[i] = (
-      <G0 as Group>::Scalar::random(&mut OsRng),
-      <G1 as Group>::Scalar::random(&mut OsRng)
-    );
+    ring_keys[i] =
+      (<G0 as Group>::Scalar::random(&mut OsRng), <G1 as Group>::Scalar::random(&mut OsRng));
     ring[i] = (generators.0.alt * ring_keys[i].0, generators.1.alt * ring_keys[i].1);
   }
 
@@ -41,7 +39,7 @@ fn test_aos<const RING_LEN: usize>(default: Re<G0, G1>) {
       &ring,
       actual,
       ring_keys[actual],
-      default.clone()
+      default.clone(),
     );
 
     let mut batch = (BatchVerifier::new(0), BatchVerifier::new(0));

crypto/dleq/src/tests/cross_group/mod.rs

@@ -13,9 +13,9 @@ use transcript::{Transcript, RecommendedTranscript};
 
 use crate::{
   cross_group::{
-    scalar::mutual_scalar_from_bytes,
-    Generators, ClassicLinearDLEq, EfficientLinearDLEq, ConciseLinearDLEq, CompromiseLinearDLEq
-  }
+    scalar::mutual_scalar_from_bytes, Generators, ClassicLinearDLEq, EfficientLinearDLEq,
+    ConciseLinearDLEq, CompromiseLinearDLEq,
+  },
 };
 
 mod scalar;
@@ -34,16 +34,17 @@ pub(crate) fn generators() -> (Generators<G0>, Generators<G1>) {
     Generators::new(
       ProjectivePoint::GENERATOR,
       ProjectivePoint::from_bytes(
-        &(hex!("0250929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0").into())
-      ).unwrap()
+        &(hex!("0250929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0").into()),
+      )
+      .unwrap(),
     ),
-
     Generators::new(
       EdwardsPoint::generator(),
-      EdwardsPoint::from_bytes(
-        &hex!("8b655970153799af2aeadc9ff1add0ea6c7251d54154cfa92c173a0dd39c1f94")
-      ).unwrap()
-    )
+      EdwardsPoint::from_bytes(&hex!(
+        "8b655970153799af2aeadc9ff1add0ea6c7251d54154cfa92c173a0dd39c1f94"
+      ))
+      .unwrap(),
+    ),
   )
 }
 
@@ -60,7 +61,7 @@ macro_rules! verify_and_deserialize {
       let deserialized = <$type>::deserialize(&mut std::io::Cursor::new(&buf)).unwrap();
       assert_eq!($proof, deserialized);
     }
-  }
+  };
 }
 
 macro_rules! test_dleq {
@@ -110,7 +111,7 @@ macro_rules! test_dleq {
             &mut OsRng,
             &mut transcript(),
             generators,
-            Blake2b512::new().chain_update(seed)
+            Blake2b512::new().chain_update(seed),
           )
         } else {
           let mut key;
@@ -121,14 +122,14 @@ macro_rules! test_dleq {
             res.is_none()
           } {}
           let res = res.unwrap();
-          assert_eq!(key, res.1.0);
+          assert_eq!(key, res.1 .0);
           res
         };
 
         verify_and_deserialize!($type::<G0, G1>, proof, generators, keys);
       }
     }
-  }
+  };
 }
 
 test_dleq!("ClassicLinear", benchmark_classic_linear, test_classic_linear, ClassicLinearDLEq);
@@ -155,12 +156,8 @@ fn test_rejection_sampling() {
 
   assert!(
     // Either would work
-    EfficientLinearDLEq::prove_without_bias(
-      &mut OsRng,
-      &mut transcript(),
-      generators(),
-      pow_2
-    ).is_none()
+    EfficientLinearDLEq::prove_without_bias(&mut OsRng, &mut transcript(), generators(), pow_2)
+      .is_none()
   );
 }
 
@@ -174,12 +171,9 @@ fn test_remainder() {
   assert_eq!(keys.0 + Scalar::one(), Scalar::from(2u64).pow_vartime(&[255]));
   assert_eq!(keys.0, keys.1);
 
-  let (proof, res) = ConciseLinearDLEq::prove_without_bias(
-    &mut OsRng,
-    &mut transcript(),
-    generators,
-    keys.0
-  ).unwrap();
+  let (proof, res) =
+    ConciseLinearDLEq::prove_without_bias(&mut OsRng, &mut transcript(), generators, keys.0)
+      .unwrap();
   assert_eq!(keys, res);
 
   verify_and_deserialize!(

crypto/dleq/src/tests/cross_group/schnorr.rs

@@ -1,28 +1,29 @@
 use rand_core::OsRng;
 
-use group::{ff::{Field, PrimeFieldBits}, prime::PrimeGroup};
+use group::{
+  ff::{Field, PrimeFieldBits},
+  prime::PrimeGroup,
+};
 use multiexp::BatchVerifier;
 
 use transcript::{Transcript, RecommendedTranscript};
 
 use crate::cross_group::schnorr::SchnorrPoK;
 
-fn test_schnorr<G: PrimeGroup>() where G::Scalar: PrimeFieldBits {
+fn test_schnorr<G: PrimeGroup>()
+where
+  G::Scalar: PrimeFieldBits,
+{
   let private = G::Scalar::random(&mut OsRng);
 
   let transcript = RecommendedTranscript::new(b"Schnorr Test");
   let mut batch = BatchVerifier::new(3);
-  SchnorrPoK::prove(
-    &mut OsRng,
-    &mut transcript.clone(),
-    G::generator(),
-    private
-  ).verify(
+  SchnorrPoK::prove(&mut OsRng, &mut transcript.clone(), G::generator(), private).verify(
     &mut OsRng,
     &mut transcript.clone(),
     G::generator(),
     G::generator() * private,
-    &mut batch
+    &mut batch,
   );
   assert!(batch.verify_vartime());
 }

crypto/dleq/src/tests/mod.rs

@@ -20,18 +20,22 @@ fn test_dleq() {
   let generators = [
     ProjectivePoint::GENERATOR,
     ProjectivePoint::from_bytes(
-      &(hex!("0250929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0").into())
-    ).unwrap(),
+      &(hex!("0250929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0").into()),
+    )
+    .unwrap(),
     // Just an increment of the last byte from the previous, where the previous two are valid
     ProjectivePoint::from_bytes(
-      &(hex!("0250929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac4").into())
-    ).unwrap(),
+      &(hex!("0250929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac4").into()),
+    )
+    .unwrap(),
     ProjectivePoint::from_bytes(
-      &(hex!("0250929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803aca").into())
-    ).unwrap(),
+      &(hex!("0250929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803aca").into()),
+    )
+    .unwrap(),
     ProjectivePoint::from_bytes(
-      &(hex!("0250929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803acb").into())
-    ).unwrap()
+      &(hex!("0250929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803acb").into()),
+    )
+    .unwrap(),
   ];
 
   for i in 0 .. 5 {
@@ -48,9 +52,8 @@ fn test_dleq() {
     {
       let mut buf = vec![];
       proof.serialize(&mut buf).unwrap();
-      let deserialized = DLEqProof::<ProjectivePoint>::deserialize(
-        &mut std::io::Cursor::new(&buf)
-      ).unwrap();
+      let deserialized =
+        DLEqProof::<ProjectivePoint>::deserialize(&mut std::io::Cursor::new(&buf)).unwrap();
       assert_eq!(proof, deserialized);
     }
   }