Update publish-nym-binaries.yml

.github/workflows/publish-nym-binaries.yml

@@ -30,6 +30,7 @@ jobs:
       mixnode_hash: ${{ steps.binary-hashes.outputs.mixnode_hash }}
       gateway_hash: ${{ steps.binary-hashes.outputs.gateway_hash }}
       nymvisor_hash: ${{ steps.binary-hashes.outputs.nymvisor_hash }}
+      nymnode_hash: ${{ steps.binary-hashes.outputs.nymnode_hash }}
       socks5_hash: ${{ steps.binary-hashes.outputs.socks5_hash }}
       netreq_hash: ${{ steps.binary-hashes.outputs.netreq_hash }}
       cli_hash: ${{ steps.binary-hashes.outputs.cli_hash }}
@@ -38,6 +39,7 @@ jobs:
       mixnode_version: ${{ steps.binary-versions.outputs.mixnode_version }}
       gateway_version: ${{ steps.binary-versions.outputs.gateway_version }}
       nymvisor_version: ${{ steps.binary-versions.outputs.nymvisor_version }}
+      nymnode_version: ${{ steps.binary-versions.outputs.nymnode_version }}
       socks5_version: ${{ steps.binary-versions.outputs.socks5_version }}
       netreq_version: ${{ steps.binary-versions.outputs.netreq_version }}
       cli_version: ${{ steps.binary-versions.outputs.cli_version }}
@@ -81,6 +83,7 @@ jobs:
             target/release/nym-network-statistics
             target/release/nym-cli
             target/release/nymvisor
+            target/release/nym-node
           retention-days: 30
 
       - id: create-release
@@ -99,6 +102,7 @@ jobs:
             target/release/nym-network-statistics
             target/release/nym-cli
             target/release/nymvisor
