Apply an initial set of rustfmt rules

2025-12-09 04:39:24 +00:00 · 2022-07-15 01:26:07 -04:00
parent 0b879a53fa
commit e67033a207
67 changed files with 1983 additions and 1796 deletions
--- a/crypto/frost/src/tests/literal/dalek.rs
+++ b/crypto/frost/src/tests/literal/dalek.rs
@@ -1,6 +1,9 @@
 use rand::rngs::OsRng;

-use crate::{curve, tests::vectors::{Vectors, test_with_vectors}};
+use crate::{
+  curve,
+  tests::vectors::{Vectors, test_with_vectors},
+};

 #[cfg(any(test, feature = "ristretto"))]
 #[test]
@@ -12,7 +15,7 @@ fn ristretto_vectors() {
      shares: &[
        "5c3430d391552f6e60ecdc093ff9f6f4488756aa6cebdbad75a768010b8f830e",
        "b06fc5eac20b4f6e1b271d9df2343d843e1e1fb03c4cbb673f2872d459ce6f01",
-        "f17e505f0e2581c6acfe54d3846a622834b5e7b50cad9a2109a97ba7a80d5c04"
+        "f17e505f0e2581c6acfe54d3846a622834b5e7b50cad9a2109a97ba7a80d5c04",
      ],
      group_secret: "1b25a55e463cfd15cf14a5d3acc3d15053f08da49c8afcf3ab265f2ebc4f970b",
      group_key: "e2a62f39eede11269e3bd5a7d97554f5ca384f9f6d3dd9c3c0d05083c7254f57",
@@ -22,20 +25,20 @@ fn ristretto_vectors() {
      nonces: &[
        [
          "eb0dc12ae7b746d36e3f2de46ce3833a05b9d4af5434eeb8cafaefda76906d00",
-          "491e91aa9df514ef598d5e0c7c5cdd088fbde4965b96069d546c0f04f1822b03"
+          "491e91aa9df514ef598d5e0c7c5cdd088fbde4965b96069d546c0f04f1822b03",
        ],
        [
          "abd12b8e6f255ee1e540eab029003a6e956567617720f61115f0941615892209",
-          "218e22625f93f262f025bd2d13c46ba722aa29fe585ceed66ff442d98fe4e509"
-        ]
+          "218e22625f93f262f025bd2d13c46ba722aa29fe585ceed66ff442d98fe4e509",
+        ],
      ],
      sig_shares: &[
        "efae3a83437fa8cd96194aacc56a7eb841630c280da99e7764a81d1340323306",
-        "96ddc4582e45eabce46f07b9e9375f8b49d35d1510fd34ac02b1e79d6100a602"
+        "96ddc4582e45eabce46f07b9e9375f8b49d35d1510fd34ac02b1e79d6100a602",
      ],
      sig: "7ec584cef9a383afb43883b73bcaa6313afe878bd5fe75a608311b866a76ec67".to_owned() +
-           "858cffdb71c4928a7b895165afa2dd438b366a3d1da6d323675905b1a132d908"
-    }
+        "858cffdb71c4928a7b895165afa2dd438b366a3d1da6d323675905b1a132d908",
+    },
  );
 }

