Create a dedicated crate for the DKG (#141)

* Add dkg crate

* Remove F_len and G_len

They're generally no longer used.

* Replace hash_to_vec with a provided method around associated type H: Digest

Part of trying to minimize this trait so it can be moved elsewhere. Vec, 
which isn't std, may have been a blocker.

* Encrypt secret shares within the FROST library

Reduces requirements on callers in order to be correct.

* Update usage of Zeroize within FROST

* Inline functions in key_gen

There was no reason to have them separated as they were. sign probably 
has the same statement available, yet that isn't the focus right now.

* Add a ciphersuite package which provides hash_to_F

* Set the Ciphersuite version to something valid

* Have ed448 export Scalar/FieldElement/Point at the top level

* Move FROST over to Ciphersuite

* Correct usage of ff in ciphersuite

* Correct documentation handling

* Move Schnorr signatures to their own crate

* Remove unused feature from schnorr

* Fix Schnorr tests

* Split DKG into a separate crate

* Add serialize to Commitments and SecretShare

Helper for buf = vec![]; .write(buf).unwrap(); buf

* Move FROST over to the new dkg crate

* Update Monero lib to latest FROST

* Correct ethereum's usage of features

* Add serialize to GeneratorProof

* Add serialize helper function to FROST

* Rename AddendumSerialize to WriteAddendum

* Update processor

* Slight fix to processor

processor/src/wallet.rs

@@ -6,8 +6,8 @@ use group::GroupEncoding;
 
 use transcript::{Transcript, RecommendedTranscript};
 use frost::{
-  curve::Curve,
-  FrostError, FrostKeys,
+  curve::{Ciphersuite, Curve},
+  FrostError, ThresholdKeys,
   sign::{Writable, PreprocessMachine, SignMachine, SignatureMachine},
 };
 
@@ -17,12 +17,12 @@ use crate::{
 };
 
 pub struct WalletKeys<C: Curve> {
-  keys: FrostKeys<C>,
+  keys: ThresholdKeys<C>,
   creation_block: usize,
 }
 
 impl<C: Curve> WalletKeys<C> {
-  pub fn new(keys: FrostKeys<C>, creation_block: usize) -> WalletKeys<C> {
+  pub fn new(keys: ThresholdKeys<C>, creation_block: usize) -> WalletKeys<C> {
     WalletKeys { keys, creation_block }
   }
 
@@ -34,13 +34,13 @@ impl<C: Curve> WalletKeys<C> {
   // system, there are potentially other benefits to binding this to a specific group key
   // It's no longer possible to influence group key gen to key cancel without breaking the hash
   // function as well, although that degree of influence means key gen is broken already
-  fn bind(&self, chain: &[u8]) -> FrostKeys<C> {
+  fn bind(&self, chain: &[u8]) -> ThresholdKeys<C> {
     const DST: &[u8] = b"Serai Processor Wallet Chain Bind";
     let mut transcript = RecommendedTranscript::new(DST);
     transcript.append_message(b"chain", chain);
     transcript.append_message(b"curve", C::ID);
     transcript.append_message(b"group_key", self.keys.group_key().to_bytes().as_ref());
-    self.keys.offset(C::hash_to_F(DST, &transcript.challenge(b"offset")))
+    self.keys.offset(<C as Ciphersuite>::hash_to_F(DST, &transcript.challenge(b"offset")))
   }
 }
 
@@ -203,8 +203,8 @@ fn select_inputs_outputs<C: Coin>(
 pub struct Wallet<D: CoinDb, C: Coin> {
   db: D,
   coin: C,
-  keys: Vec<(FrostKeys<C::Curve>, Vec<C::Output>)>,
-  pending: Vec<(usize, FrostKeys<C::Curve>)>,
+  keys: Vec<(ThresholdKeys<C::Curve>, Vec<C::Output>)>,
+  pending: Vec<(usize, ThresholdKeys<C::Curve>)>,
 }
 
 impl<D: CoinDb, C: Coin> Wallet<D, C> {
@@ -344,11 +344,7 @@ impl<D: CoinDb, C: Coin> Wallet<D, C> {
 
     let (attempt, commitments) = attempt.preprocess(&mut OsRng);
     let commitments = network
-      .round({
-        let mut buf = vec![];
-        commitments.write(&mut buf).unwrap();
-        buf
-      })
+      .round(commitments.serialize())
       .await
       .map_err(SignError::NetworkError)?
       .drain()
@@ -364,11 +360,7 @@ impl<D: CoinDb, C: Coin> Wallet<D, C> {
 
     let (attempt, share) = attempt.sign(commitments, b"").map_err(SignError::FrostError)?;
     let shares = network
-      .round({
-        let mut buf = vec![];
-        share.write(&mut buf).unwrap();
-        buf
-      })
+      .round(share.serialize())
       .await
       .map_err(SignError::NetworkError)?
       .drain()