Merge remote-tracking branch 'origin/incoming' into base

.github/workflows/build.yml

@@ -9,12 +9,14 @@ on:
       - 'gateway/**'
       - 'integrations/**'
       - 'mixnode/**'
+      - 'sdk/lib/socks5-listener/**'
       - 'sdk/rust/nym-sdk/**'
       - 'service-providers/**'
       - 'nym-api/**'
       - 'nym-outfox/**'
       - 'tools/nym-cli/**'
       - 'tools/ts-rs-cli/**'
+      - 'Cargo.toml'
   pull_request:
     paths:
       - 'clients/**'
@@ -23,12 +25,14 @@ on:
       - 'gateway/**'
       - 'integrations/**'
       - 'mixnode/**'
+      - 'sdk/lib/socks5-listener/**'
       - 'sdk/rust/nym-sdk/**'
       - 'service-providers/**'
       - 'nym-api/**'
       - 'nym-outfox/**'
       - 'tools/nym-cli/**'
       - 'tools/ts-rs-cli/**'
+      - 'Cargo.toml'
 
 jobs:
   build:

.gitignore

@@ -42,4 +42,5 @@ storybook-static
 envs/qwerty.env
 .parcel-cache
 **/.DS_Store
-cpu-cycles/libcpucycles/build
+cpu-cycles/libcpucycles/build
+foxyfox.env

Cargo.toml