@@ -49,7 +52,7 @@ fn ed25519_vectors() {
      shares: &[
        "929dcc590407aae7d388761cddb0c0db6f5627aea8e217f4a033f2ec83d93509",
        "a91e66e012e4364ac9aaa405fcafd370402d9859f7b6685c07eed76bf409e80d",
-        "d3cb090a075eb154e82fdb4b3cb507f110040905468bb9c46da8bdea643a9a02"
+        "d3cb090a075eb154e82fdb4b3cb507f110040905468bb9c46da8bdea643a9a02",
      ],
      group_secret: "7b1c33d3f5291d85de664833beb1ad469f7fb6025a0ec78b3a790c6e13a98304",
      group_key: "15d21ccd7ee42959562fc8aa63224c8851fb3ec85a3faf66040d380fb9738673",
@@ -59,19 +62,19 @@ fn ed25519_vectors() {
      nonces: &[
        [
          "d9aad97e1a1127bb87702ce8d81d8c07c7cbca89e784868d8e3876ff6b459700",
-          "5063be2774520d08a5ccd7f1213fb1179a5fa292bf13bc91cb28e7bd4d4a690c"
+          "5063be2774520d08a5ccd7f1213fb1179a5fa292bf13bc91cb28e7bd4d4a690c",
        ],
        [
          "86961f3a429ac0c5696f49e6d796817ff653f83c07f34e9e1f4d4c8c515b7900",
-          "72225ec11c1315d9f1ea0e78b1160ed95800fadd0191d23fd2f2c90ac96cb307"
-        ]
+          "72225ec11c1315d9f1ea0e78b1160ed95800fadd0191d23fd2f2c90ac96cb307",
+        ],
      ],
      sig_shares: &[
        "caae171b83bff0c2c6f56a1276892918ba228146f6344b85d2ec6efeb6f16d0d",
-        "ea6fdbf61683cf5f1f742e1b91583f0f667f0369efd2e33399b96d5a3ff0300d"
+        "ea6fdbf61683cf5f1f742e1b91583f0f667f0369efd2e33399b96d5a3ff0300d",
      ],
      sig: "5da10008c13c04dd72328ba8e0f72b63cad43c3bf4b7eaada1c78225afbd977e".to_owned() +
-           "c74afdb47fdfadca0fcda18a28e8891220a284afe5072fb96ba6dc58f6e19e0a"
-    }
+        "c74afdb47fdfadca0fcda18a28e8891220a284afe5072fb96ba6dc58f6e19e0a",
+    },
  );
 }
--- a/crypto/frost/src/tests/literal/kp256.rs
+++ b/crypto/frost/src/tests/literal/kp256.rs
@@ -19,7 +19,7 @@ fn secp256k1_non_ietf() {
      shares: &[
        "08f89ffe80ac94dcb920c26f3f46140bfc7f95b493f8310f5fc1ea2b01f4254c",
        "04f0feac2edcedc6ce1253b7fab8c86b856a797f44d83d82a385554e6e401984",
-        "00e95d59dd0d46b0e303e500b62b7ccb0e555d49f5b849f5e748c071da8c0dbc"
+        "00e95d59dd0d46b0e303e500b62b7ccb0e555d49f5b849f5e748c071da8c0dbc",
      ],
      group_secret: "0d004150d27c3bf2a42f312683d35fac7394b1e9e318249c1bfe7f0795a83114",
      group_key: "02f37c34b66ced1fb51c34a90bdae006901f10625cc06c4f64663b0eae87d87b4f",
@@ -29,20 +29,20 @@ fn secp256k1_non_ietf() {
      nonces: &[
        [
          "31c3c1b76b76664569859b9251fbabed9d4d432c6f5aaa03ed41f9c231935798",
-          "206f4ffaeb602ccb57cbe50e146ac690e6d7317d4b93377061d9d1b4caf78a26"
+          "206f4ffaeb602ccb57cbe50e146ac690e6d7317d4b93377061d9d1b4caf78a26",
        ],
        [
          "0d3945bc1553676a5dd910cb4f14437d99ed421516b2617357b984820fdca520",
-          "635e0fd90caaf40b5e986d0ee0f58778e4d88731bc6ac70350ef702ffe20a21b"
-        ]
+          "635e0fd90caaf40b5e986d0ee0f58778e4d88731bc6ac70350ef702ffe20a21b",
+        ],
      ],
      sig_shares: &[
        "18b71e284c5d008896ed8847b234ec829eda376d6208838ee7faf2ce21b154c1",
-        "a452a49c8116124d0a283f3589a96b704894b43246e47e59d376353bcc638311"
+        "a452a49c8116124d0a283f3589a96b704894b43246e47e59d376353bcc638311",
      ],
      sig: "03dafb28ee7ad033fd15ed470d07156617260d74a9d76a15d371d7b613d2b111e".to_owned() +
-           "7bd09c2c4cd7312d5a115c77d3bde57f2e76eeb9fa8ed01e8bb712809ee14d7d2"
-    }
+        "7bd09c2c4cd7312d5a115c77d3bde57f2e76eeb9fa8ed01e8bb712809ee14d7d2",
+    },
  );
 }

