add missed stuff from rebase

Cargo.toml

@@ -148,7 +148,7 @@ members = [
     "sdk/ffi/shared",
     "sdk/rust/nym-sdk",
     "smolmix",
-    "service-providers/authenticator",
+    # "service-providers/authenticator",
     "service-providers/common",
     "service-providers/ip-packet-router",
     "service-providers/network-requester",

nym-gateway-directory/Cargo.toml

@@ -11,10 +11,10 @@ license.workspace = true
 futures.workspace = true
 itertools.workspace = true
 nym-client-core = { path = "../common/client-core" }
-nym-common = { git = "https://github.com/nymtech/nym-vpn-client/", rev = "c7e38aae038748f7d577a8b1ae02931fff97e868" } # nym-vpn-core 1.11.0
+nym-common = { git = "https://github.com/nymtech/nym-vpn-client/", rev = "5ab01ba06057449614dd6a8450d04358c5ec33d1" }
 nym-http-api-client = { path = "../common/http-api-client" }
-nym-offline-monitor = { git = "https://github.com/nymtech/nym-vpn-client/", rev = "c7e38aae038748f7d577a8b1ae02931fff97e868" } # nym-vpn-core 1.11.0
-nym-vpn-api-client = { git = "https://github.com/nymtech/nym-vpn-client/", rev = "c7e38aae038748f7d577a8b1ae02931fff97e868" } # nym-vpn-core 1.11.0
+nym-offline-monitor = { git = "https://github.com/nymtech/nym-vpn-client/", rev = "5ab01ba06057449614dd6a8450d04358c5ec33d1" }
+nym-vpn-api-client = { git = "https://github.com/nymtech/nym-vpn-client/", rev = "5ab01ba06057449614dd6a8450d04358c5ec33d1" }
 nym-sphinx = { path = "../common/nymsphinx" } # replaces the types pulled in from nym-sdk in nym-vpn-client repo
 nym-topology = { path = "../common/topology" } # replaces the types pulled in from nym-sdk in nym-vpn-client repo
 nym-validator-client = { path = "../common/client-libs/validator-client" }

nym-ip-packet-client/Cargo.toml

@@ -16,7 +16,7 @@ workspace = true
 bincode.workspace = true
 bytes.workspace = true
 futures.workspace = true
-nym-gateway-directory = { path = "../nym-gateway-directory" }
+# nym-gateway-directory = { path = "../nym-gateway-directory" }
 nym-ip-packet-requests = { path = "../common/ip-packet-requests" }
 nym-sdk = {path = "../sdk/rust/nym-sdk" }
 thiserror.workspace = true

nym-ip-packet-client/src/lib.rs

@@ -0,0 +1,14 @@
+// Copyright 2023-2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: GPL-3.0-only
+
+mod connect;
+mod error;
+mod helpers;
+mod listener;
+
+pub use connect::IprClientConnect;
+pub use error::Error;
+pub use listener::{IprListener, MixnetMessageOutcome};
+
+// Re-export the currently used version
+pub use nym_ip_packet_requests::v8 as current;

nym-ip-packet-client/src/listener.rs

@@ -0,0 +1,121 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: GPL-3.0-only
+
+use bytes::Bytes;
+use futures::StreamExt;
+use nym_ip_packet_requests::{codec::MultiIpPacketCodec, v8::response::ControlResponse};
+use nym_sdk::mixnet::ReconstructedMessage;
+use tokio_util::codec::FramedRead;
+use tracing::{debug, error, info, warn};
+
+use crate::{
+    current::{
+        request::{ControlRequest, IpPacketRequest, IpPacketRequestData},
+        response::{InfoLevel, IpPacketResponse, IpPacketResponseData},
+    },
+    helpers::check_ipr_message_version,
+};
+
+pub enum MixnetMessageOutcome {
+    IpPackets(Vec<Bytes>),
+    MixnetSelfPing,
+    Disconnect,
+}
+
+pub struct IprListener {}
+
+#[derive(Debug, thiserror::Error)]
+pub enum IprListenerError {
+    #[error(transparent)]
+    IprClientError(#[from] crate::Error),
+}
+
+impl IprListener {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    fn is_mix_ping(&self, request: &IpPacketRequest) -> bool {
+        match request.data {
+            IpPacketRequestData::Control(ref control) => {
+                matches!(**control, ControlRequest::Ping(_))
+            }
+            _ => {
+                debug!("Received unexpected request: {request:?}");
+                false
+            }
+        }
+    }
+
+    pub async fn handle_reconstructed_message(
+        &mut self,
+        message: ReconstructedMessage,
+    ) -> Result<Option<MixnetMessageOutcome>, IprListenerError> {
+        check_ipr_message_version(&message)?;
+
+        match IpPacketResponse::from_reconstructed_message(&message) {
+            Ok(response) => {
+                match response.data {
+                    IpPacketResponseData::Data(data_response) => {
+                        // Un-bundle the mixnet message and send the individual IP packets
+                        // to the tun device
+                        let framed_reader = FramedRead::new(
+                            data_response.ip_packet.as_ref(),
+                            MultiIpPacketCodec::new(),
+                        );
+                        let responses: Vec<Bytes> = framed_reader
+                            .filter_map(|res| async { res.ok().map(|packet| packet.into_bytes()) })
+                            .collect()
+                            .await;
+                        return Ok(Some(MixnetMessageOutcome::IpPackets(responses)));
+                    }
+                    IpPacketResponseData::Control(control_response) => match *control_response {
+                        ControlResponse::Connect(_) => {
+                            info!("Received connect response when already connected - ignoring");
+                        }
+                        ControlResponse::Disconnect(_) => {
+                            info!("Received disconnect response");
+                            return Ok(Some(MixnetMessageOutcome::Disconnect));
+                        }
+                        ControlResponse::UnrequestedDisconnect(_) => {
+                            info!("Received unrequested disconnect response, ignoring for now");
+                        }
+                        ControlResponse::Pong(_) => {
+                            info!("Received pong response, ignoring for now");
+                        }
+                        ControlResponse::Health(_) => {
+                            info!("Received health response, ignoring for now");
+                        }
+                        ControlResponse::Info(info) => {
+                            let msg =
+                                format!("Received info response from the mixnet: {}", info.reply);
+                            match info.level {
+                                InfoLevel::Info => info!("{msg}"),
+                                InfoLevel::Warn => warn!("{msg}"),
+                                InfoLevel::Error => error!("{msg}"),
+                            }
+                        }
+                    },
+                }
+            }
+            Err(err) => {
+                // The exception to when we are not expecting a response, is when we
+                // are sending a ping to ourselves.
+                if let Ok(request) = IpPacketRequest::from_reconstructed_message(&message) {
+                    if self.is_mix_ping(&request) {
+                        return Ok(Some(MixnetMessageOutcome::MixnetSelfPing));
+                    }
+                } else {
+                    warn!("Failed to deserialize reconstructed message: {err}");
+                }
+            }
+        }
+        Ok(None)
+    }
+}
+
+impl Default for IprListener {
+    fn default() -> Self {
+        Self::new()
+    }
+}

sdk/rust/nym-sdk/Cargo.toml

@@ -51,7 +51,7 @@ nym-bin-common = { workspace = true, features = [
 ] }
 
 nym-gateway-directory = { path = "../../../nym-gateway-directory" }
-nym-vpn-api-client = { git = "https://github.com/nymtech/nym-vpn-client/", rev = "c7e38aae038748f7d577a8b1ae02931fff97e868" } # nym-vpn-core 1.11.0
+nym-vpn-api-client = { git = "https://github.com/nymtech/nym-vpn-client/", rev = "5ab01ba06057449614dd6a8450d04358c5ec33d1" }
 
 bytecodec = { workspace = true }
 httpcodec = { workspace = true }