Feature/wasm client compilation fixes (#501)

* Gateway client wasm-specific fixes

* wasm-client adjustments

clients/webassembly/src/client/mod.rs

@@ -67,8 +67,8 @@ impl NymClient {
     pub fn new(validator_server: String) -> Self {
         let mut rng = OsRng;
         // for time being generate new keys each time...
-        let identity = identity::KeyPair::new_with_rng(&mut rng);
-        let encryption_keys = encryption::KeyPair::new_with_rng(&mut rng);
+        let identity = identity::KeyPair::new(&mut rng);
+        let encryption_keys = encryption::KeyPair::new(&mut rng);
         let ack_key = AckKey::new(&mut rng);
 
         Self {
@@ -143,8 +143,9 @@ impl NymClient {
             None => console_log!("Gateway connection established - no callback specified"),
         };
 
+        let rng = rand::rngs::OsRng;
         let message_preparer = MessagePreparer::new(
-            &mut rand::rngs::OsRng,
+            rng,
             client.self_recipient(),
             DEFAULT_AVERAGE_PACKET_DELAY,
             DEFAULT_AVERAGE_ACK_DELAY,

common/client-libs/gateway-client/src/client.rs

@@ -136,15 +136,20 @@ impl GatewayClient {
         self.gateway_identity
     }
 
-    pub async fn close_connection(&mut self) -> Result<(), GatewayClientError> {
-        if self.connection.is_partially_delegated() {
-            self.recover_socket_connection().await?;
-        }
-
+    #[cfg(not(target_arch = "wasm32"))]
+    async fn _close_connection(&mut self) -> Result<(), GatewayClientError> {
         match std::mem::replace(&mut self.connection, SocketState::NotConnected) {
-            #[cfg(not(target_arch = "wasm32"))]
             SocketState::Available(mut socket) => Ok(socket.close(None).await?),
-            #[cfg(target_arch = "wasm32")]
+            SocketState::PartiallyDelegated(_) => {
+                unreachable!("this branch should have never been reached!")
+            }
+            _ => Ok(()), // no need to do anything in those cases
+        }
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    async fn _close_connection(&mut self) -> Result<(), GatewayClientError> {
+        match std::mem::replace(&mut self.connection, SocketState::NotConnected) {
             SocketState::Available(mut socket) => Ok(socket.close(None).await),
             SocketState::PartiallyDelegated(_) => {
                 unreachable!("this branch should have never been reached!")
@@ -153,14 +158,27 @@ impl GatewayClient {
         }
     }
 
+    pub async fn close_connection(&mut self) -> Result<(), GatewayClientError> {
+        if self.connection.is_partially_delegated() {
+            self.recover_socket_connection().await?;
+        }
+
+        self._close_connection().await
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
     pub async fn establish_connection(&mut self) -> Result<(), GatewayClientError> {
-        #[cfg(not(target_arch = "wasm32"))]
         let ws_stream = match connect_async(&self.gateway_address).await {
             Ok((ws_stream, _)) => ws_stream,
             Err(e) => return Err(GatewayClientError::NetworkError(e)),
         };
 
-        #[cfg(target_arch = "wasm32")]
+        self.connection = SocketState::Available(ws_stream);
+        Ok(())
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    pub async fn establish_connection(&mut self) -> Result<(), GatewayClientError> {
         let ws_stream = match JSWebsocket::new(&self.gateway_address) {
             Ok(ws_stream) => ws_stream,
             Err(e) => return Err(GatewayClientError::NetworkErrorWasm(e)),
@@ -183,7 +201,17 @@ impl GatewayClient {
                 info!("managed to reconnect!");
                 return Ok(());
             }
+
+            #[cfg(not(target_arch = "wasm32"))]
             tokio::time::delay_for(self.reconnection_backoff).await;
+
+            #[cfg(target_arch = "wasm32")]
+            if let Err(err) = wasm_timer::Delay::new(self.reconnection_backoff).await {
+                error!(
+                    "the timer has gone away while in reconnection backoff! - {}",
+                    err
+                );
+            }
         }
 
         // final attempt (done separately to be able to return a proper error)