@@ -56,7 +56,7 @@ fn p256_vectors() {
      shares: &[
        "0c9c1a0fe806c184add50bbdcac913dda73e482daf95dcb9f35dbb0d8a9f7731",
        "8d8e787bef0ff6c2f494ca45f4dad198c6bee01212d6c84067159c52e1863ad5",
-        "0e80d6e8f6192c003b5488ce1eec8f5429587d48cf001541e713b2d53c09d928"
+        "0e80d6e8f6192c003b5488ce1eec8f5429587d48cf001541e713b2d53c09d928",
      ],
      group_secret: "8ba9bba2e0fd8c4767154d35a0b7562244a4aaf6f36c8fb8735fa48b301bd8de",
      group_key: "023a309ad94e9fe8a7ba45dfc58f38bf091959d3c99cfbd02b4dc00585ec45ab70",
@@ -66,19 +66,19 @@ fn p256_vectors() {
      nonces: &[
        [
          "33a519cf070a166f9ef41a798d03423743f3e7d0b0efd5d0d963773c4c53205e",
-          "307d208d0c5728f323ae374f1ebd7f14a1a49b77d9d4bc1eab222218a17765ff"
+          "307d208d0c5728f323ae374f1ebd7f14a1a49b77d9d4bc1eab222218a17765ff",
        ],
        [
          "a614eadb972dc37b88aeceb6e899903f3104742d13f379a0e014541decbea4a4",
-          "e509791018504c5bb87edaf0f44761cc840888507c4cd80237971d78e65f70f2"
-        ]
+          "e509791018504c5bb87edaf0f44761cc840888507c4cd80237971d78e65f70f2",
+        ],
      ],
      sig_shares: &[
        "61e8b9c474df2e66ad19fd80a6e6cec1c6fe43c0a1cffd2d1c28299e93e1bbdb",
-        "9651d355ca1dea2557ba1f73e38a9f4ff1f1afc565323ef27f88a9d14df8370e"
+        "9651d355ca1dea2557ba1f73e38a9f4ff1f1afc565323ef27f88a9d14df8370e",
      ],
      sig: "02dfba781e17b830229ae4ed22ebe402873683d9dfd945d01762217fb3172c2a7".to_owned() +
-           "1f83a8d1a3efd188c04d41cf48a716e11b8eff38607023c1f9bb0d36fe1d9f2e9"
-    }
+        "1f83a8d1a3efd188c04d41cf48a716e11b8eff38607023c1f9bb0d36fe1d9f2e9",
+    },
  );
 }
--- a/crypto/frost/src/tests/mod.rs
+++ b/crypto/frost/src/tests/mod.rs
@@ -5,12 +5,10 @@ use rand_core::{RngCore, CryptoRng};
 use group::ff::Field;

 use crate::{
-  Curve,
-  FrostParams, FrostKeys,
-  lagrange,
+  Curve, FrostParams, FrostKeys, lagrange,
  key_gen::KeyGenMachine,
  algorithm::Algorithm,
-  sign::{PreprocessMachine, SignMachine, SignatureMachine, AlgorithmMachine}
+  sign::{PreprocessMachine, SignMachine, SignatureMachine, AlgorithmMachine},
 };

 // Test suites for public usage
@@ -27,22 +25,20 @@ pub const THRESHOLD: u16 = ((PARTICIPANTS / 3) * 2) + 1;

 pub fn clone_without<K: Clone + std::cmp::Eq + std::hash::Hash, V: Clone>(
  map: &HashMap<K, V>,
-  without: &K
+  without: &K,
 ) -> HashMap<K, V> {
  let mut res = map.clone();
  res.remove(without).unwrap();
  res
 }

