Enforce FROST StateMachine progression via the type system

A comment on the matter was made in 
https://github.com/serai-dex/serai/issues/12. While I do believe the API 
is slightly worse, I appreciate the explicitness.

crypto/frost/src/tests/mod.rs

@@ -8,9 +8,9 @@ use crate::{
   Curve,
   MultisigParams, MultisigKeys,
   lagrange,
-  key_gen,
+  key_gen::KeyGenMachine,
   algorithm::Algorithm,
-  sign::{StateMachine, AlgorithmMachine}
+  sign::{PreprocessMachine, SignMachine, SignatureMachine, AlgorithmMachine}
 };
 
 // Test suites for public usage
@@ -37,49 +37,36 @@ pub fn clone_without<K: Clone + std::cmp::Eq + std::hash::Hash, V: Clone>(
 pub fn key_gen<R: RngCore + CryptoRng, C: Curve>(
   rng: &mut R
 ) -> HashMap<u16, Arc<MultisigKeys<C>>> {
-  let mut params = HashMap::new();
   let mut machines = HashMap::new();
-
   let mut commitments = HashMap::new();
   for i in 1 ..= PARTICIPANTS {
-    params.insert(
-      i,
-      MultisigParams::new(
-        THRESHOLD,
-        PARTICIPANTS,
-        i
-      ).unwrap()
-    );
-    machines.insert(
-      i,
-      key_gen::StateMachine::<C>::new(
-        params[&i],
-        "FROST Test key_gen".to_string()
-      )
-    );
-    commitments.insert(
-      i,
-      machines.get_mut(&i).unwrap().generate_coefficients(rng).unwrap()
+    let machine = KeyGenMachine::<C>::new(
+      MultisigParams::new(THRESHOLD, PARTICIPANTS, i).unwrap(),
+      "FROST Test key_gen".to_string()
     );
+    let (machine, these_commitments) = machine.generate_coefficients(rng);
+    machines.insert(i, machine);
+    commitments.insert(i, these_commitments);
   }
 
   let mut secret_shares = HashMap::new();
-  for (l, machine) in machines.iter_mut() {
-    secret_shares.insert(
-      *l,
+  let mut machines = machines.drain().map(|(l, machine)| {
+    let (machine, shares) = machine.generate_secret_shares(
+      rng,
       // clone_without isn't necessary, as this machine's own data will be inserted without
       // conflict, yet using it ensures the machine's own data is actually inserted as expected
-      machine.generate_secret_shares(rng, clone_without(&commitments, l)).unwrap()
-    );
-  }
+      clone_without(&commitments, &l)
+    ).unwrap();
+    secret_shares.insert(l, shares);
+    (l, machine)
+  }).collect::<HashMap<_, _>>();
 
   let mut verification_shares = None;
   let mut group_key = None;
-  let mut keys = HashMap::new();
-  for (i, machine) in machines.iter_mut() {
+  machines.drain().map(|(i, machine)| {
     let mut our_secret_shares = HashMap::new();
     for (l, shares) in &secret_shares {
-      if i == l {
+      if i == *l {
         continue;
       }
       our_secret_shares.insert(*l, shares[&i].clone());
@@ -98,10 +85,8 @@ pub fn key_gen<R: RngCore + CryptoRng, C: Curve>(
     }
     assert_eq!(group_key.unwrap(), these_keys.group_key());
 
-    keys.insert(*i, Arc::new(these_keys));
-  }
-
-  keys
+    (i, Arc::new(these_keys))
+  }).collect::<HashMap<_, _>>()
 }
 
 pub fn recover<C: Curve>(keys: &HashMap<u16, MultisigKeys<C>>) -> C::F {
@@ -147,27 +132,28 @@ pub fn algorithm_machines<R: RngCore, C: Curve, A: Algorithm<C>>(
   ).collect()
 }
 
-pub fn sign<R: RngCore + CryptoRng, M: StateMachine>(
+pub fn sign<R: RngCore + CryptoRng, M: PreprocessMachine>(
   rng: &mut R,
   mut machines: HashMap<u16, M>,
   msg: &[u8]
 ) -> M::Signature {
   let mut commitments = HashMap::new();
-  for (i, machine) in machines.iter_mut() {
-    commitments.insert(*i, machine.preprocess(rng).unwrap());
-  }
+  let mut machines = machines.drain().map(|(i, machine)| {
+    let (machine, preprocess) = machine.preprocess(rng);
+    commitments.insert(i, preprocess);
+    (i, machine)
+  }).collect::<HashMap<_, _>>();
 
   let mut shares = HashMap::new();
-  for (i, machine) in machines.iter_mut() {
-    shares.insert(
-      *i,
-      machine.sign(clone_without(&commitments, i), msg).unwrap()
-    );
-  }
+  let mut machines = machines.drain().map(|(i, machine)| {
+    let (machine, share) = machine.sign(clone_without(&commitments, &i), msg).unwrap();
+    shares.insert(i, share);
+    (i, machine)
+  }).collect::<HashMap<_, _>>();
 
   let mut signature = None;
-  for (i, machine) in machines.iter_mut() {
-    let sig = machine.complete(clone_without(&shares, i)).unwrap();
+  for (i, machine) in machines.drain() {
+    let sig = machine.complete(clone_without(&shares, &i)).unwrap();
     if signature.is_none() {
       signature = Some(sig.clone());
     }

crypto/frost/src/tests/vectors.rs

@@ -5,7 +5,7 @@ use rand_core::{RngCore, CryptoRng};
 use crate::{
   Curve, MultisigKeys,
   algorithm::{Schnorr, Hram},
-  sign::{PreprocessPackage, StateMachine, AlgorithmMachine},
+  sign::{PreprocessPackage, SignMachine, SignatureMachine, AlgorithmMachine},
   tests::{curve::test_curve, schnorr::test_schnorr, recover}
 };
 
@@ -92,33 +92,40 @@ pub fn test_with_vectors<
 
   let mut commitments = HashMap::new();
   let mut c = 0;
-  for (i, machine) in machines.iter_mut() {
+  let mut machines = machines.drain(..).map(|(i, machine)| {
     let nonces = [
       C::F_from_slice(&hex::decode(vectors.nonces[c][0]).unwrap()).unwrap(),
       C::F_from_slice(&hex::decode(vectors.nonces[c][1]).unwrap()).unwrap()
     ];
+    c += 1;
 
     let mut serialized = C::G_to_bytes(&(C::GENERATOR * nonces[0]));
     serialized.extend(&C::G_to_bytes(&(C::GENERATOR * nonces[1])));
 
-    machine.unsafe_override_preprocess(
+    let (machine, serialized) = machine.unsafe_override_preprocess(
       PreprocessPackage { nonces, serialized: serialized.clone() }
     );
 
-    commitments.insert(*i, serialized);
-    c += 1;
-  }
+    commitments.insert(i, serialized);
+    (i, machine)
+  }).collect::<Vec<_>>();
 
   let mut shares = HashMap::new();
   c = 0;
-  for (i, machine) in machines.iter_mut() {
-    let share = machine.sign(commitments.clone(), &hex::decode(vectors.msg).unwrap()).unwrap();
-    assert_eq!(share, hex::decode(vectors.sig_shares[c]).unwrap());
-    shares.insert(*i, share);
-    c += 1;
-  }
+  let mut machines = machines.drain(..).map(|(i, machine)| {
+    let (machine, share) = machine.sign(
+      commitments.clone(),
+      &hex::decode(vectors.msg).unwrap()
+    ).unwrap();
 
-  for (_, machine) in machines.iter_mut() {
+    assert_eq!(share, hex::decode(vectors.sig_shares[c]).unwrap());
+    c += 1;
+
+    shares.insert(i, share);
+    (i, machine)
+  }).collect::<HashMap<_, _>>();
+
+  for (_, machine) in machines.drain() {
     let sig = machine.complete(shares.clone()).unwrap();
     let mut serialized = C::G_to_bytes(&sig.R);
     serialized.extend(C::F_to_bytes(&sig.s));