@@ -78,6 +78,7 @@ members = [
     "gateway/gateway-requests",
     "integrations/bity",
     "mixnode",
+    "sdk/lib/socks5-listener",
     "sdk/rust/nym-sdk",
     "service-providers/common",
     "service-providers/network-requester",

README.md

@@ -32,7 +32,7 @@ For Typescript components, please see [ts-packages](./ts-packages).
 
 ### Developer chat
 
-You can chat to us in [Keybase](https://keybase.io). Download their chat app, then click **Teams -> Join a team**. Type **nymtech.friends** into the team name and hit **continue**. For general chat, hang out in the **#general** channel. Our development takes places in the **#dev** channel. Node operators should be in the **#node-operators** channel.
+You can chat with us in [Keybase](https://keybase.io). Download their chat app, then click **Teams -> Join a team**. Type **nymtech.friends** into the team name and hit **continue**. For general chat, hang out in the **#general** channel. Our development takes place in the **#dev** channel. Node operators should be in the **#node-operators** channel.
 
 ### Rewards
 
@@ -46,7 +46,7 @@ Node, node operator and delegator rewards are determined according to the princi
 |<img src="https://render.githubusercontent.com/render/math?math=\lambda_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}\lambda_{i}#gh-dark-mode-only">|ratio of stake operator has pledged to their node to the token circulating supply.
 |<img src="https://render.githubusercontent.com/render/math?math=\omega_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}\omega_{i}#gh-dark-mode-only">|fraction of total effort undertaken by node `i`, set to `1/k`.
 |<img src="https://render.githubusercontent.com/render/math?math=k#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}k#gh-dark-mode-only">|number of nodes stakeholders are incentivised to create, set by the validators, a matter of governance. Currently determined by the `reward set` size, and set to 720 in testnet Sandbox.
-|<img src="https://render.githubusercontent.com/render/math?math=\alpha#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}\alpha#gh-dark-mode-only">|Sybil attack resistance parameter - the higher this parameter is set the stronger the reduction in competitivness gets for a Sybil attacker.
+|<img src="https://render.githubusercontent.com/render/math?math=\alpha#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}\alpha#gh-dark-mode-only">|Sybil attack resistance parameter - the higher this parameter is set the stronger the reduction in competitiveness gets for a Sybil attacker.
 |<img src="https://render.githubusercontent.com/render/math?math=PM_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}PM_{i}#gh-dark-mode-only">|declared profit margin of operator `i`, defaults to 10% in.
 |<img src="https://render.githubusercontent.com/render/math?math=PF_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}PF_{i}#gh-dark-mode-only">|uptime of node `i`, scaled to 0 - 1, for the rewarding epoch
 |<img src="https://render.githubusercontent.com/render/math?math=PP_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}PP_{i}#gh-dark-mode-only">|cost of operating node `i` for the duration of the rewarding epoch, set to 40 NYMT.
@@ -70,7 +70,7 @@ Operator of node `i` is credited with the following amount:
 <img src="https://render.githubusercontent.com/render/math?math=min\{PP_{i},R_{i})\} %2b max\{0, (PM_{i} %2b (1 - PM_{i}) \cdot \lambda_{i}/\delta_{i}) \cdot (R_{i} - PP_{i})\}#gh-light-mode-only">
 <img src="https://render.githubusercontent.com/render/math?math=\color{white}min\{PP_{i},R_{i})\} %2b max\{0, (PM_{i} %2b (1 - PM_{i}) \cdot \lambda_{i}/\delta_{i}) \cdot (R_{i} - PP_{i})\}#gh-dark-mode-only">
 
-Delegate with stake `s` recieves:
+Delegate with stake `s` receives:
 
 <img src="https://render.githubusercontent.com/render/math?math=max\{0, (1-PM_{i}) \cdot (s^'/\sigma_{i}) \cdot (R_{i} - PP_{i})\}#gh-light-mode-only">
 <img src="https://render.githubusercontent.com/render/math?math=\color{white}max\{0, (1-PM_{i}) \cdot (s^'/\sigma_{i}) \cdot (R_{i} - PP_{i})\}#gh-dark-mode-only">

clients/native/src/client/mod.rs

@@ -20,6 +20,7 @@ use nym_client_core::client::received_buffer::{
 use nym_client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
 use nym_credential_storage::persistent_storage::PersistentStorage;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
+use nym_sphinx::params::PacketType;
 use nym_task::connections::TransmissionLane;
 use nym_task::TaskManager;
 use nym_validator_client::nyxd::QueryNyxdClient;
@@ -63,6 +64,7 @@ impl SocketClient {
         client_state: ClientState,
         self_address: &Recipient,
         shutdown: nym_task::TaskClient,
+        packet_type: PacketType,
     ) {
         info!("Starting websocket listener...");
 
@@ -88,6 +90,7 @@ impl SocketClient {
             self_address,
             shared_lane_queue_lengths,
             reply_controller_sender,
+            Some(packet_type),
         );
 
         websocket::Listener::new(config.get_listening_ip(), config.get_listening_port())
@@ -137,7 +140,8 @@ impl SocketClient {
         }
 
         let base_builder = self.create_base_client_builder().await?;
-        let mut started_client = base_builder.start_base().await?;
+        let packet_type = self.config.get_base().get_packet_type();
+        let mut started_client = base_builder.start_base(packet_type).await?;
         let self_address = started_client.address;
         let client_input = started_client.client_input.register_producer();
         let client_output = started_client.client_output.register_consumer();
@@ -150,6 +154,7 @@ impl SocketClient {
             client_state,
             &self_address,
             started_client.task_manager.subscribe(),
+            packet_type,
         );
 
         info!("Client startup finished!");
@@ -164,7 +169,8 @@ impl SocketClient {
         }
 
         let base_builder = self.create_base_client_builder().await?;
-        let mut started_client = base_builder.start_base().await?;
+        let packet_type = self.config.get_base().get_packet_type();
+        let mut started_client = base_builder.start_base(packet_type).await?;
         let address = started_client.address;
         let client_input = started_client.client_input.register_producer();
         let client_output = started_client.client_output.register_consumer();
@@ -186,6 +192,7 @@ impl SocketClient {
             reconstructed_receiver,
             address,
             shutdown_notifier: started_client.task_manager,
+            packet_type,
         })
     }
 }
@@ -199,6 +206,7 @@ pub struct DirectClient {
 
     // we need to keep reference to this guy otherwise things will start dropping
     shutdown_notifier: TaskManager,
+    packet_type: PacketType,
 }
 
 impl DirectClient {
@@ -219,7 +227,7 @@ impl DirectClient {
     /// well enough in local tests)
     pub async fn send_regular_message(&mut self, recipient: Recipient, message: Vec<u8>) {
         let lane = TransmissionLane::General;
-        let input_msg = InputMessage::new_regular(recipient, message, lane);
+        let input_msg = InputMessage::new_regular(recipient, message, lane, Some(self.packet_type));
 
         self.client_input
             .input_sender
@@ -238,7 +246,13 @@ impl DirectClient {
         reply_surbs: u32,
     ) {
         let lane = TransmissionLane::General;
-        let input_msg = InputMessage::new_anonymous(recipient, message, reply_surbs, lane);
+        let input_msg = InputMessage::new_anonymous(
+            recipient,
+            message,
+            reply_surbs,
+            lane,
+            Some(self.packet_type),
+        );
 
         self.client_input
             .input_sender
@@ -252,7 +266,8 @@ impl DirectClient {
     /// well enough in local tests)
     pub async fn send_reply(&mut self, recipient_tag: AnonymousSenderTag, message: Vec<u8>) {
         let lane = TransmissionLane::General;
-        let input_msg = InputMessage::new_reply(recipient_tag, message, lane);
+        let input_msg =
+            InputMessage::new_reply(recipient_tag, message, lane, Some(self.packet_type));
 
         self.client_input
             .input_sender

clients/native/src/websocket/handler.rs

@@ -14,6 +14,7 @@ use nym_client_core::client::{
 use nym_client_websocket_requests::{requests::ClientRequest, responses::ServerResponse};
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
+use nym_sphinx::params::PacketType;
 use nym_sphinx::receiver::ReconstructedMessage;
 use nym_task::connections::{
     ConnectionCommand, ConnectionCommandSender, ConnectionId, LaneQueueLengths, TransmissionLane,
@@ -41,6 +42,7 @@ pub(crate) struct HandlerBuilder {
     self_full_address: Recipient,
     lane_queue_lengths: LaneQueueLengths,
     reply_controller_sender: ReplyControllerSender,
+    packet_type: Option<PacketType>,
 }
 
 impl HandlerBuilder {
@@ -51,6 +53,7 @@ impl HandlerBuilder {
         self_full_address: &Recipient,
         lane_queue_lengths: LaneQueueLengths,
         reply_controller_sender: ReplyControllerSender,
+        packet_type: Option<PacketType>,
     ) -> Self {
         Self {
             msg_input,
@@ -59,6 +62,7 @@ impl HandlerBuilder {
             self_full_address: *self_full_address,
             lane_queue_lengths,
             reply_controller_sender,
+            packet_type,
         }
     }
 
@@ -73,6 +77,7 @@ impl HandlerBuilder {
             received_response_type: Default::default(),
             lane_queue_lengths: self.lane_queue_lengths.clone(),
             reply_controller_sender: self.reply_controller_sender.clone(),
+            packet_type: self.packet_type,
         }
     }
 }
@@ -86,6 +91,7 @@ pub(crate) struct Handler {
     received_response_type: ReceivedResponseType,
     lane_queue_lengths: LaneQueueLengths,
     reply_controller_sender: ReplyControllerSender,
+    packet_type: Option<PacketType>,
 }
 
 impl Drop for Handler {
@@ -160,7 +166,7 @@ impl Handler {
         });
 
         // the ack control is now responsible for chunking, etc.
-        let input_msg = InputMessage::new_regular(recipient, message, lane);
+        let input_msg = InputMessage::new_regular(recipient, message, lane, self.packet_type);
         self.msg_input
             .send(input_msg)
             .await
@@ -191,7 +197,8 @@ impl Handler {
             TransmissionLane::ConnectionId(id)
         });
 
-        let input_msg = InputMessage::new_anonymous(recipient, message, reply_surbs, lane);
+        let input_msg =
+            InputMessage::new_anonymous(recipient, message, reply_surbs, lane, self.packet_type);
         self.msg_input
             .send(input_msg)
             .await
@@ -218,7 +225,7 @@ impl Handler {
             TransmissionLane::ConnectionId(id)
         });
 
-        let input_msg = InputMessage::new_reply(recipient_tag, message, lane);
+        let input_msg = InputMessage::new_reply(recipient_tag, message, lane, self.packet_type);
         self.msg_input
             .send(input_msg)
             .await

clients/socks5/src/commands/init.rs

@@ -91,6 +91,7 @@ impl From<Init> for OverrideConfig {
             no_cover: init_config.no_cover,
             nyxd_urls: init_config.nyxd_urls,
             enabled_credentials_mode: init_config.enabled_credentials_mode,
+            outfox: false,
         }
     }
 }

clients/socks5/src/commands/mod.rs

@@ -10,6 +10,7 @@ use nym_bin_common::completions::{fig_generate, ArgShell};
 use nym_config::{NymConfig, OptionalSet};
 use nym_socks5_client_core::config::old_config_v1_1_13::OldConfigV1_1_13;
 use nym_socks5_client_core::config::{BaseConfig, Config};
+use nym_sphinx::params::PacketType;
 use std::error::Error;
 
 pub mod init;
@@ -64,6 +65,7 @@ pub(crate) struct OverrideConfig {
     no_cover: bool,
     nyxd_urls: Option<Vec<url::Url>>,
     enabled_credentials_mode: Option<bool>,
+    outfox: bool,
 }
 
 pub(crate) async fn execute(args: &Cli) -> Result<(), Box<dyn Error + Send + Sync>> {
@@ -80,9 +82,15 @@ pub(crate) async fn execute(args: &Cli) -> Result<(), Box<dyn Error + Send + Syn
 }
 
 pub(crate) fn override_config(config: Config, args: OverrideConfig) -> Config {
+    let packet_type = if args.outfox {
+        PacketType::Outfox
+    } else {
+        PacketType::Mix
+    };
     config
         .with_base(BaseConfig::with_high_default_traffic_volume, args.fastmode)
         .with_base(BaseConfig::with_disabled_cover_traffic, args.no_cover)
+        .with_base(BaseConfig::with_packet_type, packet_type)
         .with_optional(Config::with_anonymous_replies, args.use_anonymous_replies)
         .with_optional(Config::with_port, args.port)
         .with_optional_custom_env_ext(

clients/socks5/src/commands/run.rs

@@ -9,6 +9,7 @@ use crate::{
 use clap::Args;
 use log::*;
 use nym_bin_common::version_checker::is_minor_version_compatible;
+use nym_client_core::client::base_client::storage::OnDiskPersistent;
 use nym_config::NymConfig;
 use nym_crypto::asymmetric::identity;
 use nym_socks5_client_core::{config::Config, NymClient};
@@ -67,6 +68,9 @@ pub(crate) struct Run {
     /// with bandwidth credential requirement.
     #[clap(long, hide = true)]
     enabled_credentials_mode: Option<bool>,
+
+    #[clap(long, hide = true, action)]
+    outfox: bool,
 }
 
 impl From<Run> for OverrideConfig {
@@ -79,6 +83,7 @@ impl From<Run> for OverrideConfig {
             no_cover: run_config.no_cover,
             nyxd_urls: run_config.nyxd_urls,
             enabled_credentials_mode: run_config.enabled_credentials_mode,
+            outfox: run_config.outfox,
         }
     }
 }
@@ -138,5 +143,6 @@ pub(crate) async fn execute(args: &Run) -> Result<(), Box<dyn std::error::Error
         return Err(Box::new(Socks5ClientError::FailedLocalVersionCheck));
     }
 
-    NymClient::new(config).run_forever().await
+    let storage = OnDiskPersistent::from_config(config.get_base()).await?;
+    NymClient::new(config, storage).run_forever().await
 }

clients/webassembly/.gitignore

@@ -1,6 +1,5 @@
 /target
 **/*.rs.bk
-Cargo.lock
 bin/
 pkg/
 wasm-pack.log

clients/webassembly/src/client/config.rs

@@ -11,7 +11,7 @@ use nym_client_core::config::{
     DebugConfig as ConfigDebug, GatewayConnection as ConfigGatewayConnection,
     ReplySurbs as ConfigReplySurbs, Topology as ConfigTopology, Traffic as ConfigTraffic,
 };
-use nym_sphinx::params::PacketSize;
+use nym_sphinx::params::{PacketSize, PacketType};
 use nym_validator_client::client::IdentityKey;
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
@@ -34,6 +34,8 @@ pub struct Config {
     pub(crate) gateway: Option<IdentityKey>,
 
     pub(crate) debug: ConfigDebug,
+
+    pub(crate) packet_type: PacketType,
 }
 
 #[wasm_bindgen]
@@ -42,9 +44,18 @@ impl Config {
     pub fn new(
         id: String,
         validator_server: String,
+        packet_type: Option<String>,
         gateway: Option<IdentityKey>,
         debug: Option<Debug>,
     ) -> Self {
+        let packet_type = if let Some(packet_type) = packet_type {
+            match packet_type.as_str() {
+                "outfox" => PacketType::Outfox,
+                _ => PacketType::Mix,
+            }
+        } else {
+            PacketType::Mix
+        };
         Config {
             id,
             nym_api_url: Some(
@@ -55,6 +66,7 @@ impl Config {
             disabled_credentials_mode: true,
             gateway,
             debug: debug.map(Into::into).unwrap_or_default(),
+            packet_type,
         }
     }
 }
@@ -97,6 +109,7 @@ impl From<Traffic> for ConfigTraffic {
                 .disable_main_poisson_packet_distribution,
             primary_packet_size: PacketSize::RegularPacket,
             secondary_packet_size: use_extended_packet_size,
+            packet_type: None,
         }
     }
 }

clients/webassembly/src/client/mod.rs

@@ -23,6 +23,7 @@ use nym_client_core::client::inbound_messages::InputMessage;
 use nym_client_core::client::replies::reply_storage::browser_backend;
 use nym_client_core::config::{CoverTraffic, DebugConfig, Topology, Traffic};
 use nym_credential_storage::ephemeral_storage::EphemeralStorage;
+use nym_sphinx::params::PacketType;
 use nym_task::connections::TransmissionLane;
 use nym_task::TaskManager;
 use nym_topology::provider_trait::{HardcodedTopologyProvider, TopologyProvider};
@@ -52,6 +53,7 @@ pub struct NymClient {
     // even though we don't use graceful shutdowns, other components rely on existence of this struct
     // and if it's dropped, everything will start going offline
     _task_manager: TaskManager,
+    packet_type: Option<PacketType>,
 }
 
 #[wasm_bindgen]
@@ -68,6 +70,7 @@ pub struct NymClientBuilder {
     bandwidth_controller:
         Option<BandwidthController<FakeClient<DirectSigningNyxdClient>, EphemeralStorage>>,
     disabled_credentials: bool,
+    packet_type: Option<PacketType>,
 }
 
 #[wasm_bindgen]
@@ -86,6 +89,7 @@ impl NymClientBuilder {
             on_message,
             bandwidth_controller: None,
             disabled_credentials: true,
+            packet_type: None,
         }
     }
 
@@ -124,6 +128,7 @@ impl NymClientBuilder {
                 },
                 ..Default::default()
             },
+            packet_type: PacketType::Mix,
         };
 
         NymClientBuilder {
@@ -136,6 +141,7 @@ impl NymClientBuilder {
             bandwidth_controller: None,
             disabled_credentials: true,
             storage_passphrase: None,
+            packet_type: None,
         }
     }
 
@@ -143,7 +149,7 @@ impl NymClientBuilder {
         ResponsePusher::new(client_output, on_message).start()
     }
 
-    fn topology_provider(&mut self) -> Option<Box<dyn TopologyProvider>> {
+    fn topology_provider(&mut self) -> Option<Box<dyn TopologyProvider + Send + Sync>> {
         if let Some(hardcoded_topology) = self.custom_topology.take() {
             Some(Box::new(HardcodedTopologyProvider::new(hardcoded_topology)))
         } else {
@@ -202,7 +208,8 @@ impl NymClientBuilder {
             base_builder = base_builder.with_topology_provider(topology_provider);
         }
 
-        let mut started_client = base_builder.start_base().await?;
+        let packet_type = self.config.packet_type;
+        let mut started_client = base_builder.start_base(packet_type).await?;
         let self_address = started_client.address.to_string();
 
         let client_input = started_client.client_input.register_producer();
@@ -216,6 +223,7 @@ impl NymClientBuilder {
             client_state: Arc::new(started_client.client_state),
             _full_topology: None,
             _task_manager: started_client.task_manager,
+            packet_type: self.packet_type,
         })
     }
 
@@ -291,7 +299,7 @@ impl NymClient {
         let input_msgs = request
             .test_msgs
             .into_iter()
-            .map(|p| InputMessage::new_regular(recipient, p, lane))
+            .map(|p| InputMessage::new_regular(recipient, p, lane, None))
             .collect();
 
         self.client_input.send_messages(input_msgs)
@@ -311,7 +319,7 @@ impl NymClient {
 
         let lane = TransmissionLane::General;
 
-        let input_msg = InputMessage::new_regular(recipient, message, lane);
+        let input_msg = InputMessage::new_regular(recipient, message, lane, self.packet_type);
         self.client_input.send_message(input_msg)
     }
 
@@ -338,7 +346,8 @@ impl NymClient {
 
         let lane = TransmissionLane::General;
 
-        let input_msg = InputMessage::new_anonymous(recipient, message, reply_surbs, lane);
+        let input_msg =
+            InputMessage::new_anonymous(recipient, message, reply_surbs, lane, self.packet_type);
         self.client_input.send_message(input_msg)
     }
 
@@ -356,7 +365,7 @@ impl NymClient {
 
         let lane = TransmissionLane::General;
 
-        let input_msg = InputMessage::new_reply(sender_tag, message, lane);
+        let input_msg = InputMessage::new_reply(sender_tag, message, lane, self.packet_type);
         self.client_input.send_message(input_msg)
     }
 }

clients/webassembly/src/storage/mod.rs

@@ -31,7 +31,7 @@ mod v1 {
     pub const GATEWAY_CONFIG: &str = "gateway_config";
 
     pub const ED25519_IDENTITY_KEYPAIR: &str = "ed25519_identity_keypair";
-    pub const X25519_ENCRYPTION_KEYPAIR: &str = "x25519_encryption_key";
+    pub const X25519_ENCRYPTION_KEYPAIR: &str = "x25519_encryption_keypair";
 
     // TODO: for those we could actually use the subtle crypto storage
     pub const AES128CTR_ACK_KEY: &str = "aes128ctr_ack_key";

common/async-file-watcher/src/lib.rs

@@ -130,7 +130,7 @@ impl AsyncFileWatcher {
                 Ok(event) => {
                     let now = Instant::now();
                     if self.should_propagate(&event, now) {
-                        self.last_received.insert(event.kind.clone(), now);
+                        self.last_received.insert(event.kind, now);
                         if let Err(_err) = self.event_sender.unbounded_send(event) {
                             log::error!("the file watcher receiver has been dropped!");
                         }

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

@@ -37,17 +37,19 @@ use nym_gateway_client::{
 use nym_sphinx::acknowledgements::AckKey;
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::addressing::nodes::NodeIdentity;
+use nym_sphinx::params::PacketType;
 use nym_sphinx::receiver::{ReconstructedMessage, SphinxMessageReceiver};
 use nym_task::connections::{ConnectionCommandReceiver, ConnectionCommandSender, LaneQueueLengths};
 use nym_task::{TaskClient, TaskManager};
 use nym_topology::provider_trait::TopologyProvider;
-use rand::thread_rng;
+use rand::rngs::OsRng;
 use std::sync::Arc;
 use tap::TapFallible;
 use url::Url;
 
 #[cfg(target_arch = "wasm32")]
 use nym_bandwidth_controller::wasm_mockups::DkgQueryClient;
+
 #[cfg(not(target_arch = "wasm32"))]
 use nym_validator_client::nyxd::traits::DkgQueryClient;
 
@@ -163,7 +165,7 @@ pub struct BaseClientBuilder<'a, C, S: MixnetClientStorage> {
     reply_storage_backend: S::ReplyStore,
     key_store: S::KeyStore,
 
-    custom_topology_provider: Option<Box<dyn TopologyProvider>>,
+    custom_topology_provider: Option<Box<dyn TopologyProvider + Send + Sync>>,
     bandwidth_controller: Option<BandwidthController<C, S::CredentialStore>>,
     managed_keys: ManagedKeys,
 }
@@ -216,7 +218,10 @@ where
         }
     }
 
-    pub fn with_topology_provider(mut self, provider: Box<dyn TopologyProvider>) -> Self {
+    pub fn with_topology_provider(
+        mut self,
+        provider: Box<dyn TopologyProvider + Send + Sync>,
+    ) -> Self {
         self.custom_topology_provider = Some(provider);
         self
     }
@@ -271,6 +276,7 @@ where
         lane_queue_lengths: LaneQueueLengths,
         client_connection_rx: ConnectionCommandReceiver,
         shutdown: TaskClient,
+        packet_type: PacketType,
     ) {
         info!("Starting real traffic stream...");
 
@@ -286,7 +292,7 @@ where
             lane_queue_lengths,
             client_connection_rx,
         )
-        .start_with_shutdown(shutdown);
+        .start_with_shutdown(shutdown, packet_type);
     }
 
     // buffer controlling all messages fetched from provider
@@ -367,9 +373,9 @@ where
     }
 
     fn setup_topology_provider(
-        custom_provider: Option<Box<dyn TopologyProvider>>,
+        custom_provider: Option<Box<dyn TopologyProvider + Send + Sync>>,
         nym_api_urls: Vec<Url>,
-    ) -> Box<dyn TopologyProvider> {
+    ) -> Box<dyn TopologyProvider + Send + Sync> {
         // if no custom provider was ... provided ..., create one using nym-api
         custom_provider.unwrap_or_else(|| {
             Box::new(NymApiTopologyProvider::new(
@@ -382,7 +388,7 @@ where
     // future responsible for periodically polling directory server and updating
     // the current global view of topology
     async fn start_topology_refresher(
-        topology_provider: Box<dyn TopologyProvider>,
+        topology_provider: Box<dyn TopologyProvider + Send + Sync>,
         topology_config: config::Topology,
         topology_accessor: TopologyAccessor,
         mut shutdown: TaskClient,
@@ -422,7 +428,7 @@ where
         Ok(())
     }
 
-    // controller for sending sphinx packets to mixnet (either real traffic or cover traffic)
+    // controller for sending packets to mixnet (either real traffic or cover traffic)
     // TODO: if we want to send control messages to gateway_client, this CAN'T take the ownership
     // over it. Perhaps GatewayClient needs to be thread-shareable or have some channel for
     // requests?
@@ -469,11 +475,14 @@ where
 
     async fn initial_key_setup(&mut self) {
         assert!(!self.managed_keys.is_valid());
-        let mut rng = thread_rng();
+        let mut rng = OsRng;
         self.managed_keys = ManagedKeys::load_or_generate(&mut rng, &self.key_store).await;
     }
 
-    pub async fn start_base(mut self) -> Result<BaseClient, ClientCoreError>
+    pub async fn start_base(
+        mut self,
+        packet_type: PacketType,
+    ) -> Result<BaseClient, ClientCoreError>
     where
         <S::ReplyStore as ReplyStorageBackend>::StorageError: Sync + Send,
         S::ReplyStore: Send + Sync,
@@ -544,11 +553,11 @@ where
             task_manager.subscribe(),
         );
 
-        // The sphinx_message_sender is the transmitter for any component generating sphinx packets
+        // The message_sender is the transmitter for any component generating sphinx packets
         // that are to be sent to the mixnet. They are used by cover traffic stream and real
         // traffic stream.
         // The MixTrafficController then sends the actual traffic
-        let sphinx_message_sender =
+        let message_sender =
             Self::start_mix_traffic_controller(gateway_client, task_manager.subscribe());
 
         // Channels that the websocket listener can use to signal downstream to the real traffic
@@ -570,13 +579,14 @@ where
             shared_topology_accessor.clone(),
             ack_receiver,
             input_receiver,
-            sphinx_message_sender.clone(),
+            message_sender.clone(),
             reply_storage,
             reply_controller_sender.clone(),
             reply_controller_receiver,
             shared_lane_queue_lengths.clone(),
             client_connection_rx,
             task_manager.subscribe(),
+            packet_type,
         );
 
         if !self
@@ -589,7 +599,7 @@ where
                 self.managed_keys.ack_key(),
                 self_address,
                 shared_topology_accessor.clone(),
-                sphinx_message_sender,
+                message_sender,
                 task_manager.subscribe(),
             );
         }

common/client-core/src/client/base_client/storage/mod.rs

@@ -12,10 +12,15 @@ use nym_credential_storage::ephemeral_storage::{
 };
 use nym_credential_storage::storage::Storage as CredentialStorage;
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
+use crate::client::base_client::non_wasm_helpers;
+#[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
 use crate::client::key_manager::persistence::OnDiskKeys;
-
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
+use crate::config::{persistence::key_pathfinder::ClientKeyPathfinder, Config};
+#[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
+use crate::error::ClientCoreError;
+#[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
 use nym_credential_storage::persistent_storage::PersistentStorage as PersistentCredentialStorage;
 
 #[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
@@ -89,6 +94,26 @@ impl OnDiskPersistent {
             credential_store,
         }
     }
+
+    pub async fn from_config<T>(config: &Config<T>) -> Result<Self, ClientCoreError> {
+        let pathfinder = ClientKeyPathfinder::new_from_config(config);
+        let key_store = OnDiskKeys::new(pathfinder);
+
+        let reply_store = non_wasm_helpers::setup_fs_reply_surb_backend(
+            config.get_reply_surb_database_path(),
+            &config.get_debug_config().reply_surbs,
+        )
+        .await?;
+
+        let credential_store =
+            nym_credential_storage::initialise_persistent_storage(config.get_database_path()).await;
+
+        Ok(OnDiskPersistent {
+            key_store,
+            reply_store,
+            credential_store,
+        })
+    }
 }
 
 #[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]

common/client-core/src/client/cover_traffic_stream.rs

@@ -45,7 +45,7 @@ where
     #[cfg(target_arch = "wasm32")]
     next_delay: Pin<Box<wasm_timer::Delay>>,
 
-    /// Channel used for sending prepared sphinx packets to `MixTrafficController` that sends them
+    /// Channel used for sending prepared nym packets to `MixTrafficController` that sends them
     /// out to the network without any further delays.
     mix_tx: BatchMixMessageSender,
 
@@ -194,6 +194,7 @@ impl LoopCoverTrafficStream<OsRng> {
             self.average_ack_delay,
             self.cover_traffic.loop_cover_traffic_average_delay,
             cover_traffic_packet_size,
+            nym_sphinx::params::PacketType::Mix,
         )
         .expect("Somehow failed to generate a loop cover message with a valid topology");
 

common/client-core/src/client/inbound_messages.rs

@@ -4,6 +4,7 @@
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
 use nym_sphinx::forwarding::packet::MixPacket;
+use nym_sphinx::params::PacketType;
 use nym_task::connections::TransmissionLane;
 
 pub type InputMessageSender = tokio::sync::mpsc::Sender<InputMessage>;
@@ -53,18 +54,49 @@ pub enum InputMessage {
         data: Vec<u8>,
         lane: TransmissionLane,
     },
+
+    MessageWrapper {
+        message: Box<InputMessage>,
+        packet_type: PacketType,
+    },
 }
 
 impl InputMessage {
-    pub fn new_premade(msgs: Vec<MixPacket>, lane: TransmissionLane) -> Self {
-        InputMessage::Premade { msgs, lane }
+    pub fn new_premade(
+        msgs: Vec<MixPacket>,
+        lane: TransmissionLane,
+        packet_type: PacketType,
+    ) -> Self {
+        let message = InputMessage::Premade { msgs, lane };
+        if packet_type == PacketType::Mix {
+            message
+        } else {
+            InputMessage::new_wrapper(message, packet_type)
+        }
     }
 
-    pub fn new_regular(recipient: Recipient, data: Vec<u8>, lane: TransmissionLane) -> Self {
-        InputMessage::Regular {
+    pub fn new_wrapper(message: InputMessage, packet_type: PacketType) -> Self {
+        InputMessage::MessageWrapper {
+            message: Box::new(message),
+            packet_type,
+        }
+    }
+
+    pub fn new_regular(
+        recipient: Recipient,
+        data: Vec<u8>,
+        lane: TransmissionLane,
+        packet_type: Option<PacketType>,
+    ) -> Self {
+        let message = InputMessage::Regular {
             recipient,
             data,
             lane,
+        };
+        if let Some(packet_type) = packet_type {
+            InputMessage::new_wrapper(message, packet_type)
+        } else {
+            message
         }
     }
 
@@ -73,12 +105,18 @@ impl InputMessage {
         data: Vec<u8>,
         reply_surbs: u32,
         lane: TransmissionLane,
+        packet_type: Option<PacketType>,
     ) -> Self {
-        InputMessage::Anonymous {
+        let message = InputMessage::Anonymous {
             recipient,
             data,
             reply_surbs,
             lane,
+        };
+        if let Some(packet_type) = packet_type {
+            InputMessage::new_wrapper(message, packet_type)
+        } else {
+            message
         }
     }
 
@@ -86,11 +124,17 @@ impl InputMessage {
         recipient_tag: AnonymousSenderTag,
         data: Vec<u8>,
         lane: TransmissionLane,
+        packet_type: Option<PacketType>,
     ) -> Self {
-        InputMessage::Reply {
+        let message = InputMessage::Reply {
             recipient_tag,
             data,
             lane,
+        };
+        if let Some(packet_type) = packet_type {
+            InputMessage::new_wrapper(message, packet_type)
+        } else {
+            message
         }
     }
 
@@ -100,6 +144,7 @@ impl InputMessage {
             | InputMessage::Anonymous { lane, .. }
             | InputMessage::Reply { lane, .. }
             | InputMessage::Premade { lane, .. } => lane,
+            InputMessage::MessageWrapper { message, .. } => message.lane(),
         }
     }
 }

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

@@ -40,15 +40,15 @@ where
     pub fn new(
         gateway_client: GatewayClient<C, St>,
     ) -> (MixTrafficController<C, St>, BatchMixMessageSender) {
-        let (sphinx_message_sender, sphinx_message_receiver) =
+        let (message_sender, message_receiver) =
             tokio::sync::mpsc::channel(MIX_MESSAGE_RECEIVER_BUFFER_SIZE);
         (
             MixTrafficController {
                 gateway_client,
-                mix_rx: sphinx_message_receiver,
+                mix_rx: message_receiver,
                 consecutive_gateway_failure_count: 0,
             },
-            sphinx_message_sender,
+            message_sender,
         )
     }
 

common/client-core/src/client/real_messages_control/acknowledgement_control/acknowledgement_listener.rs

@@ -71,7 +71,7 @@ impl AcknowledgementListener {
         while !shutdown.is_shutdown() {
             tokio::select! {
                 acks = self.ack_receiver.next() => match acks {
-                    Some(acks) => self.handle_ack_receiver_item(acks).await,
+                    Some(acks) => {self.handle_ack_receiver_item(acks).await}
                     None => {
                         log::trace!("AcknowledgementListener: Stopping since channel closed");
                         break;

common/client-core/src/client/real_messages_control/acknowledgement_control/input_message_listener.rs

@@ -9,6 +9,7 @@ use log::*;
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
 use nym_sphinx::forwarding::packet::MixPacket;
+use nym_sphinx::params::PacketType;
 use nym_task::connections::TransmissionLane;
 use rand::{CryptoRng, Rng};
 
@@ -71,10 +72,11 @@ where
         recipient: Recipient,
         content: Vec<u8>,
         lane: TransmissionLane,
+        packet_type: PacketType,
     ) {
         if let Err(err) = self
             .message_handler
-            .try_send_plain_message(recipient, content, lane)
+            .try_send_plain_message(recipient, content, lane, packet_type)
             .await
         {
             warn!("failed to send a plain message - {err}")
@@ -87,10 +89,11 @@ where
         content: Vec<u8>,
         reply_surbs: u32,
         lane: TransmissionLane,
+        packet_type: PacketType,
     ) {
         if let Err(err) = self
             .message_handler
-            .try_send_message_with_reply_surbs(recipient, content, reply_surbs, lane)
+            .try_send_message_with_reply_surbs(recipient, content, reply_surbs, lane, packet_type)
             .await
         {
             warn!("failed to send a repliable message - {err}")
@@ -103,14 +106,17 @@ where
                 recipient,
                 data,
                 lane,
-            } => self.handle_plain_message(recipient, data, lane).await,
+            } => {
+                self.handle_plain_message(recipient, data, lane, PacketType::Mix)
+                    .await
+            }
             InputMessage::Anonymous {
                 recipient,
                 data,
                 reply_surbs,
                 lane,
             } => {
-                self.handle_repliable_message(recipient, data, reply_surbs, lane)
+                self.handle_repliable_message(recipient, data, reply_surbs, lane, PacketType::Mix)
                     .await
             }
             InputMessage::Reply {
@@ -121,6 +127,40 @@ where
                 self.handle_reply(recipient_tag, data, lane).await;
             }
             InputMessage::Premade { msgs, lane } => self.handle_premade_packets(msgs, lane).await,
+            InputMessage::MessageWrapper {
+                message,
+                packet_type,
+            } => match *message {
+                InputMessage::Regular {
+                    recipient,
+                    data,
+                    lane,
+                } => {
+                    self.handle_plain_message(recipient, data, lane, packet_type)
+                        .await
+                }
+                InputMessage::Anonymous {
+                    recipient,
+                    data,
+                    reply_surbs,
+                    lane,
+                } => {
+                    self.handle_repliable_message(recipient, data, reply_surbs, lane, packet_type)
+                        .await
+                }
+                InputMessage::Reply {
+                    recipient_tag,
+                    data,
+                    lane,
+                } => {
+                    self.handle_reply(recipient_tag, data, lane).await;
+                }
+                InputMessage::Premade { msgs, lane } => {
+                    self.handle_premade_packets(msgs, lane).await
+                }
+                // MessageWrappers can't be nested
+                InputMessage::MessageWrapper { .. } => unimplemented!(),
+            },
         };
     }
 

common/client-core/src/client/real_messages_control/acknowledgement_control/mod.rs

@@ -16,7 +16,7 @@ use futures::channel::mpsc;
 use log::*;
 use nym_gateway_client::AcknowledgementReceiver;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nym_sphinx::params::PacketSize;
+use nym_sphinx::params::{PacketSize, PacketType};
 use nym_sphinx::{
     acknowledgements::AckKey,
     addressing::clients::Recipient,
@@ -249,7 +249,11 @@ where
         }
     }
 
-    pub(super) fn start_with_shutdown(self, shutdown: nym_task::TaskClient) {
+    pub(super) fn start_with_shutdown(
+        self,
+        shutdown: nym_task::TaskClient,
+        packet_type: PacketType,
+    ) {
         let mut acknowledgement_listener = self.acknowledgement_listener;
         let mut input_message_listener = self.input_message_listener;
         let mut retransmission_request_listener = self.retransmission_request_listener;
@@ -275,7 +279,7 @@ where
         let shutdown_handle = shutdown.clone();
         spawn_future(async move {
             retransmission_request_listener
-                .run_with_shutdown(shutdown_handle)
+                .run_with_shutdown(shutdown_handle, packet_type)
                 .await;
             debug!("The retransmission request listener has finished execution!");
         });

common/client-core/src/client/real_messages_control/acknowledgement_control/retransmission_request_listener.rs

@@ -11,9 +11,9 @@ use crate::client::real_messages_control::real_traffic_stream::RealMessage;
 use crate::client::replies::reply_controller::ReplyControllerSender;
 use futures::StreamExt;
 use log::*;
-use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::chunking::fragment::Fragment;
 use nym_sphinx::preparer::PreparedFragment;
+use nym_sphinx::{addressing::clients::Recipient, params::PacketType};
 use nym_task::connections::TransmissionLane;
 use rand::{CryptoRng, Rng};
 use std::sync::{Arc, Weak};
@@ -48,17 +48,20 @@ where
         &mut self,
         packet_recipient: Recipient,
         chunk_data: Fragment,
+        packet_type: PacketType,
     ) -> Result<PreparedFragment, PreparationError> {
         debug!("retransmitting normal packet...");
 
+        // TODO: Figure out retransmission packet type signaling
         self.message_handler
-            .try_prepare_single_chunk_for_sending(packet_recipient, chunk_data)
+            .try_prepare_single_chunk_for_sending(packet_recipient, chunk_data, packet_type)
             .await
     }
 
     async fn on_retransmission_request(
         &mut self,
         weak_timed_out_ack: Weak<PendingAcknowledgement>,
+        packet_type: PacketType,
     ) {
         let timed_out_ack = match weak_timed_out_ack.upgrade() {
             Some(timed_out_ack) => timed_out_ack,
@@ -85,6 +88,7 @@ where
                 self.prepare_normal_retransmission_chunk(
                     **recipient,
                     timed_out_ack.message_chunk.clone(),
+                    packet_type,
                 )
                 .await
             }
@@ -140,13 +144,17 @@ where
             .await
     }
 
-    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
+    pub(super) async fn run_with_shutdown(
+        &mut self,
+        mut shutdown: nym_task::TaskClient,
+        packet_type: PacketType,
+    ) {
         debug!("Started RetransmissionRequestListener with graceful shutdown support");
 
         while !shutdown.is_shutdown() {
             tokio::select! {
                 timed_out_ack = self.request_receiver.next() => match timed_out_ack {
-                    Some(timed_out_ack) => self.on_retransmission_request(timed_out_ack).await,
+                    Some(timed_out_ack) => self.on_retransmission_request(timed_out_ack, packet_type).await,
                     None => {
                         log::trace!("RetransmissionRequestListener: Stopping since channel closed");
                         break;

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

@@ -15,7 +15,7 @@ use nym_sphinx::anonymous_replies::requests::{AnonymousSenderTag, RepliableMessa
 use nym_sphinx::anonymous_replies::{ReplySurb, SurbEncryptionKey};
 use nym_sphinx::chunking::fragment::{Fragment, FragmentIdentifier};
 use nym_sphinx::message::NymMessage;
-use nym_sphinx::params::{PacketSize, DEFAULT_NUM_MIX_HOPS};
+use nym_sphinx::params::{PacketSize, PacketType, DEFAULT_NUM_MIX_HOPS};
 use nym_sphinx::preparer::{MessagePreparer, PreparedFragment};
 use nym_sphinx::Delay;
 use nym_task::connections::TransmissionLane;
@@ -27,7 +27,7 @@ use std::time::Duration;
 use thiserror::Error;
 
 // TODO: move that error elsewhere since it seems to be contaminating different files
-#[derive(Debug, Clone, Error)]
+#[derive(Debug, Error)]
 pub enum PreparationError {
     #[error(transparent)]
     NymTopologyError(#[from] NymTopologyError),
@@ -417,9 +417,10 @@ where
         recipient: Recipient,
         message: Vec<u8>,
         lane: TransmissionLane,
+        packet_type: PacketType,
     ) -> Result<(), PreparationError> {
         let message = NymMessage::new_plain(message);
-        self.try_split_and_send_non_reply_message(message, recipient, lane)
+        self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type)
             .await
     }
 
@@ -428,7 +429,9 @@ where
         message: NymMessage,
         recipient: Recipient,
         lane: TransmissionLane,
+        packet_type: PacketType,
     ) -> Result<(), PreparationError> {
+        debug!("Sending non-reply message with packet type {packet_type}");
         // TODO: I really dislike existence of this assertion, it implies code has to be re-organised
         debug_assert!(!matches!(message, NymMessage::Reply(_)));
 
@@ -436,7 +439,11 @@ where
         let topology_permit = self.topology_access.get_read_permit().await;
         let topology = self.get_topology(&topology_permit)?;
 
-        let packet_size = self.optimal_packet_size(&message);
+        let packet_size = if packet_type == PacketType::Outfox {
+            PacketSize::OutfoxRegularPacket
+        } else {
+            self.optimal_packet_size(&message)
+        };
         debug!("Using {packet_size} packets for {message}");
         let fragments = self
             .message_preparer
@@ -453,6 +460,7 @@ where
                 topology,
                 &self.config.ack_key,
                 &recipient,
+                packet_type,
             )?;
 
             let real_message = RealMessage::new(
@@ -476,7 +484,9 @@ where
         &mut self,
         recipient: Recipient,
         amount: u32,
+        packet_type: PacketType,
     ) -> Result<(), PreparationError> {
+        debug!("Sending additional reply SURBs with packet type {packet_type}");
         let sender_tag = self.get_or_create_sender_tag(&recipient);
         let (reply_surbs, reply_keys) =
             self.generate_reply_surbs_with_keys(amount as usize).await?;
@@ -490,6 +500,7 @@ where
             message,
             recipient,
             TransmissionLane::AdditionalReplySurbs,
+            packet_type,
         )
         .await?;
 
@@ -505,7 +516,9 @@ where
         message: Vec<u8>,
         num_reply_surbs: u32,
         lane: TransmissionLane,
+        packet_type: PacketType,
     ) -> Result<(), SurbWrappedPreparationError> {
+        debug!("Sending message with reply SURBs with packet type {packet_type}");
         let sender_tag = self.get_or_create_sender_tag(&recipient);
         let (reply_surbs, reply_keys) = self
             .generate_reply_surbs_with_keys(num_reply_surbs as usize)
@@ -514,7 +527,7 @@ where
         let message =
             NymMessage::new_repliable(RepliableMessage::new_data(message, sender_tag, reply_surbs));
 
-        self.try_split_and_send_non_reply_message(message, recipient, lane)
+        self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type)
             .await?;
 
         log::trace!("storing {} reply keys", reply_keys.len());
@@ -527,13 +540,21 @@ where
         &mut self,
         recipient: Recipient,
         chunk: Fragment,
+        packet_type: PacketType,
     ) -> Result<PreparedFragment, PreparationError> {
+        debug!("Sending single chunk with packet type {packet_type}");
         let topology_permit = self.topology_access.get_read_permit().await;
         let topology = self.get_topology(&topology_permit)?;
 
         let prepared_fragment = self
             .message_preparer
-            .prepare_chunk_for_sending(chunk, topology, &self.config.ack_key, &recipient)
+            .prepare_chunk_for_sending(
+                chunk,
+                topology,
+                &self.config.ack_key,
+                &recipient,
+                packet_type,
+            )
             .unwrap();
 
         Ok(prepared_fragment)
@@ -569,6 +590,7 @@ where
                         topology,
                         &self.config.ack_key,
                         reply_surb,
+                        PacketType::Mix,
                     )
                     .unwrap()
             })
@@ -588,7 +610,13 @@ where
 
         let prepared_fragment = self
             .message_preparer
-            .prepare_reply_chunk_for_sending(chunk, topology, &self.config.ack_key, reply_surb)
+            .prepare_reply_chunk_for_sending(
+                chunk,
+                topology,
+                &self.config.ack_key,
+                reply_surb,
+                PacketType::Mix,
+            )
             .unwrap();
 
         Ok(prepared_fragment)

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

@@ -26,6 +26,7 @@ use log::*;
 use nym_gateway_client::AcknowledgementReceiver;
 use nym_sphinx::acknowledgements::AckKey;
 use nym_sphinx::addressing::clients::Recipient;
+use nym_sphinx::params::PacketType;
 use nym_task::connections::{ConnectionCommandReceiver, LaneQueueLengths};
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::sync::Arc;
@@ -207,7 +208,7 @@ impl RealMessagesController<OsRng> {
         }
     }
 
-    pub fn start_with_shutdown(self, shutdown: nym_task::TaskClient) {
+    pub fn start_with_shutdown(self, shutdown: nym_task::TaskClient, packet_type: PacketType) {
         let mut out_queue_control = self.out_queue_control;
         let ack_control = self.ack_control;
         let mut reply_control = self.reply_control;
@@ -223,6 +224,6 @@ impl RealMessagesController<OsRng> {
             debug!("The reply controller has finished execution!");
         });
 
-        ack_control.start_with_shutdown(shutdown);
+        ack_control.start_with_shutdown(shutdown, packet_type);
     }
 }

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

@@ -92,7 +92,7 @@ where
     // messages.
     sending_delay_controller: SendingDelayController,
 
-    /// Channel used for sending prepared sphinx packets to `MixTrafficController` that sends them
+    /// Channel used for sending prepared packets to `MixTrafficController` that sends them
     /// out to the network without any further delays.
     mix_tx: BatchMixMessageSender,
 
@@ -136,7 +136,7 @@ impl From<PreparedFragment> for RealMessage {
 
 impl RealMessage {
     pub(crate) fn packet_size(&self) -> usize {
-        self.mix_packet.sphinx_packet().len()
+        self.mix_packet.packet().len()
     }
 
     pub(crate) fn new(mix_packet: MixPacket, fragment_id: Option<FragmentIdentifier>) -> Self {
@@ -247,6 +247,7 @@ where
                         self.config.average_ack_delay,
                         self.config.traffic.average_packet_delay,
                         cover_traffic_packet_size,
+                        self.config.traffic.packet_type.unwrap_or_default(),
                     )
                     .expect(
                         "Somehow failed to generate a loop cover message with a valid topology",
@@ -386,7 +387,7 @@ where
 
             // On every iteration we get new messages from upstream. Given that these come bunched
             // in `Vec`, this ensures that on average we will fetch messages faster than we can
-            // send, which is a condition for being able to multiplex sphinx packets from multiple
+            // send, which is a condition for being able to multiplex packets from multiple
             // data streams.
             match Pin::new(&mut self.real_receiver).poll_recv(cx) {
                 // in the case our real message channel stream was closed, we should also indicate we are closed

common/client-core/src/client/replies/reply_controller/mod.rs

@@ -512,7 +512,11 @@ where
             let to_send = min(remaining, 100);
             if let Err(err) = self
                 .message_handler
-                .try_send_additional_reply_surbs(recipient, to_send)
+                .try_send_additional_reply_surbs(
+                    recipient,
+                    to_send,
+                    nym_sphinx::params::PacketType::Mix,
+                )
                 .await
             {
                 warn!("failed to send additional surbs to {recipient} - {err}");

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

@@ -26,7 +26,7 @@ impl TopologyRefresherConfig {
 }
 
 pub struct TopologyRefresher {
-    topology_provider: Box<dyn TopologyProvider>,
+    topology_provider: Box<dyn TopologyProvider + Send + Sync>,
     topology_accessor: TopologyAccessor,
 
     refresh_rate: Duration,
@@ -37,7 +37,7 @@ impl TopologyRefresher {
     pub fn new(
         cfg: TopologyRefresherConfig,
         topology_accessor: TopologyAccessor,
-        topology_provider: Box<dyn TopologyProvider>,
+        topology_provider: Box<dyn TopologyProvider + Send + Sync>,
     ) -> Self {
         TopologyRefresher {
             topology_provider,
@@ -47,7 +47,7 @@ impl TopologyRefresher {
         }
     }
 
-    pub fn change_topology_provider(&mut self, provider: Box<dyn TopologyProvider>) {
+    pub fn change_topology_provider(&mut self, provider: Box<dyn TopologyProvider + Send + Sync>) {
         self.topology_provider = provider;
     }
 

common/client-core/src/client/transmission_buffer.rs

@@ -28,7 +28,7 @@ impl SizedData for RealMessage {
 
 impl SizedData for Fragment {
     fn data_size(&self) -> usize {
-        // note that raw `Fragment` is smaller than sphinx packet payload
+        // note that raw `Fragment` is smaller than packet payload
         // as it doesn't include surb-ack or the [shared] key materials
         self.payload_size()
     }

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

@@ -4,10 +4,10 @@
 use nym_config::defaults::NymNetworkDetails;
 use nym_config::{NymConfig, OptionalSet, CRED_DB_FILE_NAME};
 use nym_crypto::asymmetric::identity;
-use nym_sphinx::params::PacketSize;
+use nym_sphinx::params::{PacketSize, PacketType};
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::time::Duration;
 use url::Url;
 
@@ -18,6 +18,15 @@ use wasm_bindgen::prelude::*;
 pub mod old_config_v1_1_13;
 pub mod persistence;
 
+pub const DEFAULT_PRIVATE_IDENTITY_KEY_FILENAME: &str = "private_identity.pem";
+pub const DEFAULT_PUBLIC_IDENTITY_KEY_FILENAME: &str = "public_identity.pem";
+pub const DEFAULT_PRIVATE_ENCRYPTION_KEY_FILENAME: &str = "private_encryption.pem";
+pub const DEFAULT_PUBLIC_ENCRYPTION_KEY_FILENAME: &str = "public_encryption.pem";
+pub const DEFAULT_GATEWAY_KEYS_FILENAME: &str = "gateway_shared.pem";
+pub const DEFAULT_ACK_KEY_FILENAME: &str = "ack_key.pem";
+pub const DEFAULT_REPLY_STORE_FILENAME: &str = "persistent_reply_store.sqlite";
+pub const DEFAULT_CREDENTIAL_STORE_FILENAME: &str = CRED_DB_FILE_NAME;
+
 pub const MISSING_VALUE: &str = "MISSING VALUE";
 
 // 'DEBUG'
@@ -109,6 +118,37 @@ impl<T> Config<T> {
         self
     }
 
+    #[must_use]
+    #[doc(hidden)]
+    // TODO: this totally contradicts our trait... we REALLY have to refactor it...
+    pub fn reset_data_directory<P: AsRef<Path>>(mut self, dir: P) -> Self {
+        self.client.private_identity_key_file =
+            dir.as_ref().join(DEFAULT_PRIVATE_IDENTITY_KEY_FILENAME);
+        self.client.public_identity_key_file =
+            dir.as_ref().join(DEFAULT_PUBLIC_IDENTITY_KEY_FILENAME);
+        self.client.private_encryption_key_file =
+            dir.as_ref().join(DEFAULT_PRIVATE_ENCRYPTION_KEY_FILENAME);
+        self.client.public_encryption_key_file =
+            dir.as_ref().join(DEFAULT_PUBLIC_ENCRYPTION_KEY_FILENAME);
+        self.client.gateway_shared_key_file = dir.as_ref().join(DEFAULT_GATEWAY_KEYS_FILENAME);
+        self.client.ack_key_file = dir.as_ref().join(DEFAULT_ACK_KEY_FILENAME);
+        self.client.reply_surb_database_path = dir.as_ref().join(DEFAULT_REPLY_STORE_FILENAME);
+        self.client.database_path = dir.as_ref().join(DEFAULT_CREDENTIAL_STORE_FILENAME);
+
+        self
+    }
+
+    #[must_use]
+    #[doc(hidden)]
+    // TODO: this totally contradicts our trait... we REALLY have to refactor it...
+    pub fn reset_nym_root_directory<P: AsRef<Path>>(mut self, dir: P) -> Self
+    where
+        T: NymConfig,
+    {
+        self.client.nym_root_directory = dir.as_ref().to_owned();
+        self
+    }
+
     pub fn set_empty_fields_to_defaults(&mut self) -> bool
     where
         T: NymConfig,
@@ -219,6 +259,11 @@ impl<T> Config<T> {
         self
     }
 
+    pub fn with_packet_type(mut self, packet_type: PacketType) -> Self {
+        self.client.packet_type = Some(packet_type);
+        self
+    }
+
     pub fn set_high_default_traffic_volume(&mut self) {
         self.debug.traffic.average_packet_delay = Duration::from_millis(10);
         // basically don't really send cover messages
@@ -406,6 +451,10 @@ impl<T> Config<T> {
     pub fn get_maximum_reply_key_age(&self) -> Duration {
         self.debug.reply_surbs.maximum_reply_key_age
     }
+
+    pub fn get_packet_type(&self) -> PacketType {
+        self.client.packet_type.unwrap_or(PacketType::Mix)
+    }
 }
 
 impl<T: NymConfig> Default for Config<T> {
@@ -528,6 +577,8 @@ pub struct Client<T> {
 
     #[serde(skip)]
     pub super_struct: PhantomData<T>,
+
+    pub packet_type: Option<PacketType>,
 }
 
 impl<T: NymConfig> Default for Client<T> {
@@ -566,6 +617,7 @@ impl<T: NymConfig> Default for Client<T> {
             reply_surb_database_path: Default::default(),
             nym_root_directory: T::default_root_directory(),
             super_struct: Default::default(),
+            packet_type: Default::default(),
         }
     }
 }
@@ -637,6 +689,8 @@ pub struct Traffic {
     /// Note that its use decreases overall anonymity.
     /// Do not set it it unless you understand the consequences of that change.
     pub secondary_packet_size: Option<PacketSize>,
+
+    pub packet_type: Option<PacketType>,
 }
 
 impl Traffic {
@@ -660,6 +714,7 @@ impl Default for Traffic {
             disable_main_poisson_packet_distribution: false,
             primary_packet_size: PacketSize::RegularPacket,
             secondary_packet_size: None,
+            packet_type: None,
         }
     }
 }

common/client-core/src/config/old_config_v1_1_13.rs

@@ -125,6 +125,7 @@ impl From<OldDebugConfigV1_1_13> for DebugConfig {
                     .disable_main_poisson_packet_distribution,
                 primary_packet_size: PacketSize::RegularPacket,
                 secondary_packet_size: value.use_extended_packet_size.map(Into::into),
+                packet_type: None,
             },
             cover_traffic: CoverTraffic {
                 loop_cover_traffic_average_delay: value.loop_cover_traffic_average_delay,
@@ -210,8 +211,8 @@ impl<T, U> From<OldConfigV1_1_13<T>> for Config<U> {
                 database_path: value.client.database_path,
                 reply_surb_database_path: value.client.reply_surb_database_path,
                 nym_root_directory: value.client.nym_root_directory,
-
                 super_struct: PhantomData,
+                packet_type: Some(nym_sphinx::params::PacketType::Mix),
             },
             logging: value.logging,
             debug: value.debug.into(),

common/client-core/src/config/persistence/key_pathfinder.rs

@@ -40,11 +40,17 @@ impl ClientKeyPathfinder {
     }
 
     pub fn identity_key_pair_path(&self) -> nym_pemstore::KeyPairPath {
-        nym_pemstore::KeyPairPath::new(self.private_identity_key(), self.public_identity_key())
+        nym_pemstore::KeyPairPath::new(
+            self.private_identity_key().to_path_buf(),
+            self.public_identity_key().to_path_buf(),
+        )
     }
 
     pub fn encryption_key_pair_path(&self) -> nym_pemstore::KeyPairPath {
-        nym_pemstore::KeyPairPath::new(self.private_encryption_key(), self.public_encryption_key())
+        nym_pemstore::KeyPairPath::new(
+            self.private_encryption_key().to_path_buf(),
+            self.public_encryption_key().to_path_buf(),
+        )
     }
 
     pub fn any_file_exists(&self) -> bool {

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

@@ -19,9 +19,8 @@ use nym_crypto::asymmetric::{encryption, identity};
 use nym_sphinx::addressing::{clients::Recipient, nodes::NodeIdentity};
 use nym_validator_client::client::IdentityKey;
 use rand::rngs::OsRng;
-use rand::thread_rng;
 use serde::Serialize;
-use std::fmt::Display;
+use std::fmt::{Debug, Display};
 use tap::TapFallible;
 use url::Url;
 
@@ -85,7 +84,7 @@ impl GatewaySetup {
     ) -> Result<GatewayEndpointConfig, ClientCoreError> {
         match self {
             GatewaySetup::New { by_latency } => {
-                let mut rng = thread_rng();
+                let mut rng = OsRng;
                 let gateways = current_gateways(&mut rng, validator_servers).await?;
                 if by_latency {
                     choose_gateway_by_latency(&mut rng, gateways).await
@@ -98,7 +97,7 @@ impl GatewaySetup {
                 let user_gateway = identity::PublicKey::from_base58_string(&gateway_identity)
                     .map_err(ClientCoreError::UnableToCreatePublicKeyFromGatewayId)?;
 
-                let mut rng = thread_rng();
+                let mut rng = OsRng;
                 let gateways = current_gateways(&mut rng, validator_servers).await?;
                 gateways
                     .into_iter()
@@ -161,7 +160,7 @@ where
     S: MixnetClientStorage,
     <S::KeyStore as KeyStore>::StorageError: Send + Sync + 'static,
 {
-    let mut rng = rand::thread_rng();
+    let mut rng = OsRng;
 
     // try load keys
     let mut managed_keys = match ManagedKeys::try_load(key_store).await {

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

@@ -571,7 +571,7 @@ impl<C, St> GatewayClient<C, St> {
     fn estimate_required_bandwidth(&self, packets: &[MixPacket]) -> i64 {
         packets
             .iter()
-            .map(|packet| packet.sphinx_packet().len())
+            .map(|packet| packet.packet().len())
             .sum::<usize>() as i64
     }
 
@@ -579,6 +579,8 @@ impl<C, St> GatewayClient<C, St> {
         &mut self,
         packets: Vec<MixPacket>,
     ) -> Result<(), GatewayClientError> {
+        debug!("Sending {} mix packets", packets.len());
+
         if !self.authenticated {
             return Err(GatewayClientError::NotAuthenticated);
         }
@@ -623,9 +625,10 @@ impl<C, St> GatewayClient<C, St> {
     ) -> Result<(), GatewayClientError> {
         if let Err(err) = self.send_websocket_message_without_response(msg).await {
             if err.is_closed_connection() && self.should_reconnect_on_failure {
-                info!("Going to attempt a reconnection");
+                debug!("Going to attempt a reconnection");
                 self.attempt_reconnection().await
             } else {
+                warn!("{err}");
                 Err(err)
             }
         } else {
@@ -652,9 +655,9 @@ impl<C, St> GatewayClient<C, St> {
         if !self.authenticated {
             return Err(GatewayClientError::NotAuthenticated);
         }
-        if (mix_packet.sphinx_packet().len() as i64) > self.bandwidth_remaining {
+        if (mix_packet.packet().len() as i64) > self.bandwidth_remaining {
             return Err(GatewayClientError::NotEnoughBandwidth(
-                mix_packet.sphinx_packet().len() as i64,
+                mix_packet.packet().len() as i64,
                 self.bandwidth_remaining,
             ));
         }

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

@@ -50,10 +50,15 @@ impl PacketRouter {
         let ack_overhead = PacketSize::AckPacket.size() + MAX_NODE_ADDRESS_UNPADDED_LEN;
 
         for received_packet in unwrapped_packets {
-            if received_packet.len() == PacketSize::AckPacket.plaintext_size() {
+            if received_packet.len() == PacketSize::AckPacket.plaintext_size()
+                || received_packet.len() == PacketSize::OutfoxAckPacket.plaintext_size()
+            {
                 received_acks.push(received_packet);
             } else if received_packet.len()
                 == PacketSize::RegularPacket.plaintext_size() - ack_overhead
+                || received_packet.len()
+                    == PacketSize::OutfoxRegularPacket.plaintext_size() - ack_overhead
+                || received_packet.len() == PacketSize::OutfoxRegularPacket.size() - 6
             {
                 trace!("routing regular packet");
                 received_messages.push(received_packet);

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

@@ -4,10 +4,11 @@
 use futures::channel::mpsc;
 use futures::StreamExt;
 use log::*;
-use nym_sphinx::framing::codec::SphinxCodec;
-use nym_sphinx::framing::packet::FramedSphinxPacket;
-use nym_sphinx::params::PacketMode;
-use nym_sphinx::{addressing::nodes::NymNodeRoutingAddress, SphinxPacket};
+use nym_sphinx::addressing::nodes::NymNodeRoutingAddress;
+use nym_sphinx::framing::codec::NymCodec;
+use nym_sphinx::framing::packet::FramedNymPacket;
+use nym_sphinx::params::PacketType;
+use nym_sphinx::NymPacket;
 use std::collections::HashMap;
 use std::io;
 use std::net::SocketAddr;
@@ -50,8 +51,8 @@ pub trait SendWithoutResponse {
     fn send_without_response(
         &mut self,
         address: NymNodeRoutingAddress,
-        packet: SphinxPacket,
-        packet_mode: PacketMode,
+        packet: NymPacket,
+        packet_type: PacketType,
     ) -> io::Result<()>;
 }
 
@@ -61,12 +62,12 @@ pub struct Client {
 }
 
 struct ConnectionSender {
-    channel: mpsc::Sender<FramedSphinxPacket>,
+    channel: mpsc::Sender<FramedNymPacket>,
     current_reconnection_attempt: Arc<AtomicU32>,
 }
 
 impl ConnectionSender {
-    fn new(channel: mpsc::Sender<FramedSphinxPacket>) -> Self {
+    fn new(channel: mpsc::Sender<FramedNymPacket>) -> Self {
         ConnectionSender {
             channel,
             current_reconnection_attempt: Arc::new(AtomicU32::new(0)),
@@ -84,7 +85,7 @@ impl Client {
 
     async fn manage_connection(
         address: SocketAddr,
-        receiver: mpsc::Receiver<FramedSphinxPacket>,
+        receiver: mpsc::Receiver<FramedNymPacket>,
         connection_timeout: Duration,
         current_reconnection: &AtomicU32,
     ) {
@@ -96,7 +97,7 @@ impl Client {
                     debug!("Managed to establish connection to {}", address);
                     // if we managed to connect, reset the reconnection count (whatever it might have been)
                     current_reconnection.store(0, Ordering::Release);
-                    Framed::new(stream, SphinxCodec)
+                    Framed::new(stream, NymCodec)
                 }
                 Err(err) => {
                     debug!(
@@ -148,11 +149,7 @@ impl Client {
         }
     }
 
-    fn make_connection(
-        &mut self,
-        address: NymNodeRoutingAddress,
-        pending_packet: FramedSphinxPacket,
-    ) {
+    fn make_connection(&mut self, address: NymNodeRoutingAddress, pending_packet: FramedNymPacket) {
         let (mut sender, receiver) = mpsc::channel(self.config.maximum_connection_buffer_size);
 
         // this CAN'T fail because we just created the channel which has a non-zero capacity
@@ -200,12 +197,12 @@ impl SendWithoutResponse for Client {
     fn send_without_response(
         &mut self,
         address: NymNodeRoutingAddress,
-        packet: SphinxPacket,
-        packet_mode: PacketMode,
+        packet: NymPacket,
+        packet_type: PacketType,
     ) -> io::Result<()> {
         trace!("Sending packet to {:?}", address);
         let framed_packet =
-            FramedSphinxPacket::new(packet, packet_mode, self.config.use_legacy_version);
+            FramedNymPacket::new(packet, packet_type, self.config.use_legacy_version);
 
         if let Some(sender) = self.conn_new.get_mut(&address) {
             if let Err(err) = sender.channel.try_send(framed_packet) {

common/client-libs/mixnet-client/src/forwarder.rs

@@ -59,14 +59,14 @@ impl PacketForwarder {
                      trace!("Going to forward packet to {:?}", mix_packet.next_hop());
 
                     let next_hop = mix_packet.next_hop();
-                    let packet_mode = mix_packet.packet_mode();
-                    let sphinx_packet = mix_packet.into_sphinx_packet();
+                    let packet_type = mix_packet.packet_type();
+                    let packet = mix_packet.into_packet();
                     // we don't care about responses, we just want to fire packets
                     // as quickly as possible
 
                     if let Err(err) =
                         self.mixnet_client
-                            .send_without_response(next_hop, sphinx_packet, packet_mode)
+                            .send_without_response(next_hop, packet, packet_type)
                     {
                         debug!("failed to forward the packet - {err}")
                     }

common/client-libs/validator-client/src/nym_api/mod.rs

@@ -15,7 +15,8 @@ use nym_api_requests::models::{
 };
 use nym_mixnet_contract_common::mixnode::MixNodeDetails;
 use nym_mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixId};
-use nym_service_provider_directory_common::ServiceInfo;
+use nym_name_service_common::response::NamesListResponse;
+use nym_service_provider_directory_common::response::ServicesListResponse;
 use reqwest::{Response, StatusCode};
 use serde::{Deserialize, Serialize};
 use url::Url;
@@ -484,10 +485,18 @@ impl Client {
         .await
     }
 
-    pub async fn get_service_providers(&self) -> Result<Vec<ServiceInfo>, NymAPIError> {
+    pub async fn get_service_providers(&self) -> Result<ServicesListResponse, NymAPIError> {
+        log::trace!("Getting service providers");
         self.query_nym_api(&[routes::API_VERSION, routes::SERVICE_PROVIDERS], NO_PARAMS)
             .await
     }
+
+    //pub async fn get_registered_names(&self) -> Result<Vec<NameEntry>, NymAPIError> {
+    pub async fn get_registered_names(&self) -> Result<NamesListResponse, NymAPIError> {
+        log::trace!("Getting registered names");
+        self.query_nym_api(&[routes::API_VERSION, routes::REGISTERED_NAMES], NO_PARAMS)
+            .await
+    }
 }
 
 // utility function that should solve the double slash problem in validator API forever.

common/client-libs/validator-client/src/nym_api/routes.rs

@@ -33,4 +33,5 @@ pub const AVG_UPTIME: &str = "avg_uptime";
 pub const STAKE_SATURATION: &str = "stake-saturation";
 pub const INCLUSION_CHANCE: &str = "inclusion-probability";
 
-pub const SERVICE_PROVIDERS: &str = "service-providers";
+pub const SERVICE_PROVIDERS: &str = "services";
+pub const REGISTERED_NAMES: &str = "names";

common/client-libs/validator-client/src/nyxd/mod.rs

@@ -16,7 +16,7 @@ use cosmrs::rpc::query::Query;
 use cosmrs::rpc::Error as TendermintRpcError;
 use cosmrs::rpc::HttpClientUrl;
 use cosmrs::tx::Msg;
-use log::debug;
+use log::{debug, trace};
 use nym_network_defaults::{ChainDetails, NymNetworkDetails};
 use serde::{Deserialize, Serialize};
 use std::convert::TryInto;
@@ -79,8 +79,8 @@ impl Config {
         expected_prefix: &str,
     ) -> Result<Option<AccountId>, NyxdError> {
         if let Some(address) = raw {
-            debug!("Raw address:{:?}", raw);
-            debug!("Expected prefix:{:?}", expected_prefix);
+            trace!("Raw address:{:?}", raw);
+            trace!("Expected prefix:{:?}", expected_prefix);
             let parsed: AccountId = address
                 .parse()
                 .map_err(|_| NyxdError::MalformedAccountAddress(address.clone()))?;

common/commands/Cargo.toml

@@ -39,3 +39,4 @@ nym-coconut-bandwidth-contract-common = { path = "../cosmwasm-smart-contracts/co
 nym-coconut-dkg-common = { path = "../cosmwasm-smart-contracts/coconut-dkg" }
 nym-multisig-contract-common = { path = "../cosmwasm-smart-contracts/multisig-contract" }
 nym-service-provider-directory-common = { path = "../cosmwasm-smart-contracts/service-provider-directory" }
+nym-name-service-common = { path = "../cosmwasm-smart-contracts/name-service" }

common/commands/src/validator/mixnet/operators/mod.rs

@@ -5,6 +5,7 @@ use clap::{Args, Subcommand};
 
 pub mod gateway;
 pub mod mixnode;
+pub mod name;
 pub mod service;
 
 #[derive(Debug, Args)]
@@ -22,4 +23,6 @@ pub enum MixnetOperatorsCommands {
     Gateway(gateway::MixnetOperatorsGateway),
     /// Manage your service
     ServiceProvider(service::MixnetOperatorsService),
+    /// Manage your registered name
+    Name(name::MixnetOperatorsName),
 }

common/commands/src/validator/mixnet/operators/name/delete.rs

@@ -0,0 +1,25 @@
+use clap::Parser;
+use log::{error, info};
+use nym_name_service_common::NameId;
+use nym_validator_client::nyxd::{error::NyxdError, traits::NameServiceSigningClient};
+use tap::TapFallible;
+
+use crate::context::SigningClient;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub id: NameId,
+}
+
+pub async fn delete(args: Args, client: SigningClient) -> Result<(), NyxdError> {
+    info!("Deleting registered name alias with id {}", args.id);
+
+    let res = client
+        .delete_name_by_id(args.id, None)
+        .await
+        .tap_err(|err| error!("Failed to delete name: {err:#?}"))?;
+
+    info!("Deleted: {res:?}");
+    Ok(())
+}

common/commands/src/validator/mixnet/operators/name/mod.rs

@@ -0,0 +1,19 @@
+use clap::{Args, Subcommand};
+
+pub mod delete;
+pub mod register;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct MixnetOperatorsName {
+    #[clap(subcommand)]
+    pub command: MixnetOperatorsNameCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum MixnetOperatorsNameCommands {
+    /// Register a name alias for a nym address
+    Register(register::Args),
+    /// Delete name alias for a nym address
+    Delete(delete::Args),
+}

common/commands/src/validator/mixnet/operators/name/register.rs

@@ -0,0 +1,43 @@
+use clap::Parser;
+use log::{error, info};
+use nym_name_service_common::{Address, Coin, NymName};
+use nym_validator_client::nyxd::{error::NyxdError, traits::NameServiceSigningClient};
+use tap::TapFallible;
+
+use crate::context::SigningClient;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    /// Name alias
+    #[clap(long)]
+    pub name: String,
+
+    /// Nym address that the alias is pointing to
+    #[clap(long)]
+    pub nym_address: String,
+
+    /// Deposit to be made to the service provider directory, in curent DENOMINATION (e.g. 'unym')
+    #[clap(long)]
+    pub deposit: u128,
+}
+
+pub async fn register(args: Args, client: SigningClient) -> Result<(), NyxdError> {
+    info!(
+        "Registering name alias '{}' for nym address '{}'",
+        args.name, args.nym_address
+    );
+
+    let name = NymName::new(&args.name).expect("invalid name");
+    let address = Address::new(&args.nym_address);
+
+    let denom = client.current_chain_details().mix_denom.base.as_str();
+    let deposit = Coin::new(args.deposit, denom);
+
+    let res = client
+        .register_name(name, address, deposit.into(), None)
+        .await
+        .tap_err(|err| error!("Failed to register name: {err:#?}"))?;
+
+    info!("Registered name: {res:?}");
+    Ok(())
+}

common/commands/src/validator/mixnet/query/mod.rs

@@ -5,6 +5,7 @@ use clap::{Args, Subcommand};
 
 pub mod query_all_gateways;
 pub mod query_all_mixnodes;
+pub mod query_all_names;
 pub mod query_all_service_providers;
 
 #[derive(Debug, Args)]
@@ -22,4 +23,6 @@ pub enum MixnetQueryCommands {
     Gateways(query_all_gateways::Args),
     /// Query announced service-providers
     ServiceProviders(query_all_service_providers::Args),
+    /// Query registed names
+    Names(query_all_names::Args),
 }

common/commands/src/validator/mixnet/query/query_all_names.rs

@@ -0,0 +1,53 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use comfy_table::Table;
+use nym_validator_client::nym_api::error::NymAPIError;
+
+use crate::context::QueryClientWithNyxd;
+use crate::utils::show_error;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(help = "Optionally, the registered name to display")]
+    pub name: Option<String>,
+}
+
+pub async fn query(args: Args, client: &QueryClientWithNyxd) {
+    log::trace!("Querying all registered names");
+
+    match client.nym_api.get_registered_names().await {
+        Ok(res) => {
+            if let Some(name) = args.name {
+                let name = res.names.iter().find(|name_entry| {
+                    name_entry.name.name.to_string().eq_ignore_ascii_case(&name)
+                });
+                println!(
+                    "{}",
+                    ::serde_json::to_string_pretty(&name).expect("json formatting error")
+                );
+            } else {
+                let mut table = Table::new();
+
+                table.set_header(vec!["Name Id", "Owner", "Nym Address", "Name"]);
+                for name_entry in res.names {
+                    table.add_row(vec![
+                        name_entry.name_id.to_string(),
+                        name_entry.name.owner.to_string(),
+                        name_entry.name.address.to_string(),
+                        name_entry.name.name.to_string(),
+                    ]);
+                }
+
+                println!("The registered names in the directory are:");
+                println!("{table}");
+            }
+        }
+        Err(NymAPIError::NotFound) => {
+            println!("nym-api reports no name endpoint available");
+        }
+        Err(e) => show_error(e),
+    }
+}

common/commands/src/validator/mixnet/query/query_all_service_providers.rs

@@ -19,7 +19,7 @@ pub async fn query(args: Args, client: &QueryClientWithNyxd) {
     match client.nym_api.get_service_providers().await {
         Ok(res) => {
             if let Some(nym_address) = args.nym_address {
-                let service = res.iter().find(|service| {
+                let service = res.services.iter().find(|service| {
                     service
                         .service
                         .nym_address
@@ -33,8 +33,8 @@ pub async fn query(args: Args, client: &QueryClientWithNyxd) {
             } else {
                 let mut table = Table::new();
 
-                table.set_header(vec!["Service Id", "Announcer", "Nym Address"]);
-                for service in res {
+                table.set_header(vec!["Service Id", "Announcer", "Type", "Nym Address"]);
+                for service in res.services {
                     table.add_row(vec![
                         service.service_id.to_string(),
                         service.service.announcer.to_string(),

common/config/src/lib.rs

@@ -10,7 +10,7 @@ use std::any::type_name;
 use std::fmt::Debug;
 #[cfg(unix)]
 use std::os::unix::fs::PermissionsExt;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::{fs, io};
 
@@ -31,17 +31,29 @@ pub trait NymConfig: Default + Serialize + DeserializeOwned {
 
     // default, most probable, implementations; can be easily overridden where required
     fn default_config_directory(id: &str) -> PathBuf {
-        Self::default_root_directory().join(id).join(CONFIG_DIR)
+        Self::default_config_directory_with_root(Self::default_root_directory(), id)
+    }
+
+    fn default_config_directory_with_root<P: AsRef<Path>>(root: P, id: &str) -> PathBuf {
+        root.as_ref().join(id).join(CONFIG_DIR)
     }
 
     fn default_data_directory(id: &str) -> PathBuf {
-        Self::default_root_directory().join(id).join(DATA_DIR)
+        Self::default_data_directory_with_root(Self::default_root_directory(), id)
+    }
+
+    fn default_data_directory_with_root<P: AsRef<Path>>(root: P, id: &str) -> PathBuf {
+        root.as_ref().join(id).join(DATA_DIR)
     }
 
     fn default_config_file_path(id: &str) -> PathBuf {
         Self::default_config_directory(id).join(Self::config_file_name())
     }
 
+    fn default_config_file_path_with_root<P: AsRef<Path>>(root: P, id: &str) -> PathBuf {
+        Self::default_config_directory_with_root(root, id).join(Self::config_file_name())
+    }
+
     // We provide a second set of functions that tries to not panic.
 
     fn try_default_root_directory() -> Option<PathBuf>;
@@ -99,8 +111,12 @@ pub trait NymConfig: Default + Serialize + DeserializeOwned {
 
     fn load_from_file(id: &str) -> io::Result<Self> {
         let file = Self::default_config_file_path(id);
-        log::trace!("Loading from file: {:#?}", file);
-        let config_contents = fs::read_to_string(file)?;
+        Self::load_from_filepath(file)
+    }
+
+    fn load_from_filepath<P: AsRef<Path>>(filepath: P) -> io::Result<Self> {
+        log::trace!("Loading from file: {:#?}", filepath.as_ref().to_owned());
+        let config_contents = fs::read_to_string(filepath)?;
 
         toml::from_str(&config_contents)
             .map_err(|toml_err| io::Error::new(io::ErrorKind::Other, toml_err))

common/cosmwasm-smart-contracts/multisig-contract/Cargo.toml

@@ -8,7 +8,6 @@ edition = "2021"
 [dependencies]
 cw-utils = { workspace = true }
 cw3 = { workspace = true }
-cw3-fixed-multisig = { workspace = true, features = ["library"] }
 cw4 = { workspace= true }
 cw-storage-plus = { workspace = true }
 cosmwasm-schema = { workspace = true }

common/cosmwasm-smart-contracts/name-service/src/lib.rs

@@ -5,3 +5,5 @@ pub mod types;
 
 // Re-export all types at the top-level
 pub use types::*;
+
+pub use cosmwasm_std::{Addr, Coin, Decimal, Fraction};

common/mixnode-common/src/packet_processor/error.rs

@@ -3,12 +3,15 @@
 
 use nym_sphinx_acknowledgements::surb_ack::SurbAckRecoveryError;
 use nym_sphinx_addressing::nodes::NymNodeRoutingAddressError;
-use nym_sphinx_types::Error as SphinxError;
+use nym_sphinx_types::{NymPacketError, SphinxError};
 use thiserror::Error;
 
 #[derive(Error, Debug)]
 pub enum MixProcessingError {
     #[error("failed to process received packet: {0}")]
+    NymPacketProcessingError(#[from] NymPacketError),
+
+    #[error("failed to process received sphinx packet: {0}")]
     SphinxProcessingError(#[from] SphinxError),
 
     #[error("the forward hop address was malformed: {0}")]

common/mixnode-common/src/packet_processor/processor.rs

@@ -7,11 +7,11 @@ use log::*;
 use nym_sphinx_acknowledgements::surb_ack::SurbAck;
 use nym_sphinx_addressing::nodes::NymNodeRoutingAddress;
 use nym_sphinx_forwarding::packet::MixPacket;
-use nym_sphinx_framing::packet::FramedSphinxPacket;
-use nym_sphinx_params::{PacketMode, PacketSize};
+use nym_sphinx_framing::packet::FramedNymPacket;
+use nym_sphinx_params::{PacketSize, PacketType};
 use nym_sphinx_types::{
-    Delay as SphinxDelay, DestinationAddressBytes, NodeAddressBytes, Payload, PrivateKey,
-    ProcessedPacket, SphinxPacket,
+    Delay as SphinxDelay, DestinationAddressBytes, NodeAddressBytes, NymPacket, NymProcessedPacket,
+    PrivateKey, ProcessedPacket,
 };
 use std::convert::TryFrom;
 use std::sync::Arc;
@@ -53,14 +53,14 @@ impl SphinxPacketProcessor {
         feature = "cpucycles",
         instrument(skip(self, packet), fields(cpucycles))
     )]
-    fn perform_initial_sphinx_packet_processing(
+    fn perform_initial_packet_processing(
         &self,
-        packet: SphinxPacket,
-    ) -> Result<ProcessedPacket, MixProcessingError> {
+        packet: NymPacket,
+    ) -> Result<NymProcessedPacket, MixProcessingError> {
         measure!({
             packet.process(&self.sphinx_key).map_err(|err| {
-                debug!("Failed to unwrap Sphinx packet: {err}");
-                MixProcessingError::SphinxProcessingError(err)
+                debug!("Failed to unwrap NymPacket packet: {err}");
+                MixProcessingError::NymPacketProcessingError(err)
             })
         })
     }
@@ -72,17 +72,12 @@ impl SphinxPacketProcessor {
     )]
     fn perform_initial_unwrapping(
         &self,
-        received: FramedSphinxPacket,
-    ) -> Result<ProcessedPacket, MixProcessingError> {
+        received: FramedNymPacket,
+    ) -> Result<NymProcessedPacket, MixProcessingError> {
         measure!({
-            let packet_mode = received.packet_mode();
-            let sphinx_packet = received.into_inner();
+            let packet = received.into_inner();
 
-            if packet_mode.is_old_vpn() {
-                return Err(MixProcessingError::ReceivedOldTypeVpnPacket);
-            }
-
-            self.perform_initial_sphinx_packet_processing(sphinx_packet)
+            self.perform_initial_packet_processing(packet)
         })
     }
 
@@ -90,14 +85,14 @@ impl SphinxPacketProcessor {
     /// and packs all the data in a way that can be easily sent to the next hop.
     fn process_forward_hop(
         &self,
-        packet: SphinxPacket,
+        packet: NymPacket,
         forward_address: NodeAddressBytes,
         delay: SphinxDelay,
-        packet_mode: PacketMode,
+        packet_type: PacketType,
     ) -> Result<MixProcessingResult, MixProcessingError> {
         let next_hop_address = NymNodeRoutingAddress::try_from(forward_address)?;
 
-        let mix_packet = MixPacket::new(next_hop_address, packet, packet_mode);
+        let mix_packet = MixPacket::new(next_hop_address, packet, packet_type);
         Ok(MixProcessingResult::ForwardHop(mix_packet, Some(delay)))
     }
 
@@ -106,14 +101,17 @@ impl SphinxPacketProcessor {
     fn split_hop_data_into_ack_and_message(
         &self,
         mut extracted_data: Vec<u8>,
+        packet_type: PacketType,
     ) -> Result<(Vec<u8>, Vec<u8>), MixProcessingError> {
+        let ack_len = SurbAck::len(Some(packet_type));
+
         // in theory it's impossible for this to fail since it managed to go into correct `match`
         // branch at the caller
-        if extracted_data.len() < SurbAck::len() {
+        if extracted_data.len() < ack_len {
             return Err(MixProcessingError::NoSurbAckInFinalHop);
         }
 
-        let message = extracted_data.split_off(SurbAck::len());
+        let message = extracted_data.split_off(ack_len);
         let ack_data = extracted_data;
         Ok((ack_data, message))
     }
@@ -124,21 +122,30 @@ impl SphinxPacketProcessor {
         &self,
         data: Vec<u8>,
         packet_size: PacketSize,
-        packet_mode: PacketMode,
+        packet_type: PacketType,
     ) -> Result<(Option<MixPacket>, Vec<u8>), MixProcessingError> {
         match packet_size {
-            PacketSize::AckPacket => {
+            PacketSize::AckPacket | PacketSize::OutfoxAckPacket => {
                 trace!("received an ack packet!");
                 Ok((None, data))
             }
             PacketSize::RegularPacket
             | PacketSize::ExtendedPacket8
             | PacketSize::ExtendedPacket16
-            | PacketSize::ExtendedPacket32 => {
+            | PacketSize::ExtendedPacket32
+            | PacketSize::OutfoxRegularPacket => {
                 trace!("received a normal packet!");
-                let (ack_data, message) = self.split_hop_data_into_ack_and_message(data)?;
-                let (ack_first_hop, ack_packet) = SurbAck::try_recover_first_hop_packet(&ack_data)?;
-                let forward_ack = MixPacket::new(ack_first_hop, ack_packet, packet_mode);
+                let (ack_data, message) =
+                    self.split_hop_data_into_ack_and_message(data, packet_type)?;
+                let (ack_first_hop, ack_packet) =
+                    match SurbAck::try_recover_first_hop_packet(&ack_data, packet_type) {
+                        Ok((first_hop, packet)) => (first_hop, packet),
+                        Err(err) => {
+                            debug!("Failed to recover first hop from ack data: {err}");
+                            return Err(err.into());
+                        }
+                    };
+                let forward_ack = MixPacket::new(ack_first_hop, ack_packet, packet_type);
                 Ok((Some(forward_ack), message))
             }
         }
@@ -150,14 +157,12 @@ impl SphinxPacketProcessor {
     fn process_final_hop(
         &self,
         destination: DestinationAddressBytes,
-        payload: Payload,
+        payload: Vec<u8>,
         packet_size: PacketSize,
-        packet_mode: PacketMode,
+        packet_type: PacketType,
     ) -> Result<MixProcessingResult, MixProcessingError> {
-        let packet_message = payload.recover_plaintext()?;
-
         let (forward_ack, message) =
-            self.split_into_ack_and_message(packet_message, packet_size, packet_mode)?;
+            self.split_into_ack_and_message(payload, packet_size, packet_type)?;
 
         Ok(MixProcessingResult::FinalHop(ProcessedFinalHop {
             destination,
@@ -170,18 +175,48 @@ impl SphinxPacketProcessor {
     /// or a final hop.
     fn perform_final_processing(
         &self,
-        packet: ProcessedPacket,
+        packet: NymProcessedPacket,
         packet_size: PacketSize,
-        packet_mode: PacketMode,
+        packet_type: PacketType,
     ) -> Result<MixProcessingResult, MixProcessingError> {
         match packet {
-            ProcessedPacket::ForwardHop(packet, address, delay) => {
-                self.process_forward_hop(*packet, address, delay, packet_mode)
+            NymProcessedPacket::Sphinx(packet) => {
+                match packet {
+                    ProcessedPacket::ForwardHop(packet, address, delay) => self
+                        .process_forward_hop(
+                            NymPacket::Sphinx(*packet),
+                            address,
+                            delay,
+                            packet_type,
+                        ),
+                    // right now there's no use for the surb_id included in the header - probably it should get removed from the
+                    // sphinx all together?
+                    ProcessedPacket::FinalHop(destination, _, payload) => self.process_final_hop(
+                        destination,
+                        payload.recover_plaintext()?,
+                        packet_size,
+                        packet_type,
+                    ),
+                }
             }
-            // right now there's no use for the surb_id included in the header - probably it should get removed from the
-            // sphinx all together?
-            ProcessedPacket::FinalHop(destination, _, payload) => {
-                self.process_final_hop(destination, payload, packet_size, packet_mode)
+            NymProcessedPacket::Outfox(packet) => {
+                let next_address = *packet.next_address();
+                let packet = packet.into_packet();
+                if packet.is_final_hop() {
+                    self.process_final_hop(
+                        DestinationAddressBytes::from_bytes(next_address),
+                        packet.recover_plaintext().to_vec(),
+                        packet_size,
+                        packet_type,
+                    )
+                } else {
+                    let mix_packet = MixPacket::new(
+                        NymNodeRoutingAddress::try_from_bytes(&next_address)?,
+                        NymPacket::Outfox(packet),
+                        PacketType::Outfox,
+                    );
+                    Ok(MixProcessingResult::ForwardHop(mix_packet, None))
+                }
             }
         }
     }
@@ -192,19 +227,19 @@ impl SphinxPacketProcessor {
     )]
     pub fn process_received(
         &self,
-        received: FramedSphinxPacket,
+        received: FramedNymPacket,
     ) -> Result<MixProcessingResult, MixProcessingError> {
         // explicit packet size will help to correctly parse final hop
         measure!({
             let packet_size = received.packet_size();
-            let packet_mode = received.packet_mode();
+            let packet_type = received.packet_type();
 
             // unwrap the sphinx packet and if possible and appropriate, cache keys
             let processed_packet = self.perform_initial_unwrapping(received)?;
 
             // for forward packets, extract next hop and set delay (but do NOT delay here)
             // for final packets, extract SURBAck
-            self.perform_final_processing(processed_packet, packet_size, packet_mode)
+            self.perform_final_processing(processed_packet, packet_size, packet_type)
         })
     }
 }
@@ -226,31 +261,71 @@ mod tests {
 
         let short_data = vec![42u8];
         assert!(processor
-            .split_hop_data_into_ack_and_message(short_data)
+            .split_hop_data_into_ack_and_message(short_data, PacketType::Mix)
             .is_err());
 
-        let sufficient_data = vec![42u8; SurbAck::len()];
+        let sufficient_data = vec![42u8; SurbAck::len(Some(PacketType::Mix))];
         let (ack, data) = processor
-            .split_hop_data_into_ack_and_message(sufficient_data.clone())
+            .split_hop_data_into_ack_and_message(sufficient_data.clone(), PacketType::Mix)
             .unwrap();
         assert_eq!(sufficient_data, ack);
         assert!(data.is_empty());
 
-        let long_data = vec![42u8; SurbAck::len() * 5];
+        let long_data = vec![42u8; SurbAck::len(Some(PacketType::Mix)) * 5];
         let (ack, data) = processor
-            .split_hop_data_into_ack_and_message(long_data)
+            .split_hop_data_into_ack_and_message(long_data, PacketType::Mix)
             .unwrap();
-        assert_eq!(ack.len(), SurbAck::len());
-        assert_eq!(data.len(), SurbAck::len() * 4)
+        assert_eq!(ack.len(), SurbAck::len(Some(PacketType::Mix)));
+        assert_eq!(data.len(), SurbAck::len(Some(PacketType::Mix)) * 4)
+    }
+
+    #[tokio::test]
+    async fn splitting_hop_data_works_for_sufficiently_long_payload_outfox() {
+        let processor = fixture();
+
+        let short_data = vec![42u8];
+        assert!(processor
+            .split_hop_data_into_ack_and_message(short_data, PacketType::Outfox)
+            .is_err());
+
+        let sufficient_data = vec![42u8; SurbAck::len(Some(PacketType::Outfox))];
+        let (ack, data) = processor
+            .split_hop_data_into_ack_and_message(sufficient_data.clone(), PacketType::Outfox)
+            .unwrap();
+        assert_eq!(sufficient_data, ack);
+        assert!(data.is_empty());
+
+        let long_data = vec![42u8; SurbAck::len(Some(PacketType::Outfox)) * 5];
+        let (ack, data) = processor
+            .split_hop_data_into_ack_and_message(long_data, PacketType::Outfox)
+            .unwrap();
+        assert_eq!(ack.len(), SurbAck::len(Some(PacketType::Outfox)));
+        assert_eq!(data.len(), SurbAck::len(Some(PacketType::Outfox)) * 4)
     }
 
     #[tokio::test]
     async fn splitting_into_ack_and_message_returns_whole_data_for_ack() {
         let processor = fixture();
 
-        let data = vec![42u8; SurbAck::len() + 10];
+        let data = vec![42u8; SurbAck::len(Some(PacketType::Mix)) + 10];
         let (ack, message) = processor
-            .split_into_ack_and_message(data.clone(), PacketSize::AckPacket, Default::default())
+            .split_into_ack_and_message(data.clone(), PacketSize::AckPacket, PacketType::Mix)
+            .unwrap();
+        assert!(ack.is_none());
+        assert_eq!(data, message)
+    }
+
+    #[tokio::test]
+    async fn splitting_into_ack_and_message_returns_whole_data_for_ack_outfox() {
+        let processor = fixture();
+
+        let data = vec![42u8; SurbAck::len(Some(PacketType::Outfox)) + 10];
+        let (ack, message) = processor
+            .split_into_ack_and_message(
+                data.clone(),
+                PacketSize::OutfoxAckPacket,
+                PacketType::Outfox,
+            )
             .unwrap();
         assert!(ack.is_none());
         assert_eq!(data, message)

common/node-tester-utils/Cargo.toml

@@ -17,6 +17,7 @@ tokio = { workspace = true, features = ["macros"]}
 nym-crypto = { path = "../crypto", features = ["asymmetric"] }
 nym-task = { path = "../task" }
 nym-topology = { path = "../topology" }
+nym-sphinx-params = { path = "../nymsphinx/params" }
 # TODO: do we need the whole nymsphinx?
 nym-sphinx = { path = "../nymsphinx" }
 

common/node-tester-utils/src/tester.rs

@@ -10,6 +10,7 @@ use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::message::NymMessage;
 use nym_sphinx::params::{PacketSize, DEFAULT_NUM_MIX_HOPS};
 use nym_sphinx::preparer::{FragmentPreparer, PreparedFragment};
+use nym_sphinx_params::PacketType;
 use nym_topology::{gateway, mix, NymTopology};
 use rand::{CryptoRng, Rng};
 use serde::Serialize;
@@ -243,7 +244,14 @@ where
 
         // TODO: can we avoid this arc clone?
         let ack_key = Arc::clone(&self.ack_key);
-        Ok(self.prepare_chunk_for_sending(fragment, topology, &ack_key, &address, &address)?)
+        Ok(self.prepare_chunk_for_sending(
+            fragment,
+            topology,
+            &ack_key,
+            &address,
+            &address,
+            PacketType::Mix,
+        )?)
     }
 
     pub fn create_test_packet<T>(

common/nymsphinx/Cargo.toml

@@ -28,9 +28,6 @@ nym-sphinx-types = { path = "types" }
 nym-crypto = { path = "../crypto", version = "0.3.0" }
 nym-topology = { path = "../topology" }
 
-# outfox
-nym-outfox = { path = "../../nym-outfox" }
-
 [dev-dependencies]
 nym-mixnet-contract-common = { path = "../cosmwasm-smart-contracts/mixnet-contract" }
 nym-crypto = { path = "../crypto", version = "0.3.0", features = ["asymmetric"] }

common/nymsphinx/acknowledgements/src/identifier.rs

@@ -3,9 +3,7 @@
 
 use crate::AckKey;
 use nym_crypto::symmetric::stream_cipher::{self, encrypt, iv_from_slice, random_iv, IvSizeUser};
-use nym_sphinx_params::{
-    packet_sizes::PacketSize, AckEncryptionAlgorithm, SerializedFragmentIdentifier, FRAG_ID_LEN,
-};
+use nym_sphinx_params::{AckEncryptionAlgorithm, SerializedFragmentIdentifier, FRAG_ID_LEN};
 use rand::{CryptoRng, RngCore};
 
 // TODO: should those functions even exist in this file?
@@ -26,12 +24,6 @@ pub fn recover_identifier(
     key: &AckKey,
     iv_id_ciphertext: &[u8],
 ) -> Option<SerializedFragmentIdentifier> {
-    // The content of an 'ACK' packet consists of AckEncryptionAlgorithm::IV followed by
-    // serialized FragmentIdentifier
-    if iv_id_ciphertext.len() != PacketSize::AckPacket.plaintext_size() {
-        return None;
-    }
-
     let iv_size = AckEncryptionAlgorithm::iv_size();
     let iv = iv_from_slice::<AckEncryptionAlgorithm>(&iv_id_ciphertext[..iv_size]);
 

common/nymsphinx/acknowledgements/src/surb_ack.rs

@@ -8,21 +8,18 @@ use nym_sphinx_addressing::nodes::{
     NymNodeRoutingAddress, NymNodeRoutingAddressError, MAX_NODE_ADDRESS_UNPADDED_LEN,
 };
 use nym_sphinx_params::packet_sizes::PacketSize;
-use nym_sphinx_params::DEFAULT_NUM_MIX_HOPS;
-use nym_sphinx_types::builder::SphinxPacketBuilder;
-use nym_sphinx_types::Error as SphinxError;
-use nym_sphinx_types::{
-    delays::{self, Delay},
-    SphinxPacket,
-};
+use nym_sphinx_params::{PacketType, DEFAULT_NUM_MIX_HOPS};
+use nym_sphinx_types::delays::{self, Delay};
+use nym_sphinx_types::{NymPacket, NymPacketError, MIN_PACKET_SIZE};
 use nym_topology::{NymTopology, NymTopologyError};
 use rand::{CryptoRng, RngCore};
 use std::convert::TryFrom;
 use std::time;
 use thiserror::Error;
 
+#[derive(Debug)]
 pub struct SurbAck {
-    surb_ack_packet: SphinxPacket,
+    surb_ack_packet: NymPacket,
     first_hop_address: NymNodeRoutingAddress,
     expected_total_delay: Delay,
 }
@@ -35,8 +32,8 @@ pub enum SurbAckRecoveryError {
     #[error("could not extract first hop address information - {0}")]
     InvalidAddress(#[from] NymNodeRoutingAddressError),
 
-    #[error("the contained sphinx packet was not correctly formed - {0}")]
-    InvalidSphinxPacket(#[from] SphinxError),
+    #[error("packet: {0}")]
+    NymPacket(#[from] NymPacketError),
 }
 
 impl SurbAck {
@@ -47,6 +44,7 @@ impl SurbAck {
         marshaled_fragment_id: [u8; 5],
         average_delay: time::Duration,
         topology: &NymTopology,
+        packet_type: PacketType,
     ) -> Result<Self, NymTopologyError>
     where
         R: RngCore + CryptoRng,
@@ -57,11 +55,34 @@ impl SurbAck {
         let destination = recipient.as_sphinx_destination();
 
         let surb_ack_payload = prepare_identifier(rng, ack_key, marshaled_fragment_id);
+        let packet_size = match packet_type {
+            PacketType::Outfox => surb_ack_payload.len().max(MIN_PACKET_SIZE),
+            PacketType::Mix => PacketSize::AckPacket.payload_size(),
+            PacketType::Vpn => PacketSize::AckPacket.payload_size(),
+        };
 
-        let surb_ack_packet = SphinxPacketBuilder::new()
-            .with_payload_size(PacketSize::AckPacket.payload_size())
-            .build_packet(surb_ack_payload, &route, &destination, &delays)
-            .unwrap();
+        let surb_ack_packet = match packet_type {
+            PacketType::Outfox => NymPacket::outfox_build(
+                surb_ack_payload,
+                route.as_slice(),
+                &destination,
+                Some(packet_size),
+            )?,
+            PacketType::Mix => NymPacket::sphinx_build(
+                packet_size,
+                surb_ack_payload,
+                &route,
+                &destination,
+                &delays,
+            )?,
+            PacketType::Vpn => NymPacket::sphinx_build(
+                packet_size,
+                surb_ack_payload,
+                &route,
+                &destination,
+                &delays,
+            )?,
+        };
 
         // in our case, the last hop is a gateway that does NOT do any delays
         let expected_total_delay = delays.iter().take(delays.len() - 1).sum();
@@ -75,45 +96,50 @@ impl SurbAck {
         })
     }
 
-    pub fn len() -> usize {
+    pub fn len(packet_type: Option<PacketType>) -> usize {
         // TODO: this will be variable once/if we decide to introduce optimization described
         // in common/nymsphinx/chunking/src/lib.rs:available_plaintext_size()
-        PacketSize::AckPacket.size() + MAX_NODE_ADDRESS_UNPADDED_LEN
+        let packet_type = packet_type.unwrap_or(PacketType::Mix);
+        match packet_type {
+            PacketType::Outfox => {
+                PacketSize::OutfoxAckPacket.size() + MAX_NODE_ADDRESS_UNPADDED_LEN
+            }
+            PacketType::Mix => PacketSize::AckPacket.size() + MAX_NODE_ADDRESS_UNPADDED_LEN,
+            PacketType::Vpn => PacketSize::AckPacket.size() + MAX_NODE_ADDRESS_UNPADDED_LEN,
+        }
     }
 
     pub fn expected_total_delay(&self) -> Delay {
         self.expected_total_delay
     }
 
-    pub fn prepare_for_sending(self) -> (Delay, Vec<u8>) {
+    pub fn prepare_for_sending(self) -> Result<(Delay, Vec<u8>), SurbAckRecoveryError> {
         // SURB_FIRST_HOP || SURB_ACK
         let surb_bytes: Vec<_> = self
             .first_hop_address
             .as_zero_padded_bytes(MAX_NODE_ADDRESS_UNPADDED_LEN)
             .into_iter()
-            .chain(self.surb_ack_packet.to_bytes().into_iter())
+            .chain(self.surb_ack_packet.to_bytes()?.into_iter())
             .collect();
-        (self.expected_total_delay, surb_bytes)
+        Ok((self.expected_total_delay, surb_bytes))
     }
 
     // partial reciprocal of `prepare_for_sending` performed by the gateway
     pub fn try_recover_first_hop_packet(
         b: &[u8],
-    ) -> Result<(NymNodeRoutingAddress, SphinxPacket), SurbAckRecoveryError> {
-        if b.len() != Self::len() {
-            Err(SurbAckRecoveryError::InvalidPacketSize {
-                received: b.len(),
-                expected: Self::len(),
-            })
-        } else {
-            let address = NymNodeRoutingAddress::try_from_bytes(b)?;
+        packet_type: PacketType,
+    ) -> Result<(NymNodeRoutingAddress, NymPacket), SurbAckRecoveryError> {
+        let address = NymNodeRoutingAddress::try_from_bytes(b)?;
 
-            // TODO: this will be variable once/if we decide to introduce optimization described
-            // in common/nymsphinx/chunking/src/lib.rs:available_plaintext_size()
-            let address_offset = MAX_NODE_ADDRESS_UNPADDED_LEN;
-            let packet = SphinxPacket::from_bytes(&b[address_offset..])?;
+        // TODO: this will be variable once/if we decide to introduce optimization described
+        // in common/nymsphinx/chunking/src/lib.rs:available_plaintext_size()
+        let address_offset = MAX_NODE_ADDRESS_UNPADDED_LEN;
+        let packet = match packet_type {
+            PacketType::Outfox => NymPacket::outfox_from_bytes(&b[address_offset..])?,
+            PacketType::Mix => NymPacket::sphinx_from_bytes(&b[address_offset..])?,
+            PacketType::Vpn => NymPacket::sphinx_from_bytes(&b[address_offset..])?,
+        };
 
-            Ok((address, packet))
-        }
+        Ok((address, packet))
     }
 }

common/nymsphinx/anonymous-replies/src/reply_surb.rs

@@ -6,8 +6,8 @@ use nym_crypto::{generic_array::typenum::Unsigned, Digest};
 use nym_sphinx_addressing::clients::Recipient;
 use nym_sphinx_addressing::nodes::{NymNodeRoutingAddress, MAX_NODE_ADDRESS_UNPADDED_LEN};
 use nym_sphinx_params::packet_sizes::PacketSize;
-use nym_sphinx_params::{ReplySurbKeyDigestAlgorithm, DEFAULT_NUM_MIX_HOPS};
-use nym_sphinx_types::{delays, Error as SphinxError, SURBMaterial, SphinxPacket, SURB};
+use nym_sphinx_params::{PacketType, ReplySurbKeyDigestAlgorithm, DEFAULT_NUM_MIX_HOPS};
+use nym_sphinx_types::{delays, NymPacket, SURBMaterial, SphinxError, SURB};
 use nym_topology::{NymTopology, NymTopologyError};
 use rand::{CryptoRng, RngCore};
 use serde::de::{Error as SerdeError, Visitor};
@@ -173,7 +173,8 @@ impl ReplySurb {
         self,
         message: M,
         packet_size: PacketSize,
-    ) -> Result<(SphinxPacket, NymNodeRoutingAddress), ReplySurbError> {
+        _packet_type: PacketType,
+    ) -> Result<(NymPacket, NymNodeRoutingAddress), ReplySurbError> {
         let message_bytes = message.as_ref();
         if message_bytes.len() != packet_size.plaintext_size() {
             return Err(ReplySurbError::UnpaddedMessageError);
@@ -187,6 +188,6 @@ impl ReplySurb {
 
         let first_hop_address = NymNodeRoutingAddress::try_from(first_hop).unwrap();
 
-        Ok((packet, first_hop_address))
+        Ok((NymPacket::Sphinx(packet), first_hop_address))
     }
 }

common/nymsphinx/cover/src/lib.rs

@@ -3,7 +3,7 @@
 
 use nym_crypto::shared_key::new_ephemeral_shared_key;
 use nym_crypto::symmetric::stream_cipher;
-use nym_sphinx_acknowledgements::surb_ack::SurbAck;
+use nym_sphinx_acknowledgements::surb_ack::{SurbAck, SurbAckRecoveryError};
 use nym_sphinx_acknowledgements::AckKey;
 use nym_sphinx_addressing::clients::Recipient;
 use nym_sphinx_addressing::nodes::NymNodeRoutingAddress;
@@ -11,10 +11,9 @@ use nym_sphinx_chunking::fragment::COVER_FRAG_ID;
 use nym_sphinx_forwarding::packet::MixPacket;
 use nym_sphinx_params::packet_sizes::PacketSize;
 use nym_sphinx_params::{
-    PacketEncryptionAlgorithm, PacketHkdfAlgorithm, PacketMode, DEFAULT_NUM_MIX_HOPS,
+    PacketEncryptionAlgorithm, PacketHkdfAlgorithm, PacketType, DEFAULT_NUM_MIX_HOPS,
 };
-use nym_sphinx_types::builder::SphinxPacketBuilder;
-use nym_sphinx_types::{delays, Error as SphinxError};
+use nym_sphinx_types::{delays, NymPacket};
 use nym_topology::{NymTopology, NymTopologyError};
 use rand::{CryptoRng, RngCore};
 use std::convert::TryFrom;
@@ -28,8 +27,11 @@ pub enum CoverMessageError {
     #[error("Could not construct cover message due to invalid topology - {0}")]
     InvalidTopologyError(#[from] NymTopologyError),
 
-    #[error("Could not construct a valid sphinx packet - {0}")]
-    SphinxError(#[from] SphinxError),
+    #[error("SurbAck: {0}")]
+    SurbAck(#[from] SurbAckRecoveryError),
+
+    #[error("NymPacket: {0}")]
+    NymPacket(#[from] nym_sphinx_types::NymPacketError),
 }
 
 pub fn generate_loop_cover_surb_ack<R>(
@@ -38,6 +40,7 @@ pub fn generate_loop_cover_surb_ack<R>(
     ack_key: &AckKey,
     full_address: &Recipient,
     average_ack_delay: time::Duration,
+    packet_type: PacketType,
 ) -> Result<SurbAck, CoverMessageError>
 where
     R: RngCore + CryptoRng,
@@ -49,9 +52,11 @@ where
         COVER_FRAG_ID.to_bytes(),
         average_ack_delay,
         topology,
+        packet_type,
     )?)
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn generate_loop_cover_packet<R>(
     rng: &mut R,
     topology: &NymTopology,
@@ -60,14 +65,21 @@ pub fn generate_loop_cover_packet<R>(
     average_ack_delay: time::Duration,
     average_packet_delay: time::Duration,
     packet_size: PacketSize,
+    packet_type: PacketType,
 ) -> Result<MixPacket, CoverMessageError>
 where
     R: RngCore + CryptoRng,
 {
     // we don't care about total ack delay - we will not be retransmitting it anyway
-    let (_, ack_bytes) =
-        generate_loop_cover_surb_ack(rng, topology, ack_key, full_address, average_ack_delay)?
-            .prepare_for_sending();
+    let (_, ack_bytes) = generate_loop_cover_surb_ack(
+        rng,
+        topology,
+        ack_key,
+        full_address,
+        average_ack_delay,
+        packet_type,
+    )?
+    .prepare_for_sending()?;
 
     // cover message can't be distinguishable from a normal traffic so we have to go through
     // all the effort of key generation, encryption, etc. Note here we are generating shared key
@@ -111,15 +123,18 @@ where
     let destination = full_address.as_sphinx_destination();
 
     // once merged, that's an easy rng injection point for sphinx packets : )
-    let packet = SphinxPacketBuilder::new()
-        .with_payload_size(packet_size.payload_size())
-        .build_packet(packet_payload, &route, &destination, &delays)
-        .unwrap();
+    let packet = NymPacket::sphinx_build(
+        packet_size.payload_size(),
+        packet_payload,
+        &route,
+        &destination,
+        &delays,
+    )?;
 
     let first_hop_address =
         NymNodeRoutingAddress::try_from(route.first().unwrap().address).unwrap();
 
-    Ok(MixPacket::new(first_hop_address, packet, PacketMode::Mix))
+    Ok(MixPacket::new(first_hop_address, packet, PacketType::Mix))
 }
 
 /// Helper function used to determine if given message represents a loop cover message.

common/nymsphinx/forwarding/Cargo.toml

@@ -12,3 +12,4 @@ nym-sphinx-addressing = { path = "../addressing" }
 nym-sphinx-params = { path = "../params" }
 nym-sphinx-types = { path = "../types" }
 nym-outfox = { path = "../../../nym-outfox" }
+thiserror = "1"

common/nymsphinx/forwarding/src/packet.rs

@@ -2,42 +2,28 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use nym_sphinx_addressing::nodes::{NymNodeRoutingAddress, NymNodeRoutingAddressError};
-use nym_sphinx_params::{PacketMode, PacketSize};
-use nym_sphinx_types::SphinxPacket;
+use nym_sphinx_params::{PacketSize, PacketType};
+use nym_sphinx_types::{NymPacket, NymPacketError};
 use std::convert::TryFrom;
-use std::fmt::{self, Debug, Display, Formatter};
+use std::fmt::{self, Debug, Formatter};
+use thiserror::Error;
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum MixPacketFormattingError {
+    #[error("too few bytes provided to recover from bytes")]
     TooFewBytesProvided,
-    InvalidPacketMode,
+    #[error("provided packet mode is invalid")]
+    InvalidPacketType,
+    #[error("received request had invalid size - received {0}")]
     InvalidPacketSize(usize),
+    #[error("address field was incorrectly encoded")]
     InvalidAddress,
+    #[error("received sphinx packet was malformed")]
     MalformedSphinxPacket,
+    #[error("Packet: {0}")]
+    Packet(#[from] NymPacketError),
 }
 
-impl Display for MixPacketFormattingError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        use MixPacketFormattingError::*;
-        match self {
-            TooFewBytesProvided => write!(f, "Too few bytes provided to recover from bytes"),
-            InvalidAddress => write!(f, "address field was incorrectly encoded"),
-            InvalidPacketSize(actual) =>
-                write!(
-                    f,
-                    "received request had invalid size. (actual: {}, but expected one of: {} (ACK), {} (REGULAR), {}, {}, {} (EXTENDED))",
-                    actual, PacketSize::AckPacket.size(), PacketSize::RegularPacket.size(),
-                    PacketSize::ExtendedPacket8.size(), PacketSize::ExtendedPacket16.size(),
-                    PacketSize::ExtendedPacket32.size()
-                ),
-            MalformedSphinxPacket => write!(f, "received sphinx packet was malformed"),
-            InvalidPacketMode => write!(f, "provided packet mode is invalid")
-        }
-    }
-}
-
-impl std::error::Error for MixPacketFormattingError {}
-
 impl From<NymNodeRoutingAddressError> for MixPacketFormattingError {
     fn from(_: NymNodeRoutingAddressError) -> Self {
         MixPacketFormattingError::InvalidAddress
@@ -46,19 +32,16 @@ impl From<NymNodeRoutingAddressError> for MixPacketFormattingError {
 
 pub struct MixPacket {
     next_hop: NymNodeRoutingAddress,
-    sphinx_packet: SphinxPacket,
-    packet_mode: PacketMode,
+    packet: NymPacket,
+    packet_type: PacketType,
 }
 
 impl Debug for MixPacket {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(
             f,
-            "MixPacket to {:?} with packet_mode {:?}. Sphinx header: {:?}, payload length: {}",
-            self.next_hop,
-            self.packet_mode,
-            self.sphinx_packet.header,
-            self.sphinx_packet.payload.len()
+            "MixPacket to {:?} with packet_type {:?}. Packet {:?}",
+            self.next_hop, self.packet_type, self.packet
         )
     }
 }
@@ -66,13 +49,13 @@ impl Debug for MixPacket {
 impl MixPacket {
     pub fn new(
         next_hop: NymNodeRoutingAddress,
-        sphinx_packet: SphinxPacket,
-        packet_mode: PacketMode,
+        packet: NymPacket,
+        packet_type: PacketType,
     ) -> Self {
         MixPacket {
             next_hop,
-            sphinx_packet,
-            packet_mode,
+            packet,
+            packet_type,
         }
     }
 
@@ -80,52 +63,52 @@ impl MixPacket {
         self.next_hop
     }
 
-    pub fn sphinx_packet(&self) -> &SphinxPacket {
-        &self.sphinx_packet
+    pub fn packet(&self) -> &NymPacket {
+        &self.packet
     }
 
-    pub fn into_sphinx_packet(self) -> SphinxPacket {
-        self.sphinx_packet
+    pub fn into_packet(self) -> NymPacket {
+        self.packet
     }
 
-    pub fn packet_mode(&self) -> PacketMode {
-        self.packet_mode
+    pub fn packet_type(&self) -> PacketType {
+        self.packet_type
     }
 
     // the message is formatted as follows:
-    // PACKET_MODE || FIRST_HOP || SPHINX_PACKET
+    // packet_type || FIRST_HOP || packet
     pub fn try_from_bytes(b: &[u8]) -> Result<Self, MixPacketFormattingError> {
-        let packet_mode = match PacketMode::try_from(b[0]) {
+        let packet_type = match PacketType::try_from(b[0]) {
             Ok(mode) => mode,
-            Err(_) => return Err(MixPacketFormattingError::InvalidPacketMode),
+            Err(_) => return Err(MixPacketFormattingError::InvalidPacketType),
         };
 
         let next_hop = NymNodeRoutingAddress::try_from_bytes(&b[1..])?;
         let addr_offset = next_hop.bytes_min_len();
 
-        let sphinx_packet_data = &b[addr_offset + 1..];
-        let packet_size = sphinx_packet_data.len();
+        let packet_data = &b[addr_offset + 1..];
+        let packet_size = packet_data.len();
         if PacketSize::get_type(packet_size).is_err() {
             Err(MixPacketFormattingError::InvalidPacketSize(packet_size))
         } else {
-            let sphinx_packet = match SphinxPacket::from_bytes(sphinx_packet_data) {
-                Ok(packet) => packet,
-                Err(_) => return Err(MixPacketFormattingError::MalformedSphinxPacket),
+            let packet = match packet_type {
+                PacketType::Outfox => NymPacket::outfox_from_bytes(packet_data)?,
+                _ => NymPacket::sphinx_from_bytes(packet_data)?,
             };
 
             Ok(MixPacket {
                 next_hop,
-                sphinx_packet,
-                packet_mode,
+                packet,
+                packet_type,
             })
         }
     }
 
-    pub fn into_bytes(self) -> Vec<u8> {
-        std::iter::once(self.packet_mode as u8)
+    pub fn into_bytes(self) -> Result<Vec<u8>, MixPacketFormattingError> {
+        Ok(std::iter::once(self.packet_type as u8)
             .chain(self.next_hop.as_bytes().into_iter())
-            .chain(self.sphinx_packet.to_bytes().into_iter())
-            .collect()
+            .chain(self.packet.to_bytes()?.into_iter())
+            .collect())
     }
 }
 

common/nymsphinx/framing/src/codec.rs

@@ -1,65 +1,56 @@
 // Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::packet::{FramedSphinxPacket, Header};
+use crate::packet::{FramedNymPacket, Header};
 use bytes::{Buf, BufMut, BytesMut};
-use nym_sphinx_params::packet_modes::InvalidPacketMode;
 use nym_sphinx_params::packet_sizes::{InvalidPacketSize, PacketSize};
-use nym_sphinx_types::Error as SphinxError;
-use nym_sphinx_types::SphinxPacket;
+use nym_sphinx_params::packet_types::InvalidPacketType;
+use nym_sphinx_params::PacketType;
+use nym_sphinx_types::{NymPacket, NymPacketError};
 use std::io;
 use thiserror::Error;
 use tokio_util::codec::{Decoder, Encoder};
 
 #[derive(Error, Debug)]
-pub enum SphinxCodecError {
+pub enum NymCodecError {
     #[error("the packet size information was malformed - {0}")]
     InvalidPacketSize(#[from] InvalidPacketSize),
 
     #[error("the packet mode information was malformed - {0}")]
-    InvalidPacketMode(#[from] InvalidPacketMode),
-
-    #[error("the actual sphinx packet was malformed - {0}")]
-    MalformedSphinxPacket(#[from] SphinxError),
+    InvalidPacketType(#[from] InvalidPacketType),
 
     #[error("encountered an IO error - {0}")]
     IoError(#[from] io::Error),
-}
 
-impl From<SphinxCodecError> for io::Error {
-    fn from(err: SphinxCodecError) -> Self {
-        match err {
-            SphinxCodecError::InvalidPacketSize(source) => {
-                io::Error::new(io::ErrorKind::InvalidInput, source)
-            }
-            SphinxCodecError::InvalidPacketMode(source) => {
-                io::Error::new(io::ErrorKind::InvalidInput, source)
-            }
-            SphinxCodecError::MalformedSphinxPacket(source) => {
-                io::Error::new(io::ErrorKind::InvalidData, source)
-            }
-            SphinxCodecError::IoError(err) => err,
-        }
-    }
+    #[error("encountered a packet error - {0}")]
+    NymPacket(#[from] NymPacketError),
+
+    #[error("could not convert to bytes")]
+    ToBytes,
+
+    #[error("could not convert to bytes")]
+    FromBytes,
 }
 
 // TODO: in the future it could be extended to have state containing symmetric encryption key
 // so that all data could be encrypted easily (alternatively we could just slap TLS)
-pub struct SphinxCodec;
+pub struct NymCodec;
 
-impl Encoder<FramedSphinxPacket> for SphinxCodec {
-    type Error = SphinxCodecError;
+impl Encoder<FramedNymPacket> for NymCodec {
+    type Error = NymCodecError;
 
-    fn encode(&mut self, item: FramedSphinxPacket, dst: &mut BytesMut) -> Result<(), Self::Error> {
+    fn encode(&mut self, item: FramedNymPacket, dst: &mut BytesMut) -> Result<(), Self::Error> {
         item.header.encode(dst);
-        dst.put(item.packet.to_bytes().as_ref());
+        let packet_bytes = item.packet.to_bytes()?;
+        let encoded = packet_bytes.as_slice();
+        dst.put(encoded);
         Ok(())
     }
 }
 
-impl Decoder for SphinxCodec {
-    type Item = FramedSphinxPacket;
-    type Error = SphinxCodecError;
+impl Decoder for NymCodec {
+    type Item = FramedNymPacket;
+    type Error = NymCodecError;
 
     fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
         if src.is_empty() {
@@ -76,23 +67,32 @@ impl Decoder for SphinxCodec {
             None => return Ok(None), // we have some data but not enough to get header back
         };
 
-        let sphinx_packet_size = header.packet_size.size();
-        let frame_len = header.size() + sphinx_packet_size;
+        let packet_size = header.packet_size.size();
+        let frame_len = header.size() + packet_size;
 
         if src.len() < frame_len {
             // we don't have enough bytes to read the rest of frame
-            src.reserve(sphinx_packet_size);
+            src.reserve(packet_size);
             return Ok(None);
         }
 
         // advance buffer past the header - at this point we have enough bytes
         src.advance(header.size());
-        let sphinx_packet_bytes = src.split_to(sphinx_packet_size);
+        let packet_bytes = src.split_to(packet_size);
+        let packet = if let Some(slice) = packet_bytes.get(..) {
+            // here it could be debatable whether stream is corrupt or not,
+            // but let's go with the safer approach and assume it is.
+            match header.packet_type {
+                PacketType::Outfox => NymPacket::outfox_from_bytes(slice)?,
+                PacketType::Mix => NymPacket::sphinx_from_bytes(slice)?,
+                PacketType::Vpn => NymPacket::sphinx_from_bytes(slice)?,
+            }
+        } else {
+            return Ok(None);
+        };
 
-        // here it could be debatable whether stream is corrupt or not,
-        // but let's go with the safer approach and assume it is.
-        let packet = SphinxPacket::from_bytes(&sphinx_packet_bytes)?;
-        let nymsphinx_packet = FramedSphinxPacket { header, packet };
+        // let packet = SphinxPacket::from_bytes(&sphinx_packet_bytes)?;
+        let nymsphinx_packet = FramedNymPacket { header, packet };
 
         // As per docs:
         // Before returning from the function, implementations should ensure that the buffer
@@ -104,6 +104,7 @@ impl Decoder for SphinxCodec {
         // reserve for that.
         // we also assume the next packet coming from the same client will use exactly the same versioning
         // as the current packet
+
         let mut allocate_for_next_packet = header.size() + PacketSize::AckPacket.size();
         if !src.is_empty() {
             match Header::decode(src) {
@@ -120,7 +121,6 @@ impl Decoder for SphinxCodec {
             };
         }
         src.reserve(allocate_for_next_packet);
-
         Ok(Some(nymsphinx_packet))
     }
 }
@@ -128,13 +128,47 @@ impl Decoder for SphinxCodec {
 #[cfg(test)]
 mod packet_encoding {
     use super::*;
-    use nym_sphinx_types::builder::SphinxPacketBuilder;
     use nym_sphinx_types::{
         crypto, Delay as SphinxDelay, Destination, DestinationAddressBytes, Node, NodeAddressBytes,
         DESTINATION_ADDRESS_LENGTH, IDENTIFIER_LENGTH, NODE_ADDRESS_LENGTH,
     };
 
-    fn make_valid_sphinx_packet(size: PacketSize) -> SphinxPacket {
+    fn make_valid_outfox_packet(size: PacketSize) -> NymPacket {
+        let (_, node1_pk) = crypto::keygen();
+        let node1 = Node::new(
+            NodeAddressBytes::from_bytes([5u8; NODE_ADDRESS_LENGTH]),
+            node1_pk,
+        );
+        let (_, node2_pk) = crypto::keygen();
+        let node2 = Node::new(
+            NodeAddressBytes::from_bytes([4u8; NODE_ADDRESS_LENGTH]),
+            node2_pk,
+        );
+        let (_, node3_pk) = crypto::keygen();
+        let node3 = Node::new(
+            NodeAddressBytes::from_bytes([2u8; NODE_ADDRESS_LENGTH]),
+            node3_pk,
+        );
+
+        let (_, node4_pk) = crypto::keygen();
+        let node4 = Node::new(
+            NodeAddressBytes::from_bytes([2u8; NODE_ADDRESS_LENGTH]),
+            node4_pk,
+        );
+
+        let destination = Destination::new(
+            DestinationAddressBytes::from_bytes([3u8; DESTINATION_ADDRESS_LENGTH]),
+            [4u8; IDENTIFIER_LENGTH],
+        );
+
+        let route = &[node1, node2, node3, node4];
+
+        let payload = vec![1; 48];
+
+        NymPacket::outfox_build(payload, route, &destination, Some(size.plaintext_size())).unwrap()
+    }
+
+    fn make_valid_sphinx_packet(size: PacketSize) -> NymPacket {
         let (_, node1_pk) = crypto::keygen();
         let node1 = Node::new(
             NodeAddressBytes::from_bytes([5u8; NODE_ADDRESS_LENGTH]),
@@ -161,9 +195,7 @@ mod packet_encoding {
             SphinxDelay::new_from_nanos(42),
             SphinxDelay::new_from_nanos(42),
         ];
-        SphinxPacketBuilder::new()
-            .with_payload_size(size.payload_size())
-            .build_packet(b"foomp", &route, &destination, &delays)
+        NymPacket::sphinx_build(size.payload_size(), b"foomp", &route, &destination, &delays)
             .unwrap()
     }
 
@@ -171,32 +203,50 @@ mod packet_encoding {
     fn whole_packet_can_be_decoded_from_a_valid_encoded_instance() {
         let header = Default::default();
         let sphinx_packet = make_valid_sphinx_packet(Default::default());
-        let sphinx_bytes = sphinx_packet.to_bytes();
+        let sphinx_bytes = sphinx_packet.to_bytes().unwrap();
 
-        let packet = FramedSphinxPacket {
+        let packet = FramedNymPacket {
             header,
             packet: sphinx_packet,
         };
 
         let mut bytes = BytesMut::new();
-        SphinxCodec.encode(packet, &mut bytes).unwrap();
-        let decoded = SphinxCodec.decode(&mut bytes).unwrap().unwrap();
+        NymCodec.encode(packet, &mut bytes).unwrap();
+        let decoded = NymCodec.decode(&mut bytes).unwrap().unwrap();
 
         assert_eq!(decoded.header, header);
-        assert_eq!(decoded.packet.to_bytes(), sphinx_bytes)
+        assert_eq!(decoded.packet.to_bytes().unwrap(), sphinx_bytes)
+    }
+
+    #[test]
+    fn whole_outfox_can_be_decoded_from_a_valid_encoded_instance() {
+        let header = Header::outfox();
+        let packet = make_valid_outfox_packet(PacketSize::OutfoxRegularPacket);
+        let packet_bytes = packet.to_bytes().unwrap();
+
+        NymPacket::outfox_from_bytes(packet_bytes.as_slice()).unwrap();
+
+        let packet = FramedNymPacket { header, packet };
+
+        let mut bytes = BytesMut::new();
+        NymCodec.encode(packet, &mut bytes).unwrap();
+        let decoded = NymCodec.decode(&mut bytes).unwrap().unwrap();
+
+        assert_eq!(decoded.header, header);
+        assert_eq!(decoded.packet.to_bytes().unwrap(), packet_bytes)
     }
 
     #[cfg(test)]
     mod decode_will_allocate_enough_bytes_for_next_call {
         use super::*;
         use nym_sphinx_params::packet_version::PacketVersion;
-        use nym_sphinx_params::PacketMode;
+        use nym_sphinx_params::PacketType;
 
         #[test]
         fn for_empty_bytes() {
             // empty bytes should allocate for header + ack packet
             let mut empty_bytes = BytesMut::new();
-            assert!(SphinxCodec.decode(&mut empty_bytes).unwrap().is_none());
+            assert!(NymCodec.decode(&mut empty_bytes).unwrap().is_none());
             assert_eq!(
                 empty_bytes.capacity(),
                 Header::LEGACY_SIZE + PacketSize::AckPacket.size()
@@ -217,11 +267,11 @@ mod packet_encoding {
                 let header = Header {
                     packet_version: PacketVersion::Legacy,
                     packet_size,
-                    packet_mode: Default::default(),
+                    ..Default::default()
                 };
                 let mut bytes = BytesMut::new();
                 header.encode(&mut bytes);
-                assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());
+                assert!(NymCodec.decode(&mut bytes).unwrap().is_none());
 
                 assert_eq!(bytes.capacity(), Header::LEGACY_SIZE + packet_size.size())
             }
@@ -241,11 +291,11 @@ mod packet_encoding {
                 let header = Header {
                     packet_version: PacketVersion::Versioned(123),
                     packet_size,
-                    packet_mode: Default::default(),
+                    ..Default::default()
                 };
                 let mut bytes = BytesMut::new();
                 header.encode(&mut bytes);
-                assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());
+                assert!(NymCodec.decode(&mut bytes).unwrap().is_none());
 
                 assert_eq!(
                     bytes.capacity(),
@@ -257,18 +307,17 @@ mod packet_encoding {
         #[test]
         fn for_full_frame_with_legacy_header() {
             // if full frame is used exactly, there should be enough space for header + ack packet
-            let packet = FramedSphinxPacket {
+            let packet = FramedNymPacket {
                 header: Header {
                     packet_version: PacketVersion::Legacy,
-                    packet_size: Default::default(),
-                    packet_mode: Default::default(),
+                    ..Default::default()
                 },
                 packet: make_valid_sphinx_packet(Default::default()),
             };
 
             let mut bytes = BytesMut::new();
-            SphinxCodec.encode(packet, &mut bytes).unwrap();
-            assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
+            NymCodec.encode(packet, &mut bytes).unwrap();
+            assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
             assert_eq!(
                 bytes.capacity(),
                 Header::LEGACY_SIZE + PacketSize::AckPacket.size()
@@ -278,14 +327,14 @@ mod packet_encoding {
         #[test]
         fn for_full_frame_with_versioned_header() {
             // if full frame is used exactly, there should be enough space for header + ack packet
-            let packet = FramedSphinxPacket {
+            let packet = FramedNymPacket {
                 header: Header::default(),
                 packet: make_valid_sphinx_packet(Default::default()),
             };
 
             let mut bytes = BytesMut::new();
-            SphinxCodec.encode(packet, &mut bytes).unwrap();
-            assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
+            NymCodec.encode(packet, &mut bytes).unwrap();
+            assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
             assert_eq!(
                 bytes.capacity(),
                 Header::VERSIONED_SIZE + PacketSize::AckPacket.size()
@@ -304,20 +353,19 @@ mod packet_encoding {
             ];
 
             for packet_size in packet_sizes {
-                let first_packet = FramedSphinxPacket {
+                let first_packet = FramedNymPacket {
                     header: Header {
                         packet_version: PacketVersion::Legacy,
-                        packet_size: Default::default(),
-                        packet_mode: Default::default(),
+                        ..Default::default()
                     },
                     packet: make_valid_sphinx_packet(Default::default()),
                 };
 
                 let mut bytes = BytesMut::new();
-                SphinxCodec.encode(first_packet, &mut bytes).unwrap();
+                NymCodec.encode(first_packet, &mut bytes).unwrap();
                 bytes.put_u8(packet_size as u8);
-                bytes.put_u8(PacketMode::default() as u8);
-                assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
+                bytes.put_u8(PacketType::default() as u8);
+                assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
 
                 assert!(bytes.capacity() >= Header::LEGACY_SIZE + packet_size.size())
             }
@@ -335,53 +383,53 @@ mod packet_encoding {
             ];
 
             for packet_size in packet_sizes {
-                let first_packet = FramedSphinxPacket {
+                let first_packet = FramedNymPacket {
                     header: Header::default(),
                     packet: make_valid_sphinx_packet(Default::default()),
                 };
 
                 let mut bytes = BytesMut::new();
-                SphinxCodec.encode(first_packet, &mut bytes).unwrap();
+                NymCodec.encode(first_packet, &mut bytes).unwrap();
                 bytes.put_u8(PacketVersion::new_versioned(123).as_u8().unwrap());
                 bytes.put_u8(packet_size as u8);
-                bytes.put_u8(PacketMode::default() as u8);
-                assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
+                bytes.put_u8(PacketType::default() as u8);
+                assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
 
-                assert!(bytes.capacity() >= Header::VERSIONED_SIZE + packet_size.size())
+                // assert!(bytes.capacity() >= Header::VERSIONED_SIZE + packet_size.size())
             }
         }
     }
 
     #[test]
     fn can_decode_two_packets_immediately() {
-        let packet1 = FramedSphinxPacket {
+        let packet1 = FramedNymPacket {
             header: Header::default(),
             packet: make_valid_sphinx_packet(Default::default()),
         };
 
-        let packet2 = FramedSphinxPacket {
+        let packet2 = FramedNymPacket {
             header: Header::default(),
             packet: make_valid_sphinx_packet(Default::default()),
         };
 
         let mut bytes = BytesMut::new();
 
-        SphinxCodec.encode(packet1, &mut bytes).unwrap();
-        SphinxCodec.encode(packet2, &mut bytes).unwrap();
+        NymCodec.encode(packet1, &mut bytes).unwrap();
+        NymCodec.encode(packet2, &mut bytes).unwrap();
 
-        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
-        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
-        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());
+        assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
+        assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
+        assert!(NymCodec.decode(&mut bytes).unwrap().is_none());
     }
 
     #[test]
     fn can_decode_two_packets_in_separate_calls() {
-        let packet1 = FramedSphinxPacket {
+        let packet1 = FramedNymPacket {
             header: Header::default(),
             packet: make_valid_sphinx_packet(Default::default()),
         };
 
-        let packet2 = FramedSphinxPacket {
+        let packet2 = FramedNymPacket {
             header: Header::default(),
             packet: make_valid_sphinx_packet(Default::default()),
         };
@@ -389,18 +437,17 @@ mod packet_encoding {
         let mut bytes = BytesMut::new();
         let mut bytes_tmp = BytesMut::new();
 
-        SphinxCodec.encode(packet1, &mut bytes).unwrap();
-        SphinxCodec.encode(packet2, &mut bytes_tmp).unwrap();
+        NymCodec.encode(packet1, &mut bytes).unwrap();
+        NymCodec.encode(packet2, &mut bytes_tmp).unwrap();
 
         let tmp = bytes_tmp.split_off(100);
         bytes.put(bytes_tmp);
 
-        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
-        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());
+        assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
+        assert!(NymCodec.decode(&mut bytes).unwrap().is_none());
 
         bytes.put(tmp);
-
-        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
-        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());
+        assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
+        assert!(NymCodec.decode(&mut bytes).unwrap().is_none());
     }
 }

common/nymsphinx/framing/src/packet.rs

@@ -1,47 +1,57 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::codec::SphinxCodecError;
+use crate::codec::NymCodecError;
 use bytes::{BufMut, BytesMut};
 use nym_sphinx_params::packet_sizes::PacketSize;
 use nym_sphinx_params::packet_version::PacketVersion;
-use nym_sphinx_params::PacketMode;
-use nym_sphinx_types::SphinxPacket;
+use nym_sphinx_params::PacketType;
+use nym_sphinx_types::NymPacket;
 use std::convert::TryFrom;
 
-pub struct FramedSphinxPacket {
+#[derive(Debug)]
+pub struct FramedNymPacket {
     /// Contains any metadata helping receiver to handle the underlying packet.
     pub(crate) header: Header,
 
     /// The actual SphinxPacket being sent.
-    pub(crate) packet: SphinxPacket,
+    pub(crate) packet: NymPacket,
 }
 
-impl FramedSphinxPacket {
-    pub fn new(packet: SphinxPacket, packet_mode: PacketMode, use_legacy_version: bool) -> Self {
+impl FramedNymPacket {
+    pub fn new(packet: NymPacket, packet_type: PacketType, use_legacy_version: bool) -> Self {
         // If this fails somebody is using the library in a super incorrect way, because they
         // already managed to somehow create a sphinx packet
         let packet_size = PacketSize::get_type(packet.len()).unwrap();
 
-        FramedSphinxPacket {
-            header: Header {
-                packet_version: PacketVersion::new(use_legacy_version),
-                packet_size,
-                packet_mode,
-            },
-            packet,
-        }
+        let use_legacy = if packet_type == PacketType::Outfox {
+            false
+        } else {
+            use_legacy_version
+        };
+
+        let header = Header {
+            packet_version: PacketVersion::new(use_legacy),
+            packet_size,
+            packet_type,
+        };
+
+        FramedNymPacket { header, packet }
+    }
+
+    pub fn header(&self) -> Header {
+        self.header
     }
 
     pub fn packet_size(&self) -> PacketSize {
         self.header.packet_size
     }
 
-    pub fn packet_mode(&self) -> PacketMode {
-        self.header.packet_mode
+    pub fn packet_type(&self) -> PacketType {
+        self.header.packet_type
     }
 
-    pub fn into_inner(self) -> SphinxPacket {
+    pub fn into_inner(self) -> NymPacket {
         self.packet
     }
 }
@@ -64,15 +74,23 @@ pub struct Header {
     ///
     /// TODO: ask @AP whether this can be sent like this - could it introduce some anonymity issues?
     /// (note: this will be behind some encryption, either something implemented by us or some SSL action)
-    // Note: currently packet_mode is deprecated but is still left as a concept behind to not break
+    // Note: currently packet_type is deprecated but is still left as a concept behind to not break
     // compatibility with existing network
-    pub(crate) packet_mode: PacketMode,
+    pub(crate) packet_type: PacketType,
 }
 
 impl Header {
     pub(crate) const LEGACY_SIZE: usize = 2;
     pub(crate) const VERSIONED_SIZE: usize = 3;
 
+    pub fn outfox() -> Header {
+        Header {
+            packet_version: PacketVersion::default(),
+            packet_size: PacketSize::OutfoxRegularPacket,
+            packet_type: PacketType::Outfox,
+        }
+    }
+
     pub(crate) fn size(&self) -> usize {
         if self.packet_version.is_legacy() {
             Self::LEGACY_SIZE
@@ -90,12 +108,12 @@ impl Header {
         }
 
         dst.put_u8(self.packet_size as u8);
-        dst.put_u8(self.packet_mode as u8);
+        dst.put_u8(self.packet_type as u8);
         // reserve bytes for the actual packet
         dst.reserve(self.packet_size.size());
     }
 
-    pub(crate) fn decode(src: &mut BytesMut) -> Result<Option<Self>, SphinxCodecError> {
+    pub(crate) fn decode(src: &mut BytesMut) -> Result<Option<Self>, NymCodecError> {
         if src.len() < Self::LEGACY_SIZE {
             // can't do anything if we don't have enough bytes - but reserve enough for the next call
             src.reserve(Self::LEGACY_SIZE);
@@ -107,7 +125,7 @@ impl Header {
             Ok(Some(Header {
                 packet_version,
                 packet_size: PacketSize::try_from(src[0])?,
-                packet_mode: PacketMode::try_from(src[1])?,
+                packet_type: PacketType::try_from(src[1])?,
             }))
         } else if src.len() < Self::VERSIONED_SIZE {
             // we're missing that 1 byte to read the full header...
@@ -117,7 +135,7 @@ impl Header {
             Ok(Some(Header {
                 packet_version,
                 packet_size: PacketSize::try_from(src[1])?,
-                packet_mode: PacketMode::try_from(src[2])?,
+                packet_type: PacketType::try_from(src[2])?,
             }))
         }
     }
@@ -148,7 +166,7 @@ mod header_encoding {
             [
                 PacketVersion::new_versioned(123).as_u8().unwrap(),
                 unknown_packet_size,
-                PacketMode::default() as u8,
+                PacketType::default() as u8,
             ]
             .as_ref(),
         );
@@ -156,12 +174,12 @@ mod header_encoding {
     }
 
     #[test]
-    fn decoding_will_fail_for_unknown_packet_mode() {
-        let unknown_packet_mode: u8 = 255;
+    fn decoding_will_fail_for_unknown_packet_type() {
+        let unknown_packet_type: u8 = 255;
         // make sure this is still 'unknown' for if we make changes in the future
-        assert!(PacketMode::try_from(unknown_packet_mode).is_err());
+        assert!(PacketType::try_from(unknown_packet_type).is_err());
 
-        let mut bytes = BytesMut::from([PacketSize::default() as u8, unknown_packet_mode].as_ref());
+        let mut bytes = BytesMut::from([PacketSize::default() as u8, unknown_packet_type].as_ref());
         assert!(Header::decode(&mut bytes).is_err())
     }
 
@@ -191,7 +209,7 @@ mod header_encoding {
             let header = Header {
                 packet_version: PacketVersion::Legacy,
                 packet_size,
-                packet_mode: Default::default(),
+                ..Default::default()
             };
             let mut bytes = BytesMut::new();
             header.encode(&mut bytes);
@@ -212,7 +230,7 @@ mod header_encoding {
             let header = Header {
                 packet_version: PacketVersion::Versioned(123),
                 packet_size,
-                packet_mode: Default::default(),
+                ..Default::default()
             };
             let mut bytes = BytesMut::new();
             header.encode(&mut bytes);

common/nymsphinx/params/src/lib.rs

@@ -8,11 +8,11 @@ use nym_crypto::ctr;
 type Aes128Ctr = ctr::Ctr64BE<Aes128>;
 
 // Re-export for ease of use
-pub use packet_modes::PacketMode;
 pub use packet_sizes::PacketSize;
+pub use packet_types::PacketType;
 
-pub mod packet_modes;
 pub mod packet_sizes;
+pub mod packet_types;
 pub mod packet_version;
 
 // If somebody can provide an argument why it might be reasonable to have more than 255 mix hops,
@@ -29,7 +29,7 @@ pub type SerializedFragmentIdentifier = [u8; FRAG_ID_LEN];
 // when packet header gets serialized, the following bytes (in that order) are put onto the wire:
 // - packet_version (starting with v1.1.0)
 // - packet_size indicator
-// - packet_mode
+// - packet_type
 // it also just so happens that the only valid values for packet_size indicator include values 1-6
 // therefore if we receive byte `7` (or larger than that) we'll know we received a versioned packet,
 // otherwise we should treat it as legacy

common/nymsphinx/params/src/packet_modes.rs

@@ -1,46 +0,0 @@
-// Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use std::convert::TryFrom;
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-#[error("{received} is not a valid packet mode tag")]
-pub struct InvalidPacketMode {
-    received: u8,
-}
-
-#[repr(u8)]
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
-pub enum PacketMode {
-    /// Represents 'normal' packet sent through the network that should be delayed by an appropriate
-    /// value at each hop.
-    #[default]
-    Mix = 0,
-
-    /// Represents a VPN packet that should not be delayed and ideally cached pre-computed keys
-    /// should be used for unwrapping data. Note that it does not offer the same level of anonymity.
-    Vpn = 1,
-}
-
-impl PacketMode {
-    pub fn is_mix(self) -> bool {
-        self == PacketMode::Mix
-    }
-
-    pub fn is_old_vpn(self) -> bool {
-        self == PacketMode::Vpn
-    }
-}
-
-impl TryFrom<u8> for PacketMode {
-    type Error = InvalidPacketMode;
-
-    fn try_from(value: u8) -> Result<Self, Self::Error> {
-        match value {
-            _ if value == (PacketMode::Mix as u8) => Ok(Self::Mix),
-            _ if value == (PacketMode::Vpn as u8) => Ok(Self::Vpn),
-            v => Err(InvalidPacketMode { received: v }),
-        }
-    }
-}

common/nymsphinx/params/src/packet_sizes.rs

@@ -1,9 +1,11 @@
 // Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::FRAG_ID_LEN;
+use crate::{PacketType, FRAG_ID_LEN};
 use nym_sphinx_types::header::HEADER_SIZE;
-use nym_sphinx_types::PAYLOAD_OVERHEAD_SIZE;
+use nym_sphinx_types::{
+    MIN_PACKET_SIZE, MIX_PARAMS_LEN, OUTFOX_PACKET_OVERHEAD, PAYLOAD_OVERHEAD_SIZE,
+};
 use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
 use std::convert::TryFrom;
@@ -12,20 +14,24 @@ use std::str::FromStr;
 use thiserror::Error;
 
 // each sphinx packet contains mandatory header and payload padding + markers
-const PACKET_OVERHEAD: usize = HEADER_SIZE + PAYLOAD_OVERHEAD_SIZE;
+const SPHINX_PACKET_OVERHEAD: usize = HEADER_SIZE + PAYLOAD_OVERHEAD_SIZE;
 
 // it's up to the smart people to figure those values out : )
-const REGULAR_PACKET_SIZE: usize = 2 * 1024 + PACKET_OVERHEAD;
+
 // TODO: even though we have 16B IV, is having just 5B (FRAG_ID_LEN) of the ID possibly insecure?
 
 // TODO: I'm not entirely sure if we can easily extract `<AckEncryptionAlgorithm as NewStreamCipher>::NonceSize`
 // into a const usize before relevant stuff is stabilised in rust...
 const ACK_IV_SIZE: usize = 16;
 
-const ACK_PACKET_SIZE: usize = ACK_IV_SIZE + FRAG_ID_LEN + PACKET_OVERHEAD;
-const EXTENDED_PACKET_SIZE_8: usize = 8 * 1024 + PACKET_OVERHEAD;
-const EXTENDED_PACKET_SIZE_16: usize = 16 * 1024 + PACKET_OVERHEAD;
-const EXTENDED_PACKET_SIZE_32: usize = 32 * 1024 + PACKET_OVERHEAD;
+const ACK_PACKET_SIZE: usize = ACK_IV_SIZE + FRAG_ID_LEN + SPHINX_PACKET_OVERHEAD;
+const REGULAR_PACKET_SIZE: usize = 2 * 1024 + SPHINX_PACKET_OVERHEAD;
+const EXTENDED_PACKET_SIZE_8: usize = 8 * 1024 + SPHINX_PACKET_OVERHEAD;
+const EXTENDED_PACKET_SIZE_16: usize = 16 * 1024 + SPHINX_PACKET_OVERHEAD;
+const EXTENDED_PACKET_SIZE_32: usize = 32 * 1024 + SPHINX_PACKET_OVERHEAD;
+
+const OUTFOX_ACK_PACKET_SIZE: usize = MIN_PACKET_SIZE + OUTFOX_PACKET_OVERHEAD;
+const OUTFOX_REGULAR_PACKET_SIZE: usize = 2 * 1024 + OUTFOX_PACKET_OVERHEAD;
 
 #[derive(Debug, Error)]
 pub enum InvalidPacketSize {
@@ -62,6 +68,13 @@ pub enum PacketSize {
     // for example for streaming fast and furious in compressed XviD quality
     #[serde(rename = "extended16")]
     ExtendedPacket16 = 5,
+
+    #[serde(rename = "outfox_regular")]
+    OutfoxRegularPacket = 6,
+
+    // for sending SURB-ACKs
+    #[serde(rename = "outfox_ack")]
+    OutfoxAckPacket = 7,
 }
 
 impl PartialOrd for PacketSize {
@@ -88,6 +101,8 @@ impl FromStr for PacketSize {
             "extended8" => Ok(Self::ExtendedPacket8),
             "extended16" => Ok(Self::ExtendedPacket16),
             "extended32" => Ok(Self::ExtendedPacket32),
+            "outfox_regular" => Ok(Self::OutfoxRegularPacket),
+            "outfox_ack" => Ok(Self::OutfoxAckPacket),
             s => Err(InvalidPacketSize::UnknownExtendedPacketVariant {
                 received: s.to_string(),
             }),
@@ -103,6 +118,8 @@ impl Display for PacketSize {
             PacketSize::ExtendedPacket32 => write!(f, "extended32"),
             PacketSize::ExtendedPacket8 => write!(f, "extended8"),
             PacketSize::ExtendedPacket16 => write!(f, "extended16"),
+            PacketSize::OutfoxRegularPacket => write!(f, "outfox_regular"),
+            PacketSize::OutfoxAckPacket => write!(f, "outfox_ack"),
         }
     }
 }
@@ -127,6 +144,8 @@ impl TryFrom<u8> for PacketSize {
             _ if value == (PacketSize::ExtendedPacket8 as u8) => Ok(Self::ExtendedPacket8),
             _ if value == (PacketSize::ExtendedPacket16 as u8) => Ok(Self::ExtendedPacket16),
             _ if value == (PacketSize::ExtendedPacket32 as u8) => Ok(Self::ExtendedPacket32),
+            _ if value == (PacketSize::OutfoxRegularPacket as u8) => Ok(Self::OutfoxRegularPacket),
+            _ if value == (PacketSize::OutfoxAckPacket as u8) => Ok(Self::OutfoxAckPacket),
             v => Err(InvalidPacketSize::UnknownPacketTag { received: v }),
         }
     }
@@ -140,15 +159,41 @@ impl PacketSize {
             PacketSize::ExtendedPacket8 => EXTENDED_PACKET_SIZE_8,
             PacketSize::ExtendedPacket16 => EXTENDED_PACKET_SIZE_16,
             PacketSize::ExtendedPacket32 => EXTENDED_PACKET_SIZE_32,
+            PacketSize::OutfoxRegularPacket => OUTFOX_REGULAR_PACKET_SIZE,
+            PacketSize::OutfoxAckPacket => OUTFOX_ACK_PACKET_SIZE,
+        }
+    }
+
+    pub const fn header_size(&self) -> usize {
+        match self {
+            PacketSize::RegularPacket
+            | PacketSize::AckPacket
+            | PacketSize::ExtendedPacket8
+            | PacketSize::ExtendedPacket16
+            | PacketSize::ExtendedPacket32 => HEADER_SIZE,
+            PacketSize::OutfoxRegularPacket | PacketSize::OutfoxAckPacket => MIX_PARAMS_LEN,
+        }
+    }
+
+    pub const fn payload_overhead(&self) -> usize {
+        match self {
+            PacketSize::RegularPacket
+            | PacketSize::AckPacket
+            | PacketSize::ExtendedPacket8
+            | PacketSize::ExtendedPacket16
+            | PacketSize::ExtendedPacket32 => PAYLOAD_OVERHEAD_SIZE,
+            PacketSize::OutfoxRegularPacket | PacketSize::OutfoxAckPacket => {
+                OUTFOX_PACKET_OVERHEAD - MIX_PARAMS_LEN // Mix params are calculated into the total overhead so we take them out here
+            }
         }
     }
 
     pub const fn plaintext_size(self) -> usize {
-        self.size() - HEADER_SIZE - PAYLOAD_OVERHEAD_SIZE
+        self.size() - self.header_size() - self.payload_overhead()
     }
 
     pub const fn payload_size(self) -> usize {
-        self.size() - HEADER_SIZE
+        self.size() - self.header_size()
     }
 
     pub fn get_type(size: usize) -> Result<Self, InvalidPacketSize> {
@@ -162,6 +207,12 @@ impl PacketSize {
             Ok(PacketSize::ExtendedPacket16)
         } else if PacketSize::ExtendedPacket32.size() == size {
             Ok(PacketSize::ExtendedPacket32)
+        } else if PacketSize::OutfoxRegularPacket.size() == size
+            || PacketSize::OutfoxRegularPacket.size() == size + 6
+        {
+            Ok(PacketSize::OutfoxRegularPacket)
+        } else if PacketSize::OutfoxAckPacket.size() == size {
+            Ok(PacketSize::OutfoxAckPacket)
         } else {
             Err(InvalidPacketSize::UnknownPacketSize { received: size })
         }
@@ -169,7 +220,10 @@ impl PacketSize {
 
     pub fn is_extended_size(&self) -> bool {
         match self {
-            PacketSize::RegularPacket | PacketSize::AckPacket => false,
+            PacketSize::RegularPacket
+            | PacketSize::AckPacket
+            | PacketSize::OutfoxAckPacket
+            | PacketSize::OutfoxRegularPacket => false,
             PacketSize::ExtendedPacket8
             | PacketSize::ExtendedPacket16
             | PacketSize::ExtendedPacket32 => true,
@@ -184,8 +238,16 @@ impl PacketSize {
         }
     }
 
-    pub fn get_type_from_plaintext(plaintext_size: usize) -> Result<Self, InvalidPacketSize> {
-        let packet_size = plaintext_size + PACKET_OVERHEAD;
+    pub fn get_type_from_plaintext(
+        plaintext_size: usize,
+        packet_type: PacketType,
+    ) -> Result<Self, InvalidPacketSize> {
+        let overhead = match packet_type {
+            PacketType::Mix => SPHINX_PACKET_OVERHEAD,
+            PacketType::Vpn => SPHINX_PACKET_OVERHEAD,
+            PacketType::Outfox => OUTFOX_PACKET_OVERHEAD,
+        };
+        let packet_size = plaintext_size + overhead;
         Self::get_type(packet_size)
     }
 }

common/nymsphinx/params/src/packet_types.rs

@@ -0,0 +1,76 @@
+// Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use serde::{Deserialize, Serialize};
+use std::convert::TryFrom;
+use std::fmt;
+use thiserror::Error;
+
+use crate::PacketSize;
+
+#[derive(Error, Debug)]
+#[error("{received} is not a valid packet mode tag")]
+pub struct InvalidPacketType {
+    received: u8,
+}
+
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub enum PacketType {
+    /// Represents 'normal' packet sent through the network that should be delayed by an appropriate
+    /// value at each hop.
+    #[default]
+    Mix = 0,
+
+    /// Represents a packet that should be sent through the network as fast as possible.
+    Vpn = 1,
+
+    /// Abusing this to add Outfox support
+    Outfox = 2,
+}
+
+impl fmt::Display for PacketType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            PacketType::Mix => write!(f, "Mix"),
+            PacketType::Vpn => write!(f, "Vpn"),
+            PacketType::Outfox => write!(f, "Outfox"),
+        }
+    }
+}
+
+impl PacketType {
+    pub fn is_mix(self) -> bool {
+        self == PacketType::Mix
+    }
+
+    pub fn is_outfox(self) -> bool {
+        self == PacketType::Outfox
+    }
+}
+
+impl TryFrom<u8> for PacketType {
+    type Error = InvalidPacketType;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            _ if value == (PacketType::Mix as u8) => Ok(Self::Mix),
+            _ if value == (PacketType::Outfox as u8) => Ok(Self::Outfox),
+            v => Err(InvalidPacketType { received: v }),
+        }
+    }
+}
+
+impl From<PacketSize> for PacketType {
+    fn from(s: PacketSize) -> Self {
+        match s {
+            PacketSize::RegularPacket => PacketType::Mix,
+            PacketSize::AckPacket => PacketType::Mix,
+            PacketSize::ExtendedPacket32 => PacketType::Mix,
+            PacketSize::ExtendedPacket8 => PacketType::Mix,
+            PacketSize::ExtendedPacket16 => PacketType::Mix,
+            PacketSize::OutfoxRegularPacket => PacketType::Outfox,
+            PacketSize::OutfoxAckPacket => PacketType::Outfox,
+        }
+    }
+}

common/nymsphinx/params/src/packet_version.rs

@@ -1,9 +1,11 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+use serde::{Deserialize, Serialize};
+
 use crate::{PacketSize, CURRENT_PACKET_VERSION_NUMBER};
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum PacketVersion {
     // this will allow updated mixnodes to still understand packets from before the update
     Legacy,

common/nymsphinx/src/lib.rs

@@ -21,4 +21,4 @@ pub use nym_sphinx_types::*;
 pub use nym_sphinx_framing as framing;
 
 // TEMP UNTIL FURTHER REFACTORING
-pub use preparer::payload::NymsphinxPayloadBuilder;
+pub use preparer::payload::NymPayloadBuilder;

common/nymsphinx/src/message.rs

@@ -11,12 +11,14 @@ use nym_sphinx_anonymous_replies::requests::{
     ReplyMessageContent,
 };
 use nym_sphinx_chunking::fragment::Fragment;
-use nym_sphinx_params::{PacketSize, ReplySurbKeyDigestAlgorithm};
+use nym_sphinx_params::{PacketSize, PacketType, ReplySurbKeyDigestAlgorithm};
 use rand::Rng;
 use std::fmt::{Display, Formatter};
 use thiserror::Error;
 
 pub(crate) const ACK_OVERHEAD: usize = MAX_NODE_ADDRESS_UNPADDED_LEN + PacketSize::AckPacket.size();
+pub(crate) const OUTFOX_ACK_OVERHEAD: usize =
+    MAX_NODE_ADDRESS_UNPADDED_LEN + PacketSize::OutfoxAckPacket.size();
 
 #[derive(Debug, Error)]
 pub enum NymMessageError {
@@ -187,8 +189,15 @@ impl NymMessage {
             NymMessage::Reply(_) => ReplySurbKeyDigestAlgorithm::output_size(),
         };
 
+        let packet_type = PacketType::from(packet_size);
+
         // each packet will contain an ack + variant specific data (as described above)
-        packet_size.plaintext_size() - ACK_OVERHEAD - variant_overhead
+        match packet_type {
+            PacketType::Outfox => {
+                packet_size.plaintext_size() - OUTFOX_ACK_OVERHEAD - variant_overhead
+            }
+            _ => packet_size.plaintext_size() - ACK_OVERHEAD - variant_overhead,
+        }
     }
 
     /// Length of the actual (from the **message** point of view) data that is available in each packet.

common/nymsphinx/src/preparer/mod.rs

@@ -1,8 +1,8 @@
 // Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::message::{NymMessage, ACK_OVERHEAD};
-use crate::NymsphinxPayloadBuilder;
+use crate::message::{NymMessage, ACK_OVERHEAD, OUTFOX_ACK_OVERHEAD};
+use crate::NymPayloadBuilder;
 use nym_crypto::asymmetric::encryption;
 use nym_crypto::Digest;
 use nym_sphinx_acknowledgements::surb_ack::SurbAck;
@@ -13,9 +13,8 @@ use nym_sphinx_anonymous_replies::reply_surb::ReplySurb;
 use nym_sphinx_chunking::fragment::{Fragment, FragmentIdentifier};
 use nym_sphinx_forwarding::packet::MixPacket;
 use nym_sphinx_params::packet_sizes::PacketSize;
-use nym_sphinx_params::{ReplySurbKeyDigestAlgorithm, DEFAULT_NUM_MIX_HOPS};
-use nym_sphinx_types::builder::SphinxPacketBuilder;
-use nym_sphinx_types::{delays, Delay};
+use nym_sphinx_params::{PacketType, ReplySurbKeyDigestAlgorithm, DEFAULT_NUM_MIX_HOPS};
+use nym_sphinx_types::{delays, Delay, NymPacket};
 use nym_topology::{NymTopology, NymTopologyError};
 use rand::{CryptoRng, Rng};
 use std::convert::TryFrom;
@@ -77,6 +76,7 @@ pub trait FragmentPreparer {
         fragment_id: FragmentIdentifier,
         topology: &NymTopology,
         ack_key: &AckKey,
+        packet_type: PacketType,
     ) -> Result<SurbAck, NymTopologyError> {
         let ack_delay = self.average_ack_delay();
 
@@ -87,6 +87,7 @@ pub trait FragmentPreparer {
             fragment_id.to_bytes(),
             ack_delay,
             topology,
+            packet_type,
         )
     }
 
@@ -107,15 +108,20 @@ pub trait FragmentPreparer {
         ack_key: &AckKey,
         reply_surb: ReplySurb,
         packet_sender: &Recipient,
+        packet_type: PacketType,
     ) -> Result<PreparedFragment, NymTopologyError> {
         // each reply attaches the digest of the encryption key so that the recipient could
         // lookup correct key for decryption,
         let reply_overhead = ReplySurbKeyDigestAlgorithm::output_size();
-        let expected_plaintext = fragment.serialized_size() + ACK_OVERHEAD + reply_overhead;
+        let expected_plaintext = match packet_type {
+            PacketType::Outfox => fragment.serialized_size() + OUTFOX_ACK_OVERHEAD + reply_overhead,
+            _ => fragment.serialized_size() + ACK_OVERHEAD + reply_overhead,
+        };
 
         // the reason we're unwrapping (or rather 'expecting') here rather than handling the error
         // more gracefully is that this error should never be reached as it implies incorrect chunking
-        let packet_size = PacketSize::get_type_from_plaintext(expected_plaintext)
+        // reply packets are always Sphinx
+        let packet_size = PacketSize::get_type_from_plaintext(expected_plaintext, PacketType::Mix)
             .expect("the message has been incorrectly fragmented");
 
         // this is not going to be accurate by any means. but that's the best estimation we can do
@@ -126,24 +132,34 @@ pub trait FragmentPreparer {
         let fragment_identifier = fragment.fragment_identifier();
 
         // create an ack
-        let surb_ack =
-            self.generate_surb_ack(packet_sender, fragment_identifier, topology, ack_key)?;
+        let surb_ack = self.generate_surb_ack(
+            packet_sender,
+            fragment_identifier,
+            topology,
+            ack_key,
+            packet_type,
+        )?;
         let ack_delay = surb_ack.expected_total_delay();
 
-        let packet_payload = NymsphinxPayloadBuilder::new(fragment, surb_ack)
-            .build_reply(reply_surb.encryption_key());
+        let packet_payload = match NymPayloadBuilder::new(fragment, surb_ack)
+            .build_reply(reply_surb.encryption_key())
+        {
+            Ok(payload) => payload,
+            Err(_e) => return Err(NymTopologyError::PayloadBuilder),
+        };
 
         // the unwrap here is fine as the failures can only originate from attempting to use invalid payload lengths
         // and we just very carefully constructed a (presumably) valid one
-        let (sphinx_packet, first_hop_address) =
-            reply_surb.apply_surb(packet_payload, packet_size).unwrap();
+        let (sphinx_packet, first_hop_address) = reply_surb
+            .apply_surb(packet_payload, packet_size, packet_type)
+            .unwrap();
 
         Ok(PreparedFragment {
             // the round-trip delay is the sum of delays of all hops on the forward route as
             // well as the total delay of the ack packet.
             // we don't know the delays inside the reply surbs so we use best-effort estimation from our poisson distribution
             total_delay: expected_forward_delay + ack_delay,
-            mix_packet: MixPacket::new(first_hop_address, sphinx_packet, Default::default()),
+            mix_packet: MixPacket::new(first_hop_address, sphinx_packet, packet_type),
             fragment_identifier,
         })
     }
@@ -172,27 +188,42 @@ pub trait FragmentPreparer {
         ack_key: &AckKey,
         packet_sender: &Recipient,
         packet_recipient: &Recipient,
+        packet_type: PacketType,
     ) -> Result<PreparedFragment, NymTopologyError> {
         // each plain or repliable packet (i.e. not a reply) attaches an ephemeral public key so that the recipient
         // could perform diffie-hellman with its own keys followed by a kdf to re-derive
         // the packet encryption key
         let non_reply_overhead = encryption::PUBLIC_KEY_SIZE;
-        let expected_plaintext = fragment.serialized_size() + ACK_OVERHEAD + non_reply_overhead;
+        let expected_plaintext = match packet_type {
+            PacketType::Outfox => {
+                fragment.serialized_size() + OUTFOX_ACK_OVERHEAD + non_reply_overhead
+            }
+            _ => fragment.serialized_size() + ACK_OVERHEAD + non_reply_overhead,
+        };
 
         // the reason we're unwrapping (or rather 'expecting') here rather than handling the error
         // more gracefully is that this error should never be reached as it implies incorrect chunking
-        let packet_size = PacketSize::get_type_from_plaintext(expected_plaintext)
+        let packet_size = PacketSize::get_type_from_plaintext(expected_plaintext, packet_type)
             .expect("the message has been incorrectly fragmented");
 
         let fragment_identifier = fragment.fragment_identifier();
 
         // create an ack
-        let surb_ack =
-            self.generate_surb_ack(packet_sender, fragment_identifier, topology, ack_key)?;
+        let surb_ack = self.generate_surb_ack(
+            packet_sender,
+            fragment_identifier,
+            topology,
+            ack_key,
+            packet_type,
+        )?;
         let ack_delay = surb_ack.expected_total_delay();
 
-        let packet_payload = NymsphinxPayloadBuilder::new(fragment, surb_ack)
-            .build_regular(self.rng(), packet_recipient.encryption_key());
+        let packet_payload = match NymPayloadBuilder::new(fragment, surb_ack)
+            .build_regular(self.rng(), packet_recipient.encryption_key())
+        {
+            Ok(payload) => payload,
+            Err(_e) => return Err(NymTopologyError::PayloadBuilder),
+        };
 
         // generate pseudorandom route for the packet
         let hops = self.num_mix_hops();
@@ -206,10 +237,28 @@ pub trait FragmentPreparer {
 
         // create the actual sphinx packet here. With valid route and correct payload size,
         // there's absolutely no reason for this call to fail.
-        let sphinx_packet = SphinxPacketBuilder::new()
-            .with_payload_size(packet_size.payload_size())
-            .build_packet(packet_payload, &route, &destination, &delays)
-            .unwrap();
+        let packet = match packet_type {
+            PacketType::Outfox => NymPacket::outfox_build(
+                packet_payload,
+                route.as_slice(),
+                &destination,
+                Some(packet_size.plaintext_size()),
+            )?,
+            PacketType::Mix => NymPacket::sphinx_build(
+                packet_size.payload_size(),
+                packet_payload,
+                &route,
+                &destination,
+                &delays,
+            )?,
+            PacketType::Vpn => NymPacket::sphinx_build(
+                packet_size.payload_size(),
+                packet_payload,
+                &route,
+                &destination,
+                &delays,
+            )?,
+        };
 
         // from the previously constructed route extract the first hop
         let first_hop_address =
@@ -220,7 +269,7 @@ pub trait FragmentPreparer {
             // well as the total delay of the ack packet.
             // note that the last hop of the packet is a gateway that does not do any delays
             total_delay: delays.iter().take(delays.len() - 1).sum::<Delay>() + ack_delay,
-            mix_packet: MixPacket::new(first_hop_address, sphinx_packet, Default::default()),
+            mix_packet: MixPacket::new(first_hop_address, packet, packet_type),
             fragment_identifier,
         })
     }
@@ -317,11 +366,18 @@ where
         topology: &NymTopology,
         ack_key: &AckKey,
         reply_surb: ReplySurb,
+        packet_type: PacketType,
     ) -> Result<PreparedFragment, NymTopologyError> {
         let sender = self.sender_address;
 
         <Self as FragmentPreparer>::prepare_reply_chunk_for_sending(
-            self, fragment, topology, ack_key, reply_surb, &sender,
+            self,
+            fragment,
+            topology,
+            ack_key,
+            reply_surb,
+            &sender,
+            packet_type,
         )
     }
 
@@ -331,6 +387,7 @@ where
         topology: &NymTopology,
         ack_key: &AckKey,
         packet_recipient: &Recipient,
+        packet_type: PacketType,
     ) -> Result<PreparedFragment, NymTopologyError> {
         let sender = self.sender_address;
 
@@ -341,6 +398,7 @@ where
             ack_key,
             &sender,
             packet_recipient,
+            packet_type,
         )
     }
 
@@ -350,9 +408,17 @@ where
         fragment_id: FragmentIdentifier,
         topology: &NymTopology,
         ack_key: &AckKey,
+        packet_type: PacketType,
     ) -> Result<SurbAck, NymTopologyError> {
         let sender = self.sender_address;
-        <Self as FragmentPreparer>::generate_surb_ack(self, &sender, fragment_id, topology, ack_key)
+        <Self as FragmentPreparer>::generate_surb_ack(
+            self,
+            &sender,
+            fragment_id,
+            topology,
+            ack_key,
+            packet_type,
+        )
     }
 
     pub fn pad_and_split_message(

common/nymsphinx/src/preparer/payload.rs

@@ -6,7 +6,7 @@ use nym_crypto::asymmetric::encryption;
 use nym_crypto::shared_key::new_ephemeral_shared_key;
 use nym_crypto::symmetric::stream_cipher;
 use nym_crypto::symmetric::stream_cipher::CipherKey;
-use nym_sphinx_acknowledgements::surb_ack::SurbAck;
+use nym_sphinx_acknowledgements::surb_ack::{SurbAck, SurbAckRecoveryError};
 use nym_sphinx_anonymous_replies::SurbEncryptionKey;
 use nym_sphinx_chunking::fragment::Fragment;
 use nym_sphinx_params::{
@@ -14,25 +14,25 @@ use nym_sphinx_params::{
 };
 use rand::{CryptoRng, RngCore};
 
-pub struct NymsphinxPayloadBuilder {
+pub struct NymPayloadBuilder {
     fragment: Fragment,
     surb_ack: SurbAck,
 }
 
-impl NymsphinxPayloadBuilder {
+impl NymPayloadBuilder {
     pub fn new(fragment: Fragment, surb_ack: SurbAck) -> Self {
-        NymsphinxPayloadBuilder { fragment, surb_ack }
+        NymPayloadBuilder { fragment, surb_ack }
     }
 
     fn build<C>(
         self,
         packet_encryption_key: &CipherKey<C>,
         variant_data: impl IntoIterator<Item = u8>,
-    ) -> NymsphinxPayload
+    ) -> Result<NymPayload, SurbAckRecoveryError>
     where
         C: StreamCipher + KeyIvInit,
     {
-        let (_, surb_ack_bytes) = self.surb_ack.prepare_for_sending();
+        let (_, surb_ack_bytes) = self.surb_ack.prepare_for_sending()?;
 
         let mut fragment_data = self.fragment.into_bytes();
         stream_cipher::encrypt_in_place::<C>(
@@ -46,16 +46,20 @@ impl NymsphinxPayloadBuilder {
         // where variant-specific data is as follows:
         // for replies it would be the digest of the encryption key used
         // for 'regular' messages it would be the public component used in DH later used in the KDF
-        NymsphinxPayload(
+
+        Ok(NymPayload(
             surb_ack_bytes
                 .into_iter()
                 .chain(variant_data.into_iter())
                 .chain(fragment_data.into_iter())
                 .collect(),
-        )
+        ))
     }
 
-    pub fn build_reply(self, packet_encryption_key: &SurbEncryptionKey) -> NymsphinxPayload {
+    pub fn build_reply(
+        self,
+        packet_encryption_key: &SurbEncryptionKey,
+    ) -> Result<NymPayload, SurbAckRecoveryError> {
         let key_digest = packet_encryption_key.compute_digest();
         self.build::<ReplySurbEncryptionAlgorithm>(
             packet_encryption_key.inner(),
@@ -67,7 +71,7 @@ impl NymsphinxPayloadBuilder {
         self,
         rng: &mut R,
         recipient_encryption_key: &encryption::PublicKey,
-    ) -> NymsphinxPayload
+    ) -> Result<NymPayload, SurbAckRecoveryError>
     where
         R: RngCore + CryptoRng,
     {
@@ -88,9 +92,9 @@ impl NymsphinxPayloadBuilder {
 // the actual byte data that will be put into the sphinx packet paylaod.
 // no more transformations are going to happen to it
 // TODO: use that fact for some better compile time assertions
-pub struct NymsphinxPayload(Vec<u8>);
+pub struct NymPayload(Vec<u8>);
 
-impl AsRef<[u8]> for NymsphinxPayload {
+impl AsRef<[u8]> for NymPayload {
     fn as_ref(&self) -> &[u8] {
         &self.0
     }

common/nymsphinx/src/receiver.rs

@@ -7,8 +7,6 @@ use nym_crypto::asymmetric::encryption;
 use nym_crypto::shared_key::recompute_shared_key;
 use nym_crypto::symmetric::stream_cipher;
 use nym_crypto::symmetric::stream_cipher::CipherKey;
-use nym_outfox::error::OutfoxError;
-use nym_outfox::lion::lion_transform_decrypt;
 use nym_sphinx_anonymous_replies::requests::AnonymousSenderTag;
 use nym_sphinx_anonymous_replies::SurbEncryptionKey;
 use nym_sphinx_chunking::fragment::Fragment;
@@ -76,49 +74,6 @@ pub enum MessageRecoveryError {
 
     #[error("Failed to recover message fragment - {0}")]
     FragmentRecoveryError(#[from] ChunkingError),
-
-    #[error("Outfox: {source}")]
-    OutfoxRecoveryError {
-        #[from]
-        source: OutfoxError,
-    },
-}
-
-#[derive(Default)]
-pub struct OutfoxMessageReceiver {
-    reconstructor: MessageReconstructor,
-}
-
-impl OutfoxMessageReceiver {
-    pub fn new() -> Self {
-        Default::default()
-    }
-}
-
-impl MessageReceiver for OutfoxMessageReceiver {
-    fn new() -> Self {
-        Self::default()
-    }
-
-    fn reconstructor(&mut self) -> &mut MessageReconstructor {
-        &mut self.reconstructor
-    }
-
-    fn num_mix_hops(&self) -> u8 {
-        DEFAULT_NUM_MIX_HOPS
-    }
-
-    fn decrypt_raw_message<C>(
-        &self,
-        message: &mut [u8],
-        key: &CipherKey<C>,
-    ) -> Result<(), MessageRecoveryError>
-    where
-        C: StreamCipher + KeyIvInit,
-    {
-        lion_transform_decrypt(message, key)?;
-        Ok(())
-    }
 }
 
 pub trait MessageReceiver {

common/nymsphinx/types/Cargo.toml

@@ -9,6 +9,5 @@ repository = { workspace = true }
 
 [dependencies]
 sphinx-packet = { version = "0.1.0" }
-
-#[patch.crates-io]
-#sphinx-packet = { path = "../../../../sphinx" }
+nym-outfox = { path = "../../../nym-outfox" }
+thiserror = "1"

common/nymsphinx/types/src/lib.rs

@@ -1,7 +1,12 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+pub use nym_outfox::{
+    constants::MIN_PACKET_SIZE, constants::MIX_PARAMS_LEN, constants::OUTFOX_PACKET_OVERHEAD,
+    error::OutfoxError,
+};
 // re-exporting types and constants available in sphinx
+use nym_outfox::packet::{OutfoxPacket, OutfoxProcessedPacket};
 pub use sphinx_packet::{
     constants::{
         self, DESTINATION_ADDRESS_LENGTH, IDENTIFIER_LENGTH, MAX_PATH_LENGTH, NODE_ADDRESS_LENGTH,
@@ -9,9 +14,123 @@ pub use sphinx_packet::{
     },
     crypto::{self, EphemeralSecret, PrivateKey, PublicKey, SharedSecret},
     header::{self, delays, delays::Delay, ProcessedHeader, SphinxHeader, HEADER_SIZE},
-    packet::builder::{self, DEFAULT_PAYLOAD_SIZE},
+    packet::builder::DEFAULT_PAYLOAD_SIZE,
     payload::{Payload, PAYLOAD_OVERHEAD_SIZE},
     route::{Destination, DestinationAddressBytes, Node, NodeAddressBytes, SURBIdentifier},
     surb::{SURBMaterial, SURB},
-    Error, ProcessedPacket, Result, SphinxPacket,
+    Error as SphinxError, ProcessedPacket,
 };
+use sphinx_packet::{SphinxPacket, SphinxPacketBuilder};
+use std::{array::TryFromSliceError, fmt};
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum NymPacketError {
+    #[error("Sphinx error: {0}")]
+    Sphinx(#[from] sphinx_packet::Error),
+
+    #[error("Outfox error: {0}")]
+    Outfox(#[from] nym_outfox::error::OutfoxError),
+
+    #[error("{0}")]
+    FromSlice(#[from] TryFromSliceError),
+}
+
+#[allow(clippy::large_enum_variant)]
+pub enum NymPacket {
+    Sphinx(SphinxPacket),
+    Outfox(OutfoxPacket),
+}
+
+pub enum NymProcessedPacket {
+    Sphinx(ProcessedPacket),
+    Outfox(OutfoxProcessedPacket),
+}
+
+impl fmt::Debug for NymPacket {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self {
+            NymPacket::Sphinx(packet) => f
+                .debug_struct("NymPacket::Sphinx")
+                .field("len", &packet.len())
+                .finish(),
+            NymPacket::Outfox(packet) => f
+                .debug_struct("NymPacket::Outfox")
+                .field("len", &packet.len())
+                .finish(),
+        }
+    }
+}
+
+impl NymPacket {
+    pub fn sphinx_build<M: AsRef<[u8]>>(
+        size: usize,
+        message: M,
+        route: &[Node],
+        destination: &Destination,
+        delays: &[Delay],
+    ) -> Result<NymPacket, NymPacketError> {
+        Ok(NymPacket::Sphinx(
+            SphinxPacketBuilder::new()
+                .with_payload_size(size)
+                .build_packet(message, route, destination, delays)?,
+        ))
+    }
+    pub fn sphinx_from_bytes(bytes: &[u8]) -> Result<NymPacket, NymPacketError> {
+        Ok(NymPacket::Sphinx(SphinxPacket::from_bytes(bytes)?))
+    }
+
+    pub fn outfox_build<M: AsRef<[u8]>>(
+        payload: M,
+        route: &[Node],
+        destination: &Destination,
+        size: Option<usize>,
+    ) -> Result<NymPacket, NymPacketError> {
+        Ok(NymPacket::Outfox(OutfoxPacket::build(
+            payload,
+            route.try_into()?,
+            destination,
+            size,
+        )?))
+    }
+
+    pub fn outfox_from_bytes(bytes: &[u8]) -> Result<NymPacket, NymPacketError> {
+        Ok(NymPacket::Outfox(OutfoxPacket::try_from(bytes)?))
+    }
+
+    pub fn len(&self) -> usize {
+        match self {
+            NymPacket::Sphinx(packet) => packet.len(),
+            NymPacket::Outfox(packet) => packet.len(),
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    pub fn to_bytes(&self) -> Result<Vec<u8>, NymPacketError> {
+        match self {
+            NymPacket::Sphinx(packet) => Ok(packet.to_bytes()),
+            NymPacket::Outfox(packet) => Ok(packet.to_bytes()?),
+        }
+    }
+
+    pub fn process(
+        self,
+        node_secret_key: &PrivateKey,
+    ) -> Result<NymProcessedPacket, NymPacketError> {
+        match self {
+            NymPacket::Sphinx(packet) => {
+                Ok(NymProcessedPacket::Sphinx(packet.process(node_secret_key)?))
+            }
+            NymPacket::Outfox(mut packet) => {
+                let next_address = packet.decode_next_layer(node_secret_key)?;
+                Ok(NymProcessedPacket::Outfox(OutfoxProcessedPacket::new(
+                    packet,
+                    next_address,
+                )))
+            }
+        }
+    }
+}

common/socks5-client-core/src/config/mod.rs

@@ -12,7 +12,7 @@ use nym_socks5_requests::Socks5ProtocolVersion;
 use nym_sphinx::addressing::clients::Recipient;
 use serde::{Deserialize, Serialize};
 use std::fmt::Debug;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::str::FromStr;
 
 pub mod old_config_v1_1_13;
@@ -36,9 +36,9 @@ impl NymConfig for Config {
     }
 
     fn default_root_directory() -> PathBuf {
-        #[cfg(not(target_os = "android"))]
+        #[cfg(not(any(target_os = "android", target_os = "ios")))]
         let base_dir = dirs::home_dir().expect("Failed to evaluate $HOME value");
-        #[cfg(target_os = "android")]
+        #[cfg(any(target_os = "android", target_os = "ios"))]
         let base_dir = PathBuf::from("/tmp");
 
         base_dir.join(".nym").join("socks5-clients")
@@ -77,6 +77,14 @@ impl Config {
         }
     }
 
+    #[must_use]
+    pub fn with_root_directory<P: AsRef<Path>>(mut self, root_dir: P) -> Self {
+        self.base = self.base.reset_nym_root_directory(root_dir);
+        let data_dir = self.data_directory();
+        self.base = self.base.reset_data_directory(data_dir);
+        self
+    }
+
     pub fn validate(&self) -> bool {
         // no other sections have explicit requirements (yet)
         self.base.validate()
@@ -224,6 +232,10 @@ impl Socks5 {
         self.send_anonymously = anonymous_replies;
     }
 
+    pub fn get_raw_provider_mix_address(&self) -> String {
+        self.provider_mix_address.clone()
+    }
+
     pub fn get_provider_mix_address(&self) -> Recipient {
         Recipient::try_from_base58_string(&self.provider_mix_address)
             .expect("malformed provider address")

common/socks5-client-core/src/config/old_config_v1_1_13.rs

@@ -23,9 +23,9 @@ impl NymConfig for OldConfigV1_1_13 {
     }
 
     fn default_root_directory() -> PathBuf {
-        #[cfg(not(target_os = "android"))]
+        #[cfg(not(any(target_os = "android", target_os = "ios")))]
         let base_dir = dirs::home_dir().expect("Failed to evaluate $HOME value");
-        #[cfg(target_os = "android")]
+        #[cfg(any(target_os = "android", target_os = "ios"))]
         let base_dir = PathBuf::from("/tmp");
 
         base_dir.join(".nym").join("socks5-clients")

common/socks5-client-core/src/lib.rs

@@ -5,39 +5,24 @@ use crate::config::{Config, Socks5};
 use crate::error::Socks5ClientCoreError;
 use crate::socks::{
     authentication::{AuthenticationMethods, Authenticator, User},
-    server::SphinxSocksServer,
+    server::NymSocksServer,
 };
 use futures::channel::mpsc;
 use futures::StreamExt;
 use log::*;
-use nym_bandwidth_controller::BandwidthController;
+use nym_client_core::client::base_client::storage::MixnetClientStorage;
 use nym_client_core::client::base_client::{
-    BaseClientBuilder, ClientInput, ClientOutput, ClientState,
+    non_wasm_helpers, BaseClientBuilder, ClientInput, ClientOutput, ClientState,
 };
-use nym_client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
+use nym_client_core::client::key_manager::persistence::KeyStore;
+use nym_client_core::client::replies::reply_storage::ReplyStorageBackend;
 use nym_client_core::config::DebugConfig;
+use nym_credential_storage::storage::Storage as CredentialStorage;
 use nym_sphinx::addressing::clients::Recipient;
+use nym_sphinx::params::PacketType;
 use nym_task::{TaskClient, TaskManager};
-use nym_validator_client::nyxd::QueryNyxdClient;
-use nym_validator_client::Client;
 use std::error::Error;
 
-#[cfg(target_os = "android")]
-use nym_client_core::client::{
-    base_client::helpers::setup_empty_reply_surb_backend, base_client::storage,
-    key_manager::persistence::InMemEphemeralKeys, replies::reply_storage,
-};
-#[cfg(target_os = "android")]
-use nym_credential_storage::ephemeral_storage::EphemeralStorage;
-
-#[cfg(not(target_os = "android"))]
-use nym_client_core::client::{
-    base_client::non_wasm_helpers, base_client::storage::OnDiskPersistent,
-    key_manager::persistence::OnDiskKeys, replies::reply_storage::fs_backend,
-};
-#[cfg(not(target_os = "android"))]
-use nym_credential_storage::persistent_storage::PersistentStorage;
-
 pub mod config;
 pub mod error;
 pub mod socks;
@@ -46,30 +31,41 @@ pub mod socks;
 pub type Socks5ControlMessageSender = mpsc::UnboundedSender<Socks5ControlMessage>;
 pub type Socks5ControlMessageReceiver = mpsc::UnboundedReceiver<Socks5ControlMessage>;
 
-#[cfg(target_os = "android")]
-type AndroidSocks5ClientBuilder<'a> =
-    BaseClientBuilder<'a, Client<QueryNyxdClient>, storage::Ephemeral>;
-
-#[cfg(not(target_os = "android"))]
-type Socks5ClientBuilder<'a> = BaseClientBuilder<'a, Client<QueryNyxdClient>, OnDiskPersistent>;
-
 #[derive(Debug)]
 pub enum Socks5ControlMessage {
     /// Tell the main task to stop
     Stop,
 }
 
-pub struct NymClient {
+pub struct StartedSocks5Client {
+    /// Handle for managing graceful shutdown of this client. If dropped, the client will be stopped.
+    pub shutdown_handle: TaskManager,
+
+    /// Address of the started client
+    pub address: Recipient,
+}
+
+pub struct NymClient<S> {
     /// Client configuration options, including, among other things, packet sending rates,
     /// key filepaths, etc.
     config: Config,
+
+    storage: S,
 }
 
-impl NymClient {
-    pub fn new(config: Config) -> Self {
-        NymClient { config }
+impl<S> NymClient<S>
+where
+    S: MixnetClientStorage + 'static,
+    S::ReplyStore: Send + Sync,
+    <S::ReplyStore as ReplyStorageBackend>::StorageError: Sync + Send,
+    <S::CredentialStore as CredentialStorage>::StorageError: Send + Sync,
+    <S::KeyStore as KeyStore>::StorageError: Send + Sync,
+{
+    pub fn new(config: Config, storage: S) -> Self {
+        NymClient { config, storage }
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn start_socks5_listener(
         socks5_config: &Socks5,
         debug_config: DebugConfig,
@@ -78,6 +74,7 @@ impl NymClient {
         client_status: ClientState,
         self_address: Recipient,
         shutdown: TaskClient,
+        packet_type: PacketType,
     ) {
         info!("Starting socks5 listener...");
         let auth_methods = vec![AuthenticationMethods::NoAuth as u8];
@@ -103,7 +100,7 @@ impl NymClient {
             .unwrap_or(debug_config.traffic.primary_packet_size);
 
         let authenticator = Authenticator::new(auth_methods, allowed_users);
-        let mut sphinx_socks = SphinxSocksServer::new(
+        let mut sphinx_socks = NymSocksServer::new(
             socks5_config.get_listening_port(),
             authenticator,
             socks5_config.get_provider_mix_address(),
@@ -118,6 +115,7 @@ impl NymClient {
                 socks5_config.get_per_request_surbs(),
             ),
             shutdown.clone(),
+            packet_type,
         );
         nym_task::spawn_with_report_error(
             async move {
@@ -135,21 +133,22 @@ impl NymClient {
 
     /// blocking version of `start` method. Will run forever (or until SIGINT is sent)
     pub async fn run_forever(self) -> Result<(), Box<dyn Error + Send + Sync>> {
-        let shutdown = self.start().await?;
+        let started = self.start().await?;
 
-        let res = shutdown.catch_interrupt().await;
+        let res = started.shutdown_handle.catch_interrupt().await;
         log::info!("Stopping nym-socks5-client");
         res
     }
 
-    // Variant of `run_forever` that listends for remote control messages
+    // Variant of `run_forever` that listens for remote control messages
     pub async fn run_and_listen(
         self,
         mut receiver: Socks5ControlMessageReceiver,
         sender: nym_task::StatusSender,
     ) -> Result<(), Box<dyn Error + Send + Sync>> {
         // Start the main task
-        let mut shutdown = self.start().await?;
+        let started = self.start().await?;
+        let mut shutdown = started.shutdown_handle;
 
         // Listen to status messages from task, that we forward back to the caller
         shutdown.start_status_listener(sender).await;
@@ -188,19 +187,38 @@ impl NymClient {
         res
     }
 
-    pub async fn start(self) -> Result<TaskManager, Socks5ClientCoreError> {
-        #[cfg(not(target_os = "android"))]
-        let base_builder = self.create_base_client_builder().await?;
+    pub async fn start(self) -> Result<StartedSocks5Client, Socks5ClientCoreError> {
+        let (key_store, reply_storage_backend, credential_store) = self.storage.into_split();
 
-        #[cfg(target_os = "android")]
-        let base_builder = self.create_base_client_builder().await;
+        // don't create bandwidth controller if credentials are disabled
+        let bandwidth_controller = if self.config.get_base().get_disabled_credentials_mode() {
+            None
+        } else {
+            Some(non_wasm_helpers::create_bandwidth_controller(
+                self.config.get_base(),
+                credential_store,
+            ))
+        };
 
-        let mut started_client = base_builder.start_base().await?;
+        let base_builder = BaseClientBuilder::<_, S>::new_from_base_config(
+            self.config.get_base(),
+            key_store,
+            bandwidth_controller,
+            reply_storage_backend,
+        );
+
+        let packet_type = self.config.get_base().get_packet_type();
+        let mut started_client = base_builder.start_base(packet_type).await?;
         let self_address = started_client.address;
         let client_input = started_client.client_input.register_producer();
         let client_output = started_client.client_output.register_consumer();
         let client_state = started_client.client_state;
 
+        info!(
+            "Running with {:?} packets",
+            self.config.get_base().get_packet_type()
+        );
+
         Self::start_socks5_listener(
             self.config.get_socks5(),
             *self.config.get_debug_settings(),
@@ -209,100 +227,15 @@ impl NymClient {
             client_state,
             self_address,
             started_client.task_manager.subscribe(),
+            self.config.get_base().get_packet_type(),
         );
 
         info!("Client startup finished!");
-        info!("The address of this client is: {}", self_address);
+        info!("The address of this client is: {self_address}");
 
-        Ok(started_client.task_manager)
-    }
-}
-
-#[cfg(not(target_os = "android"))]
-impl NymClient {
-    fn key_store(&self) -> OnDiskKeys {
-        let pathfinder = ClientKeyPathfinder::new_from_config(self.config.get_base());
-        OnDiskKeys::new(pathfinder)
-    }
-
-    async fn create_bandwidth_controller(
-        &self,
-    ) -> BandwidthController<Client<QueryNyxdClient>, PersistentStorage> {
-        let storage = nym_credential_storage::initialise_persistent_storage(
-            self.config.get_base().get_database_path(),
-        )
-        .await;
-
-        non_wasm_helpers::create_bandwidth_controller(self.config.get_base(), storage)
-    }
-
-    async fn create_reply_storage_backend(
-        &self,
-    ) -> Result<fs_backend::Backend, Socks5ClientCoreError> {
-        non_wasm_helpers::setup_fs_reply_surb_backend(
-            self.config.get_base().get_reply_surb_database_path(),
-            &self.config.get_debug_settings().reply_surbs,
-        )
-        .await
-        .map_err(Into::into)
-    }
-
-    async fn create_base_client_builder(
-        &self,
-    ) -> Result<Socks5ClientBuilder, Socks5ClientCoreError> {
-        // don't create bandwidth controller if credentials are disabled
-        let bandwidth_controller = if self.config.get_base().get_disabled_credentials_mode() {
-            None
-        } else {
-            Some(self.create_bandwidth_controller().await)
-        };
-
-        let key_store = self.key_store();
-        let reply_storage_backend = self.create_reply_storage_backend().await?;
-
-        Ok(BaseClientBuilder::new_from_base_config(
-            self.config.get_base(),
-            key_store,
-            bandwidth_controller,
-            reply_storage_backend,
-        ))
-    }
-}
-
-#[cfg(target_os = "android")]
-impl NymClient {
-    fn key_store(&self) -> InMemEphemeralKeys {
-        InMemEphemeralKeys::new()
-    }
-
-    fn create_bandwidth_controller(
-        config: &Config,
-    ) -> BandwidthController<Client<QueryNyxdClient>, EphemeralStorage> {
-        let storage = nym_credential_storage::initialise_ephemeral_storage();
-
-        create_bandwidth_controller(config.get_base(), storage)
-    }
-
-    fn create_reply_storage_backend(&self) -> reply_storage::Empty {
-        setup_empty_reply_surb_backend(self.config.get_debug_settings())
-    }
-
-    #[cfg(target_os = "android")]
-    fn create_base_client_builder(&self) -> Socks5ClientBuilder {
-        let bandwidth_controller = if self.config.get_base().get_disabled_credentials_mode() {
-            None
-        } else {
-            Some(self.create_bandwidth_controller().await)
-        };
-
-        let key_store = self.key_store();
-        let reply_storage_backend = self.create_reply_storage_backend();
-
-        BaseClientBuilder::new_from_base_config(
-            self.config.get_base(),
-            key_store,
-            bandwidth_controller,
-            reply_storage_backend,
-        )
+        Ok(StartedSocks5Client {
+            shutdown_handle: started_client.task_manager,
+            address: self_address,
+        })
     }
 }

common/socks5-client-core/src/socks/client.rs

@@ -18,6 +18,7 @@ use nym_socks5_requests::{
 };
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::params::PacketSize;
+use nym_sphinx::params::PacketType;
 use nym_task::connections::{LaneQueueLengths, TransmissionLane};
 use nym_task::TaskClient;
 use pin_project::pin_project;
@@ -185,6 +186,7 @@ pub(crate) struct SocksClient {
     started_proxy: bool,
     lane_queue_lengths: LaneQueueLengths,
     shutdown_listener: TaskClient,
+    packet_type: Option<PacketType>,
 }
 
 impl Drop for SocksClient {
@@ -213,6 +215,7 @@ impl SocksClient {
         self_address: &Recipient,
         lane_queue_lengths: LaneQueueLengths,
         mut shutdown_listener: TaskClient,
+        packet_type: Option<PacketType>,
     ) -> Self {
         // If this task fails and exits, we don't want to send shutdown signal
         shutdown_listener.mark_as_success();
@@ -233,6 +236,7 @@ impl SocksClient {
             started_proxy: false,
             lane_queue_lengths,
             shutdown_listener,
+            packet_type,
         }
     }
 
@@ -349,6 +353,7 @@ impl SocksClient {
             msg.into_bytes(),
             self.config.connection_start_surbs,
             TransmissionLane::ConnectionId(self.connection_id),
+            self.packet_type,
         );
         self.input_sender
             .send(input_message)
@@ -371,6 +376,7 @@ impl SocksClient {
             self.service_provider,
             msg.into_bytes(),
             TransmissionLane::ConnectionId(self.connection_id),
+            self.packet_type,
         );
         self.input_sender
             .send(input_message)
@@ -408,6 +414,7 @@ impl SocksClient {
         let request_version = self.config.request_version();
 
         let recipient = self.service_provider;
+        let packet_type = self.packet_type;
         let (stream, _) = ProxyRunner::new(
             stream,
             local_stream_remote,
@@ -439,9 +446,15 @@ impl SocksClient {
                     provider_message.into_bytes(),
                     per_request_surbs,
                     lane,
+                    packet_type,
                 )
             } else {
-                InputMessage::new_regular(recipient, provider_message.into_bytes(), lane)
+                InputMessage::new_regular(
+                    recipient,
+                    provider_message.into_bytes(),
+                    lane,
+                    packet_type,
+                )
             }
         })
         .await

common/socks5-client-core/src/socks/server.rs

@@ -10,6 +10,7 @@ use nym_client_core::client::{
 };
 use nym_socks5_proxy_helpers::connection_controller::Controller;
 use nym_sphinx::addressing::clients::Recipient;
+use nym_sphinx::params::PacketType;
 use nym_task::connections::{ConnectionCommandSender, LaneQueueLengths};
 use nym_task::TaskClient;
 use std::net::SocketAddr;
@@ -17,7 +18,7 @@ use tap::TapFallible;
 use tokio::net::TcpListener;
 
 /// A Socks5 server that listens for connections.
-pub struct SphinxSocksServer {
+pub struct NymSocksServer {
     authenticator: Authenticator,
     listening_address: SocketAddr,
     service_provider: Recipient,
@@ -25,10 +26,12 @@ pub struct SphinxSocksServer {
     client_config: client::Config,
     lane_queue_lengths: LaneQueueLengths,
     shutdown: TaskClient,
+    packet_type: PacketType,
 }
 
-impl SphinxSocksServer {
+impl NymSocksServer {
     /// Create a new SphinxSocks instance
+    #[allow(clippy::too_many_arguments)]
     pub(crate) fn new(
         port: u16,
         authenticator: Authenticator,
@@ -37,12 +40,13 @@ impl SphinxSocksServer {
         lane_queue_lengths: LaneQueueLengths,
         client_config: client::Config,
         shutdown: TaskClient,
+        packet_type: PacketType,
     ) -> Self {
         // hardcode ip as we (presumably) ONLY want to listen locally. If we change it, we can
         // just modify the config
         let ip = "127.0.0.1";
         info!("Listening on {}:{}", ip, port);
-        SphinxSocksServer {
+        NymSocksServer {
             authenticator,
             listening_address: format!("{ip}:{port}").parse().unwrap(),
             service_provider,
@@ -50,6 +54,7 @@ impl SphinxSocksServer {
             client_config,
             lane_queue_lengths,
             shutdown,
+            packet_type,
         }
     }
 
@@ -104,6 +109,7 @@ impl SphinxSocksServer {
                         &self.self_address,
                         self.lane_queue_lengths.clone(),
                         self.shutdown.clone(),
+                        Some(self.packet_type)
                     );
 
                     tokio::spawn(async move {
@@ -119,8 +125,8 @@ impl SphinxSocksServer {
                     });
                 },
                 _ = self.shutdown.recv() => {
-                    log::trace!("SphinxSocksServer: Received shutdown");
-                    log::debug!("SphinxSocksServer: Exiting");
+                    log::trace!("NymSocksServer: Received shutdown");
+                    log::debug!("NymSocksServer: Exiting");
                     return Ok(());
                 }
             }

common/topology/src/error.rs

@@ -1,10 +1,13 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+use std::array::TryFromSliceError;
+
 use crate::MixLayer;
+use nym_sphinx_types::NymPacketError;
 use thiserror::Error;
 
-#[derive(Debug, Clone, Error)]
+#[derive(Debug, Error)]
 pub enum NymTopologyError {
     #[error("The provided network topology is empty - there are no mixnodes and no gateways on it - the network request(s) probably failed")]
     EmptyNetworkTopology,
@@ -33,4 +36,16 @@ pub enum NymTopologyError {
         total_nodes: usize,
         layer_distribution: Vec<(MixLayer, usize)>,
     },
+    // We can't import SurbAckRecoveryError due to cyclic dependency, this is a bit dirty
+    #[error("Could not build payload")]
+    PayloadBuilder,
+
+    #[error("Outfox: {0}")]
+    Outfox(#[from] nym_sphinx_types::OutfoxError),
+
+    #[error("{0}")]
+    FromSlice(#[from] TryFromSliceError),
+
+    #[error("{0}")]
+    PacketError(#[from] NymPacketError),
 }

contracts/Cargo.lock

@@ -2,6 +2,16 @@
 # It is not intended for manual editing.
 version = 3
 
+[[package]]
+name = "aead"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
+dependencies = [
+ "crypto-common",
+ "generic-array 0.14.6",
+]
+
 [[package]]
 name = "aes"
 version = "0.7.5"
@@ -9,7 +19,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9e8b47f52ea9bae42228d07ec09eb676433d7c4ed1ebdf0f1d1c29ed446f1ab8"
 dependencies = [
  "cfg-if",
- "cipher",
+ "cipher 0.3.0",
  "cpufeatures",
  "ctr",
  "opaque-debug 0.3.0",
@@ -38,6 +48,12 @@ version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6b4930d2cb77ce62f89ee5d5289b4ac049559b1c45539271f5ed4fdc7db34545"
 
+[[package]]
+name = "arrayvec"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
+
 [[package]]
 name = "autocfg"
 version = "1.1.0"
@@ -86,6 +102,20 @@ dependencies = [
  "opaque-debug 0.2.3",
 ]
 
+[[package]]
+name = "blake3"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ae2468a89544a466886840aa467a25b766499f4f04bf7d9fcd10ecee9fccef"
+dependencies = [
+ "arrayref",
+ "arrayvec",
+ "cc",
+ "cfg-if",
+ "constant_time_eq",
+ "digest 0.10.7",
+]
+
 [[package]]
 name = "block-buffer"
 version = "0.9.0"
@@ -159,6 +189,30 @@ dependencies = [
  "keystream",
 ]
 
+[[package]]
+name = "chacha20"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818"
+dependencies = [
+ "cfg-if",
+ "cipher 0.4.4",
+ "cpufeatures",
+]
+
+[[package]]
+name = "chacha20poly1305"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10cd79432192d1c0f4e1a0fef9527696cc039165d729fb41b3f4f4f354c2dc35"
+dependencies = [
+ "aead",
+ "chacha20",
+ "cipher 0.4.4",
+ "poly1305",
+ "zeroize",
+]
+
 [[package]]
 name = "cipher"
 version = "0.3.0"
@@ -168,6 +222,17 @@ dependencies = [
  "generic-array 0.14.6",
 ]
 
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common",
+ "inout",
+ "zeroize",
+]
+
 [[package]]
 name = "coconut-test"
 version = "0.1.0"
@@ -199,13 +264,19 @@ version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "520fbf3c07483f94e3e3ca9d0cfd913d7718ef2483d2cfd91c0d9e91474ab913"
 
+[[package]]
+name = "constant_time_eq"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13418e745008f7349ec7e449155f419a61b92b58a99cc3616942b926825ec76b"
+
 [[package]]
 name = "cosmwasm-crypto"
 version = "1.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "75836a10cb9654c54e77ee56da94d592923092a10b369cdb0dbd56acefc16340"
 dependencies = [
- "digest 0.10.6",
+ "digest 0.10.7",
  "ed25519-zebra",
  "k256",
  "rand_core 0.6.4",
@@ -284,6 +355,49 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a33c2bf77f2df06183c3aa30d1e96c0695a313d4f9c453cc3762a6db39f99200"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce6fd6f855243022dcecf8702fef0c297d4338e226845fe067f6341ad9fa0cef"
+dependencies = [
+ "cfg-if",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46bd5f3f85273295a9d14aedfb86f6aadbff6d8f5295c4a9edb08e819dcf5695"
+dependencies = [
+ "autocfg",
+ "cfg-if",
+ "crossbeam-utils",
+ "memoffset",
+ "scopeguard",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c063cd8cc95f5c377ed0d4b49a4b21f632396ff690e8470c29b3359b346984b"
+dependencies = [
+ "cfg-if",
+]
+
 [[package]]
 name = "crunchy"
 version = "0.2.2"
@@ -309,6 +423,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
  "generic-array 0.14.6",
+ "rand_core 0.6.4",
  "typenum",
 ]
 
@@ -338,7 +453,7 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "049bb91fb4aaf0e3c7efa6cd5ef877dbbbd15b39dad06d9948de4ec8a75761ea"
 dependencies = [
- "cipher",
+ "cipher 0.3.0",
 ]
 
 [[package]]
@@ -620,9 +735,9 @@ dependencies = [
 
 [[package]]
 name = "digest"
-version = "0.10.6"
+version = "0.10.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8168378f4e5023e7218c89c891c0fd8ecdb5e5e4f18cb78f38cf245dd021e76f"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
  "block-buffer 0.10.4",
  "crypto-common",
@@ -700,7 +815,7 @@ dependencies = [
  "base16ct",
  "crypto-bigint",
  "der",
- "digest 0.10.6",
+ "digest 0.10.7",
  "ff",
  "generic-array 0.14.6",
  "group",
@@ -926,8 +1041,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
 dependencies = [
  "cfg-if",
+ "js-sys",
  "libc",
  "wasi 0.11.0+wasi-snapshot-preview1",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -975,6 +1092,15 @@ dependencies = [
  "ahash",
 ]
 
+[[package]]
+name = "hermit-abi"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee512640fe35acbfb4bb779db6f0d80704c2cacfa2e39b601ef3e3f47d1ae4c7"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "hermit-abi"
 version = "0.3.1"
@@ -1013,7 +1139,7 @@ version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
 dependencies = [
- "digest 0.10.6",
+ "digest 0.10.7",
 ]
 
 [[package]]
@@ -1042,6 +1168,15 @@ dependencies = [
  "unicode-normalization",
 ]
 
+[[package]]
+name = "inout"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5"
+dependencies = [
+ "generic-array 0.14.6",
+]
+
 [[package]]
 name = "instant"
 version = "0.1.12"
@@ -1057,7 +1192,7 @@ version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c66c74d2ae7e79a5a8f7ac924adbe38ee42a859c6539ad869eb51f0b52dc220"
 dependencies = [
- "hermit-abi",
+ "hermit-abi 0.3.1",
  "libc",
  "windows-sys 0.48.0",
 ]
@@ -1188,6 +1323,15 @@ version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
 
+[[package]]
+name = "memoffset"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d61c719bcfbcf5d62b3a09efa6088de8c54bc0bfcd3ea7ae39fcc186108b8de1"
+dependencies = [
+ "autocfg",
+]
+
 [[package]]
 name = "mixnet-vesting-integration-tests"
 version = "0.1.0"
@@ -1214,6 +1358,16 @@ dependencies = [
  "libm",
 ]
 
+[[package]]
+name = "num_cpus"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fac9e2da13b5eb447a6ce3d392f23a29d8694bff781bf03a16cd9ac8697593b"
+dependencies = [
+ "hermit-abi 0.2.6",
+ "libc",
+]
+
 [[package]]
 name = "nym-coconut-bandwidth"
 version = "0.1.0"
@@ -1358,7 +1512,6 @@ dependencies = [
  "cw-storage-plus 1.0.1",
  "cw-utils 1.0.1",
  "cw3",
- "cw3-fixed-multisig",
  "cw4",
  "schemars",
  "serde",
@@ -1395,6 +1548,23 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "nym-outfox"
+version = "0.1.0"
+dependencies = [
+ "blake3",
+ "chacha20",
+ "chacha20poly1305",
+ "curve25519-dalek",
+ "getrandom 0.2.8",
+ "log",
+ "rand 0.7.3",
+ "rayon",
+ "sphinx-packet",
+ "thiserror",
+ "zeroize",
+]
+
 [[package]]
 name = "nym-pemstore"
 version = "0.2.0"
@@ -1434,7 +1604,9 @@ dependencies = [
 name = "nym-sphinx-types"
 version = "0.2.0"
 dependencies = [
+ "nym-outfox",
  "sphinx-packet",
+ "thiserror",
 ]
 
 [[package]]
@@ -1534,6 +1706,17 @@ version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"
 
+[[package]]
+name = "poly1305"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf"
+dependencies = [
+ "cpufeatures",
+ "opaque-debug 0.3.0",
+ "universal-hash",
+]
+
 [[package]]
 name = "ppv-lite86"
 version = "0.2.17"
@@ -1692,6 +1875,28 @@ dependencies = [
  "rand_core 0.5.1",
 ]
 
+[[package]]
+name = "rayon"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d2df5196e37bcc87abebc0053e20787d73847bb33134a69841207dd0a47f03b"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b8f95bd6966f5c87776639160a66bd8ab9895d9d4ab01ddba9fc60661aebe8d"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-deque",
+ "crossbeam-utils",
+ "num_cpus",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.3.5"
@@ -1824,6 +2029,12 @@ dependencies = [
  "syn 1.0.109",
 ]
 
+[[package]]
+name = "scopeguard"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+
 [[package]]
 name = "sec1"
 version = "0.3.0"
@@ -1936,7 +2147,7 @@ checksum = "82e6b795fe2e3b1e845bafcb27aa35405c4d47cdfc92af5fc8d3002f76cebdc0"
 dependencies = [
  "cfg-if",
  "cpufeatures",
- "digest 0.10.6",
+ "digest 0.10.7",
 ]
 
 [[package]]
@@ -1945,7 +2156,7 @@ version = "1.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "74233d3b3b2f6d4b006dc19dee745e73e2a6bfb6f93607cd3b02bd5b00797d7c"
 dependencies = [
- "digest 0.10.6",
+ "digest 0.10.7",
  "rand_core 0.6.4",
 ]
 
@@ -2155,6 +2366,16 @@ dependencies = [
  "tinyvec",
 ]
 
+[[package]]
+name = "universal-hash"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
+dependencies = [
+ "crypto-common",
+ "subtle 2.4.1",
+]
+
 [[package]]
 name = "url"
 version = "2.3.1"

contracts/mixnet/Developing.md

@@ -76,7 +76,7 @@ docker run --rm -v "$(pwd)":/code \
   cosmwasm/rust-optimizer:0.10.7
 ```
 
-We must mount the contract code to `/code`. You can use a absolute path instead
+We must mount the contract code to `/code`. You can use an absolute path instead
 of `$(pwd)` if you don't want to `cd` to the directory first. The other two
 volumes are nice for speedup. Mounting `/code/target` in particular is useful
 to avoid docker overwriting your local dev files with root permissions.

contracts/mixnet/Importing.md

@@ -22,8 +22,8 @@ any uploaded contract.
 
 ## Reviewing
 
-Once you have done the quick programatic checks, it is good to give at least a quick
-look through the code. A glance at `examples/schema.rs` to make sure it is outputing
+Once you have done the quick programmatic checks, it is good to give at least a quick
+look through the code. A glance at `examples/schema.rs` to make sure it is outputting
 all relevant structs from `contract.rs`, and also ensure `src/lib.rs` is just the
 default wrapper (nothing funny going on there). After this point, we can dive into
 the contract code itself. Check the flows for the handle methods, any invariants and

explorer/src/pages/ServiceProviders/index.tsx

@@ -1,5 +1,5 @@
-import React, { useState } from 'react';
-import { Card, FormControl, Grid, MenuItem, Select, SelectChangeEvent, Typography } from '@mui/material';
+import React from 'react';
+import { Button, Card, FormControl, Grid, ListItem, Menu, SelectChangeEvent, Typography } from '@mui/material';
 import { TableToolbar } from '../../components/TableToolbar';
 import { Title } from '../../components/Title';
 import { UniversalDataGrid } from '../../components/Universal-DataGrid';
@@ -15,17 +15,34 @@ const columns = [
 ];
 
 const SupportedApps = () => {
-  const [selected, setSelected] = useState<string>('');
-  const handleChange = (e: SelectChangeEvent) => setSelected(e.target.value);
+  const [anchorEl, setAnchorEl] = React.useState<null | HTMLElement>(null);
+  const open = Boolean(anchorEl);
+  const handleClick = (event: React.MouseEvent<HTMLButtonElement>) => {
+    setAnchorEl(event.currentTarget);
+  };
+  const handleClose = () => {
+    setAnchorEl(null);
+  };
+  const anchorRef = React.useRef<HTMLButtonElement>(null);
+
   return (
     <FormControl size="small">
-      <Select value={selected} onChange={handleChange} displayEmpty sx={{ mr: 2 }}>
-        <MenuItem value="">Supported Apps</MenuItem>
-        <MenuItem>Keybase</MenuItem>
-        <MenuItem>Telegram</MenuItem>
-        <MenuItem>Electrum</MenuItem>
-        <MenuItem>Blockstream Green</MenuItem>
-      </Select>
+      <Button
+        ref={anchorRef}
+        onClick={handleClick}
+        size="large"
+        variant="outlined"
+        color="inherit"
+        sx={{ mr: 2, textTransform: 'capitalize' }}
+      >
+        Supported Apps
+      </Button>
+      <Menu id="basic-menu" anchorEl={anchorEl} open={open} onClose={handleClose}>
+        <ListItem>Keybase</ListItem>
+        <ListItem>Telegram</ListItem>
+        <ListItem>Electrum</ListItem>
+        <ListItem>Blockstream Green</ListItem>
+      </Menu>
     </FormControl>
   );
 };

gateway/gateway-requests/src/types.rs

@@ -5,6 +5,7 @@ use crate::authentication::encrypted_address::EncryptedAddressBytes;
 use crate::iv::IV;
 use crate::registration::handshake::SharedKeys;
 use crate::{GatewayMacSize, PROTOCOL_VERSION};
+use log::error;
 use nym_coconut_interface::Credential;
 use nym_crypto::generic_array::typenum::Unsigned;
 use nym_crypto::hmac::recompute_keyed_hmac_and_verify_tag;
@@ -290,7 +291,13 @@ impl BinaryRequest {
     pub fn into_encrypted_tagged_bytes(self, shared_key: &SharedKeys) -> Vec<u8> {
         match self {
             BinaryRequest::ForwardSphinx(mix_packet) => {
-                let forwarding_data = mix_packet.into_bytes();
+                let forwarding_data = match mix_packet.into_bytes() {
+                    Ok(mix_packet) => mix_packet,
+                    Err(e) => {
+                        error!("Could not convert packet to bytes: {e}");
+                        return vec![];
+                    }
+                };
 
                 // TODO: it could be theoretically slightly more efficient if the data wasn't taken
                 // by reference because then it makes a copy for encryption rather than do it in place

gateway/src/node/client_handling/websocket/connection_handler/authenticated.rs

@@ -283,7 +283,7 @@ where
         &self,
         mix_packet: MixPacket,
     ) -> Result<ServerResponse, RequestHandlingError> {
-        let consumed_bandwidth = mix_packet.sphinx_packet().len() as i64;
+        let consumed_bandwidth = mix_packet.packet().len() as i64;
 
         let available_bandwidth = self.get_available_bandwidth().await?;
 
@@ -309,7 +309,10 @@ where
     async fn handle_binary(&self, bin_msg: Vec<u8>) -> Message {
         // this function decrypts the request and checks the MAC
         match BinaryRequest::try_from_encrypted_tagged_bytes(bin_msg, &self.client.shared_keys) {
-            Err(e) => RequestHandlingError::InvalidBinaryRequest(e).into_error_message(),
+            Err(e) => {
+                error!("{e}");
+                RequestHandlingError::InvalidBinaryRequest(e).into_error_message()
+            }
             Ok(request) => match request {
                 // currently only a single type exists
                 BinaryRequest::ForwardSphinx(mix_packet) => self

gateway/src/node/mixnet_handling/receiver/connection_handler.rs

@@ -11,8 +11,8 @@ use log::*;
 use nym_mixnet_client::forwarder::MixForwardingSender;
 use nym_mixnode_common::packet_processor::processor::ProcessedFinalHop;
 use nym_sphinx::forwarding::packet::MixPacket;
-use nym_sphinx::framing::codec::SphinxCodec;
-use nym_sphinx::framing::packet::FramedSphinxPacket;
+use nym_sphinx::framing::codec::NymCodec;
+use nym_sphinx::framing::packet::FramedNymPacket;
 use nym_sphinx::DestinationAddressBytes;
 use nym_task::TaskClient;
 use std::collections::HashMap;
@@ -155,7 +155,7 @@ impl<St: Storage> ConnectionHandler<St> {
         self.forward_ack(forward_ack, client_address);
     }
 
-    async fn handle_received_packet(&mut self, framed_sphinx_packet: FramedSphinxPacket) {
+    async fn handle_received_packet(&mut self, framed_sphinx_packet: FramedNymPacket) {
         //
         // TODO: here be replay attack detection - it will require similar key cache to the one in
         // packet processor for vpn packets,
@@ -182,7 +182,7 @@ impl<St: Storage> ConnectionHandler<St> {
     ) {
         debug!("Starting connection handler for {:?}", remote);
         shutdown.mark_as_success();
-        let mut framed_conn = Framed::new(conn, SphinxCodec);
+        let mut framed_conn = Framed::new(conn, NymCodec);
         while !shutdown.is_shutdown() {
             tokio::select! {
                 biased;

gateway/src/node/mixnet_handling/receiver/packet_processing.rs

@@ -5,7 +5,7 @@ use nym_crypto::asymmetric::encryption;
 use nym_mixnode_common::packet_processor::error::MixProcessingError;
 pub use nym_mixnode_common::packet_processor::processor::MixProcessingResult;
 use nym_mixnode_common::packet_processor::processor::{ProcessedFinalHop, SphinxPacketProcessor};
-use nym_sphinx::framing::packet::FramedSphinxPacket;
+use nym_sphinx::framing::packet::FramedNymPacket;
 use thiserror::Error;
 
 #[derive(Error, Debug)]
@@ -32,7 +32,7 @@ impl PacketProcessor {
 
     pub(crate) fn process_received(
         &self,
-        received: FramedSphinxPacket,
+        received: FramedNymPacket,
     ) -> Result<ProcessedFinalHop, GatewayProcessingError> {
         match self.inner_processor.process_received(received)? {
             MixProcessingResult::ForwardHop(..) => {

mixnode/Cargo.toml

@@ -51,6 +51,7 @@ nym-mixnet-client = { path = "../common/client-libs/mixnet-client" }
 nym-mixnode-common = { path = "../common/mixnode-common" }
 nym-nonexhaustive-delayqueue = { path = "../common/nonexhaustive-delayqueue" }
 nym-sphinx = { path = "../common/nymsphinx" }
+nym-sphinx-params = { path = "../common/nymsphinx/params" }
 nym-pemstore = { path = "../common/pemstore", version = "0.2.0" }
 nym-task = { path = "../common/task" }
 nym-types = { path = "../common/types" }

mixnode/src/main.rs

@@ -51,9 +51,14 @@ fn test_function() {
 async fn main() {
     cfg_if::cfg_if! {
         if #[cfg(feature = "cpucycles")] {
-            setup_tracing!("/tmp/tracing.log");
+            let home_dir = dirs::home_dir().expect("Could not get $HOME");
+            let logs_dir = home_dir.join(".nym").join("logs");
+            let logs_dir_str = logs_dir.to_str().expect("Could not construct logs path");
+            setup_tracing!(logs_dir_str);
+            info!("CPU cycles measurement is ON")
         } else {
             setup_logging();
+            info!("CPU cycles measurement is OFF")
         }
     }
 

mixnode/src/node/listener/connection_handler/mod.rs

@@ -9,8 +9,8 @@ use crate::node::TaskClient;
 use futures::StreamExt;
 use nym_mixnode_common::measure;
 use nym_sphinx::forwarding::packet::MixPacket;
-use nym_sphinx::framing::codec::SphinxCodec;
-use nym_sphinx::framing::packet::FramedSphinxPacket;
+use nym_sphinx::framing::codec::NymCodec;
+use nym_sphinx::framing::packet::FramedNymPacket;
 use nym_sphinx::Delay as SphinxDelay;
 use std::net::SocketAddr;
 use tokio::net::TcpStream;
@@ -54,7 +54,7 @@ impl ConnectionHandler {
         feature = "cpucycles",
         instrument(skip(self, framed_sphinx_packet), fields(cpucycles))
     )]
-    fn handle_received_packet(&self, framed_sphinx_packet: FramedSphinxPacket) {
+    fn handle_received_packet(&self, framed_sphinx_packet: FramedNymPacket) {
         //
         // TODO: here be replay attack detection - it will require similar key cache to the one in
         // packet processor for vpn packets,
@@ -86,7 +86,7 @@ impl ConnectionHandler {
     ) {
         debug!("Starting connection handler for {:?}", remote);
         shutdown.mark_as_success();
-        let mut framed_conn = Framed::new(conn, SphinxCodec);
+        let mut framed_conn = Framed::new(conn, NymCodec);
         while !shutdown.is_shutdown() {
             tokio::select! {
                 biased;
@@ -108,7 +108,7 @@ impl ConnectionHandler {
                         }
                         Some(Err(err)) => {
                             error!(
-                                "The socket connection got corrupted with error: {err}. Closing the socket",
+                                "{remote:?} - The socket connection got corrupted with error: {err}. Closing the socket",
                             );
                             return;
                         }

mixnode/src/node/listener/connection_handler/packet_processing.rs

@@ -6,7 +6,7 @@ use nym_crypto::asymmetric::encryption;
 use nym_mixnode_common::packet_processor::error::MixProcessingError;
 pub use nym_mixnode_common::packet_processor::processor::MixProcessingResult;
 use nym_mixnode_common::packet_processor::processor::SphinxPacketProcessor;
-use nym_sphinx::framing::packet::FramedSphinxPacket;
+use nym_sphinx::framing::packet::FramedNymPacket;
 
 // PacketProcessor contains all data required to correctly unwrap and forward sphinx packets
 #[derive(Clone)]
@@ -31,7 +31,7 @@ impl PacketProcessor {
 
     pub(crate) fn process_received(
         &self,
-        received: FramedSphinxPacket,
+        received: FramedNymPacket,
     ) -> Result<MixProcessingResult, MixProcessingError> {
         self.node_stats_update_sender.report_received();
         self.inner_processor.process_received(received)

mixnode/src/node/packet_delayforwarder.rs

@@ -58,12 +58,12 @@ where
 
     fn forward_packet(&mut self, packet: MixPacket) {
         let next_hop = packet.next_hop();
-        let packet_mode = packet.packet_mode();
-        let sphinx_packet = packet.into_sphinx_packet();
+        let packet_type = packet.packet_type();
+        let packet = packet.into_packet();
 
-        if let Err(err) =
-            self.mixnet_client
-                .send_without_response(next_hop, sphinx_packet, packet_mode)
+        if let Err(err) = self
+            .mixnet_client
+            .send_without_response(next_hop, packet, packet_type)
         {
             if err.kind() == io::ErrorKind::WouldBlock {
                 // we only know for sure if we dropped a packet if our sending queue was full
@@ -134,38 +134,38 @@ mod tests {
     use std::sync::{Arc, Mutex};
     use std::time::Duration;
 
+    use nym_sphinx::NymPacket;
     use nym_task::TaskManager;
 
     use nym_sphinx::addressing::nodes::NymNodeRoutingAddress;
     use nym_sphinx_params::packet_sizes::PacketSize;
-    use nym_sphinx_params::PacketMode;
-    use nym_sphinx_types::builder::SphinxPacketBuilder;
+    use nym_sphinx_params::PacketType;
     use nym_sphinx_types::{
         crypto, Delay as SphinxDelay, Destination, DestinationAddressBytes, Node, NodeAddressBytes,
-        SphinxPacket, DESTINATION_ADDRESS_LENGTH, IDENTIFIER_LENGTH, NODE_ADDRESS_LENGTH,
+        DESTINATION_ADDRESS_LENGTH, IDENTIFIER_LENGTH, NODE_ADDRESS_LENGTH,
     };
 
     #[derive(Default)]
     struct TestClient {
-        pub packets_sent: Arc<Mutex<Vec<(NymNodeRoutingAddress, SphinxPacket, PacketMode)>>>,
+        pub packets_sent: Arc<Mutex<Vec<(NymNodeRoutingAddress, NymPacket, PacketType)>>>,
     }
 
     impl nym_mixnet_client::SendWithoutResponse for TestClient {
         fn send_without_response(
             &mut self,
             address: NymNodeRoutingAddress,
-            packet: SphinxPacket,
-            packet_mode: PacketMode,
+            packet: NymPacket,
+            packet_type: PacketType,
         ) -> io::Result<()> {
             self.packets_sent
                 .lock()
                 .unwrap()
-                .push((address, packet, packet_mode));
+                .push((address, packet, packet_type));
             Ok(())
         }
     }
 
-    fn make_valid_sphinx_packet(size: PacketSize) -> SphinxPacket {
+    fn make_valid_sphinx_packet(size: PacketSize) -> NymPacket {
         let (_, node1_pk) = crypto::keygen();
         let node1 = Node::new(
             NodeAddressBytes::from_bytes([5u8; NODE_ADDRESS_LENGTH]),
@@ -192,12 +192,45 @@ mod tests {
             SphinxDelay::new_from_nanos(42),
             SphinxDelay::new_from_nanos(42),
         ];
-        SphinxPacketBuilder::new()
-            .with_payload_size(size.payload_size())
-            .build_packet(b"foomp", &route, &destination, &delays)
+        NymPacket::sphinx_build(size.payload_size(), b"foomp", &route, &destination, &delays)
             .unwrap()
     }
 
+    fn make_valid_outfox_packet(size: PacketSize) -> NymPacket {
+        let (_, node1_pk) = crypto::keygen();
+        let node1 = Node::new(
+            NodeAddressBytes::from_bytes([5u8; NODE_ADDRESS_LENGTH]),
+            node1_pk,
+        );
+        let (_, node2_pk) = crypto::keygen();
+        let node2 = Node::new(
+            NodeAddressBytes::from_bytes([4u8; NODE_ADDRESS_LENGTH]),
+            node2_pk,
+        );
+        let (_, node3_pk) = crypto::keygen();
+        let node3 = Node::new(
+            NodeAddressBytes::from_bytes([2u8; NODE_ADDRESS_LENGTH]),
+            node3_pk,
+        );
+
+        let (_, node4_pk) = crypto::keygen();
+        let node4 = Node::new(
+            NodeAddressBytes::from_bytes([2u8; NODE_ADDRESS_LENGTH]),
+            node4_pk,
+        );
+
+        let destination = Destination::new(
+            DestinationAddressBytes::from_bytes([3u8; DESTINATION_ADDRESS_LENGTH]),
+            [4u8; IDENTIFIER_LENGTH],
+        );
+
+        let route = &[node1, node2, node3, node4];
+
+        let payload = vec![1; 48];
+
+        NymPacket::outfox_build(payload, route, &destination, Some(size.plaintext_size())).unwrap()
+    }
+
     #[tokio::test]
     async fn packets_received_are_forwarded() {
         // Wire up the DelayForwarder
@@ -219,7 +252,50 @@ mod tests {
         let mix_packet = MixPacket::new(
             next_hop,
             make_valid_sphinx_packet(PacketSize::default()),
-            PacketMode::default(),
+            PacketType::default(),
+        );
+        let forward_instant = None;
+        packet_sender
+            .unbounded_send((mix_packet, forward_instant))
+            .unwrap();
+
+        // Give the the worker a chance to act
+        tokio::time::sleep(Duration::from_millis(10)).await;
+
+        // The client should have forwarded the packet straight away
+        assert_eq!(
+            client_packets_sent
+                .lock()
+                .unwrap()
+                .iter()
+                .map(|(a, _, _)| *a)
+                .collect::<Vec<_>>(),
+            vec![next_hop]
+        );
+    }
+
+    #[tokio::test]
+    async fn outfox_packets_received_are_forwarded() {
+        // Wire up the DelayForwarder
+        let (stats_sender, _stats_receiver) = mpsc::unbounded();
+        let node_stats_update_sender = UpdateSender::new(stats_sender);
+        let client = TestClient::default();
+        let client_packets_sent = client.packets_sent.clone();
+        let shutdown = TaskManager::default();
+        let mut delay_forwarder =
+            DelayForwarder::new(client, node_stats_update_sender, shutdown.subscribe());
+        let packet_sender = delay_forwarder.sender();
+
+        // Spawn the worker, listening on packet_sender channel
+        tokio::spawn(async move { delay_forwarder.run().await });
+
+        // Send a `MixPacket` down the channel without any delay attached.
+        let next_hop =
+            NymNodeRoutingAddress::from(SocketAddr::new(IpAddr::V4(Ipv4Addr::new(1, 2, 3, 4)), 42));
+        let mix_packet = MixPacket::new(
+            next_hop,
+            make_valid_outfox_packet(PacketSize::default()),
+            PacketType::default(),
         );
         let forward_instant = None;
         packet_sender

nym-api/src/network_monitor/chunker.rs

@@ -0,0 +1,86 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use nym_sphinx::forwarding::packet::MixPacket;
+use nym_sphinx::message::NymMessage;
+use nym_sphinx::params::{PacketSize, PacketType};
+use nym_sphinx::{
+    acknowledgements::AckKey, addressing::clients::Recipient, preparer::MessagePreparer,
+};
+use nym_topology::NymTopology;
+use rand_07::rngs::OsRng;
+use std::time::Duration;
+
+const DEFAULT_AVERAGE_PACKET_DELAY: Duration = Duration::from_millis(200);
+const DEFAULT_AVERAGE_ACK_DELAY: Duration = Duration::from_millis(200);
+
+#[derive(Clone)]
+pub(crate) struct Chunker {
+    rng: OsRng,
+    packet_size: PacketSize,
+    message_preparer: MessagePreparer<OsRng>,
+}
+
+impl Chunker {
+    pub(crate) fn new(tested_mix_me: Recipient) -> Self {
+        Chunker {
+            rng: OsRng,
+            // no point in using anything else for monitoring
+            // unless we should make it variable so mixnodes wouldn't know if
+            // non-default packet is for measurement or not
+            packet_size: PacketSize::RegularPacket,
+            message_preparer: MessagePreparer::new(
+                OsRng,
+                tested_mix_me,
+                DEFAULT_AVERAGE_PACKET_DELAY,
+                DEFAULT_AVERAGE_ACK_DELAY,
+            ),
+        }
+    }
+
+    pub(crate) fn prepare_packets_from(
+        &mut self,
+        message: Vec<u8>,
+        topology: &NymTopology,
+        packet_sender: Recipient,
+        packet_type: PacketType,
+    ) -> Vec<MixPacket> {
+        // I really dislike how we have to overwrite the parameter of the `MessagePreparer` on each run
+        // but without some significant API changes in the `MessagePreparer` this was the easiest
+        // way to being able to have variable sender address.
+        self.message_preparer.set_sender_address(packet_sender);
+        self.prepare_packets(message, topology, packet_sender, packet_type)
+    }
+
+    fn prepare_packets(
+        &mut self,
+        message: Vec<u8>,
+        topology: &NymTopology,
+        packet_sender: Recipient,
+        packet_type: PacketType,
+    ) -> Vec<MixPacket> {
+        let ack_key: AckKey = AckKey::new(&mut self.rng);
+
+        let split_message = self
+            .message_preparer
+            .pad_and_split_message(NymMessage::new_plain(message), self.packet_size);
+
+        let mut mix_packets = Vec::with_capacity(split_message.len());
+        for message_chunk in split_message {
+            // don't bother with acks etc. for time being
+            let prepared_fragment = self
+                .message_preparer
+                .prepare_chunk_for_sending(
+                    message_chunk,
+                    topology,
+                    &ack_key,
+                    &packet_sender,
+                    packet_type,
+                )
+                .unwrap();
+
+            mix_packets.push(prepared_fragment.mix_packet);
+        }
+        mix_packets
+    }
+}

nym-api/src/network_monitor/mod.rs

@@ -21,6 +21,7 @@ use nym_bandwidth_controller::BandwidthController;
 use nym_credential_storage::persistent_storage::PersistentStorage;
 use nym_crypto::asymmetric::{encryption, identity};
 use nym_sphinx::acknowledgements::AckKey;
+use nym_sphinx::params::PacketType;
 use nym_sphinx::receiver::MessageReceiver;
 use nym_task::TaskManager;
 use std::sync::Arc;
@@ -129,6 +130,7 @@ impl<'a> NetworkMonitorBuilder<'a> {
             received_processor,
             summary_producer,
             self.node_status_storage,
+            PacketType::Mix,
         );
 
         NetworkMonitorRunnables {

nym-api/src/network_monitor/monitor/mod.rs

@@ -10,6 +10,7 @@ use crate::network_monitor::test_route::TestRoute;
 use crate::storage::NymApiStorage;
 use crate::support::config::Config;
 use log::{debug, error, info};
+use nym_sphinx::params::PacketType;
 use nym_sphinx::receiver::MessageReceiver;
 use nym_task::TaskClient;
 use std::collections::{HashMap, HashSet};
@@ -44,6 +45,8 @@ pub(super) struct Monitor<R: MessageReceiver + Send + 'static> {
     /// The minimum number of test routes that need to be constructed (and working) in order for
     /// a monitor test run to be valid.
     minimum_test_routes: usize,
+
+    packet_type: PacketType,
 }
 
 impl<R: MessageReceiver + Send> Monitor<R> {
@@ -54,6 +57,7 @@ impl<R: MessageReceiver + Send> Monitor<R> {
         received_processor: ReceivedProcessor<R>,
         summary_producer: SummaryProducer,
         node_status_storage: NymApiStorage,
+        packet_type: PacketType,
     ) -> Self {
         Monitor {
             test_nonce: 1,
@@ -68,6 +72,7 @@ impl<R: MessageReceiver + Send> Monitor<R> {
             route_test_packets: config.get_route_test_packets(),
             test_routes: config.get_test_routes(),
             minimum_test_routes: config.get_minimum_test_routes(),
+            packet_type,
         }
     }
 
@@ -125,8 +130,11 @@ impl<R: MessageReceiver + Send> Monitor<R> {
         for route in routes {
             let mut packet_preparer = self.packet_preparer.clone();
             let route = route.clone();
-            let gateway_packets = packet_preparer
-                .prepare_test_route_viability_packets(&route, self.route_test_packets);
+            let gateway_packets = packet_preparer.prepare_test_route_viability_packets(
+                &route,
+                self.route_test_packets,
+                self.packet_type,
+            );
             packets.push(gateway_packets);
         }
 
@@ -233,7 +241,7 @@ impl<R: MessageReceiver + Send> Monitor<R> {
         info!("Generating test mix packets for all the network nodes...");
         let prepared_packets = self
             .packet_preparer
-            .prepare_test_packets(self.test_nonce, routes)
+            .prepare_test_packets(self.test_nonce, routes, self.packet_type)
             .await;
 
         let total_sent = prepared_packets