use PublicKey type throughout the workspace (#495)

Author: conradoplg

Cargo.lock

@@ -11,6 +11,7 @@ use eyre::eyre;
 
 use frost_core::{keys::PublicKeyPackage, Ciphersuite, Identifier};
 use frost_rerandomized::Randomizer;
+use frostd::PublicKey;
 
 use crate::input::read_from_file_or_stdin;
 
@@ -86,7 +87,7 @@ pub struct ProcessedArgs<C: Ciphersuite> {
     pub http: bool,
 
     /// Signers to use in HTTP mode, as a map of public keys to identifiers.
-    pub signers: HashMap<Vec<u8>, Identifier<C>>,
+    pub signers: HashMap<PublicKey, Identifier<C>>,
 
     /// The number of participants.
     pub num_signers: u16,
@@ -116,7 +117,7 @@ pub struct ProcessedArgs<C: Ciphersuite> {
     pub comm_privkey: Option<Vec<u8>>,
 
     /// The coordinator's communication public key for HTTP mode.
-    pub comm_pubkey: Option<Vec<u8>>,
+    pub comm_pubkey: Option<PublicKey>,
 }
 
 impl<C: Ciphersuite + 'static> ProcessedArgs<C> {

coordinator/src/args.rs

@@ -43,7 +43,7 @@ pub enum SessionState<C: Ciphersuite> {
         /// Commitments sent by participants so far, for each message being
         /// signed.
         commitments: HashMap<Identifier<C>, Vec<SigningCommitments<C>>>,
-        pubkeys: HashMap<Vec<u8>, Identifier<C>>,
+        pubkeys: HashMap<PublicKey, Identifier<C>>,
     },
     /// Commitments have been sent by all participants. Coordinator can create
     /// SigningPackage and send to participants. Waiting for participants to
@@ -54,7 +54,7 @@ pub enum SessionState<C: Ciphersuite> {
         /// All commitments sent by participants, for each message being signed.
         commitments: HashMap<Identifier<C>, Vec<SigningCommitments<C>>>,
         /// Pubkey -> Identifier mapping.
-        pubkeys: HashMap<Vec<u8>, Identifier<C>>,
+        pubkeys: HashMap<PublicKey, Identifier<C>>,
         /// Signature shares sent by participants so far, for each message being
         /// signed.
         signature_shares: HashMap<Identifier<C>, Vec<SignatureShare<C>>>,
@@ -74,7 +74,7 @@ impl<C: Ciphersuite> SessionState<C> {
     pub fn new(
         num_messages: usize,
         num_signers: usize,
-        pubkeys: HashMap<Vec<u8>, Identifier<C>>,
+        pubkeys: HashMap<PublicKey, Identifier<C>>,
     ) -> Self {
         let args = SessionStateArgs {
             num_messages,
@@ -113,7 +113,7 @@ impl<C: Ciphersuite> SessionState<C> {
     /// Handle commitments sent by a participant.
     fn handle_commitments(
         &mut self,
-        pubkey: Vec<u8>,
+        pubkey: PublicKey,
         commitments: Vec<SigningCommitments<C>>,
     ) -> Result<(), Box<dyn Error>> {
         if let SessionState::WaitingForCommitments {
@@ -164,7 +164,7 @@ impl<C: Ciphersuite> SessionState<C> {
     ) -> Result<
         (
             Vec<BTreeMap<Identifier<C>, SigningCommitments<C>>>,
-            HashMap<Vec<u8>, Identifier<C>>,
+            HashMap<PublicKey, Identifier<C>>,
         ),
         Box<dyn Error>,
     > {
@@ -197,7 +197,7 @@ impl<C: Ciphersuite> SessionState<C> {
     /// Handle signature share sent by a participant.
     fn handle_signature_share(
         &mut self,
-        pubkey: Vec<u8>,
+        pubkey: PublicKey,
         signature_shares: Vec<SignatureShare<C>>,
     ) -> Result<(), Box<dyn Error>> {
         if let SessionState::WaitingForSignatureShares {
@@ -265,11 +265,11 @@ pub struct HTTPComms<C: Ciphersuite> {
     access_token: Option<String>,
     args: ProcessedArgs<C>,
     state: SessionState<C>,
-    pubkeys: HashMap<Vec<u8>, Identifier<C>>,
+    pubkeys: HashMap<PublicKey, Identifier<C>>,
     // The "send" Noise objects by pubkey of recipients.
-    send_noise: Option<HashMap<Vec<u8>, Noise>>,
+    send_noise: Option<HashMap<PublicKey, Noise>>,
     // The "receive" Noise objects by pubkey of senders.
-    recv_noise: Option<HashMap<Vec<u8>, Noise>>,
+    recv_noise: Option<HashMap<PublicKey, Noise>>,
     _phantom: PhantomData<C>,
 }
 
@@ -295,7 +295,7 @@ impl<C: Ciphersuite> HTTPComms<C> {
     }
 
     // Encrypts a message for a given recipient.
-    fn encrypt(&mut self, recipient: &Vec<u8>, msg: Vec<u8>) -> Result<Vec<u8>, Box<dyn Error>> {
+    fn encrypt(&mut self, recipient: &PublicKey, msg: Vec<u8>) -> Result<Vec<u8>, Box<dyn Error>> {
         let noise_map = self
             .send_noise
             .as_mut()
@@ -390,7 +390,7 @@ impl<C: Ciphersuite + 'static> Comms<C> for HTTPComms<C> {
             .post(format!("{}/create_new_session", self.host_port))
             .bearer_auth(self.access_token.as_ref().expect("was just set"))
             .json(&frostd::CreateNewSessionArgs {
-                pubkeys: self.args.signers.keys().cloned().map(PublicKey).collect(),
+                pubkeys: self.args.signers.keys().cloned().collect(),
                 message_count: 1,
             })
             .send()
@@ -423,7 +423,7 @@ impl<C: Ciphersuite + 'static> Comms<C> for HTTPComms<C> {
             let send_noise = Noise::new(
                 builder
                     .local_private_key(comm_privkey)
-                    .remote_public_key(comm_participant_pubkey)
+                    .remote_public_key(&comm_participant_pubkey.0)
                     .build_initiator()?,
             );
             let builder = snow::Builder::new(
@@ -434,7 +434,7 @@ impl<C: Ciphersuite + 'static> Comms<C> for HTTPComms<C> {
             let recv_noise = Noise::new(
                 builder
                     .local_private_key(comm_privkey)
-                    .remote_public_key(comm_participant_pubkey)
+                    .remote_public_key(&comm_participant_pubkey.0)
                     .build_responder()?,
             );
             send_noise_map.insert(comm_participant_pubkey.clone(), send_noise);
@@ -506,7 +506,7 @@ impl<C: Ciphersuite + 'static> Comms<C> for HTTPComms<C> {
                 )
                 .json(&frostd::SendArgs {
                     session_id: self.session_id.unwrap(),
-                    recipients: vec![frostd::PublicKey(recipient.clone())],
+                    recipients: vec![recipient.clone()],
                     msg,
                 })
                 .send()

coordinator/src/comms/http.rs

@@ -2,6 +2,7 @@ use std::rc::Rc;
 
 use clap::Parser;
 use frost_core::{Ciphersuite, Identifier};
+use frostd::PublicKey;
 
 #[derive(Parser, Debug, Default)]
 #[command(author, version, about, long_about = None)]
@@ -30,15 +31,15 @@ pub struct ProcessedArgs<C: Ciphersuite> {
     pub comm_privkey: Option<Vec<u8>>,
 
     /// The participant's communication public key for HTTP mode.
-    pub comm_pubkey: Option<Vec<u8>>,
+    pub comm_pubkey: Option<PublicKey>,
 
     /// A function that confirms that a public key from the server is trusted by
     /// the user; returns the same public key. For HTTP mode.
     // It is a `Rc<dyn Fn>` to make it easier to use;
     // using `fn()` would preclude using closures and using generics would
     // require a lot of code change for something simple.
     #[allow(clippy::type_complexity)]
-    pub comm_participant_pubkey_getter: Option<Rc<dyn Fn(&Vec<u8>) -> Option<Vec<u8>>>>,
+    pub comm_participant_pubkey_getter: Option<Rc<dyn Fn(&PublicKey) -> Option<PublicKey>>>,
 
     /// The threshold to use for the shares
     pub min_signers: u16,
@@ -48,7 +49,7 @@ pub struct ProcessedArgs<C: Ciphersuite> {
 
     /// The list of pubkeys for the other participants. This is only required
     /// for the first participant who creates the DKG session.
-    pub participants: Vec<Vec<u8>>,
+    pub participants: Vec<PublicKey>,
 
     /// Identifier to use for the participant. Only needed for CLI mode.
     pub identifier: Option<Identifier<C>>,

dkg/src/args.rs

@@ -2,6 +2,7 @@ use eyre::eyre;
 use frost_core::keys::{KeyPackage, PublicKeyPackage};
 use frost_core::{self as frost, Ciphersuite, Identifier};
 
+use frostd::PublicKey;
 use rand::thread_rng;
 use reddsa::frost::redpallas::keys::EvenY;
 use std::collections::HashMap;
@@ -77,7 +78,7 @@ pub async fn cli_for_processed_args<C: Ciphersuite + 'static + MaybeIntoEvenY>(
     (
         KeyPackage<C>,
         PublicKeyPackage<C>,
-        HashMap<Vec<u8>, Identifier<C>>,
+        HashMap<PublicKey, Identifier<C>>,
     ),
     Box<dyn Error>,
 > {

dkg/src/cli.rs

@@ -6,6 +6,7 @@ use frost_core::{
     keys::dkg::{round1, round2},
     Ciphersuite,
 };
+use frostd::PublicKey;
 
 use std::{
     collections::{BTreeMap, HashMap},
@@ -46,5 +47,7 @@ pub trait Comms<C: Ciphersuite> {
     ) -> Result<BTreeMap<Identifier<C>, round2::Package<C>>, Box<dyn Error>>;
 
     /// Return the map of public keys to identifiers for all participants.
-    fn get_pubkey_identifier_map(&self) -> Result<HashMap<Vec<u8>, Identifier<C>>, Box<dyn Error>>;
+    fn get_pubkey_identifier_map(
+        &self,
+    ) -> Result<HashMap<PublicKey, Identifier<C>>, Box<dyn Error>>;
 }

dkg/src/comms.rs

@@ -9,6 +9,7 @@ use frost_core::Ciphersuite;
 use async_trait::async_trait;
 
 use frost::{keys::PublicKeyPackage, Identifier};
+use frostd::PublicKey;
 
 use std::collections::HashMap;
 use std::{
@@ -138,7 +139,9 @@ where
         Ok(received_round2_packages)
     }
 
-    fn get_pubkey_identifier_map(&self) -> Result<HashMap<Vec<u8>, Identifier<C>>, Box<dyn Error>> {
+    fn get_pubkey_identifier_map(
+        &self,
+    ) -> Result<HashMap<PublicKey, Identifier<C>>, Box<dyn Error>> {
         Ok(Default::default())
     }
 }