Handle clients with different versions in IPR

common/ip-packet-requests/src/v6/conversion.rs

@@ -0,0 +1,69 @@
+// Copyright 2024 - Nym Technologies SA <[email protected]>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::{v6, v7};
+
+impl From<v7::response::StaticConnectFailureReason> for v6::response::StaticConnectFailureReason {
+    fn from(failure: v7::response::StaticConnectFailureReason) -> Self {
+        match failure {
+            v7::response::StaticConnectFailureReason::RequestedIpAlreadyInUse => {
+                v6::response::StaticConnectFailureReason::RequestedIpAlreadyInUse
+            }
+            v7::response::StaticConnectFailureReason::RequestedNymAddressAlreadyInUse => {
+                v6::response::StaticConnectFailureReason::RequestedNymAddressAlreadyInUse
+            }
+            v7::response::StaticConnectFailureReason::OutOfDateTimestamp => {
+                v6::response::StaticConnectFailureReason::Other("out of date timestamp".to_string())
+            }
+            v7::response::StaticConnectFailureReason::Other(reason) => {
+                v6::response::StaticConnectFailureReason::Other(reason)
+            }
+        }
+    }
+}
+
+impl From<v7::response::DynamicConnectFailureReason> for v6::response::DynamicConnectFailureReason {
+    fn from(failure: v7::response::DynamicConnectFailureReason) -> Self {
+        match failure {
+            v7::response::DynamicConnectFailureReason::RequestedNymAddressAlreadyInUse => {
+                v6::response::DynamicConnectFailureReason::RequestedNymAddressAlreadyInUse
+            }
+            v7::response::DynamicConnectFailureReason::NoAvailableIp => {
+                v6::response::DynamicConnectFailureReason::NoAvailableIp
+            }
+            v7::response::DynamicConnectFailureReason::Other(err) => {
+                v6::response::DynamicConnectFailureReason::Other(err)
+            }
+        }
+    }
+}
+
+impl From<v7::response::InfoResponseReply> for v6::response::InfoResponseReply {
+    fn from(reply: v7::response::InfoResponseReply) -> Self {
+        match reply {
+            v7::response::InfoResponseReply::Generic { msg } => {
+                v6::response::InfoResponseReply::Generic { msg }
+            }
+            v7::response::InfoResponseReply::VersionMismatch {
+                request_version,
+                response_version,
+            } => v6::response::InfoResponseReply::VersionMismatch {
+                request_version,
+                response_version,
+            },
+            v7::response::InfoResponseReply::ExitPolicyFilterCheckFailed { dst } => {
+                v6::response::InfoResponseReply::ExitPolicyFilterCheckFailed { dst }
+            }
+        }
+    }
+}
+
+impl From<v7::response::InfoLevel> for v6::response::InfoLevel {
+    fn from(level: v7::response::InfoLevel) -> Self {
+        match level {
+            v7::response::InfoLevel::Info => v6::response::InfoLevel::Info,
+            v7::response::InfoLevel::Warn => v6::response::InfoLevel::Warn,
+            v7::response::InfoLevel::Error => v6::response::InfoLevel::Error,
+        }
+    }
+}

common/ip-packet-requests/src/v6/mod.rs

@@ -1,3 +1,4 @@
+pub mod conversion;
 pub mod request;
 pub mod response;
 

common/ip-packet-requests/src/v7/request.rs

@@ -198,6 +198,17 @@ impl IpPacketRequestData {
             | IpPacketRequestData::Health(_) => None,
         }
     }
+
+    pub fn signable_request(&self) -> Option<Result<Vec<u8>, SignatureError>> {
+        match self {
+            IpPacketRequestData::StaticConnect(request) => Some(request.request()),
+            IpPacketRequestData::DynamicConnect(request) => Some(request.request()),
+            IpPacketRequestData::Disconnect(request) => Some(request.request()),
+            IpPacketRequestData::Data(_) => None,
+            IpPacketRequestData::Ping(_) => None,
+            IpPacketRequestData::Health(_) => None,
+        }
+    }
 }
 
 // A static connect request is when the client provides the internal IP address it will use on the

sdk/rust/nym-sdk/src/mixnet.rs