+            target/release/nym-node
 
   push-release-data-client:
     if: ${{ (startsWith(github.ref, 'refs/tags/nym-binaries-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}

CHANGELOG.md

@@ -4,6 +4,20 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 
 ## [Unreleased]
 
+## [2024.3-eclipse] (2024-04-22)
+
+- Initial release of the first iteration of the Nym Node
+- Improvements to gateway functionality
+- IPR development
+- Removal of allow list in favour of implementing an exit policy
+- Explorer delegation: enables direct delegation to nodes via the Nym Explorer
+
+
+## [2024.2-fast-and-furious] (2024-03-25)
+
+- Internal testing pre-release 
+
+
 ## [2024.1-marabou] (2024-02-15)
 
 **New Features:**

Cargo.lock

@@ -2547,7 +2547,7 @@ checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
 
 [[package]]
 name = "explorer-api"
-version = "1.1.33"
+version = "1.1.34"
 dependencies = [
  "chrono",
  "clap 4.4.7",
@@ -3507,7 +3507,7 @@ dependencies = [
  "futures-util",
  "http 0.2.9",
  "hyper 0.14.27",
- "rustls 0.21.10",
+ "rustls 0.21.11",
  "tokio",
  "tokio-rustls 0.24.1",
 ]
@@ -5024,7 +5024,7 @@ dependencies = [
 
 [[package]]
 name = "nym-api"
-version = "1.1.35"
+version = "1.1.37"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -5113,6 +5113,7 @@ dependencies = [
  "schemars",
  "serde",
  "tendermint",
+ "time",
  "ts-rs",
 ]
 
@@ -5185,7 +5186,7 @@ dependencies = [
 
 [[package]]
 name = "nym-cli"
-version = "1.1.34"
+version = "1.1.35"
 dependencies = [
  "anyhow",
  "base64 0.13.1",
@@ -5266,7 +5267,7 @@ dependencies = [
 
 [[package]]
 name = "nym-client"
-version = "1.1.33"
+version = "1.1.34"
 dependencies = [
  "bs58 0.5.0",
  "clap 4.4.7",
@@ -5683,7 +5684,7 @@ dependencies = [
 
 [[package]]
 name = "nym-gateway"
-version = "1.1.33"
+version = "1.1.35"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -5978,7 +5979,7 @@ dependencies = [
 
 [[package]]
 name = "nym-mixnode"
-version = "1.1.35"
+version = "1.1.37"
 dependencies = [
  "anyhow",
  "axum",
@@ -6097,7 +6098,7 @@ dependencies = [
 
 [[package]]
 name = "nym-network-requester"
-version = "1.1.33"
+version = "1.1.34"
 dependencies = [
  "addr",
  "anyhow",
@@ -6149,7 +6150,7 @@ dependencies = [
 
 [[package]]
 name = "nym-network-statistics"
-version = "1.1.33"
+version = "1.1.34"
 dependencies = [
  "dirs 4.0.0",
  "log",
@@ -6437,7 +6438,7 @@ dependencies = [
 
 [[package]]
 name = "nym-socks5-client"
-version = "1.1.33"
+version = "1.1.34"
 dependencies = [
  "bs58 0.5.0",
  "clap 4.4.7",
@@ -8317,7 +8318,7 @@ dependencies = [
  "once_cell",
  "percent-encoding",
  "pin-project-lite 0.2.13",
- "rustls 0.21.10",
+ "rustls 0.21.11",
  "rustls-native-certs",
  "rustls-pemfile",
  "serde",
@@ -8701,9 +8702,9 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.21.10"
+version = "0.21.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9d5a6813c0759e4609cd494e8e725babae6a2ca7b62a5536a13daaec6fcb7ba"
+checksum = "7fecbfb7b1444f477b345853b1fce097a2c6fb637b2bfb87e6bc5db0f043fae4"
 dependencies = [
  "log",
  "ring 0.17.4",
@@ -10100,7 +10101,7 @@ version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
 dependencies = [
- "rustls 0.21.10",
+ "rustls 0.21.11",
  "tokio",
 ]
 
@@ -10161,7 +10162,7 @@ checksum = "212d5dcb2a1ce06d81107c3d0ffa3121fe974b73f068c8282cb1c32328113b6c"
 dependencies = [
  "futures-util",
  "log",
- "rustls 0.21.10",
+ "rustls 0.21.11",
  "rustls-native-certs",
  "tokio",
  "tokio-rustls 0.24.1",
@@ -10595,7 +10596,7 @@ dependencies = [
  "httparse",
  "log",
  "rand 0.8.5",
- "rustls 0.21.10",
+ "rustls 0.21.11",
  "sha1",
  "thiserror",
  "url",

clients/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.33"
+version = "1.1.34"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"

clients/socks5/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.33"
+version = "1.1.34"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 description = "A SOCKS5 localhost proxy that converts incoming messages to Sphinx and sends them to a Nym address"
 edition = "2021"

common/client-core/src/client/mix_traffic/mod.rs

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::client::mix_traffic::transceiver::GatewayTransceiver;
-use crate::error::ClientCoreError;
 use crate::spawn_future;
 use log::*;
 use nym_sphinx::forwarding::packet::MixPacket;
@@ -61,15 +60,8 @@ impl MixTrafficController {
         )
     }
 
-    async fn on_messages(
-        &mut self,
-        mut mix_packets: Vec<MixPacket>,
-    ) -> Result<(), ClientCoreError> {
+    async fn on_messages(&mut self, mut mix_packets: Vec<MixPacket>) {
         debug_assert!(!mix_packets.is_empty());
-        info!(
-            "JON: MixTrafficController: Sending {} sphinx packets to the gateway",
-            mix_packets.len()
-        );
 
         let result = if mix_packets.len() == 1 {
             let mix_packet = mix_packets.pop().unwrap();
@@ -80,56 +72,42 @@ impl MixTrafficController {
                 .await
         };
 
-        let r = match result {
+        match result {
             Err(err) => {
                 error!("Failed to send sphinx packet(s) to the gateway: {err}");
                 self.consecutive_gateway_failure_count += 1;
                 if self.consecutive_gateway_failure_count == MAX_FAILURE_COUNT {
-                    Err(ClientCoreError::GatewayMaxRetriesExceeded)
-                } else {
-                    Err(ClientCoreError::GatewayClientSendError {
-                        gateway_client_error: err.to_string(),
-                    })
+                    // todo: in the future this should initiate a 'graceful' shutdown or try
+                    // to reconnect?
+                    panic!("failed to send sphinx packet to the gateway {MAX_FAILURE_COUNT} times in a row - assuming the gateway is dead. Can't do anything about it yet :(")
                 }
             }
             Ok(_) => {
                 trace!("We *might* have managed to forward sphinx packet(s) to the gateway!");
                 self.consecutive_gateway_failure_count = 0;
-                Ok(())
             }
-        };
-        info!("JON: MixTrafficController: done sending sphinx packets to the gateway");
-        r
+        }
     }
 
     pub fn start_with_shutdown(mut self, mut shutdown: nym_task::TaskClient) {
         spawn_future(async move {
             debug!("Started MixTrafficController with graceful shutdown support");
 
-            // let mut shutdown0 = shutdown.recv_with_delay();
-            // tokio::pin!(shutdown0);
-
             loop {
                 tokio::select! {
-                    biased;
-                    _ = shutdown.recv_with_delay() => {
-                    // _ = &mut shutdown0 => {
-                        log::trace!("MixTrafficController: Received shutdown");
-                        break;
-                    }
                     mix_packets = self.mix_rx.recv() => match mix_packets {
                         Some(mix_packets) => {
-                            log::info!("JON: MixTrafficController: mix_rx recv");
-                            if let Err(err) = self.on_messages(mix_packets).await {
-                                log::error!("MixTrafficController: failed to send mix packets to the gateway: {err}");
-                            }
-                            log::info!("JON: MixTrafficController: done with mix_rx recv");
+                            self.on_messages(mix_packets).await;
                         },
                         None => {
                             log::trace!("MixTrafficController: Stopping since channel closed");
                             break;
                         }
                     },
+                    _ = shutdown.recv_with_delay() => {
+                        log::trace!("MixTrafficController: Received shutdown");
+                        break;
+                    }
                 }
             }
             shutdown.recv_timeout().await;

common/client-core/src/client/mix_traffic/transceiver.rs

@@ -19,12 +19,6 @@ use futures::channel::{mpsc, oneshot};
 #[error(transparent)]
 pub struct ErasedGatewayError(Box<dyn std::error::Error + Send + Sync>);
 
-impl ErasedGatewayError {
-    pub fn downcast<T: std::error::Error + 'static>(&self) -> Option<&T> {
-        self.0.downcast_ref::<T>()
-    }
-}
-
 fn erase_err<E: std::error::Error + Send + Sync + 'static>(err: E) -> ErasedGatewayError {
     ErasedGatewayError(Box::new(err))
 }
@@ -46,7 +40,6 @@ pub trait GatewaySender {
         &mut self,
         packets: Vec<MixPacket>,
     ) -> Result<(), ErasedGatewayError> {
-        log::info!("GatewaySender::batch_send_mix_packets - sending {} packets", packets.len());
         // allow for optimisation when sending multiple packets
         for packet in packets {
             self.send_mix_packet(packet).await?;
@@ -85,10 +78,7 @@ impl<G: GatewayTransceiver + ?Sized + Send> GatewayTransceiver for Box<G> {
 impl<G: GatewaySender + ?Sized + Send> GatewaySender for Box<G> {
     #[inline]
     async fn send_mix_packet(&mut self, packet: MixPacket) -> Result<(), ErasedGatewayError> {
-        log::info!("JON: Box<GatewaySender>::send_mix_packet - sending a packet");
-        let r = (**self).send_mix_packet(packet).await;
-        log::info!("JON: Box<GatewaySender>::send_mix_packet - sent a packet");
-        r
+        (**self).send_mix_packet(packet).await
     }
 
     #[inline]
@@ -96,10 +86,7 @@ impl<G: GatewaySender + ?Sized + Send> GatewaySender for Box<G> {
         &mut self,
         packets: Vec<MixPacket>,
     ) -> Result<(), ErasedGatewayError> {
-        log::info!("JON: Box<GatewaySender>::batch_send_mix_packets - sending {} packets", packets.len());
-        let r = (**self).batch_send_mix_packets(packets).await;
-        log::info!("JON: Box<GatewaySender>::batch_send_mix_packets - sent packets");
-        r
+        (**self).batch_send_mix_packets(packets).await
     }
 }
 
@@ -143,26 +130,20 @@ where
     St: Send,
 {
     async fn send_mix_packet(&mut self, packet: MixPacket) -> Result<(), ErasedGatewayError> {
-        log::info!("JON: RemoteGateway::send_mix_packet - sending a packet");
-        let r = self.gateway_client
+        self.gateway_client
             .send_mix_packet(packet)
             .await
-            .map_err(erase_err);
-        log::info!("JON: RemoteGateway::send_mix_packet - sent a packet");
-        r
+            .map_err(erase_err)
     }
 
     async fn batch_send_mix_packets(
         &mut self,
         packets: Vec<MixPacket>,
     ) -> Result<(), ErasedGatewayError> {
-        log::info!("JON: RemoteGateway::batch_send_mix_packets - sending {} packets", packets.len());
-        let r = self.gateway_client
+        self.gateway_client
             .batch_send_mix_packets(packets)
             .await
-            .map_err(erase_err);
-        log::info!("JON: RemoteGateway::batch_send_mix_packets - sent packets");
-        r
+            .map_err(erase_err)
     }
 }
 
@@ -222,13 +203,10 @@ mod nonwasm_sealed {
     #[async_trait]
     impl GatewaySender for LocalGateway {
         async fn send_mix_packet(&mut self, packet: MixPacket) -> Result<(), ErasedGatewayError> {
-            log::info!("JON: LocalGateway::send_mix_packet - sending a packet");
-            let r = self.packet_forwarder
+            self.packet_forwarder
                 .unbounded_send(packet)
                 .map_err(|err| err.into_send_error())
-                .map_err(erase_err);
-            log::info!("JON: LocalGateway::send_mix_packet - sent a packet");
-            r
+                .map_err(erase_err)
         }
     }
 
@@ -283,7 +261,6 @@ impl GatewayReceiver for MockGateway {
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 impl GatewaySender for MockGateway {
     async fn send_mix_packet(&mut self, packet: MixPacket) -> Result<(), ErasedGatewayError> {
-        log::info!("MockGateway::send_mix_packet - sending a packet");
         self.sent.push(packet);
         Ok(())
     }

common/client-core/src/client/real_messages_control/message_handler.rs

@@ -632,23 +632,15 @@ where
     }
 
     pub(crate) fn update_ack_delay(&self, id: FragmentIdentifier, new_delay: Delay) {
-        if self
-            .action_sender
+        self.action_sender
             .unbounded_send(Action::UpdateDelay(id, new_delay))
-            .is_err()
-        {
-            log::debug!("action control task has died");
-        }
+            .expect("action control task has died")
     }
 
     pub(crate) fn insert_pending_acks(&self, pending_acks: Vec<PendingAcknowledgement>) {
-        if self
-            .action_sender
+        self.action_sender
             .unbounded_send(Action::new_insert(pending_acks))
-            .is_err()
-        {
-            log::debug!("action control task has died");
-        }
+            .expect("action control task has died")
     }
 
     // tells real message sender (with the poisson timer) to send this to the mix network

common/client-core/src/client/real_messages_control/real_traffic_stream.rs

@@ -198,9 +198,7 @@ where
         // queues and client load rather than the required delay. So realistically we can treat
         // whatever is about to happen as negligible additional delay.
         trace!("{} is about to get sent to the mixnet", frag_id);
-        if self.sent_notifier.unbounded_send(frag_id).is_err() {
-            debug!("Failed to notify about sent packet");
-        }
+        self.sent_notifier.unbounded_send(frag_id).unwrap();
     }
 
     fn loop_cover_message_size(&mut self) -> PacketSize {
@@ -272,8 +270,7 @@ where
         };
 
         if let Err(err) = self.mix_tx.send(vec![next_message]).await {
-            log::debug!("Failed to send: {err}");
-            return;
+            log::error!("Failed to send: {err}");
         } else {
             let event = if fragment_id.is_some() {
                 PacketStatisticsEvent::RealPacketSent(packet_size)

common/client-core/src/error.rs

@@ -78,9 +78,6 @@ pub enum ClientCoreError {
         source: tungstenite::Error,
     },
 
-    #[error("max number of retries for gateway connection has been exceeded")]
-    GatewayMaxRetriesExceeded,
-
     #[cfg(target_arch = "wasm32")]
     #[error("failed to establish gateway connection (wasm)")]
     GatewayJsConnectionFailure,
@@ -91,11 +88,6 @@ pub enum ClientCoreError {
     #[error("timed out while trying to establish gateway connection")]
     GatewayConnectionTimeout,
 
-    #[error("failed to send sphinx packet to the gateway: {gateway_client_error}")]
-    GatewayClientSendError {
-        gateway_client_error: String,
-    },
-
     #[error("no ping measurements for the gateway ({identity}) performed")]
     NoGatewayMeasurements { identity: String },
 

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

@@ -333,7 +333,6 @@ impl<C, St> GatewayClient<C, St> {
         &mut self,
         msg: Message,
     ) -> Result<ServerResponse, GatewayClientError> {
-        log::info!("JON: GatewayClient: send_websocket_message");
         let should_restart_mixnet_listener = if self.connection.is_partially_delegated() {
             self.recover_socket_connection().await?;
             true
@@ -352,7 +351,6 @@ impl<C, St> GatewayClient<C, St> {
         if should_restart_mixnet_listener {
             self.start_listening_for_mixnet_messages()?;
         }
-        log::info!("JON: GatewayClient: send_websocket_message done");
         response
     }
 
@@ -360,8 +358,7 @@ impl<C, St> GatewayClient<C, St> {
         &mut self,
         messages: Vec<Message>,
     ) -> Result<(), GatewayClientError> {
-        log::info!("JON: GatewayClient: batch_send_websocket_messages_without_response"); 
-        let r = match self.connection {
+        match self.connection {
             SocketState::Available(ref mut conn) => {
                 let stream_messages: Vec<_> = messages.into_iter().map(Ok).collect();
                 let mut send_stream = futures::stream::iter(stream_messages);
@@ -384,17 +381,14 @@ impl<C, St> GatewayClient<C, St> {
             }
             SocketState::NotConnected => Err(GatewayClientError::ConnectionNotEstablished),
             _ => Err(GatewayClientError::ConnectionInInvalidState),
-        };
-        log::info!("JON: GatewayClient: batch_send_websocket_messages_without_response done");
-        r
+        }
     }
 
     async fn send_websocket_message_without_response(
         &mut self,
         msg: Message,
     ) -> Result<(), GatewayClientError> {
-        log::info!("JON: GatewayClient: send_websocket_message_without_response");
-        let r = match self.connection {
+        match self.connection {
             SocketState::Available(ref mut conn) => Ok(conn.send(msg).await?),
             SocketState::PartiallyDelegated(ref mut partially_delegated) => {
                 if let Err(err) = partially_delegated.send_without_response(msg).await {
@@ -410,9 +404,7 @@ impl<C, St> GatewayClient<C, St> {
             }
             SocketState::NotConnected => Err(GatewayClientError::ConnectionNotEstablished),
             _ => Err(GatewayClientError::ConnectionInInvalidState),
-        };
-        log::info!("JON: GatewayClient: send_websocket_message_without_response done");
-        r
+        }
     }
 
     fn check_gateway_protocol(
@@ -666,7 +658,6 @@ impl<C, St> GatewayClient<C, St> {
         &mut self,
         packets: Vec<MixPacket>,
     ) -> Result<(), GatewayClientError> {
-        info!("JON: GatewayClient: batch_send_mix_packets");
         debug!("Sending {} mix packets", packets.len());
 
         if !self.authenticated {
@@ -693,11 +684,10 @@ impl<C, St> GatewayClient<C, St> {
             })
             .collect();
 
-        let r = if let Err(err) = self
+        if let Err(err) = self
             .batch_send_websocket_messages_without_response(messages)
             .await
         {
-            log::error!("GatewayClient: Failed to send sphinx packets to the gateway: {err}");
             if err.is_closed_connection() && self.should_reconnect_on_failure {
                 self.attempt_reconnection().await
             } else {
@@ -705,17 +695,14 @@ impl<C, St> GatewayClient<C, St> {
             }
         } else {
             Ok(())
-        };
-        log::info!("JON: GatewayClient: batch_send_mix_packets done");
-        r
+        }
     }
 
     async fn send_with_reconnection_on_failure(
         &mut self,
         msg: Message,
     ) -> Result<(), GatewayClientError> {
-        log::info!("JON: GatewayClient: send_with_reconnection_on_failure");
-        let r = if let Err(err) = self.send_websocket_message_without_response(msg).await {
+        if let Err(err) = self.send_websocket_message_without_response(msg).await {
             if err.is_closed_connection() && self.should_reconnect_on_failure {
                 debug!("Going to attempt a reconnection");
                 self.attempt_reconnection().await
@@ -725,9 +712,7 @@ impl<C, St> GatewayClient<C, St> {
             }
         } else {
             Ok(())
-        };
-        log::info!("JON: GatewayClient: send_with_reconnection_on_failure done");
-        r
+        }
     }
 
     pub async fn send_ping_message(&mut self) -> Result<(), GatewayClientError> {
@@ -746,7 +731,6 @@ impl<C, St> GatewayClient<C, St> {
         &mut self,
         mix_packet: MixPacket,
     ) -> Result<(), GatewayClientError> {
-        log::info!("JON: GatewayClient: send_mix_packet");
         if !self.authenticated {
             return Err(GatewayClientError::NotAuthenticated);
         }
@@ -766,9 +750,7 @@ impl<C, St> GatewayClient<C, St> {
                 .as_ref()
                 .expect("no shared key present even though we're authenticated!"),
         );
-        let r = self.send_with_reconnection_on_failure(msg).await;
-        log::info!("JON: GatewayClient: send_mix_packet done");
-        r
+        self.send_with_reconnection_on_failure(msg).await
     }
 
     async fn recover_socket_connection(&mut self) -> Result<(), GatewayClientError> {

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

@@ -74,9 +74,6 @@ pub enum GatewayClientError {
     #[error("Timed out")]
     Timeout,
 
-    #[error("timeout sending ws message to the gateway")]
-    TimeoutOnSendingWs,
-
     #[error("Failed to send mixnet message")]
     MixnetMsgSenderFailedToSend,
 
@@ -96,7 +93,6 @@ pub enum GatewayClientError {
 
 impl GatewayClientError {
     pub fn is_closed_connection(&self) -> bool {
-        log::info!("GatewayClientError::is_closed_connection");
         match self {
             GatewayClientError::NetworkError(ws_err) => match ws_err {
                 WsError::AlreadyClosed | WsError::ConnectionClosed => true,

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

@@ -158,9 +158,6 @@ impl PartiallyDelegated {
                     _ = shutdown.recv() => {
                         log::trace!("GatewayClient listener: Received shutdown");
                         log::debug!("GatewayClient listener: Exiting");
-                        // The packet router a task client, and as such we need to make
-                        // sure it's dropped to not stall the shutdown process.
-                        // drop(packet_router);
                         return;
                     }
                     _ = &mut notify_receiver => {
@@ -217,31 +214,16 @@ impl PartiallyDelegated {
         &mut self,
         msg: Message,
     ) -> Result<(), GatewayClientError> {
-        log::info!("JON: PartiallyDelegated::send_without_response - sending a message");
-        // let r = self.sink_half.send(msg).await;
-        // Ok(r?)
-        let r = tokio::time::timeout(Duration::from_secs(3), self.sink_half.send(msg)).await;
-        let rr = match r {
-            Ok(rr) => Ok(rr?),
-            Err(_) => {
-                log::error!("JON: PartiallyDelegated::send_without_response - timeout sending a message");
-                Err(GatewayClientError::TimeoutOnSendingWs)
-            }
-        };
-        log::info!("JON: PartiallyDelegated::send_without_response - sent a message: {rr:?}");
-        rr
+        Ok(self.sink_half.send(msg).await?)
     }
 
     pub(crate) async fn batch_send_without_response(
         &mut self,
         messages: Vec<Message>,
     ) -> Result<(), GatewayClientError> {
-        log::info!("JON: PartiallyDelegated::batch_send_without_response - sending {} messages", messages.len());
         let stream_messages: Vec<_> = messages.into_iter().map(Ok).collect();
         let mut send_stream = futures::stream::iter(stream_messages);
-        let r = Ok(self.sink_half.send_all(&mut send_stream).await?);
-        log::info!("JON: PartiallyDelegated::batch_send_without_response - sent messages");
-        r
+        Ok(self.sink_half.send_all(&mut send_stream).await?)
     }
 
     pub(crate) async fn merge(self) -> Result<WsConn, GatewayClientError> {

explorer-api/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "explorer-api"
-version = "1.1.33"
+version = "1.1.34"
 edition = "2021"
 license.workspace = true
 

gateway/Cargo.toml

@@ -4,7 +4,7 @@
 [package]
 name = "nym-gateway"
 license = "GPL-3.0"
-version = "1.1.33"
+version = "1.1.35"
 authors = [
     "Dave Hrycyszyn <futurechimp@users.noreply.github.com>",
     "Jędrzej Stuczyński <andrew@nymtech.net>",

mixnode/Cargo.toml

@@ -4,7 +4,7 @@
 [package]
 name = "nym-mixnode"
 license = "GPL-3.0"
-version = "1.1.35"
+version = "1.1.37"
 authors = [
     "Dave Hrycyszyn <futurechimp@users.noreply.github.com>",
     "Jędrzej Stuczyński <andrew@nymtech.net>",

mixnode/src/node/http/legacy/mod.rs

@@ -1,6 +1,8 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: GPL-3.0-only
 
+#![allow(unused)]
+
 use crate::node::http::legacy::description::description;
 use crate::node::http::legacy::hardware::hardware;
 use crate::node::http::legacy::state::MixnodeAppState;

mixnode/src/node/http/mod.rs

@@ -105,7 +105,7 @@ impl<'a> HttpApiBuilder<'a> {
 
         let router = nym_node_http_api::NymNodeRouter::new(config, None, None);
         let server = router
-            .with_merged(legacy::routes(self.legacy_mixnode, self.legacy_descriptor))
+            // .with_merged(legacy::routes(self.legacy_mixnode, self.legacy_descriptor))
             .build_server(&bind_address)?
             .with_task_client(task_client);
         tokio::spawn(async move { server.run().await });

nym-api/Cargo.toml

@@ -4,7 +4,7 @@
 [package]
 name = "nym-api"
 license = "GPL-3.0"
-version = "1.1.35"
+version = "1.1.37"
 authors = [
     "Dave Hrycyszyn <futurechimp@users.noreply.github.com>",
     "Jędrzej Stuczyński <andrew@nymtech.net>",

nym-api/nym-api-requests/Cargo.toml

@@ -15,12 +15,14 @@ schemars = { workspace = true, features = ["preserve_order"] }
 serde = { workspace = true, features = ["derive"] }
 ts-rs = { workspace = true, optional = true }
 tendermint = { workspace = true }
+time = { workspace = true, features = ["serde", "parsing", "formatting"] }
+
 
 # for serde on secp256k1 signatures
 ecdsa = { version = "0.16", features = ["serde"] }
 
 nym-credentials-interface = { path = "../../common/credentials-interface" }
-nym-crypto = { path = "../../common/crypto", features = ["serde", "asymmetric"]}
+nym-crypto = { path = "../../common/crypto", features = ["serde", "asymmetric"] }
 
 nym-mixnet-contract-common = { path = "../../common/cosmwasm-smart-contracts/mixnet-contract" }
 nym-node-requests = { path = "../../nym-node/nym-node-requests", default-features = false }

nym-api/nym-api-requests/src/models.rs

@@ -10,11 +10,15 @@ use nym_mixnet_contract_common::{
     GatewayBond, IdentityKey, Interval, MixId, MixNode, Percent, RewardedSetNodeStatus,
 };
 use nym_node_requests::api::v1::node::models::BinaryBuildInformationOwned;
+use schemars::gen::SchemaGenerator;
+use schemars::schema::{InstanceType, Schema, SchemaObject};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::fmt::{Display, Formatter};
 use std::net::IpAddr;
+use std::ops::{Deref, DerefMut};
 use std::{fmt, time::Duration};
+use time::OffsetDateTime;
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
 pub struct RequestError {
@@ -404,8 +408,71 @@ impl From<nym_node_requests::api::v1::gateway::models::WebSockets> for WebSocket
     }
 }
 
+const fn unix_epoch() -> OffsetDateTime {
+    OffsetDateTime::UNIX_EPOCH
+}
+
+// for all intents and purposes it's just OffsetDateTime, but we need JsonSchema...
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+pub struct OffsetDateTimeJsonSchemaWrapper(#[serde(default = "unix_epoch")] pub OffsetDateTime);
+
+impl Default for OffsetDateTimeJsonSchemaWrapper {
+    fn default() -> Self {
+        OffsetDateTimeJsonSchemaWrapper(unix_epoch())
+    }
+}
+
+impl From<OffsetDateTimeJsonSchemaWrapper> for OffsetDateTime {
+    fn from(value: OffsetDateTimeJsonSchemaWrapper) -> Self {
+        value.0
+    }
+}
+
+impl From<OffsetDateTime> for OffsetDateTimeJsonSchemaWrapper {
+    fn from(value: OffsetDateTime) -> Self {
+        OffsetDateTimeJsonSchemaWrapper(value)
+    }
+}
+
+impl Deref for OffsetDateTimeJsonSchemaWrapper {
+    type Target = OffsetDateTime;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for OffsetDateTimeJsonSchemaWrapper {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+// implementation taken from: https://github.com/GREsau/schemars/pull/207
+impl JsonSchema for OffsetDateTimeJsonSchemaWrapper {
+    fn is_referenceable() -> bool {
+        false
+    }
+
+    fn schema_name() -> String {
+        "DateTime".into()
+    }
+
+    fn json_schema(_: &mut SchemaGenerator) -> Schema {
+        SchemaObject {
+            instance_type: Some(InstanceType::String.into()),
+            format: Some("date-time".into()),
+            ..Default::default()
+        }
+        .into()
+    }
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize, schemars::JsonSchema)]
 pub struct NymNodeDescription {
+    #[serde(default)]
+    pub last_polled: OffsetDateTimeJsonSchemaWrapper,
+
     pub host_information: HostInformation,
 
     // TODO: do we really care about ALL build info or just the version?

nym-api/src/node_describe_cache/mod.rs

@@ -16,6 +16,7 @@ use nym_mixnet_contract_common::Gateway;
 use nym_node_requests::api::client::{NymNodeApiClientError, NymNodeApiClientExt};
 use std::collections::HashMap;
 use thiserror::Error;
+use time::OffsetDateTime;
 
 // type alias for ease of use
 pub type DescribedNodes = HashMap<IdentityKey, NymNodeDescription>;
@@ -182,6 +183,7 @@ async fn get_gateway_description(
 
     let description = NymNodeDescription {
         host_information: host_info.data.into(),
+        last_polled: OffsetDateTime::now_utc().into(),
         build_information: build_info,
         network_requester,
         ip_packet_router,
@@ -211,7 +213,7 @@ impl CacheItemProvider for NodeDescriptionProvider {
         }
 
         // TODO: somehow bypass the 'higher-ranked lifetime error' and remove that redundant clone
-        let websockets = stream::iter(
+        let node_description = stream::iter(
             gateways
                 // .deref()
                 // .clone()
@@ -232,7 +234,7 @@ impl CacheItemProvider for NodeDescriptionProvider {
         .collect::<HashMap<_, _>>()
         .await;
 
-        Ok(websockets)
+        Ok(node_description)
     }
 }
 

nym-wallet/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym_wallet"
-version = "1.2.12"
+version = "1.2.13"
 description = "Nym Native Wallet"
 authors = ["Nym Technologies SA"]
 license = ""

nym-wallet/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "package": {
     "productName": "nym-wallet",
-    "version": "1.2.12"
+    "version": "1.2.13"
   },
   "build": {
     "distDir": "../dist",

service-providers/network-requester/Cargo.toml

@@ -4,7 +4,7 @@
 [package]
 name = "nym-network-requester"
 license = "GPL-3.0"
-version = "1.1.33"
+version = "1.1.34"
 authors.workspace = true
 edition.workspace = true
 rust-version = "1.70"

service-providers/network-statistics/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-network-statistics"
-version = "1.1.33"
+version = "1.1.34"
 edition = "2021"
 license.workspace = true
 

tools/nym-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-cli"
-version = "1.1.34"
+version = "1.1.35"
 authors.workspace = true
 edition = "2021"
 license.workspace = true