Apply an initial set of rustfmt rules

crypto/multiexp/src/batch.rs

@@ -9,15 +9,20 @@ use crate::{multiexp, multiexp_vartime};
 pub struct BatchVerifier<Id: Copy, G: Group>(Vec<(Id, Vec<(G::Scalar, G)>)>);
 
 #[cfg(feature = "batch")]
-impl<Id: Copy, G: Group> BatchVerifier<Id, G> where <G as Group>::Scalar: PrimeFieldBits {
+impl<Id: Copy, G: Group> BatchVerifier<Id, G>
+where
+  <G as Group>::Scalar: PrimeFieldBits,
+{
   pub fn new(capacity: usize) -> BatchVerifier<Id, G> {
     BatchVerifier(Vec::with_capacity(capacity))
   }
 
-  pub fn queue<
-    R: RngCore + CryptoRng,
-    I: IntoIterator<Item = (G::Scalar, G)>
-  >(&mut self, rng: &mut R, id: Id, pairs: I) {
+  pub fn queue<R: RngCore + CryptoRng, I: IntoIterator<Item = (G::Scalar, G)>>(
+    &mut self,
+    rng: &mut R,
+    id: Id,
+    pairs: I,
+  ) {
     // Define a unique scalar factor for this set of variables so individual items can't overlap
     let u = if self.0.len() == 0 {
       G::Scalar::one()
@@ -35,16 +40,16 @@ impl<Id: Copy, G: Group> BatchVerifier<Id, G> where <G as Group>::Scalar: PrimeF
 
   #[must_use]
   pub fn verify(&self) -> bool {
-    multiexp(
-      &self.0.iter().flat_map(|pairs| pairs.1.iter()).cloned().collect::<Vec<_>>()
-    ).is_identity().into()
+    multiexp(&self.0.iter().flat_map(|pairs| pairs.1.iter()).cloned().collect::<Vec<_>>())
+      .is_identity()
+      .into()
   }
 
   #[must_use]
   pub fn verify_vartime(&self) -> bool {
-    multiexp_vartime(
-      &self.0.iter().flat_map(|pairs| pairs.1.iter()).cloned().collect::<Vec<_>>()
-    ).is_identity().into()
+    multiexp_vartime(&self.0.iter().flat_map(|pairs| pairs.1.iter()).cloned().collect::<Vec<_>>())
+      .is_identity()
+      .into()
   }
 
   // A constant time variant may be beneficial for robust protocols
@@ -53,17 +58,21 @@ impl<Id: Copy, G: Group> BatchVerifier<Id, G> where <G as Group>::Scalar: PrimeF
     while slice.len() > 1 {
       let split = slice.len() / 2;
       if multiexp_vartime(
-        &slice[.. split].iter().flat_map(|pairs| pairs.1.iter()).cloned().collect::<Vec<_>>()
-      ).is_identity().into() {
+        &slice[.. split].iter().flat_map(|pairs| pairs.1.iter()).cloned().collect::<Vec<_>>(),
+      )
+      .is_identity()
+      .into()
+      {
         slice = &slice[split ..];
       } else {
         slice = &slice[.. split];
       }
     }
 
-    slice.get(0).filter(
-      |(_, value)| !bool::from(multiexp_vartime(value).is_identity())
-    ).map(|(id, _)| *id)
+    slice
+      .get(0)
+      .filter(|(_, value)| !bool::from(multiexp_vartime(value).is_identity()))
+      .map(|(id, _)| *id)
   }
 
   pub fn verify_with_vartime_blame(&self) -> Result<(), Id> {

crypto/multiexp/src/lib.rs

@@ -15,10 +15,10 @@ pub use batch::BatchVerifier;
 #[cfg(test)]
 mod tests;
 
-pub(crate) fn prep_bits<G: Group>(
-  pairs: &[(G::Scalar, G)],
-  window: u8
-) -> Vec<Vec<u8>> where G::Scalar: PrimeFieldBits {
+pub(crate) fn prep_bits<G: Group>(pairs: &[(G::Scalar, G)], window: u8) -> Vec<Vec<u8>>
+where
+  G::Scalar: PrimeFieldBits,
+{
   let w_usize = usize::from(window);
 
   let mut groupings = vec![];
@@ -37,10 +37,7 @@ pub(crate) fn prep_bits<G: Group>(
   groupings
 }
 
-pub(crate) fn prep_tables<G: Group>(
-  pairs: &[(G::Scalar, G)],
-  window: u8
-) -> Vec<Vec<G>> {
+pub(crate) fn prep_tables<G: Group>(pairs: &[(G::Scalar, G)], window: u8) -> Vec<Vec<G>> {
   let mut tables = Vec::with_capacity(pairs.len());
   for pair in pairs {
     let p = tables.len();
@@ -59,7 +56,7 @@ enum Algorithm {
   Null,
   Single,
   Straus(u8),
-  Pippenger(u8)
+  Pippenger(u8),
 }
 
 /*
@@ -157,20 +154,26 @@ fn algorithm(len: usize) -> Algorithm {
 }
 
 // Performs a multiexp, automatically selecting the optimal algorithm based on amount of pairs
-pub fn multiexp<G: Group>(pairs: &[(G::Scalar, G)]) -> G where G::Scalar: PrimeFieldBits {
+pub fn multiexp<G: Group>(pairs: &[(G::Scalar, G)]) -> G
+where
+  G::Scalar: PrimeFieldBits,
+{
   match algorithm(pairs.len()) {
     Algorithm::Null => Group::identity(),
     Algorithm::Single => pairs[0].1 * pairs[0].0,
     Algorithm::Straus(window) => straus(pairs, window),
-    Algorithm::Pippenger(window) => pippenger(pairs, window)
+    Algorithm::Pippenger(window) => pippenger(pairs, window),
   }
 }
 
-pub fn multiexp_vartime<G: Group>(pairs: &[(G::Scalar, G)]) -> G where G::Scalar: PrimeFieldBits {
+pub fn multiexp_vartime<G: Group>(pairs: &[(G::Scalar, G)]) -> G
+where
+  G::Scalar: PrimeFieldBits,
+{
   match algorithm(pairs.len()) {
     Algorithm::Null => Group::identity(),
     Algorithm::Single => pairs[0].1 * pairs[0].0,
     Algorithm::Straus(window) => straus_vartime(pairs, window),
-    Algorithm::Pippenger(window) => pippenger_vartime(pairs, window)
+    Algorithm::Pippenger(window) => pippenger_vartime(pairs, window),
   }
 }

crypto/multiexp/src/pippenger.rs

@@ -3,10 +3,10 @@ use group::Group;
 
 use crate::prep_bits;
 
-pub(crate) fn pippenger<G: Group>(
-  pairs: &[(G::Scalar, G)],
-  window: u8
-) -> G where G::Scalar: PrimeFieldBits {
+pub(crate) fn pippenger<G: Group>(pairs: &[(G::Scalar, G)], window: u8) -> G
+where
+  G::Scalar: PrimeFieldBits,
+{
   let bits = prep_bits(pairs, window);
 
   let mut res = G::identity();
@@ -30,10 +30,10 @@ pub(crate) fn pippenger<G: Group>(
   res
 }
 
-pub(crate) fn pippenger_vartime<G: Group>(
-  pairs: &[(G::Scalar, G)],
-  window: u8
-) -> G where G::Scalar: PrimeFieldBits {
+pub(crate) fn pippenger_vartime<G: Group>(pairs: &[(G::Scalar, G)], window: u8) -> G
+where
+  G::Scalar: PrimeFieldBits,
+{
   let bits = prep_bits(pairs, window);
 
   let mut res = G::identity();

crypto/multiexp/src/straus.rs

@@ -3,10 +3,10 @@ use group::Group;
 
 use crate::{prep_bits, prep_tables};
 
-pub(crate) fn straus<G: Group>(
-  pairs: &[(G::Scalar, G)],
-  window: u8
-) -> G where G::Scalar: PrimeFieldBits {
+pub(crate) fn straus<G: Group>(pairs: &[(G::Scalar, G)], window: u8) -> G
+where
+  G::Scalar: PrimeFieldBits,
+{
   let groupings = prep_bits(pairs, window);
   let tables = prep_tables(pairs, window);
 
@@ -23,10 +23,10 @@ pub(crate) fn straus<G: Group>(
   res
 }
 
-pub(crate) fn straus_vartime<G: Group>(
-  pairs: &[(G::Scalar, G)],
-  window: u8
-) -> G where G::Scalar: PrimeFieldBits {
+pub(crate) fn straus_vartime<G: Group>(pairs: &[(G::Scalar, G)], window: u8) -> G
+where
+  G::Scalar: PrimeFieldBits,
+{
   let groupings = prep_bits(pairs, window);
   let tables = prep_tables(pairs, window);
 

crypto/multiexp/src/tests/mod.rs

@@ -11,7 +11,10 @@ use dalek_ff_group::EdwardsPoint;
 use crate::{straus, pippenger, multiexp, multiexp_vartime};
 
 #[allow(dead_code)]
-fn benchmark_internal<G: Group>(straus_bool: bool) where G::Scalar: PrimeFieldBits {
+fn benchmark_internal<G: Group>(straus_bool: bool)
+where
+  G::Scalar: PrimeFieldBits,
+{
   let runs: usize = 20;
 
   let mut start = 0;
@@ -64,7 +67,10 @@ fn benchmark_internal<G: Group>(straus_bool: bool) where G::Scalar: PrimeFieldBi
       current += 1;
       println!(
         "{} {} is more efficient at {} with {}µs per",
-        if straus_bool { "Straus" } else { "Pippenger" }, current, pairs.len(), next_per
+        if straus_bool { "Straus" } else { "Pippenger" },
+        current,
+        pairs.len(),
+        next_per
       );
       if current >= 8 {
         return;
@@ -73,7 +79,10 @@ fn benchmark_internal<G: Group>(straus_bool: bool) where G::Scalar: PrimeFieldBi
   }
 }
 
-fn test_multiexp<G: Group>() where G::Scalar: PrimeFieldBits {
+fn test_multiexp<G: Group>()
+where
+  G::Scalar: PrimeFieldBits,
+{
   let mut pairs = Vec::with_capacity(1000);
   let mut sum = G::identity();
   for _ in 0 .. 10 {