-pub fn key_gen<R: RngCore + CryptoRng, C: Curve>(
-  rng: &mut R
-) -> HashMap<u16, Arc<FrostKeys<C>>> {
+pub fn key_gen<R: RngCore + CryptoRng, C: Curve>(rng: &mut R) -> HashMap<u16, Arc<FrostKeys<C>>> {
  let mut machines = HashMap::new();
  let mut commitments = HashMap::new();
  for i in 1 ..= PARTICIPANTS {
    let machine = KeyGenMachine::<C>::new(
      FrostParams::new(THRESHOLD, PARTICIPANTS, i).unwrap(),
-      "FROST Test key_gen".to_string()
+      "FROST Test key_gen".to_string(),
    );
    let (machine, these_commitments) = machine.generate_coefficients(rng);
    machines.insert(i, machine);
@@ -50,41 +46,45 @@ pub fn key_gen<R: RngCore + CryptoRng, C: Curve>(
  }

  let mut secret_shares = HashMap::new();
-  let mut machines = machines.drain().map(|(l, machine)| {
-    let (machine, shares) = machine.generate_secret_shares(
-      rng,
-      clone_without(&commitments, &l)
-    ).unwrap();
-    secret_shares.insert(l, shares);
-    (l, machine)
-  }).collect::<HashMap<_, _>>();
+  let mut machines = machines
+    .drain()
+    .map(|(l, machine)| {
+      let (machine, shares) =
+        machine.generate_secret_shares(rng, clone_without(&commitments, &l)).unwrap();
+      secret_shares.insert(l, shares);
+      (l, machine)
+    })
+    .collect::<HashMap<_, _>>();

  let mut verification_shares = None;
  let mut group_key = None;
-  machines.drain().map(|(i, machine)| {
-    let mut our_secret_shares = HashMap::new();
-    for (l, shares) in &secret_shares {
-      if i == *l {
-        continue;
+  machines
+    .drain()
+    .map(|(i, machine)| {
+      let mut our_secret_shares = HashMap::new();
+      for (l, shares) in &secret_shares {
+        if i == *l {
+          continue;
+        }
+        our_secret_shares.insert(*l, Cursor::new(shares[&i].clone()));
      }
-      our_secret_shares.insert(*l, Cursor::new(shares[&i].clone()));
-    }
-    let these_keys = machine.complete(rng, our_secret_shares).unwrap();
+      let these_keys = machine.complete(rng, our_secret_shares).unwrap();

-    // Verify the verification_shares are agreed upon
-    if verification_shares.is_none() {
-      verification_shares = Some(these_keys.verification_shares());
-    }
-    assert_eq!(verification_shares.as_ref().unwrap(), &these_keys.verification_shares());
+      // Verify the verification_shares are agreed upon
+      if verification_shares.is_none() {
+        verification_shares = Some(these_keys.verification_shares());
+      }
+      assert_eq!(verification_shares.as_ref().unwrap(), &these_keys.verification_shares());

-    // Verify the group keys are agreed upon
-    if group_key.is_none() {
-      group_key = Some(these_keys.group_key());
-    }
-    assert_eq!(group_key.unwrap(), these_keys.group_key());
+      // Verify the group keys are agreed upon
+      if group_key.is_none() {
+        group_key = Some(these_keys.group_key());
+      }
+      assert_eq!(group_key.unwrap(), these_keys.group_key());

-    (i, Arc::new(these_keys))
-  }).collect::<HashMap<_, _>>()
+      (i, Arc::new(these_keys))
+    })
+    .collect::<HashMap<_, _>>()
 }

 pub fn recover<C: Curve>(keys: &HashMap<u16, FrostKeys<C>>) -> C::F {
@@ -92,10 +92,9 @@ pub fn recover<C: Curve>(keys: &HashMap<u16, FrostKeys<C>>) -> C::F {
  assert!(keys.len() >= first.params().t().into(), "not enough keys provided");
  let included = keys.keys().cloned().collect::<Vec<_>>();

-  let group_private = keys.iter().fold(
-    C::F::zero(),
-    |accum, (i, keys)| accum + (keys.secret_share() * lagrange::<C::F>(*i, &included))
-  );
+  let group_private = keys.iter().fold(C::F::zero(), |accum, (i, keys)| {
+    accum + (keys.secret_share() * lagrange::<C::F>(*i, &included))
+  });
  assert_eq!(C::GENERATOR * group_private, first.group_key(), "failed to recover keys");
  group_private
 }
@@ -114,40 +113,45 @@ pub fn algorithm_machines<R: RngCore, C: Curve, A: Algorithm<C>>(
    included.push(n);
  }

-  keys.iter().filter_map(
-    |(i, keys)| if included.contains(&i) {
-      Some((
-        *i,
-        AlgorithmMachine::new(
-          algorithm.clone(),
-          keys.clone(),
-          &included.clone()
-        ).unwrap()
-      ))
-    } else {
-      None
-    }
-  ).collect()
+  keys
+    .iter()
+    .filter_map(|(i, keys)| {
+      if included.contains(&i) {
+        Some((
+          *i,
+          AlgorithmMachine::new(algorithm.clone(), keys.clone(), &included.clone()).unwrap(),
+        ))
+      } else {
+        None
+      }
+    })
+    .collect()
 }

 pub fn sign<R: RngCore + CryptoRng, M: PreprocessMachine>(
  rng: &mut R,
  mut machines: HashMap<u16, M>,
-  msg: &[u8]
+  msg: &[u8],
 ) -> M::Signature {
  let mut commitments = HashMap::new();
-  let mut machines = machines.drain().map(|(i, machine)| {
-    let (machine, preprocess) = machine.preprocess(rng);
-    commitments.insert(i, Cursor::new(preprocess));
-    (i, machine)
-  }).collect::<HashMap<_, _>>();
+  let mut machines = machines
+    .drain()
+    .map(|(i, machine)| {
+      let (machine, preprocess) = machine.preprocess(rng);
+      commitments.insert(i, Cursor::new(preprocess));
+      (i, machine)
+    })
+    .collect::<HashMap<_, _>>();

  let mut shares = HashMap::new();
-  let mut machines = machines.drain().map(|(i, machine)| {
-    let (machine, share) = machine.sign(clone_without(&commitments, &i), msg).unwrap();
-    shares.insert(i, Cursor::new(share));
-    (i, machine)
-  }).collect::<HashMap<_, _>>();
+  let mut machines = machines
+    .drain()
+    .map(|(i, machine)| {
+      let (machine, share) = machine.sign(clone_without(&commitments, &i), msg).unwrap();
+      shares.insert(i, Cursor::new(share));
+      (i, machine)
+    })
+    .collect::<HashMap<_, _>>();

  let mut signature = None;
  for (i, machine) in machines.drain() {
--- a/crypto/frost/src/tests/schnorr.rs
+++ b/crypto/frost/src/tests/schnorr.rs
@@ -5,34 +5,32 @@ use rand_core::{RngCore, CryptoRng};
 use group::{ff::Field, GroupEncoding};

 use crate::{
-  Curve, FrostKeys, schnorr::{self, SchnorrSignature}, algorithm::{Hram, Schnorr},
-  tests::{key_gen, algorithm_machines, sign as sign_test}
+  Curve, FrostKeys,
+  schnorr::{self, SchnorrSignature},
+  algorithm::{Hram, Schnorr},
+  tests::{key_gen, algorithm_machines, sign as sign_test},
 };

 pub(crate) fn core_sign<R: RngCore + CryptoRng, C: Curve>(rng: &mut R) {
  let private_key = C::F::random(&mut *rng);
  let nonce = C::F::random(&mut *rng);
  let challenge = C::F::random(rng); // Doesn't bother to craft an HRAM
-  assert!(
-    schnorr::verify::<C>(
-      C::GENERATOR * private_key,
-      challenge,
-      &schnorr::sign(private_key, nonce, challenge)
-    )
-  );
+  assert!(schnorr::verify::<C>(
+    C::GENERATOR * private_key,
+    challenge,
+    &schnorr::sign(private_key, nonce, challenge)
+  ));
 }

 // The above sign function verifies signing works
 // This verifies invalid signatures don't pass, using zero signatures, which should effectively be
 // random
 pub(crate) fn core_verify<R: RngCore + CryptoRng, C: Curve>(rng: &mut R) {
-  assert!(
-    !schnorr::verify::<C>(
-      C::GENERATOR * C::F::random(&mut *rng),
-      C::F::random(rng),
-      &SchnorrSignature { R: C::GENERATOR * C::F::zero(), s: C::F::zero() }
-    )
-  );
+  assert!(!schnorr::verify::<C>(
+    C::GENERATOR * C::F::random(&mut *rng),
+    C::F::random(rng),
+    &SchnorrSignature { R: C::GENERATOR * C::F::zero(), s: C::F::zero() }
+  ));
 }

 pub(crate) fn core_batch_verify<R: RngCore + CryptoRng, C: Curve>(rng: &mut R) {
@@ -47,9 +45,9 @@ pub(crate) fn core_batch_verify<R: RngCore + CryptoRng, C: Curve>(rng: &mut R) {
  }

  // Batch verify
-  let triplets = (0 .. 5).map(
-    |i| (u16::try_from(i + 1).unwrap(), C::GENERATOR * keys[i], challenges[i], sigs[i])
-  ).collect::<Vec<_>>();
+  let triplets = (0 .. 5)
+    .map(|i| (u16::try_from(i + 1).unwrap(), C::GENERATOR * keys[i], challenges[i], sigs[i]))
+    .collect::<Vec<_>>();
  schnorr::batch_verify(rng, &triplets).unwrap();

  // Shift 1 from s from one to another and verify it fails
@@ -80,7 +78,7 @@ pub(crate) fn core_batch_verify<R: RngCore + CryptoRng, C: Curve>(rng: &mut R) {
 fn sign_core<R: RngCore + CryptoRng, C: Curve>(
  rng: &mut R,
  group_key: C::G,
-  keys: &HashMap<u16, Arc<FrostKeys<C>>>
+  keys: &HashMap<u16, Arc<FrostKeys<C>>>,
 ) {
  const MESSAGE: &'static [u8] = b"Hello, World!";

@@ -91,7 +89,7 @@ fn sign_core<R: RngCore + CryptoRng, C: Curve>(

 #[derive(Clone)]
 pub struct TestHram<C: Curve> {
-  _curve: PhantomData<C>
+  _curve: PhantomData<C>,
 }
 impl<C: Curve> Hram<C> for TestHram<C> {
  #[allow(non_snake_case)]
--- a/crypto/frost/src/tests/vectors.rs
+++ b/crypto/frost/src/tests/vectors.rs
@@ -5,10 +5,11 @@ use rand_core::{RngCore, CryptoRng};
 use group::{ff::PrimeField, GroupEncoding};

 use crate::{
-  curve::Curve, FrostKeys,
+  curve::Curve,
+  FrostKeys,
  algorithm::{Schnorr, Hram},
  sign::{PreprocessPackage, SignMachine, SignatureMachine, AlgorithmMachine},
-  tests::{clone_without, curve::test_curve, schnorr::test_schnorr, recover}
+  tests::{clone_without, curve::test_curve, schnorr::test_schnorr, recover},
 };

 pub struct Vectors {
@@ -21,17 +22,17 @@ pub struct Vectors {
  pub included: &'static [u16],
  pub nonces: &'static [[&'static str; 2]],
  pub sig_shares: &'static [&'static str],
-  pub sig: String
+  pub sig: String,
 }

 // Load these vectors into FrostKeys using a custom serialization it'll deserialize
 fn vectors_to_multisig_keys<C: Curve>(vectors: &Vectors) -> HashMap<u16, FrostKeys<C>> {
-  let shares = vectors.shares.iter().map(
-    |secret| C::read_F(&mut Cursor::new(hex::decode(secret).unwrap())).unwrap()
-  ).collect::<Vec<_>>();
-  let verification_shares = shares.iter().map(
-    |secret| C::GENERATOR * secret
-  ).collect::<Vec<_>>();
+  let shares = vectors
+    .shares
+    .iter()
+    .map(|secret| C::read_F(&mut Cursor::new(hex::decode(secret).unwrap())).unwrap())
+    .collect::<Vec<_>>();
+  let verification_shares = shares.iter().map(|secret| C::GENERATOR * secret).collect::<Vec<_>>();

  let mut keys = HashMap::new();
  for i in 1 ..= u16::try_from(shares.len()).unwrap() {
@@ -59,11 +60,10 @@ fn vectors_to_multisig_keys<C: Curve>(vectors: &Vectors) -> HashMap<u16, FrostKe
  keys
 }

-pub fn test_with_vectors<
-  R: RngCore + CryptoRng,
-  C: Curve,
-  H: Hram<C>
->(rng: &mut R, vectors: Vectors) {
+pub fn test_with_vectors<R: RngCore + CryptoRng, C: Curve, H: Hram<C>>(
+  rng: &mut R,
+  vectors: Vectors,
+) {
  // Do basic tests before trying the vectors
  test_curve::<_, C>(&mut *rng);
  test_schnorr::<_, C>(rng);
@@ -87,54 +87,59 @@ pub fn test_with_vectors<
      AlgorithmMachine::new(
        Schnorr::<C, H>::new(),
        Arc::new(keys[i].clone()),
-        vectors.included.clone()
-      ).unwrap()
+        vectors.included.clone(),
+      )
+      .unwrap(),
    ));
  }

  let mut commitments = HashMap::new();
  let mut c = 0;
-  let mut machines = machines.drain(..).map(|(i, machine)| {
-    let nonces = [
-      C::read_F(&mut Cursor::new(hex::decode(vectors.nonces[c][0]).unwrap())).unwrap(),
-      C::read_F(&mut Cursor::new(hex::decode(vectors.nonces[c][1]).unwrap())).unwrap()
-    ];
-    c += 1;
-    let these_commitments = vec![[C::GENERATOR * nonces[0], C::GENERATOR * nonces[1]]];
-    let machine = machine.unsafe_override_preprocess(
-      PreprocessPackage {
+  let mut machines = machines
+    .drain(..)
+    .map(|(i, machine)| {
+      let nonces = [
+        C::read_F(&mut Cursor::new(hex::decode(vectors.nonces[c][0]).unwrap())).unwrap(),
+        C::read_F(&mut Cursor::new(hex::decode(vectors.nonces[c][1]).unwrap())).unwrap(),
+      ];
+      c += 1;
+      let these_commitments = vec![[C::GENERATOR * nonces[0], C::GENERATOR * nonces[1]]];
+      let machine = machine.unsafe_override_preprocess(PreprocessPackage {
        nonces: vec![nonces],
        commitments: vec![these_commitments.clone()],
-        addendum: vec![]
-      }
-    );
+        addendum: vec![],
+      });

-    commitments.insert(
-      i,
-      Cursor::new(
-        [
-          these_commitments[0][0].to_bytes().as_ref(),
-          these_commitments[0][1].to_bytes().as_ref()
-        ].concat().to_vec()
-      )
-    );
-    (i, machine)
-  }).collect::<Vec<_>>();
+      commitments.insert(
+        i,
+        Cursor::new(
+          [
+            these_commitments[0][0].to_bytes().as_ref(),
+            these_commitments[0][1].to_bytes().as_ref(),
+          ]
+          .concat()
+          .to_vec(),
+        ),
+      );
+      (i, machine)
+    })
+    .collect::<Vec<_>>();

  let mut shares = HashMap::new();
  c = 0;
-  let mut machines = machines.drain(..).map(|(i, machine)| {
-    let (machine, share) = machine.sign(
-      clone_without(&commitments, &i),
-      &hex::decode(vectors.msg).unwrap()
-    ).unwrap();
+  let mut machines = machines
+    .drain(..)
+    .map(|(i, machine)| {
+      let (machine, share) =
+        machine.sign(clone_without(&commitments, &i), &hex::decode(vectors.msg).unwrap()).unwrap();

-    assert_eq!(share, hex::decode(vectors.sig_shares[c]).unwrap());
-    c += 1;
+      assert_eq!(share, hex::decode(vectors.sig_shares[c]).unwrap());
+      c += 1;

-    shares.insert(i, Cursor::new(share));
-    (i, machine)
-  }).collect::<HashMap<_, _>>();
+      shares.insert(i, Cursor::new(share));
+      (i, machine)
+    })
+    .collect::<HashMap<_, _>>();

  for (i, machine) in machines.drain() {
    let sig = machine.complete(clone_without(&shares, &i)).unwrap();