@@ -67,6 +67,7 @@ pub use nym_credential_storage::{
     ephemeral_storage::EphemeralStorage as EphemeralCredentialStorage,
     models::StoredIssuedCredential, storage::Storage as CredentialStorage,
 };
+pub use nym_crypto::asymmetric::ed25519;
 pub use nym_network_defaults::NymNetworkDetails;
 pub use nym_socks5_client_core::config::Socks5;
 pub use nym_sphinx::{

service-providers/ip-packet-router/src/connected_client_handler.rs

@@ -2,12 +2,13 @@
 // SPDX-License-Identifier: GPL-3.0-only
 
 use bytes::Bytes;
-use nym_ip_packet_requests::{codec::MultiIpPacketCodec, v6::response::IpPacketResponse};
+use nym_ip_packet_requests::codec::MultiIpPacketCodec;
 use nym_sdk::mixnet::{MixnetMessageSender, Recipient};
 
 use crate::{
     constants::CLIENT_HANDLER_ACTIVITY_TIMEOUT,
     error::{IpPacketRouterError, Result},
+    mixnet_listener::SupportedClientVersion,
     util::create_message::create_input_message,
 };
 
@@ -18,20 +19,37 @@ use crate::{
 // This handler is spawned as a task, and it listens to IP packets passed from the tun_listener,
 // encodes it, and then sends to mixnet.
 pub(crate) struct ConnectedClientHandler {
+    // The address of the client that this handler is connected to
     nym_address: Recipient,
+
+    // The number of hops the packet should take before reaching the client
     mix_hops: Option<u8>,
+
+    // Channel to receive packets from the tun_listener
     forward_from_tun_rx: tokio::sync::mpsc::UnboundedReceiver<Vec<u8>>,
+
+    // Channel to send packets to the mixnet
     mixnet_client_sender: nym_sdk::mixnet::MixnetClientSender,
+
+    // Channel to receive close signal
     close_rx: tokio::sync::oneshot::Receiver<()>,
+
+    // Interval to check for activity timeout
     activity_timeout: tokio::time::Interval,
+
+    // Encoder to bundle multiple packets into a single one
     encoder: MultiIpPacketCodec,
+
+    // The version of the client
+    client_version: SupportedClientVersion,
 }
 
 impl ConnectedClientHandler {
     pub(crate) fn start(
         reply_to: Recipient,
         reply_to_hops: Option<u8>,
         buffer_timeout: std::time::Duration,
+        client_version: SupportedClientVersion,
         mixnet_client_sender: nym_sdk::mixnet::MixnetClientSender,
     ) -> (
         tokio::sync::mpsc::UnboundedSender<Vec<u8>>,
@@ -55,6 +73,7 @@ impl ConnectedClientHandler {
             close_rx,
             activity_timeout,
             encoder,
+            client_version,
         };
 
         let handle = tokio::spawn(async move {
@@ -67,9 +86,18 @@ impl ConnectedClientHandler {
     }
 
     async fn send_packets_to_mixnet(&mut self, packets: Bytes) -> Result<()> {
-        let response_packet = IpPacketResponse::new_ip_packet(packets)
-            .to_bytes()
-            .map_err(|err| IpPacketRouterError::FailedToSerializeResponsePacket { source: err })?;
+        let response_packet = match self.client_version {
+            SupportedClientVersion::V6 => {
+                nym_ip_packet_requests::v6::response::IpPacketResponse::new_ip_packet(packets)
+                    .to_bytes()
+            }
+            SupportedClientVersion::V7 => {
+                nym_ip_packet_requests::v7::response::IpPacketResponse::new_ip_packet(packets)
+                    .to_bytes()
+            }
+        }
+        .map_err(|err| IpPacketRouterError::FailedToSerializeResponsePacket { source: err })?;
+
         let input_message = create_input_message(self.nym_address, response_packet, self.mix_hops);
 
         self.mixnet_client_sender

service-providers/ip-packet-router/src/error.rs

@@ -96,6 +96,9 @@ pub enum IpPacketRouterError {
     FailedToVerifyRequest {
         source: nym_ip_packet_requests::v7::signature::SignatureError,
     },
+
+    #[error("client is connected with an invalid version: {version}")]
+    InvalidConnectedClientVersion { version: u8 },
 }
 
 pub type Result<T> = std::result::Result<T, IpPacketRouterError>;