Provider using new key types

sfw-provider/src/main.rs

@@ -1,6 +1,6 @@
 use crate::provider::ServiceProvider;
 use clap::{App, Arg, ArgMatches, SubCommand};
-use nym_client::identity::mixnet::KeyPair;
+use crypto::identity::{MixnetIdentityKeyPair, MixnetIdentityPrivateKey, MixnetIdentityPublicKey};
 use std::net::ToSocketAddrs;
 use std::path::PathBuf;
 use std::process;
@@ -73,7 +73,7 @@ fn main() {
 fn run(matches: &ArgMatches) {
     println!("{}", banner());
     let config = new_config(matches);
-    let provider = ServiceProvider::new(&config);
+    let provider = ServiceProvider::new(config);
 
     provider.start().unwrap()
 }
@@ -100,7 +100,7 @@ fn new_config(matches: &ArgMatches) -> provider::Config {
         Err(err) => panic!("Invalid client port value provided - {:?}", err),
     };
 
-    let key_pair = KeyPair::new(); // TODO: persist this so keypairs don't change every restart
+    let key_pair = crypto::identity::DummyMixIdentityKeyPair::new(); // TODO: persist this so keypairs don't change every restart
     let store_dir = PathBuf::from(
         matches
             .value_of("storeDir")
@@ -136,9 +136,9 @@ fn new_config(matches: &ArgMatches) -> provider::Config {
     provider::Config {
         mix_socket_address,
         directory_server,
-        public_key: key_pair.public,
+        public_key: key_pair.public_key,
         client_socket_address,
-        secret_key: key_pair.private,
+        secret_key: key_pair.private_key,
         store_dir: PathBuf::from(store_dir),
     }
 }

sfw-provider/src/provider/mod.rs

@@ -1,8 +1,9 @@
 use crate::provider::client_handling::{ClientProcessingData, ClientRequestProcessor};
 use crate::provider::mix_handling::{MixPacketProcessor, MixProcessingData};
 use crate::provider::storage::ClientStorage;
-use curve25519_dalek::montgomery::MontgomeryPoint;
-use curve25519_dalek::scalar::Scalar;
+use crypto::identity::{
+    DummyMixIdentityPrivateKey, DummyMixIdentityPublicKey, MixnetIdentityPublicKey,
+};
 use directory_client::presence::MixProviderClient;
 use futures::io::Error;
 use futures::lock::Mutex as FMutex;
@@ -29,18 +30,11 @@ pub struct Config {
     pub client_socket_address: SocketAddr,
     pub directory_server: String,
     pub mix_socket_address: SocketAddr,
-    pub public_key: MontgomeryPoint,
-    pub secret_key: Scalar,
+    pub public_key: DummyMixIdentityPublicKey,
+    pub secret_key: DummyMixIdentityPrivateKey,
     pub store_dir: PathBuf,
 }
 
-impl Config {
-    pub fn public_key_string(public_key: MontgomeryPoint) -> String {
-        let key_bytes = public_key.to_bytes().to_vec();
-        base64::encode_config(&key_bytes, base64::URL_SAFE)
-    }
-}
-
 #[derive(Debug)]
 pub enum ProviderError {
     TcpListenerBindingError,
@@ -94,7 +88,7 @@ impl ClientLedger {
     fn current_clients(&self) -> Vec<MixProviderClient> {
         self.0
             .iter()
-            .map(|(_, &v)| Config::public_key_string(MontgomeryPoint(v)))
+            .map(|(_, v)| base64::encode_config(v, base64::URL_SAFE))
             .map(|pub_key| MixProviderClient { pub_key })
             .collect()
     }
@@ -109,14 +103,14 @@ pub struct ServiceProvider {
     directory_server: String,
     mix_network_address: SocketAddr,
     client_network_address: SocketAddr,
-    secret_key: Scalar,
-    public_key: MontgomeryPoint,
+    public_key: DummyMixIdentityPublicKey,
+    secret_key: DummyMixIdentityPrivateKey,
     store_dir: PathBuf,
     registered_clients_ledger: ClientLedger,
 }
 
 impl ServiceProvider {
-    pub fn new(config: &Config) -> Self {
+    pub fn new(config: Config) -> Self {
         ServiceProvider {
             mix_network_address: config.mix_socket_address,
             client_network_address: config.client_socket_address,
@@ -238,7 +232,7 @@ impl ServiceProvider {
 
     async fn start_mixnet_listening(
         address: SocketAddr,
-        secret_key: Scalar,
+        secret_key: DummyMixIdentityPrivateKey,
         store_dir: PathBuf,
     ) -> Result<(), ProviderError> {
         let mut listener = tokio::net::TcpListener::bind(address).await?;
@@ -260,7 +254,7 @@ impl ServiceProvider {
         address: SocketAddr,
         store_dir: PathBuf,
         client_ledger: Arc<FMutex<ClientLedger>>,
-        secret_key: Scalar,
+        secret_key: DummyMixIdentityPrivateKey,
     ) -> Result<(), ProviderError> {
         let mut listener = tokio::net::TcpListener::bind(address).await?;
         let processing_data =
@@ -299,7 +293,7 @@ impl ServiceProvider {
         let presence_future = rt.spawn(presence_notifier.run());
         let mix_future = rt.spawn(ServiceProvider::start_mixnet_listening(
             self.mix_network_address,
-            self.secret_key,
+            self.secret_key.clone(),
             self.store_dir.clone(),
         ));
         let client_future = rt.spawn(ServiceProvider::start_client_listening(