update branch for latest changes

.github/workflows/build-and-upload-binaries-ci.yml

@@ -4,34 +4,11 @@ on:
   workflow_dispatch:
   push:
     paths:
-      - 'clients/**'
-      - 'common/**'
-      - 'contracts/**'
-      - 'explorer-api/**'
-      - 'gateway/**'
-      - 'integrations/**'
       - 'mixnode/**'
-      - 'sdk/rust/nym-sdk/**'
-      - 'service-providers/**'
-      - 'nym-api/**'
-      - 'nym-outfox/**'
-      - 'tools/nym-cli/**'
-      - 'tools/ts-rs-cli/**'
+
   pull_request:
     paths:
-      - 'clients/**'
-      - 'common/**'
-      - 'contracts/**'
-      - 'explorer-api/**'
-      - 'gateway/**'
-      - 'integrations/**'
       - 'mixnode/**'
-      - 'sdk/rust/nym-sdk/**'
-      - 'service-providers/**'
-      - 'nym-api/**'
-      - 'nym-outfox/**'
-      - 'tools/nym-cli/**'
-      - 'tools/ts-rs-cli/**'
 
 env:
   NETWORK: mainnet
@@ -65,11 +42,11 @@ jobs:
         with:
           toolchain: stable
 
-      - name: Build all binaries
+      - name: Build all mixnode binary
         uses: actions-rs/cargo@v1
         with:
           command: build
-          args: --workspace --release --all
+          args: --manifest-path mixnode/Cargo.toml --release --features cpucycles
 
       - name: Install Rust stable
         uses: actions-rs/toolchain@v1
@@ -79,34 +56,12 @@ jobs:
           override: true
           components: rustfmt, clippy
 
-      - name: Install wasm-opt
-        run: cargo install --version 0.112.0 wasm-opt
-
-      - name: Build release contracts
-        run: make wasm
-
       - name: Prepare build output
         shell: bash
         env:
           OUTPUT_DIR: ci-builds/${{ github.ref_name }}
         run: |
-          cp target/release/nym-client $OUTPUT_DIR
-          cp target/release/nym-gateway $OUTPUT_DIR
           cp target/release/nym-mixnode $OUTPUT_DIR
-          cp target/release/nym-socks5-client $OUTPUT_DIR
-          cp target/release/nym-api $OUTPUT_DIR
-          cp target/release/nym-network-requester $OUTPUT_DIR
-          cp target/release/nym-network-statistics $OUTPUT_DIR
-          cp target/release/nym-cli $OUTPUT_DIR
-          cp target/release/nym-credential-client $OUTPUT_DIR
-          cp target/release/explorer-api $OUTPUT_DIR
-          
-          cp contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm $OUTPUT_DIR
-          cp contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm $OUTPUT_DIR
-          cp contracts/target/wasm32-unknown-unknown/release/nym_coconut_bandwidth.wasm $OUTPUT_DIR
-          cp contracts/target/wasm32-unknown-unknown/release/nym_coconut_dkg.wasm $OUTPUT_DIR
-          cp contracts/target/wasm32-unknown-unknown/release/cw3_flex_multisig.wasm $OUTPUT_DIR
-          cp contracts/target/wasm32-unknown-unknown/release/cw4_group.wasm $OUTPUT_DIR
 
       - name: Deploy branch to CI www
         continue-on-error: true

.gitignore

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

Cargo.lock

@@ -3626,7 +3626,6 @@ dependencies = [
  "cfg-if",
  "clap 4.1.11",
  "colored",
- "cpu-cycles",
  "cupid",
  "dirs",
  "futures",
@@ -3786,7 +3785,6 @@ dependencies = [
  "log",
  "nym-crypto",
  "nym-sphinx",
- "nym-sphinx-params",
  "nym-task",
  "nym-topology",
  "rand 0.7.3",
@@ -3828,9 +3826,8 @@ dependencies = [
  "curve25519-dalek",
  "fastrand",
  "getrandom 0.2.8",
- "rand 0.7.3",
  "rayon",
- "sphinx-packet",
+ "sphinx-packet 0.1.0 (git+https://github.com/nymtech/sphinx.git)",
  "thiserror",
  "zeroize",
 ]
@@ -4081,7 +4078,6 @@ dependencies = [
  "nym-sphinx-addressing",
  "nym-sphinx-params",
  "nym-sphinx-types",
- "thiserror",
 ]
 
 [[package]]
@@ -4109,9 +4105,7 @@ dependencies = [
 name = "nym-sphinx-types"
 version = "0.2.0"
 dependencies = [
- "nym-outfox",
- "sphinx-packet",
- "thiserror",
+ "sphinx-packet 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -5912,6 +5906,29 @@ dependencies = [
  "subtle 2.4.1",
 ]
 
+[[package]]
+name = "sphinx-packet"
+version = "0.1.0"
+source = "git+https://github.com/nymtech/sphinx.git#ca107d94360cdf8bbfbdb12fe5320ed74f80e40c"
+dependencies = [
+ "aes 0.7.5",
+ "arrayref",
+ "blake2",
+ "bs58",
+ "byteorder",
+ "chacha",
+ "curve25519-dalek",
+ "digest 0.9.0",
+ "hkdf 0.11.0",
+ "hmac 0.11.0",
+ "lioness",
+ "log",
+ "rand 0.7.3",
+ "rand_distr",
+ "sha2 0.9.9",
+ "subtle 2.4.1",
+]
+
 [[package]]
 name = "spin"
 version = "0.5.2"

Makefile

@@ -60,7 +60,7 @@ clippy: clippy-$(1) clippy-examples-$(1)
 check: check-$(1)
 cargo-test: test-$(1)
 cargo-test-expensive: test-expensive-$(1)
-build: build-$(1) build-examples-$(1)
+build: build-$(1) build-$(1)-examples
 build-release-all: build-release-$(1)
 fmt: fmt-$(1)
 

clients/native/src/client/mod.rs

@@ -16,7 +16,6 @@ use nym_client_core::client::received_buffer::{
 };
 use nym_client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
 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;
@@ -120,7 +119,6 @@ impl SocketClient {
             self_address,
             shared_lane_queue_lengths,
             reply_controller_sender,
-            None,
         );
 
         websocket::Listener::new(config.get_listening_ip(), config.get_listening_port())
@@ -180,10 +178,7 @@ impl SocketClient {
         Ok(started_client.task_manager)
     }
 
-    pub async fn start_direct(
-        self,
-        packet_type: Option<PacketType>,
-    ) -> Result<DirectClient, ClientError> {
+    pub async fn start_direct(self) -> Result<DirectClient, ClientError> {
         if self.config.get_socket_type().is_websocket() {
             return Err(ClientError::InvalidSocketMode);
         }
@@ -229,7 +224,6 @@ impl SocketClient {
             reconstructed_receiver,
             address,
             shutdown_notifier: started_client.task_manager,
-            packet_type,
         })
     }
 }
@@ -243,7 +237,6 @@ pub struct DirectClient {
 
     // we need to keep reference to this guy otherwise things will start dropping
     shutdown_notifier: TaskManager,
-    packet_type: Option<PacketType>,
 }
 
 impl DirectClient {
@@ -264,7 +257,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, self.packet_type);
+        let input_msg = InputMessage::new_regular(recipient, message, lane);
 
         self.client_input
             .input_sender
@@ -283,8 +276,7 @@ impl DirectClient {
         reply_surbs: u32,
     ) {
         let lane = TransmissionLane::General;
-        let input_msg =
-            InputMessage::new_anonymous(recipient, message, reply_surbs, lane, self.packet_type);
+        let input_msg = InputMessage::new_anonymous(recipient, message, reply_surbs, lane);
 
         self.client_input
             .input_sender
@@ -298,7 +290,7 @@ 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, self.packet_type);
+        let input_msg = InputMessage::new_reply(recipient_tag, message, lane);
 
         self.client_input
             .input_sender

clients/native/src/websocket/handler.rs

@@ -14,7 +14,6 @@ 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,
@@ -42,7 +41,6 @@ pub(crate) struct HandlerBuilder {
     self_full_address: Recipient,
     lane_queue_lengths: LaneQueueLengths,
     reply_controller_sender: ReplyControllerSender,
-    packet_type: Option<PacketType>,
 }
 
 impl HandlerBuilder {
@@ -53,7 +51,6 @@ impl HandlerBuilder {
         self_full_address: &Recipient,
         lane_queue_lengths: LaneQueueLengths,
         reply_controller_sender: ReplyControllerSender,
-        packet_type: Option<PacketType>,
     ) -> Self {
         Self {
             msg_input,
@@ -62,7 +59,6 @@ impl HandlerBuilder {
             self_full_address: *self_full_address,
             lane_queue_lengths,
             reply_controller_sender,
-            packet_type,
         }
     }
 
@@ -77,7 +73,6 @@ 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,
         }
     }
 }
@@ -91,7 +86,6 @@ pub(crate) struct Handler {
     received_response_type: ReceivedResponseType,
     lane_queue_lengths: LaneQueueLengths,
     reply_controller_sender: ReplyControllerSender,
-    packet_type: Option<PacketType>,
 }
 
 impl Drop for Handler {
@@ -166,7 +160,7 @@ impl Handler {
         });
 
         // the ack control is now responsible for chunking, etc.
-        let input_msg = InputMessage::new_regular(recipient, message, lane, self.packet_type);
+        let input_msg = InputMessage::new_regular(recipient, message, lane);
         self.msg_input
             .send(input_msg)
             .await
@@ -197,8 +191,7 @@ impl Handler {
             TransmissionLane::ConnectionId(id)
         });
 
-        let input_msg =
-            InputMessage::new_anonymous(recipient, message, reply_surbs, lane, self.packet_type);
+        let input_msg = InputMessage::new_anonymous(recipient, message, reply_surbs, lane);
         self.msg_input
             .send(input_msg)
             .await
@@ -225,7 +218,7 @@ impl Handler {
             TransmissionLane::ConnectionId(id)
         });
 
-        let input_msg = InputMessage::new_reply(recipient_tag, message, lane, self.packet_type);
+        let input_msg = InputMessage::new_reply(recipient_tag, message, lane);
         self.msg_input
             .send(input_msg)
             .await

clients/socks5/src/commands/init.rs

@@ -91,7 +91,6 @@ 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,7 +10,6 @@ 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;
@@ -65,7 +64,6 @@ 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>> {
@@ -82,15 +80,9 @@ 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

@@ -67,9 +67,6 @@ 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 {
@@ -82,7 +79,6 @@ 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,
         }
     }
 }

clients/webassembly/src/client/mod.rs

@@ -21,7 +21,6 @@ use nym_client_core::config::{
     CoverTraffic, DebugConfig, GatewayEndpointConfig, 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};
@@ -50,7 +49,6 @@ 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]
@@ -69,7 +67,6 @@ pub struct NymClientBuilder {
     bandwidth_controller:
         Option<BandwidthController<FakeClient<DirectSigningNyxdClient>, EphemeralStorage>>,
     disabled_credentials: bool,
-    packet_type: Option<PacketType>,
 }
 
 #[wasm_bindgen]
@@ -85,7 +82,6 @@ impl NymClientBuilder {
             on_message,
             bandwidth_controller: None,
             disabled_credentials: true,
-            packet_type: None,
         }
     }
 
@@ -136,7 +132,6 @@ impl NymClientBuilder {
             on_message,
             bandwidth_controller: None,
             disabled_credentials: true,
-            packet_type: None,
         }
     }
 
@@ -194,7 +189,6 @@ impl NymClientBuilder {
             client_state: Arc::new(started_client.client_state),
             _full_topology: None,
             _task_manager: started_client.task_manager,
-            packet_type: self.packet_type,
         })
     }
 
@@ -261,7 +255,7 @@ impl NymClient {
         let input_msgs = request
             .test_msgs
             .into_iter()
-            .map(|p| InputMessage::new_regular(recipient, p, lane, None))
+            .map(|p| InputMessage::new_regular(recipient, p, lane))
             .collect();
 
         self.client_input.send_messages(input_msgs)
@@ -281,7 +275,7 @@ impl NymClient {
 
         let lane = TransmissionLane::General;
 
-        let input_msg = InputMessage::new_regular(recipient, message, lane, self.packet_type);
+        let input_msg = InputMessage::new_regular(recipient, message, lane);
         self.client_input.send_message(input_msg)
     }
 
@@ -308,8 +302,7 @@ impl NymClient {
 
         let lane = TransmissionLane::General;
 
-        let input_msg =
-            InputMessage::new_anonymous(recipient, message, reply_surbs, lane, self.packet_type);
+        let input_msg = InputMessage::new_anonymous(recipient, message, reply_surbs, lane);
         self.client_input.send_message(input_msg)
     }
 
@@ -327,7 +320,7 @@ impl NymClient {
 
         let lane = TransmissionLane::General;
 
-        let input_msg = InputMessage::new_reply(sender_tag, message, lane, self.packet_type);
+        let input_msg = InputMessage::new_reply(sender_tag, message, lane);
         self.client_input.send_message(input_msg)
     }
 }

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

@@ -409,7 +409,7 @@ where
         Ok(())
     }
 
-    // controller for sending packets to mixnet (either real traffic or cover traffic)
+    // controller for sending sphinx 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?
@@ -524,11 +524,11 @@ where
             task_manager.subscribe(),
         );
 
-        // The message_sender is the transmitter for any component generating sphinx packets
+        // The sphinx_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 message_sender =
+        let sphinx_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
@@ -550,7 +550,7 @@ where
             shared_topology_accessor.clone(),
             ack_receiver,
             input_receiver,
-            message_sender.clone(),
+            sphinx_message_sender.clone(),
             reply_storage,
             reply_controller_sender.clone(),
             reply_controller_receiver,
@@ -569,7 +569,7 @@ where
                 self.key_manager.ack_key(),
                 self_address,
                 shared_topology_accessor.clone(),
-                message_sender,
+                sphinx_message_sender,
                 task_manager.subscribe(),
             );
         }

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 nym packets to `MixTrafficController` that sends them
+    /// Channel used for sending prepared sphinx packets to `MixTrafficController` that sends them
     /// out to the network without any further delays.
     mix_tx: BatchMixMessageSender,
 

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

@@ -4,7 +4,6 @@
 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>;
@@ -54,49 +53,18 @@ 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,
-        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_premade(msgs: Vec<MixPacket>, lane: TransmissionLane) -> Self {
+        InputMessage::Premade { msgs, lane }
     }
 
-    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 {
+    pub fn new_regular(recipient: Recipient, data: Vec<u8>, lane: TransmissionLane) -> Self {
+        InputMessage::Regular {
             recipient,
             data,
             lane,
-        };
-        if let Some(packet_type) = packet_type {
-            InputMessage::new_wrapper(message, packet_type)
-        } else {
-            message
         }
     }
 
@@ -105,18 +73,12 @@ impl InputMessage {
         data: Vec<u8>,
         reply_surbs: u32,
         lane: TransmissionLane,
-        packet_type: Option<PacketType>,
     ) -> Self {
-        let message = InputMessage::Anonymous {
+        InputMessage::Anonymous {
             recipient,
             data,
             reply_surbs,
             lane,
-        };
-        if let Some(packet_type) = packet_type {
-            InputMessage::new_wrapper(message, packet_type)
-        } else {
-            message
         }
     }
 
@@ -124,17 +86,11 @@ impl InputMessage {
         recipient_tag: AnonymousSenderTag,
         data: Vec<u8>,
         lane: TransmissionLane,
-        packet_type: Option<PacketType>,
     ) -> Self {
-        let message = InputMessage::Reply {
+        InputMessage::Reply {
             recipient_tag,
             data,
             lane,
-        };
-        if let Some(packet_type) = packet_type {
-            InputMessage::new_wrapper(message, packet_type)
-        } else {
-            message
         }
     }
 
@@ -144,7 +100,6 @@ 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

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

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

@@ -9,7 +9,6 @@ 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};
 
@@ -72,11 +71,10 @@ 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, packet_type)
+            .try_send_plain_message(recipient, content, lane)
             .await
         {
             warn!("failed to send a plain message - {err}")
@@ -89,11 +87,10 @@ 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, packet_type)
+            .try_send_message_with_reply_surbs(recipient, content, reply_surbs, lane)
             .await
         {
             warn!("failed to send a repliable message - {err}")
@@ -106,17 +103,14 @@ where
                 recipient,
                 data,
                 lane,
-            } => {
-                self.handle_plain_message(recipient, data, lane, PacketType::Mix)
-                    .await
-            }
+            } => self.handle_plain_message(recipient, data, lane).await,
             InputMessage::Anonymous {
                 recipient,
                 data,
                 reply_surbs,
                 lane,
             } => {
-                self.handle_repliable_message(recipient, data, reply_surbs, lane, PacketType::Mix)
+                self.handle_repliable_message(recipient, data, reply_surbs, lane)
                     .await
             }
             InputMessage::Reply {
@@ -127,40 +121,6 @@ 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/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};
@@ -51,10 +51,8 @@ where
     ) -> 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, PacketType::Mix)
+            .try_prepare_single_chunk_for_sending(packet_recipient, chunk_data)
             .await
     }
 

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, PacketType, DEFAULT_NUM_MIX_HOPS};
+use nym_sphinx::params::{PacketSize, DEFAULT_NUM_MIX_HOPS};
 use nym_sphinx::preparer::{MessagePreparer, PreparedFragment};
 use nym_sphinx::Delay;
 use nym_task::connections::TransmissionLane;
@@ -417,10 +417,9 @@ 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, packet_type)
+        self.try_split_and_send_non_reply_message(message, recipient, lane)
             .await
     }
 
@@ -429,7 +428,6 @@ where
         message: NymMessage,
         recipient: Recipient,
         lane: TransmissionLane,
-        packet_type: PacketType,
     ) -> Result<(), PreparationError> {
         // TODO: I really dislike existence of this assertion, it implies code has to be re-organised
         debug_assert!(!matches!(message, NymMessage::Reply(_)));
@@ -455,7 +453,6 @@ where
                 topology,
                 &self.config.ack_key,
                 &recipient,
-                &packet_type,
             )?;
 
             let real_message = RealMessage::new(
@@ -479,7 +476,6 @@ where
         &mut self,
         recipient: Recipient,
         amount: u32,
-        packet_type: PacketType,
     ) -> Result<(), PreparationError> {
         let sender_tag = self.get_or_create_sender_tag(&recipient);
         let (reply_surbs, reply_keys) =
@@ -494,7 +490,6 @@ where
             message,
             recipient,
             TransmissionLane::AdditionalReplySurbs,
-            packet_type,
         )
         .await?;
 
@@ -510,7 +505,6 @@ where
         message: Vec<u8>,
         num_reply_surbs: u32,
         lane: TransmissionLane,
-        packet_type: PacketType,
     ) -> Result<(), SurbWrappedPreparationError> {
         let sender_tag = self.get_or_create_sender_tag(&recipient);
         let (reply_surbs, reply_keys) = self
@@ -520,7 +514,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, packet_type)
+        self.try_split_and_send_non_reply_message(message, recipient, lane)
             .await?;
 
         log::trace!("storing {} reply keys", reply_keys.len());
@@ -533,20 +527,13 @@ where
         &mut self,
         recipient: Recipient,
         chunk: Fragment,
-        packet_type: PacketType,
     ) -> Result<PreparedFragment, PreparationError> {
         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,
-                &packet_type,
-            )
+            .prepare_chunk_for_sending(chunk, topology, &self.config.ack_key, &recipient)
             .unwrap();
 
         Ok(prepared_fragment)
@@ -582,7 +569,6 @@ where
                         topology,
                         &self.config.ack_key,
                         reply_surb,
-                        PacketType::Mix,
                     )
                     .unwrap()
             })
@@ -602,13 +588,7 @@ where
 
         let prepared_fragment = self
             .message_preparer
-            .prepare_reply_chunk_for_sending(
-                chunk,
-                topology,
-                &self.config.ack_key,
-                reply_surb,
-                PacketType::Mix,
-            )
+            .prepare_reply_chunk_for_sending(chunk, topology, &self.config.ack_key, reply_surb)
             .unwrap();
 
         Ok(prepared_fragment)

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 packets to `MixTrafficController` that sends them
+    /// Channel used for sending prepared sphinx 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.packet().len()
+        self.mix_packet.sphinx_packet().len()
     }
 
     pub(crate) fn new(mix_packet: MixPacket, fragment_id: Option<FragmentIdentifier>) -> Self {
@@ -386,7 +386,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 packets from multiple
+            // send, which is a condition for being able to multiplex sphinx 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,11 +512,7 @@ where
             let to_send = min(remaining, 100);
             if let Err(err) = self
                 .message_handler
-                .try_send_additional_reply_surbs(
-                    recipient,
-                    to_send,
-                    nym_sphinx::params::PacketType::Mix,
-                )
+                .try_send_additional_reply_surbs(recipient, to_send)
                 .await
             {
                 warn!("failed to send additional surbs to {recipient} - {err}");

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 packet payload
+        // note that raw `Fragment` is smaller than sphinx packet payload
         // as it doesn't include surb-ack or the [shared] key materials
         self.payload_size()
     }

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

@@ -3,7 +3,7 @@
 
 use nym_config::defaults::NymNetworkDetails;
 use nym_config::{NymConfig, OptionalSet, CRED_DB_FILE_NAME};
-use nym_sphinx::params::{PacketSize, PacketType};
+use nym_sphinx::params::PacketSize;
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
 use std::path::PathBuf;
@@ -217,11 +217,6 @@ 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
@@ -409,10 +404,6 @@ 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> {
@@ -527,8 +518,6 @@ pub struct Client<T> {
 
     #[serde(skip)]
     pub super_struct: PhantomData<T>,
-
-    pub packet_type: Option<PacketType>,
 }
 
 impl<T: NymConfig> Default for Client<T> {
@@ -567,7 +556,6 @@ 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(),
         }
     }
 }

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

@@ -210,8 +210,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-libs/gateway-client/src/client.rs

@@ -605,7 +605,7 @@ where
     fn estimate_required_bandwidth(&self, packets: &[MixPacket]) -> i64 {
         packets
             .iter()
-            .map(|packet| packet.packet().len())
+            .map(|packet| packet.sphinx_packet().len())
             .sum::<usize>() as i64
     }
 
@@ -686,9 +686,9 @@ where
         if !self.authenticated {
             return Err(GatewayClientError::NotAuthenticated);
         }
-        if (mix_packet.packet().len() as i64) > self.bandwidth_remaining {
+        if (mix_packet.sphinx_packet().len() as i64) > self.bandwidth_remaining {
             return Err(GatewayClientError::NotEnoughBandwidth(
-                mix_packet.packet().len() as i64,
+                mix_packet.sphinx_packet().len() as i64,
                 self.bandwidth_remaining,
             ));
         }

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

@@ -4,11 +4,10 @@
 use futures::channel::mpsc;
 use futures::StreamExt;
 use log::*;
-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 nym_sphinx::framing::codec::SphinxCodec;
+use nym_sphinx::framing::packet::FramedSphinxPacket;
+use nym_sphinx::params::PacketMode;
+use nym_sphinx::{addressing::nodes::NymNodeRoutingAddress, SphinxPacket};
 use std::collections::HashMap;
 use std::io;
 use std::net::SocketAddr;
@@ -51,8 +50,8 @@ pub trait SendWithoutResponse {
     fn send_without_response(
         &mut self,
         address: NymNodeRoutingAddress,
-        packet: NymPacket,
-        packet_type: PacketType,
+        packet: SphinxPacket,
+        packet_mode: PacketMode,
     ) -> io::Result<()>;
 }
 
@@ -62,12 +61,12 @@ pub struct Client {
 }
 
 struct ConnectionSender {
-    channel: mpsc::Sender<FramedNymPacket>,
+    channel: mpsc::Sender<FramedSphinxPacket>,
     current_reconnection_attempt: Arc<AtomicU32>,
 }
 
 impl ConnectionSender {
-    fn new(channel: mpsc::Sender<FramedNymPacket>) -> Self {
+    fn new(channel: mpsc::Sender<FramedSphinxPacket>) -> Self {
         ConnectionSender {
             channel,
             current_reconnection_attempt: Arc::new(AtomicU32::new(0)),
@@ -85,7 +84,7 @@ impl Client {
 
     async fn manage_connection(
         address: SocketAddr,
-        receiver: mpsc::Receiver<FramedNymPacket>,
+        receiver: mpsc::Receiver<FramedSphinxPacket>,
         connection_timeout: Duration,
         current_reconnection: &AtomicU32,
     ) {
@@ -97,7 +96,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, NymCodec)
+                    Framed::new(stream, SphinxCodec)
                 }
                 Err(err) => {
                     debug!(
@@ -149,7 +148,11 @@ impl Client {
         }
     }
 
-    fn make_connection(&mut self, address: NymNodeRoutingAddress, pending_packet: FramedNymPacket) {
+    fn make_connection(
+        &mut self,
+        address: NymNodeRoutingAddress,
+        pending_packet: FramedSphinxPacket,
+    ) {
         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
@@ -197,12 +200,12 @@ impl SendWithoutResponse for Client {
     fn send_without_response(
         &mut self,
         address: NymNodeRoutingAddress,
-        packet: NymPacket,
-        packet_type: PacketType,
+        packet: SphinxPacket,
+        packet_mode: PacketMode,
     ) -> io::Result<()> {
         trace!("Sending packet to {:?}", address);
         let framed_packet =
-            FramedNymPacket::new(packet, packet_type, self.config.use_legacy_version);
+            FramedSphinxPacket::new(packet, packet_mode, 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_type = mix_packet.packet_type();
-                    let packet = mix_packet.into_packet();
+                    let packet_mode = mix_packet.packet_mode();
+                    let sphinx_packet = mix_packet.into_sphinx_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, packet, packet_type)
+                            .send_without_response(next_hop, sphinx_packet, packet_mode)
                     {
                         debug!("failed to forward the packet - {err}")
                     }

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

@@ -3,15 +3,12 @@
 
 use nym_sphinx_acknowledgements::surb_ack::SurbAckRecoveryError;
 use nym_sphinx_addressing::nodes::NymNodeRoutingAddressError;
-use nym_sphinx_types::{NymPacketError, SphinxError};
+use nym_sphinx_types::Error as 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::FramedNymPacket;
-use nym_sphinx_params::{PacketSize, PacketType};
+use nym_sphinx_framing::packet::FramedSphinxPacket;
+use nym_sphinx_params::{PacketMode, PacketSize};
 use nym_sphinx_types::{
-    Delay as SphinxDelay, DestinationAddressBytes, NodeAddressBytes, NymPacket, Payload,
-    PrivateKey, ProcessedPacket,
+    Delay as SphinxDelay, DestinationAddressBytes, NodeAddressBytes, Payload, PrivateKey,
+    ProcessedPacket, SphinxPacket,
 };
 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_packet_processing(
+    fn perform_initial_sphinx_packet_processing(
         &self,
-        packet: NymPacket,
+        packet: SphinxPacket,
     ) -> Result<ProcessedPacket, MixProcessingError> {
         measure!({
             packet.process(&self.sphinx_key).map_err(|err| {
                 debug!("Failed to unwrap Sphinx packet: {err}");
-                MixProcessingError::NymPacketProcessingError(err)
+                MixProcessingError::SphinxProcessingError(err)
             })
         })
     }
@@ -72,12 +72,17 @@ impl SphinxPacketProcessor {
     )]
     fn perform_initial_unwrapping(
         &self,
-        received: FramedNymPacket,
+        received: FramedSphinxPacket,
     ) -> Result<ProcessedPacket, MixProcessingError> {
         measure!({
-            let packet = received.into_inner();
+            let packet_mode = received.packet_mode();
+            let sphinx_packet = received.into_inner();
 
-            self.perform_initial_packet_processing(packet)
+            if packet_mode.is_old_vpn() {
+                return Err(MixProcessingError::ReceivedOldTypeVpnPacket);
+            }
+
+            self.perform_initial_sphinx_packet_processing(sphinx_packet)
         })
     }
 
@@ -85,14 +90,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: NymPacket,
+        packet: SphinxPacket,
         forward_address: NodeAddressBytes,
         delay: SphinxDelay,
-        packet_type: PacketType,
+        packet_mode: PacketMode,
     ) -> Result<MixProcessingResult, MixProcessingError> {
         let next_hop_address = NymNodeRoutingAddress::try_from(forward_address)?;
 
-        let mix_packet = MixPacket::new(next_hop_address, packet, packet_type);
+        let mix_packet = MixPacket::new(next_hop_address, packet, packet_mode);
         Ok(MixProcessingResult::ForwardHop(mix_packet, Some(delay)))
     }
 
@@ -119,25 +124,21 @@ impl SphinxPacketProcessor {
         &self,
         data: Vec<u8>,
         packet_size: PacketSize,
-        packet_type: PacketType,
+        packet_mode: PacketMode,
     ) -> Result<(Option<MixPacket>, Vec<u8>), MixProcessingError> {
         match packet_size {
-            PacketSize::AckPacket | PacketSize::OutfoxAckPacket => {
+            PacketSize::AckPacket => {
                 trace!("received an ack packet!");
                 Ok((None, data))
             }
             PacketSize::RegularPacket
             | PacketSize::ExtendedPacket8
             | PacketSize::ExtendedPacket16
-            | PacketSize::ExtendedPacket32
-            | PacketSize::OutfoxRegularPacket
-            | PacketSize::OutfoxExtendedPacket8
-            | PacketSize::OutfoxExtendedPacket16
-            | PacketSize::OutfoxExtendedPacket32 => {
+            | PacketSize::ExtendedPacket32 => {
                 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_type);
+                let forward_ack = MixPacket::new(ack_first_hop, ack_packet, packet_mode);
                 Ok((Some(forward_ack), message))
             }
         }
@@ -151,12 +152,12 @@ impl SphinxPacketProcessor {
         destination: DestinationAddressBytes,
         payload: Payload,
         packet_size: PacketSize,
-        packet_type: PacketType,
+        packet_mode: PacketMode,
     ) -> Result<MixProcessingResult, MixProcessingError> {
         let packet_message = payload.recover_plaintext()?;
 
         let (forward_ack, message) =
-            self.split_into_ack_and_message(packet_message, packet_size, packet_type)?;
+            self.split_into_ack_and_message(packet_message, packet_size, packet_mode)?;
 
         Ok(MixProcessingResult::FinalHop(ProcessedFinalHop {
             destination,
@@ -171,16 +172,16 @@ impl SphinxPacketProcessor {
         &self,
         packet: ProcessedPacket,
         packet_size: PacketSize,
-        packet_type: PacketType,
+        packet_mode: PacketMode,
     ) -> Result<MixProcessingResult, MixProcessingError> {
         match packet {
             ProcessedPacket::ForwardHop(packet, address, delay) => {
-                self.process_forward_hop(NymPacket::Sphinx(*packet), address, delay, packet_type)
+                self.process_forward_hop(*packet, address, delay, packet_mode)
             }
             // 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_type)
+                self.process_final_hop(destination, payload, packet_size, packet_mode)
             }
         }
     }
@@ -191,19 +192,19 @@ impl SphinxPacketProcessor {
     )]
     pub fn process_received(
         &self,
-        received: FramedNymPacket,
+        received: FramedSphinxPacket,
     ) -> Result<MixProcessingResult, MixProcessingError> {
         // explicit packet size will help to correctly parse final hop
         measure!({
             let packet_size = received.packet_size();
-            let packet_type = received.packet_type();
+            let packet_mode = received.packet_mode();
 
             // 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_type)
+            self.perform_final_processing(processed_packet, packet_size, packet_mode)
         })
     }
 }

common/node-tester-utils/Cargo.toml

@@ -17,7 +17,6 @@ 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,7 +10,6 @@ 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;
@@ -171,14 +170,7 @@ 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,
-            &PacketType::Mix,
-        )?)
+        Ok(self.prepare_chunk_for_sending(fragment, topology, &ack_key, &address, &address)?)
     }
 }
 

common/nymsphinx/acknowledgements/src/surb_ack.rs

@@ -10,8 +10,11 @@ use nym_sphinx_addressing::nodes::{
 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::delays::{self, Delay};
-use nym_sphinx_types::{NymPacket, NymPacketError};
+use nym_sphinx_types::Error as SphinxError;
+use nym_sphinx_types::{
+    delays::{self, Delay},
+    SphinxPacket,
+};
 use nym_topology::{NymTopology, NymTopologyError};
 use rand::{CryptoRng, RngCore};
 use std::convert::TryFrom;
@@ -19,7 +22,7 @@ use std::time;
 use thiserror::Error;
 
 pub struct SurbAck {
-    surb_ack_packet: NymPacket,
+    surb_ack_packet: SphinxPacket,
     first_hop_address: NymNodeRoutingAddress,
     expected_total_delay: Delay,
 }
@@ -32,8 +35,8 @@ pub enum SurbAckRecoveryError {
     #[error("could not extract first hop address information - {0}")]
     InvalidAddress(#[from] NymNodeRoutingAddressError),
 
-    #[error("packet: {0}")]
-    NymPacket(#[from] NymPacketError),
+    #[error("the contained sphinx packet was not correctly formed - {0}")]
+    InvalidSphinxPacket(#[from] SphinxError),
 }
 
 impl SurbAck {
@@ -55,12 +58,10 @@ impl SurbAck {
 
         let surb_ack_payload = prepare_identifier(rng, ack_key, marshaled_fragment_id);
 
-        let surb_ack_packet = NymPacket::Sphinx(
-            SphinxPacketBuilder::new()
-                .with_payload_size(PacketSize::AckPacket.payload_size())
-                .build_packet(surb_ack_payload, &route, &destination, &delays)
-                .unwrap(),
-        );
+        let surb_ack_packet = SphinxPacketBuilder::new()
+            .with_payload_size(PacketSize::AckPacket.payload_size())
+            .build_packet(surb_ack_payload, &route, &destination, &delays)
+            .unwrap();
 
         // 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();
@@ -84,21 +85,21 @@ impl SurbAck {
         self.expected_total_delay
     }
 
-    pub fn prepare_for_sending(self) -> Result<(Delay, Vec<u8>), SurbAckRecoveryError> {
+    pub fn prepare_for_sending(self) -> (Delay, Vec<u8>) {
         // 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();
-        Ok((self.expected_total_delay, surb_bytes))
+        (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, NymPacket), SurbAckRecoveryError> {
+    ) -> Result<(NymNodeRoutingAddress, SphinxPacket), SurbAckRecoveryError> {
         if b.len() != Self::len() {
             Err(SurbAckRecoveryError::InvalidPacketSize {
                 received: b.len(),
@@ -110,7 +111,7 @@ impl SurbAck {
             // 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 = NymPacket::sphinx_from_bytes(&b[address_offset..])?;
+            let packet = SphinxPacket::from_bytes(&b[address_offset..])?;
 
             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::{PacketType, ReplySurbKeyDigestAlgorithm, DEFAULT_NUM_MIX_HOPS};
-use nym_sphinx_types::{delays, NymPacket, SURBMaterial, SphinxError, SURB};
+use nym_sphinx_params::{ReplySurbKeyDigestAlgorithm, DEFAULT_NUM_MIX_HOPS};
+use nym_sphinx_types::{delays, Error as SphinxError, SURBMaterial, SphinxPacket, SURB};
 use nym_topology::{NymTopology, NymTopologyError};
 use rand::{CryptoRng, RngCore};
 use serde::de::{Error as SerdeError, Visitor};
@@ -173,8 +173,7 @@ impl ReplySurb {
         self,
         message: M,
         packet_size: PacketSize,
-        _packet_type: PacketType,
-    ) -> Result<(NymPacket, NymNodeRoutingAddress), ReplySurbError> {
+    ) -> Result<(SphinxPacket, NymNodeRoutingAddress), ReplySurbError> {
         let message_bytes = message.as_ref();
         if message_bytes.len() != packet_size.plaintext_size() {
             return Err(ReplySurbError::UnpaddedMessageError);
@@ -188,6 +187,6 @@ impl ReplySurb {
 
         let first_hop_address = NymNodeRoutingAddress::try_from(first_hop).unwrap();
 
-        Ok((NymPacket::Sphinx(packet), first_hop_address))
+        Ok((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, SurbAckRecoveryError};
+use nym_sphinx_acknowledgements::surb_ack::SurbAck;
 use nym_sphinx_acknowledgements::AckKey;
 use nym_sphinx_addressing::clients::Recipient;
 use nym_sphinx_addressing::nodes::NymNodeRoutingAddress;
@@ -11,10 +11,10 @@ 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, PacketType, DEFAULT_NUM_MIX_HOPS,
+    PacketEncryptionAlgorithm, PacketHkdfAlgorithm, PacketMode, DEFAULT_NUM_MIX_HOPS,
 };
 use nym_sphinx_types::builder::SphinxPacketBuilder;
-use nym_sphinx_types::{delays, NymPacket};
+use nym_sphinx_types::{delays, Error as SphinxError};
 use nym_topology::{NymTopology, NymTopologyError};
 use rand::{CryptoRng, RngCore};
 use std::convert::TryFrom;
@@ -28,8 +28,8 @@ pub enum CoverMessageError {
     #[error("Could not construct cover message due to invalid topology - {0}")]
     InvalidTopologyError(#[from] NymTopologyError),
 
-    #[error("SurbAck: {0}")]
-    SurbAck(#[from] SurbAckRecoveryError),
+    #[error("Could not construct a valid sphinx packet - {0}")]
+    SphinxError(#[from] SphinxError),
 }
 
 pub fn generate_loop_cover_surb_ack<R>(
@@ -67,7 +67,7 @@ where
     // 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()?;
+            .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,17 +111,15 @@ where
     let destination = full_address.as_sphinx_destination();
 
     // once merged, that's an easy rng injection point for sphinx packets : )
-    let packet = NymPacket::Sphinx(
-        SphinxPacketBuilder::new()
-            .with_payload_size(packet_size.payload_size())
-            .build_packet(packet_payload, &route, &destination, &delays)
-            .unwrap(),
-    );
+    let packet = SphinxPacketBuilder::new()
+        .with_payload_size(packet_size.payload_size())
+        .build_packet(packet_payload, &route, &destination, &delays)
+        .unwrap();
 
     let first_hop_address =
         NymNodeRoutingAddress::try_from(route.first().unwrap().address).unwrap();
 
-    Ok(MixPacket::new(first_hop_address, packet, PacketType::Mix))
+    Ok(MixPacket::new(first_hop_address, packet, PacketMode::Mix))
 }
 
 /// Helper function used to determine if given message represents a loop cover message.

common/nymsphinx/forwarding/Cargo.toml

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

common/nymsphinx/framing/src/codec.rs

@@ -1,55 +1,65 @@
 // Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::packet::{FramedNymPacket, Header};
+use crate::packet::{FramedSphinxPacket, Header};
 use bytes::{Buf, BufMut, BytesMut};
+use nym_sphinx_params::packet_modes::InvalidPacketMode;
 use nym_sphinx_params::packet_sizes::{InvalidPacketSize, PacketSize};
-use nym_sphinx_params::packet_types::InvalidPacketType;
-use nym_sphinx_params::PacketType;
-use nym_sphinx_types::{NymPacket, NymPacketError};
+use nym_sphinx_types::Error as SphinxError;
+use nym_sphinx_types::SphinxPacket;
 use std::io;
 use thiserror::Error;
 use tokio_util::codec::{Decoder, Encoder};
 
 #[derive(Error, Debug)]
-pub enum NymCodecError {
+pub enum SphinxCodecError {
     #[error("the packet size information was malformed - {0}")]
     InvalidPacketSize(#[from] InvalidPacketSize),
 
     #[error("the packet mode information was malformed - {0}")]
-    InvalidPacketType(#[from] InvalidPacketType),
+    InvalidPacketMode(#[from] InvalidPacketMode),
+
+    #[error("the actual sphinx packet was malformed - {0}")]
+    MalformedSphinxPacket(#[from] SphinxError),
 
     #[error("encountered an IO error - {0}")]
     IoError(#[from] io::Error),
+}
 
-    #[error("encountered a packet error - {0}")]
-    NymPacket(#[from] NymPacketError),
-
-    #[error("could not convert to bytes")]
-    ToBytes,
-
-    #[error("could not convert to bytes")]
-    FromBytes,
+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,
+        }
+    }
 }
 
 // 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 NymCodec;
+pub struct SphinxCodec;
 
-impl Encoder<FramedNymPacket> for NymCodec {
-    type Error = NymCodecError;
+impl Encoder<FramedSphinxPacket> for SphinxCodec {
+    type Error = SphinxCodecError;
 
-    fn encode(&mut self, item: FramedNymPacket, dst: &mut BytesMut) -> Result<(), Self::Error> {
+    fn encode(&mut self, item: FramedSphinxPacket, dst: &mut BytesMut) -> Result<(), Self::Error> {
         item.header.encode(dst);
-        let packet_bytes = item.packet.to_bytes()?;
-        dst.put(packet_bytes.as_slice());
+        dst.put(item.packet.to_bytes().as_ref());
         Ok(())
     }
 }
 
-impl Decoder for NymCodec {
-    type Item = FramedNymPacket;
-    type Error = NymCodecError;
+impl Decoder for SphinxCodec {
+    type Item = FramedSphinxPacket;
+    type Error = SphinxCodecError;
 
     fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
         if src.is_empty() {
@@ -66,32 +76,23 @@ impl Decoder for NymCodec {
             None => return Ok(None), // we have some data but not enough to get header back
         };
 
-        let packet_size = header.packet_size.size();
-        let frame_len = header.size() + packet_size;
+        let sphinx_packet_size = header.packet_size.size();
+        let frame_len = header.size() + sphinx_packet_size;
 
         if src.len() < frame_len {
             // we don't have enough bytes to read the rest of frame
-            src.reserve(packet_size);
+            src.reserve(sphinx_packet_size);
             return Ok(None);
         }
 
         // advance buffer past the header - at this point we have enough bytes
         src.advance(header.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);
-        };
+        let sphinx_packet_bytes = src.split_to(sphinx_packet_size);
 
-        // let packet = SphinxPacket::from_bytes(&sphinx_packet_bytes)?;
-        let nymsphinx_packet = FramedNymPacket { header, packet };
+        // 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 };
 
         // As per docs:
         // Before returning from the function, implementations should ensure that the buffer
@@ -119,6 +120,7 @@ impl Decoder for NymCodec {
             };
         }
         src.reserve(allocate_for_next_packet);
+
         Ok(Some(nymsphinx_packet))
     }
 }
@@ -126,42 +128,13 @@ impl Decoder for NymCodec {
 #[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_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 route = &[node1, node2, node3, node4];
-
-        let payload = vec![1; 48];
-
-        NymPacket::outfox_build(payload, route, Some(size.plaintext_size())).unwrap()
-    }
-
-    fn make_valid_sphinx_packet(size: PacketSize) -> NymPacket {
+    fn make_valid_sphinx_packet(size: PacketSize) -> SphinxPacket {
         let (_, node1_pk) = crypto::keygen();
         let node1 = Node::new(
             NodeAddressBytes::from_bytes([5u8; NODE_ADDRESS_LENGTH]),
@@ -188,7 +161,9 @@ mod packet_encoding {
             SphinxDelay::new_from_nanos(42),
             SphinxDelay::new_from_nanos(42),
         ];
-        NymPacket::sphinx_build(size.payload_size(), b"foomp", &route, &destination, &delays)
+        SphinxPacketBuilder::new()
+            .with_payload_size(size.payload_size())
+            .build_packet(b"foomp", &route, &destination, &delays)
             .unwrap()
     }
 
@@ -196,50 +171,32 @@ 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().unwrap();
+        let sphinx_bytes = sphinx_packet.to_bytes();
 
-        let packet = FramedNymPacket {
+        let packet = FramedSphinxPacket {
             header,
             packet: sphinx_packet,
         };
 
         let mut bytes = BytesMut::new();
-        NymCodec.encode(packet, &mut bytes).unwrap();
-        let decoded = NymCodec.decode(&mut bytes).unwrap().unwrap();
+        SphinxCodec.encode(packet, &mut bytes).unwrap();
+        let decoded = SphinxCodec.decode(&mut bytes).unwrap().unwrap();
 
         assert_eq!(decoded.header, header);
-        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)
+        assert_eq!(decoded.packet.to_bytes(), sphinx_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::PacketType;
+        use nym_sphinx_params::PacketMode;
 
         #[test]
         fn for_empty_bytes() {
             // empty bytes should allocate for header + ack packet
             let mut empty_bytes = BytesMut::new();
-            assert!(NymCodec.decode(&mut empty_bytes).unwrap().is_none());
+            assert!(SphinxCodec.decode(&mut empty_bytes).unwrap().is_none());
             assert_eq!(
                 empty_bytes.capacity(),
                 Header::LEGACY_SIZE + PacketSize::AckPacket.size()
@@ -260,11 +217,11 @@ mod packet_encoding {
                 let header = Header {
                     packet_version: PacketVersion::Legacy,
                     packet_size,
-                    ..Default::default()
+                    packet_mode: Default::default(),
                 };
                 let mut bytes = BytesMut::new();
                 header.encode(&mut bytes);
-                assert!(NymCodec.decode(&mut bytes).unwrap().is_none());
+                assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());
 
                 assert_eq!(bytes.capacity(), Header::LEGACY_SIZE + packet_size.size())
             }
@@ -284,11 +241,11 @@ mod packet_encoding {
                 let header = Header {
                     packet_version: PacketVersion::Versioned(123),
                     packet_size,
-                    ..Default::default()
+                    packet_mode: Default::default(),
                 };
                 let mut bytes = BytesMut::new();
                 header.encode(&mut bytes);
-                assert!(NymCodec.decode(&mut bytes).unwrap().is_none());
+                assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());
 
                 assert_eq!(
                     bytes.capacity(),
@@ -300,17 +257,18 @@ 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 = FramedNymPacket {
+            let packet = FramedSphinxPacket {
                 header: Header {
                     packet_version: PacketVersion::Legacy,
-                    ..Default::default()
+                    packet_size: Default::default(),
+                    packet_mode: Default::default(),
                 },
                 packet: make_valid_sphinx_packet(Default::default()),
             };
 
             let mut bytes = BytesMut::new();
-            NymCodec.encode(packet, &mut bytes).unwrap();
-            assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
+            SphinxCodec.encode(packet, &mut bytes).unwrap();
+            assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
             assert_eq!(
                 bytes.capacity(),
                 Header::LEGACY_SIZE + PacketSize::AckPacket.size()
@@ -320,14 +278,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 = FramedNymPacket {
+            let packet = FramedSphinxPacket {
                 header: Header::default(),
                 packet: make_valid_sphinx_packet(Default::default()),
             };
 
             let mut bytes = BytesMut::new();
-            NymCodec.encode(packet, &mut bytes).unwrap();
-            assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
+            SphinxCodec.encode(packet, &mut bytes).unwrap();
+            assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
             assert_eq!(
                 bytes.capacity(),
                 Header::VERSIONED_SIZE + PacketSize::AckPacket.size()
@@ -346,19 +304,20 @@ mod packet_encoding {
             ];
 
             for packet_size in packet_sizes {
-                let first_packet = FramedNymPacket {
+                let first_packet = FramedSphinxPacket {
                     header: Header {
                         packet_version: PacketVersion::Legacy,
-                        ..Default::default()
+                        packet_size: Default::default(),
+                        packet_mode: Default::default(),
                     },
                     packet: make_valid_sphinx_packet(Default::default()),
                 };
 
                 let mut bytes = BytesMut::new();
-                NymCodec.encode(first_packet, &mut bytes).unwrap();
+                SphinxCodec.encode(first_packet, &mut bytes).unwrap();
                 bytes.put_u8(packet_size as u8);
-                bytes.put_u8(PacketType::default() as u8);
-                assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
+                bytes.put_u8(PacketMode::default() as u8);
+                assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
 
                 assert!(bytes.capacity() >= Header::LEGACY_SIZE + packet_size.size())
             }
@@ -376,53 +335,53 @@ mod packet_encoding {
             ];
 
             for packet_size in packet_sizes {
-                let first_packet = FramedNymPacket {
+                let first_packet = FramedSphinxPacket {
                     header: Header::default(),
                     packet: make_valid_sphinx_packet(Default::default()),
                 };
 
                 let mut bytes = BytesMut::new();
-                NymCodec.encode(first_packet, &mut bytes).unwrap();
+                SphinxCodec.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(PacketType::default() as u8);
-                assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
+                bytes.put_u8(PacketMode::default() as u8);
+                assert!(SphinxCodec.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 = FramedNymPacket {
+        let packet1 = FramedSphinxPacket {
             header: Header::default(),
             packet: make_valid_sphinx_packet(Default::default()),
         };
 
-        let packet2 = FramedNymPacket {
+        let packet2 = FramedSphinxPacket {
             header: Header::default(),
             packet: make_valid_sphinx_packet(Default::default()),
         };
 
         let mut bytes = BytesMut::new();
 
-        NymCodec.encode(packet1, &mut bytes).unwrap();
-        NymCodec.encode(packet2, &mut bytes).unwrap();
+        SphinxCodec.encode(packet1, &mut bytes).unwrap();
+        SphinxCodec.encode(packet2, &mut bytes).unwrap();
 
-        assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
-        assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
-        assert!(NymCodec.decode(&mut bytes).unwrap().is_none());
+        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
+        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
+        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());
     }
 
     #[test]
     fn can_decode_two_packets_in_separate_calls() {
-        let packet1 = FramedNymPacket {
+        let packet1 = FramedSphinxPacket {
             header: Header::default(),
             packet: make_valid_sphinx_packet(Default::default()),
         };
 
-        let packet2 = FramedNymPacket {
+        let packet2 = FramedSphinxPacket {
             header: Header::default(),
             packet: make_valid_sphinx_packet(Default::default()),
         };
@@ -430,17 +389,18 @@ mod packet_encoding {
         let mut bytes = BytesMut::new();
         let mut bytes_tmp = BytesMut::new();
 
-        NymCodec.encode(packet1, &mut bytes).unwrap();
-        NymCodec.encode(packet2, &mut bytes_tmp).unwrap();
+        SphinxCodec.encode(packet1, &mut bytes).unwrap();
+        SphinxCodec.encode(packet2, &mut bytes_tmp).unwrap();
 
         let tmp = bytes_tmp.split_off(100);
         bytes.put(bytes_tmp);
 
-        assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
-        assert!(NymCodec.decode(&mut bytes).unwrap().is_none());
+        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
+        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());
 
         bytes.put(tmp);
-        assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
-        assert!(NymCodec.decode(&mut bytes).unwrap().is_none());
+
+        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
+        assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());
     }
 }

common/nymsphinx/framing/src/packet.rs

@@ -1,52 +1,47 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::codec::NymCodecError;
+use crate::codec::SphinxCodecError;
 use bytes::{BufMut, BytesMut};
 use nym_sphinx_params::packet_sizes::PacketSize;
 use nym_sphinx_params::packet_version::PacketVersion;
-use nym_sphinx_params::PacketType;
-use nym_sphinx_types::NymPacket;
+use nym_sphinx_params::PacketMode;
+use nym_sphinx_types::SphinxPacket;
 use std::convert::TryFrom;
 
-#[derive(Debug)]
-pub struct FramedNymPacket {
+pub struct FramedSphinxPacket {
     /// Contains any metadata helping receiver to handle the underlying packet.
     pub(crate) header: Header,
 
     /// The actual SphinxPacket being sent.
-    pub(crate) packet: NymPacket,
+    pub(crate) packet: SphinxPacket,
 }
 
-impl FramedNymPacket {
-    pub fn new(packet: NymPacket, packet_type: PacketType, use_legacy_version: bool) -> Self {
+impl FramedSphinxPacket {
+    pub fn new(packet: SphinxPacket, packet_mode: PacketMode, 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();
 
-        FramedNymPacket {
+        FramedSphinxPacket {
             header: Header {
                 packet_version: PacketVersion::new(use_legacy_version),
                 packet_size,
-                packet_type,
+                packet_mode,
             },
             packet,
         }
     }
 
-    pub fn header(&self) -> Header {
-        self.header
-    }
-
     pub fn packet_size(&self) -> PacketSize {
         self.header.packet_size
     }
 
-    pub fn packet_type(&self) -> PacketType {
-        self.header.packet_type
+    pub fn packet_mode(&self) -> PacketMode {
+        self.header.packet_mode
     }
 
-    pub fn into_inner(self) -> NymPacket {
+    pub fn into_inner(self) -> SphinxPacket {
         self.packet
     }
 }
@@ -69,23 +64,15 @@ 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_type is deprecated but is still left as a concept behind to not break
+    // Note: currently packet_mode is deprecated but is still left as a concept behind to not break
     // compatibility with existing network
-    pub(crate) packet_type: PacketType,
+    pub(crate) packet_mode: PacketMode,
 }
 
 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
@@ -103,12 +90,12 @@ impl Header {
         }
 
         dst.put_u8(self.packet_size as u8);
-        dst.put_u8(self.packet_type as u8);
+        dst.put_u8(self.packet_mode as u8);
         // reserve bytes for the actual packet
         dst.reserve(self.packet_size.size());
     }
 
-    pub(crate) fn decode(src: &mut BytesMut) -> Result<Option<Self>, NymCodecError> {
+    pub(crate) fn decode(src: &mut BytesMut) -> Result<Option<Self>, SphinxCodecError> {
         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);
@@ -120,7 +107,7 @@ impl Header {
             Ok(Some(Header {
                 packet_version,
                 packet_size: PacketSize::try_from(src[0])?,
-                packet_type: PacketType::try_from(src[1])?,
+                packet_mode: PacketMode::try_from(src[1])?,
             }))
         } else if src.len() < Self::VERSIONED_SIZE {
             // we're missing that 1 byte to read the full header...
@@ -130,7 +117,7 @@ impl Header {
             Ok(Some(Header {
                 packet_version,
                 packet_size: PacketSize::try_from(src[1])?,
-                packet_type: PacketType::try_from(src[2])?,
+                packet_mode: PacketMode::try_from(src[2])?,
             }))
         }
     }
@@ -161,7 +148,7 @@ mod header_encoding {
             [
                 PacketVersion::new_versioned(123).as_u8().unwrap(),
                 unknown_packet_size,
-                PacketType::default() as u8,
+                PacketMode::default() as u8,
             ]
             .as_ref(),
         );
@@ -169,12 +156,12 @@ mod header_encoding {
     }
 
     #[test]
-    fn decoding_will_fail_for_unknown_packet_type() {
-        let unknown_packet_type: u8 = 255;
+    fn decoding_will_fail_for_unknown_packet_mode() {
+        let unknown_packet_mode: u8 = 255;
         // make sure this is still 'unknown' for if we make changes in the future
-        assert!(PacketType::try_from(unknown_packet_type).is_err());
+        assert!(PacketMode::try_from(unknown_packet_mode).is_err());
 
-        let mut bytes = BytesMut::from([PacketSize::default() as u8, unknown_packet_type].as_ref());
+        let mut bytes = BytesMut::from([PacketSize::default() as u8, unknown_packet_mode].as_ref());
         assert!(Header::decode(&mut bytes).is_err())
     }
 
@@ -204,7 +191,7 @@ mod header_encoding {
             let header = Header {
                 packet_version: PacketVersion::Legacy,
                 packet_size,
-                ..Default::default()
+                packet_mode: Default::default(),
             };
             let mut bytes = BytesMut::new();
             header.encode(&mut bytes);
@@ -225,7 +212,7 @@ mod header_encoding {
             let header = Header {
                 packet_version: PacketVersion::Versioned(123),
                 packet_size,
-                ..Default::default()
+                packet_mode: 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_type
+// - packet_mode
 // 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

@@ -0,0 +1,46 @@
+// 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

@@ -3,7 +3,7 @@
 
 use crate::FRAG_ID_LEN;
 use nym_sphinx_types::header::HEADER_SIZE;
-use nym_sphinx_types::{MIX_PARAMS_LEN, OUTFOX_PACKET_OVERHEAD, PAYLOAD_OVERHEAD_SIZE};
+use nym_sphinx_types::PAYLOAD_OVERHEAD_SIZE;
 use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
 use std::convert::TryFrom;
@@ -12,27 +12,20 @@ use std::str::FromStr;
 use thiserror::Error;
 
 // each sphinx packet contains mandatory header and payload padding + markers
-const SPHINX_PACKET_OVERHEAD: usize = HEADER_SIZE + PAYLOAD_OVERHEAD_SIZE;
+const 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 + 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 = ACK_IV_SIZE + FRAG_ID_LEN + OUTFOX_PACKET_OVERHEAD;
-const OUTFOX_REGULAR_PACKET_SIZE: usize = 2 * 1024 + OUTFOX_PACKET_OVERHEAD;
-const OUTFOX_EXTENDED_PACKET_SIZE_8: usize = 8 * 1024 + OUTFOX_PACKET_OVERHEAD;
-const OUTFOX_EXTENDED_PACKET_SIZE_16: usize = 16 * 1024 + OUTFOX_PACKET_OVERHEAD;
-const OUTFOX_EXTENDED_PACKET_SIZE_32: usize = 32 * 1024 + OUTFOX_PACKET_OVERHEAD;
+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;
 
 #[derive(Debug, Error)]
 pub enum InvalidPacketSize {
@@ -69,25 +62,6 @@ 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,
-
-    // for example for streaming fast and furious in uncompressed 10bit 4K HDR quality
-    #[serde(rename = "outfox_extended32")]
-    OutfoxExtendedPacket32 = 8,
-
-    // for example for streaming fast and furious in heavily compressed lossy RealPlayer quality
-    #[serde(rename = "outfox_extended8")]
-    OutfoxExtendedPacket8 = 9,
-
-    // for example for streaming fast and furious in compressed XviD quality
-    #[serde(rename = "outfox_extended16")]
-    OutfoxExtendedPacket16 = 10,
 }
 
 impl PartialOrd for PacketSize {
@@ -114,11 +88,6 @@ 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),
-            "outfox_extended8" => Ok(Self::OutfoxExtendedPacket8),
-            "outfox_extended16" => Ok(Self::OutfoxExtendedPacket16),
-            "outfox_extended32" => Ok(Self::OutfoxExtendedPacket32),
             s => Err(InvalidPacketSize::UnknownExtendedPacketVariant {
                 received: s.to_string(),
             }),
@@ -134,11 +103,6 @@ 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"),
-            PacketSize::OutfoxExtendedPacket32 => write!(f, "outfox_extended32"),
-            PacketSize::OutfoxExtendedPacket8 => write!(f, "outfox_extended8"),
-            PacketSize::OutfoxExtendedPacket16 => write!(f, "outfox_extended16"),
         }
     }
 }
@@ -163,17 +127,6 @@ 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),
-            _ if value == (PacketSize::OutfoxExtendedPacket8 as u8) => {
-                Ok(Self::OutfoxExtendedPacket8)
-            }
-            _ if value == (PacketSize::OutfoxExtendedPacket16 as u8) => {
-                Ok(Self::OutfoxExtendedPacket16)
-            }
-            _ if value == (PacketSize::OutfoxExtendedPacket32 as u8) => {
-                Ok(Self::OutfoxExtendedPacket32)
-            }
             v => Err(InvalidPacketSize::UnknownPacketTag { received: v }),
         }
     }
@@ -187,50 +140,15 @@ 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,
-            PacketSize::OutfoxExtendedPacket8 => OUTFOX_EXTENDED_PACKET_SIZE_8,
-            PacketSize::OutfoxExtendedPacket16 => OUTFOX_EXTENDED_PACKET_SIZE_16,
-            PacketSize::OutfoxExtendedPacket32 => OUTFOX_EXTENDED_PACKET_SIZE_32,
-        }
-    }
-
-    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
-            | PacketSize::OutfoxExtendedPacket8
-            | PacketSize::OutfoxExtendedPacket16
-            | PacketSize::OutfoxExtendedPacket32 => 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
-            | PacketSize::OutfoxExtendedPacket8
-            | PacketSize::OutfoxExtendedPacket16
-            | PacketSize::OutfoxExtendedPacket32 => OUTFOX_PACKET_OVERHEAD - MIX_PARAMS_LEN,
         }
     }
 
     pub const fn plaintext_size(self) -> usize {
-        self.size() - self.header_size() - self.payload_overhead()
+        self.size() - HEADER_SIZE - PAYLOAD_OVERHEAD_SIZE
     }
 
     pub const fn payload_size(self) -> usize {
-        self.size() - self.header_size()
+        self.size() - HEADER_SIZE
     }
 
     pub fn get_type(size: usize) -> Result<Self, InvalidPacketSize> {
@@ -244,16 +162,6 @@ impl PacketSize {
             Ok(PacketSize::ExtendedPacket16)
         } else if PacketSize::ExtendedPacket32.size() == size {
             Ok(PacketSize::ExtendedPacket32)
-        } else if PacketSize::OutfoxRegularPacket.size() == size {
-            Ok(PacketSize::OutfoxRegularPacket)
-        } else if PacketSize::OutfoxAckPacket.size() == size {
-            Ok(PacketSize::OutfoxAckPacket)
-        } else if PacketSize::OutfoxExtendedPacket8.size() == size {
-            Ok(PacketSize::OutfoxExtendedPacket8)
-        } else if PacketSize::OutfoxExtendedPacket16.size() == size {
-            Ok(PacketSize::OutfoxExtendedPacket16)
-        } else if PacketSize::OutfoxExtendedPacket32.size() == size {
-            Ok(PacketSize::OutfoxExtendedPacket32)
         } else {
             Err(InvalidPacketSize::UnknownPacketSize { received: size })
         }
@@ -261,16 +169,10 @@ impl PacketSize {
 
     pub fn is_extended_size(&self) -> bool {
         match self {
-            PacketSize::RegularPacket
-            | PacketSize::AckPacket
-            | PacketSize::OutfoxAckPacket
-            | PacketSize::OutfoxRegularPacket => false,
+            PacketSize::RegularPacket | PacketSize::AckPacket => false,
             PacketSize::ExtendedPacket8
             | PacketSize::ExtendedPacket16
-            | PacketSize::ExtendedPacket32
-            | PacketSize::OutfoxExtendedPacket8
-            | PacketSize::OutfoxExtendedPacket16
-            | PacketSize::OutfoxExtendedPacket32 => true,
+            | PacketSize::ExtendedPacket32 => true,
         }
     }
 
@@ -283,15 +185,8 @@ impl PacketSize {
     }
 
     pub fn get_type_from_plaintext(plaintext_size: usize) -> Result<Self, InvalidPacketSize> {
-        let sphinx_packet_size = plaintext_size + SPHINX_PACKET_OVERHEAD;
-        let outfox_packet_size = plaintext_size + OUTFOX_PACKET_OVERHEAD;
-        match Self::get_type(sphinx_packet_size) {
-            Ok(t) => Ok(t),
-            Err(_) => {
-                println!("Got Outfox!");
-                Self::get_type(outfox_packet_size)
-            }
-        }
+        let packet_size = plaintext_size + PACKET_OVERHEAD;
+        Self::get_type(packet_size)
     }
 }
 

common/nymsphinx/params/src/packet_types.rs

@@ -1,49 +0,0 @@
-// Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use serde::{Deserialize, Serialize};
-use std::convert::TryFrom;
-use thiserror::Error;
-
-#[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 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 }),
-        }
-    }
-}

common/nymsphinx/params/src/packet_version.rs

@@ -1,11 +1,9 @@
 // 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, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum PacketVersion {
     // this will allow updated mixnodes to still understand packets from before the update
     Legacy,

common/nymsphinx/src/lib.rs

@@ -19,4 +19,4 @@ pub use nym_sphinx_params as params;
 pub use nym_sphinx_types::*;
 
 // TEMP UNTIL FURTHER REFACTORING
-pub use preparer::payload::NymPayloadBuilder;
+pub use preparer::payload::NymsphinxPayloadBuilder;

common/nymsphinx/src/preparer/mod.rs

@@ -2,10 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::message::{NymMessage, ACK_OVERHEAD};
-use crate::NymPayloadBuilder;
+use crate::NymsphinxPayloadBuilder;
 use nym_crypto::asymmetric::encryption;
 use nym_crypto::Digest;
-use nym_outfox::packet::OutfoxPacket;
 use nym_sphinx_acknowledgements::surb_ack::SurbAck;
 use nym_sphinx_acknowledgements::AckKey;
 use nym_sphinx_addressing::clients::Recipient;
@@ -14,9 +13,9 @@ 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::{PacketType, ReplySurbKeyDigestAlgorithm, DEFAULT_NUM_MIX_HOPS};
+use nym_sphinx_params::{ReplySurbKeyDigestAlgorithm, DEFAULT_NUM_MIX_HOPS};
 use nym_sphinx_types::builder::SphinxPacketBuilder;
-use nym_sphinx_types::{delays, Delay, NymPacket};
+use nym_sphinx_types::{delays, Delay};
 use nym_topology::{NymTopology, NymTopologyError};
 use rand::{CryptoRng, Rng};
 use std::convert::TryFrom;
@@ -102,7 +101,6 @@ 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,
@@ -126,18 +124,13 @@ pub trait FragmentPreparer {
             self.generate_surb_ack(packet_sender, fragment_identifier, topology, ack_key)?;
         let ack_delay = surb_ack.expected_total_delay();
 
-        let packet_payload = match NymPayloadBuilder::new(fragment, surb_ack)
-            .build_reply(reply_surb.encryption_key())
-        {
-            Ok(payload) => payload,
-            Err(_e) => return Err(NymTopologyError::PayloadBuilder),
-        };
+        let packet_payload = NymsphinxPayloadBuilder::new(fragment, surb_ack)
+            .build_reply(reply_surb.encryption_key());
 
         // 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, packet_type)
-            .unwrap();
+        let (sphinx_packet, first_hop_address) =
+            reply_surb.apply_surb(packet_payload, packet_size).unwrap();
 
         Ok(PreparedFragment {
             // the round-trip delay is the sum of delays of all hops on the forward route as
@@ -173,7 +166,6 @@ 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
@@ -193,12 +185,8 @@ pub trait FragmentPreparer {
             self.generate_surb_ack(packet_sender, fragment_identifier, topology, ack_key)?;
         let ack_delay = surb_ack.expected_total_delay();
 
-        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),
-        };
+        let packet_payload = NymsphinxPayloadBuilder::new(fragment, surb_ack)
+            .build_regular(self.rng(), packet_recipient.encryption_key());
 
         // generate pseudorandom route for the packet
         let hops = self.num_mix_hops();
@@ -212,25 +200,10 @@ 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 packet = match packet_type {
-            PacketType::Outfox => NymPacket::Outfox(OutfoxPacket::build(
-                packet_payload,
-                route.as_slice().try_into()?,
-                Some(packet_size.payload_size()),
-            )?),
-            PacketType::Mix => NymPacket::Sphinx({
-                SphinxPacketBuilder::new()
-                    .with_payload_size(packet_size.payload_size())
-                    .build_packet(packet_payload, &route, &destination, &delays)
-                    .unwrap()
-            }),
-            PacketType::Vpn => NymPacket::Sphinx(
-                SphinxPacketBuilder::new()
-                    .with_payload_size(packet_size.payload_size())
-                    .build_packet(packet_payload, &route, &destination, &delays)
-                    .unwrap(),
-            ),
-        };
+        let sphinx_packet = SphinxPacketBuilder::new()
+            .with_payload_size(packet_size.payload_size())
+            .build_packet(packet_payload, &route, &destination, &delays)
+            .unwrap();
 
         // from the previously constructed route extract the first hop
         let first_hop_address =
@@ -241,7 +214,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, packet, Default::default()),
+            mix_packet: MixPacket::new(first_hop_address, sphinx_packet, Default::default()),
             fragment_identifier,
         })
     }
@@ -338,18 +311,11 @@ 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,
-            packet_type,
+            self, fragment, topology, ack_key, reply_surb, &sender,
         )
     }
 
@@ -359,7 +325,6 @@ where
         topology: &NymTopology,
         ack_key: &AckKey,
         packet_recipient: &Recipient,
-        packet_type: &PacketType,
     ) -> Result<PreparedFragment, NymTopologyError> {
         let sender = self.sender_address;
 
@@ -370,7 +335,6 @@ where
             ack_key,
             &sender,
             packet_recipient,
-            packet_type,
         )
     }
 

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, SurbAckRecoveryError};
+use nym_sphinx_acknowledgements::surb_ack::SurbAck;
 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 NymPayloadBuilder {
+pub struct NymsphinxPayloadBuilder {
     fragment: Fragment,
     surb_ack: SurbAck,
 }
 
-impl NymPayloadBuilder {
+impl NymsphinxPayloadBuilder {
     pub fn new(fragment: Fragment, surb_ack: SurbAck) -> Self {
-        NymPayloadBuilder { fragment, surb_ack }
+        NymsphinxPayloadBuilder { fragment, surb_ack }
     }
 
     fn build<C>(
         self,
         packet_encryption_key: &CipherKey<C>,
         variant_data: impl IntoIterator<Item = u8>,
-    ) -> Result<NymPayload, SurbAckRecoveryError>
+    ) -> NymsphinxPayload
     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,19 +46,16 @@ impl NymPayloadBuilder {
         // 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
-        Ok(NymPayload(
+        NymsphinxPayload(
             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,
-    ) -> Result<NymPayload, SurbAckRecoveryError> {
+    pub fn build_reply(self, packet_encryption_key: &SurbEncryptionKey) -> NymsphinxPayload {
         let key_digest = packet_encryption_key.compute_digest();
         self.build::<ReplySurbEncryptionAlgorithm>(
             packet_encryption_key.inner(),
@@ -70,7 +67,7 @@ impl NymPayloadBuilder {
         self,
         rng: &mut R,
         recipient_encryption_key: &encryption::PublicKey,
-    ) -> Result<NymPayload, SurbAckRecoveryError>
+    ) -> NymsphinxPayload
     where
         R: RngCore + CryptoRng,
     {
@@ -91,9 +88,9 @@ impl NymPayloadBuilder {
 // 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 NymPayload(Vec<u8>);
+pub struct NymsphinxPayload(Vec<u8>);
 
-impl AsRef<[u8]> for NymPayload {
+impl AsRef<[u8]> for NymsphinxPayload {
     fn as_ref(&self) -> &[u8] {
         &self.0
     }

common/nymsphinx/src/receiver.rs

@@ -7,6 +7,8 @@ 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;
@@ -74,6 +76,49 @@ 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,5 +9,6 @@ repository = { workspace = true }
 
 [dependencies]
 sphinx-packet = { version = "0.1.0" }
-nym-outfox = { path = "../../../nym-outfox" }
-thiserror = "1"
+
+#[patch.crates-io]
+#sphinx-packet = { path = "../../../../sphinx" }

common/nymsphinx/types/src/lib.rs

@@ -1,11 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-pub use nym_outfox::{
-    constants::MIX_PARAMS_LEN, constants::OUTFOX_PACKET_OVERHEAD, error::OutfoxError,
-};
 // re-exporting types and constants available in sphinx
-use nym_outfox::packet::OutfoxPacket;
 pub use sphinx_packet::{
     constants::{
         self, DESTINATION_ADDRESS_LENGTH, IDENTIFIER_LENGTH, MAX_PATH_LENGTH, NODE_ADDRESS_LENGTH,
@@ -17,101 +13,5 @@ pub use sphinx_packet::{
     payload::{Payload, PAYLOAD_OVERHEAD_SIZE},
     route::{Destination, DestinationAddressBytes, Node, NodeAddressBytes, SURBIdentifier},
     surb::{SURBMaterial, SURB},
-    Error as SphinxError, ProcessedPacket,
+    Error, ProcessedPacket, Result, SphinxPacket,
 };
-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),
-}
-
-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],
-        size: Option<usize>,
-    ) -> Result<NymPacket, NymPacketError> {
-        Ok(NymPacket::Outfox(OutfoxPacket::build(
-            payload,
-            route.try_into()?,
-            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<ProcessedPacket, NymPacketError> {
-        match self {
-            NymPacket::Sphinx(packet) => Ok(packet.process(node_secret_key)?),
-            NymPacket::Outfox(_packet) => todo!(),
-        }
-    }
-}

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

@@ -5,7 +5,7 @@ use crate::config::{Config, Socks5};
 use crate::error::Socks5ClientCoreError;
 use crate::socks::{
     authentication::{AuthenticationMethods, Authenticator, User},
-    server::NymSocksServer,
+    server::SphinxSocksServer,
 };
 use futures::channel::mpsc;
 use futures::StreamExt;
@@ -18,7 +18,6 @@ use nym_client_core::client::key_manager::KeyManager;
 use nym_client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
 use nym_credential_storage::storage::Storage;
 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;
@@ -102,7 +101,6 @@ impl NymClient {
         BandwidthController::new(storage, client)
     }
 
-    #[allow(clippy::too_many_arguments)]
     pub fn start_socks5_listener(
         socks5_config: &Socks5,
         debug_config: DebugConfig,
@@ -111,7 +109,6 @@ 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];
@@ -137,7 +134,7 @@ impl NymClient {
             .unwrap_or(debug_config.traffic.primary_packet_size);
 
         let authenticator = Authenticator::new(auth_methods, allowed_users);
-        let mut sphinx_socks = NymSocksServer::new(
+        let mut sphinx_socks = SphinxSocksServer::new(
             socks5_config.get_listening_port(),
             authenticator,
             socks5_config.get_provider_mix_address(),
@@ -152,7 +149,6 @@ impl NymClient {
                 socks5_config.get_per_request_surbs(),
             ),
             shutdown.clone(),
-            packet_type,
         );
         nym_task::spawn_with_report_error(
             async move {
@@ -265,8 +261,6 @@ impl NymClient {
         let client_output = started_client.client_output.register_consumer();
         let client_state = started_client.client_state;
 
-        info!("{:?}", self.config.get_base().get_packet_type());
-
         Self::start_socks5_listener(
             self.config.get_socks5(),
             *self.config.get_debug_settings(),
@@ -275,7 +269,6 @@ impl NymClient {
             client_state,
             self_address,
             started_client.task_manager.subscribe(),
-            self.config.get_base().get_packet_type(),
         );
 
         info!("Client startup finished!");

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

@@ -18,7 +18,6 @@ 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;
@@ -186,7 +185,6 @@ pub(crate) struct SocksClient {
     started_proxy: bool,
     lane_queue_lengths: LaneQueueLengths,
     shutdown_listener: TaskClient,
-    packet_type: Option<PacketType>,
 }
 
 impl Drop for SocksClient {
@@ -215,7 +213,6 @@ 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();
@@ -236,7 +233,6 @@ impl SocksClient {
             started_proxy: false,
             lane_queue_lengths,
             shutdown_listener,
-            packet_type,
         }
     }
 
@@ -353,7 +349,6 @@ impl SocksClient {
             msg.into_bytes(),
             self.config.connection_start_surbs,
             TransmissionLane::ConnectionId(self.connection_id),
-            self.packet_type,
         );
         self.input_sender
             .send(input_message)
@@ -376,7 +371,6 @@ impl SocksClient {
             self.service_provider,
             msg.into_bytes(),
             TransmissionLane::ConnectionId(self.connection_id),
-            self.packet_type,
         );
         self.input_sender
             .send(input_message)
@@ -414,7 +408,6 @@ 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,
@@ -446,15 +439,9 @@ impl SocksClient {
                     provider_message.into_bytes(),
                     per_request_surbs,
                     lane,
-                    packet_type,
                 )
             } else {
-                InputMessage::new_regular(
-                    recipient,
-                    provider_message.into_bytes(),
-                    lane,
-                    packet_type,
-                )
+                InputMessage::new_regular(recipient, provider_message.into_bytes(), lane)
             }
         })
         .await

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

@@ -10,7 +10,6 @@ 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;
@@ -18,7 +17,7 @@ use tap::TapFallible;
 use tokio::net::TcpListener;
 
 /// A Socks5 server that listens for connections.
-pub struct NymSocksServer {
+pub struct SphinxSocksServer {
     authenticator: Authenticator,
     listening_address: SocketAddr,
     service_provider: Recipient,
@@ -26,12 +25,10 @@ pub struct NymSocksServer {
     client_config: client::Config,
     lane_queue_lengths: LaneQueueLengths,
     shutdown: TaskClient,
-    packet_type: PacketType,
 }
 
-impl NymSocksServer {
+impl SphinxSocksServer {
     /// Create a new SphinxSocks instance
-    #[allow(clippy::too_many_arguments)]
     pub(crate) fn new(
         port: u16,
         authenticator: Authenticator,
@@ -40,13 +37,12 @@ impl NymSocksServer {
         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);
-        NymSocksServer {
+        SphinxSocksServer {
             authenticator,
             listening_address: format!("{ip}:{port}").parse().unwrap(),
             service_provider,
@@ -54,7 +50,6 @@ impl NymSocksServer {
             client_config,
             lane_queue_lengths,
             shutdown,
-            packet_type,
         }
     }
 
@@ -109,7 +104,6 @@ impl NymSocksServer {
                         &self.self_address,
                         self.lane_queue_lengths.clone(),
                         self.shutdown.clone(),
-                        Some(self.packet_type)
                     );
 
                     tokio::spawn(async move {
@@ -125,8 +119,8 @@ impl NymSocksServer {
                     });
                 },
                 _ = self.shutdown.recv() => {
-                    log::trace!("NymSocksServer: Received shutdown");
-                    log::debug!("NymSocksServer: Exiting");
+                    log::trace!("SphinxSocksServer: Received shutdown");
+                    log::debug!("SphinxSocksServer: Exiting");
                     return Ok(());
                 }
             }

common/socks5/proxy-helpers/src/proxy_runner/inbound.rs

@@ -4,7 +4,6 @@
 use super::MixProxySender;
 use super::SHUTDOWN_TIMEOUT;
 use crate::available_reader::AvailableReader;
-use crate::proxy_runner::KEEPALIVE_INTERVAL;
 use bytes::Bytes;
 use futures::FutureExt;
 use futures::StreamExt;
@@ -36,23 +35,6 @@ async fn send_empty_close<F, S>(
         .expect("BatchRealMessageReceiver has stopped receiving!");
 }
 
-async fn send_empty_keepalive<F, S>(
-    connection_id: ConnectionId,
-    message_sender: &mut OrderedMessageSender,
-    mix_sender: &MixProxySender<S>,
-    adapter_fn: F,
-) where
-    F: Fn(ConnectionId, Vec<u8>, bool) -> S,
-    S: Debug,
-{
-    log::trace!("Sending keepalive for connection: {connection_id}");
-    let ordered_msg = message_sender.wrap_message(Vec::new()).into_bytes();
-    mix_sender
-        .send(adapter_fn(connection_id, ordered_msg, false))
-        .await
-        .expect("BatchRealMessageReceiver has stopped receiving!");
-}
-
 #[allow(clippy::too_many_arguments)]
 async fn deal_with_data<F, S>(
     read_data: Option<io::Result<Bytes>>,
@@ -203,8 +185,6 @@ where
 
     tokio::pin!(shutdown_future);
 
-    let mut keepalive_timer = tokio::time::interval(KEEPALIVE_INTERVAL);
-
     loop {
         select! {
             read_data = &mut available_reader.next() => {
@@ -220,10 +200,6 @@ where
                 ).await {
                     break
                 }
-                keepalive_timer.reset();
-            }
-            _ = keepalive_timer.tick() => {
-                send_empty_keepalive(connection_id, &mut message_sender, &mix_sender, &adapter_fn).await;
             }
             _ = &mut shutdown_future => {
                 debug!(

common/socks5/proxy-helpers/src/proxy_runner/mod.rs

@@ -15,10 +15,6 @@ mod outbound;
 // TODO: make this configurable
 const SHUTDOWN_TIMEOUT: Duration = Duration::from_secs(30);
 
-// Send empty keepalive messages regurarly to keep the connection alive. This should be smaller
-// than [`MIX_TTL`].
-const KEEPALIVE_INTERVAL: Duration = Duration::from_secs(60);
-
 #[derive(Debug)]
 pub struct ProxyMessage {
     pub data: Vec<u8>,

common/topology/src/lib.rs

@@ -8,7 +8,6 @@ use nym_mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixId};
 use nym_sphinx_addressing::nodes::NodeIdentity;
 use nym_sphinx_types::Node as SphinxNode;
 use rand::{CryptoRng, Rng};
-use std::array::TryFromSliceError;
 use std::collections::BTreeMap;
 use std::convert::TryInto;
 use std::fmt::{self, Display, Formatter};
@@ -53,15 +52,6 @@ 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),
 }
 
 #[derive(Debug, Clone)]

contracts/Cargo.lock

@@ -2,16 +2,6 @@
 # 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.7",
-]
-
 [[package]]
 name = "aes"
 version = "0.7.5"
@@ -19,7 +9,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9e8b47f52ea9bae42228d07ec09eb676433d7c4ed1ebdf0f1d1c29ed446f1ab8"
 dependencies = [
  "cfg-if",
- "cipher 0.3.0",
+ "cipher",
  "cpufeatures",
  "ctr",
  "opaque-debug 0.3.0",
@@ -31,7 +21,7 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
 dependencies = [
- "getrandom 0.2.9",
+ "getrandom 0.2.8",
  "once_cell",
  "version_check",
 ]
@@ -44,15 +34,9 @@ checksum = "7de8ce5e0f9f8d88245311066a578d72b7af3e7088f32783804676302df237e4"
 
 [[package]]
 name = "arrayref"
-version = "0.3.7"
+version = "0.3.6"
 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"
+checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544"
 
 [[package]]
 name = "autocfg"
@@ -102,36 +86,13 @@ 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.6",
-]
-
 [[package]]
 name = "block-buffer"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
 dependencies = [
- "generic-array 0.14.7",
-]
-
-[[package]]
-name = "block-buffer"
-version = "0.10.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
-dependencies = [
- "generic-array 0.14.7",
+ "generic-array 0.14.6",
 ]
 
 [[package]]
@@ -142,9 +103,9 @@ checksum = "771fe0050b883fcc3ea2359b1a96bcfbc090b7116eae7c3c512c7a083fdf23d3"
 
 [[package]]
 name = "bumpalo"
-version = "3.12.1"
+version = "3.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b1ce199063694f33ffb7dd4e0ee620741495c32833cde5aa08f02a0bf96f0c8"
+checksum = "0d261e256854913907f67ed06efbc3338dfe6179796deefc1ff763fc1aee5535"
 
 [[package]]
 name = "byte-tools"
@@ -189,48 +150,13 @@ 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"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ee52072ec15386f770805afd189a01c8841be8696bed250fa2f13c4c0d6dfb7"
 dependencies = [
- "generic-array 0.14.7",
-]
-
-[[package]]
-name = "cipher"
-version = "0.4.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
-dependencies = [
- "crypto-common",
- "inout",
- "zeroize",
+ "generic-array 0.14.6",
 ]
 
 [[package]]
@@ -264,12 +190,6 @@ version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e4c78c047431fee22c1a7bb92e00ad095a02a983affe4d8a72e2a2c62c1b94f3"
 
-[[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.0.0"
@@ -331,56 +251,13 @@ dependencies = [
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.7"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e4c1eaa2012c47becbbad2ab175484c2a84d1185b566fb2cc5b8707343dfe58"
+checksum = "28d997bd5e24a5928dd43e46dc529867e207907fe0b239c3477d924f7f2ca320"
 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"
@@ -393,23 +270,12 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "03c6a1d5fa1de37e071642dfa44ec552ca5b299adb128fab16138e24b548fd21"
 dependencies = [
- "generic-array 0.14.7",
+ "generic-array 0.14.6",
  "rand_core 0.6.4",
  "subtle 2.4.1",
  "zeroize",
 ]
 
-[[package]]
-name = "crypto-common"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
-dependencies = [
- "generic-array 0.14.7",
- "rand_core 0.6.4",
- "typenum",
-]
-
 [[package]]
 name = "crypto-mac"
 version = "0.7.0"
@@ -426,7 +292,7 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b1d1a86f49236c215f271d40892d5fc950490551400b02ef360692c29815c714"
 dependencies = [
- "generic-array 0.14.7",
+ "generic-array 0.14.6",
  "subtle 2.4.1",
 ]
 
@@ -436,14 +302,14 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "049bb91fb4aaf0e3c7efa6cd5ef877dbbbd15b39dad06d9948de4ec8a75761ea"
 dependencies = [
- "cipher 0.3.0",
+ "cipher",
 ]
 
 [[package]]
 name = "curve25519-dalek"
-version = "3.2.0"
+version = "3.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b9fdf9972b2bd6af2d913799d9ebc165ea4d2e65878e329d9c6b372c4491b61"
+checksum = "90f9d052967f590a76e62eb387bd0bbb1b000182c3cefe5364db6b7211651bc0"
 dependencies = [
  "byteorder",
  "digest 0.9.0",
@@ -632,18 +498,7 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
 dependencies = [
- "generic-array 0.14.7",
-]
-
-[[package]]
-name = "digest"
-version = "0.10.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8168378f4e5023e7218c89c891c0fd8ecdb5e5e4f18cb78f38cf245dd021e76f"
-dependencies = [
- "block-buffer 0.10.4",
- "crypto-common",
- "subtle 2.4.1",
+ "generic-array 0.14.6",
 ]
 
 [[package]]
@@ -718,7 +573,7 @@ dependencies = [
  "crypto-bigint",
  "der",
  "ff",
- "generic-array 0.14.7",
+ "generic-array 0.14.6",
  "group",
  "rand_core 0.6.4",
  "sec1",
@@ -748,13 +603,13 @@ dependencies = [
 
 [[package]]
 name = "errno"
-version = "0.3.1"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bcfec3a70f97c962c307b2d2c56e358cf1d00b558d74262b5f929ee8cc7e73a"
+checksum = "f639046355ee4f37944e44f60642c6f3a7efa3cf6b78c78a0d989a8ce6c396a1"
 dependencies = [
  "errno-dragonfly",
  "libc",
- "windows-sys 0.48.0",
+ "winapi",
 ]
 
 [[package]]
@@ -818,9 +673,9 @@ dependencies = [
 
 [[package]]
 name = "generic-array"
-version = "0.14.7"
+version = "0.14.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9"
 dependencies = [
  "typenum",
  "version_check",
@@ -841,15 +696,13 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.9"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c85e1d9ab2eadba7e5040d4e09cbd6d072b76a557ad64e797c2cb9d4da21d7e4"
+checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
 dependencies = [
  "cfg-if",
- "js-sys",
  "libc",
  "wasi 0.11.0+wasi-snapshot-preview1",
- "wasm-bindgen",
 ]
 
 [[package]]
@@ -897,15 +750,6 @@ 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"
@@ -964,15 +808,6 @@ 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.7",
-]
-
 [[package]]
 name = "instant"
 version = "0.1.12"
@@ -984,13 +819,13 @@ dependencies = [
 
 [[package]]
 name = "io-lifetimes"
-version = "1.0.10"
+version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c66c74d2ae7e79a5a8f7ac924adbe38ee42a859c6539ad869eb51f0b52dc220"
+checksum = "09270fd4fa1111bc614ed2246c7ef56239a3063d5be0d1ec3b589c505d400aeb"
 dependencies = [
- "hermit-abi 0.3.1",
+ "hermit-abi",
  "libc",
- "windows-sys 0.48.0",
+ "windows-sys 0.45.0",
 ]
 
 [[package]]
@@ -1053,9 +888,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
 [[package]]
 name = "libc"
-version = "0.2.142"
+version = "0.2.140"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a987beff54b60ffa6d51982e1aa1146bc42f19bd26be28b0586f252fccf5317"
+checksum = "99227334921fae1a979cf0bfdfcc6b3e5ce376ef57e16fb6fb3ea2ed6095f80c"
 
 [[package]]
 name = "libgit2-sys"
@@ -1089,9 +924,9 @@ dependencies = [
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.3.4"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36eb31c1778188ae1e64398743890d0877fef36d11521ac60406b42016e8c2cf"
+checksum = "f051f77a7c8e6957c0696eac88f26b0117e54f52d3fc682ab19397a8812846a4"
 
 [[package]]
 name = "lioness"
@@ -1114,15 +949,6 @@ dependencies = [
  "cfg-if",
 ]
 
-[[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"
@@ -1149,16 +975,6 @@ 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"
@@ -1305,22 +1121,6 @@ dependencies = [
  "thiserror",
 ]
 
-[[package]]
-name = "nym-outfox"
-version = "0.1.0"
-dependencies = [
- "blake3",
- "chacha20",
- "chacha20poly1305",
- "curve25519-dalek",
- "getrandom 0.2.9",
- "rand",
- "rayon",
- "sphinx-packet",
- "thiserror",
- "zeroize",
-]
-
 [[package]]
 name = "nym-pemstore"
 version = "0.2.0"
@@ -1359,9 +1159,7 @@ dependencies = [
 name = "nym-sphinx-types"
 version = "0.2.0"
 dependencies = [
- "nym-outfox",
  "sphinx-packet",
- "thiserror",
 ]
 
 [[package]]
@@ -1450,17 +1248,6 @@ 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"
@@ -1493,9 +1280,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.56"
+version = "1.0.52"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b63bdb0cd06f1f4dedf69b254734f9b45af66e4a031e42a7480257d9898b435"
+checksum = "1d0e1ae9e836cc3beddd63db0df682593d7e2d3d891ae8c9083d2113e1744224"
 dependencies = [
  "unicode-ident",
 ]
@@ -1586,7 +1373,7 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom 0.2.9",
+ "getrandom 0.2.8",
 ]
 
 [[package]]
@@ -1608,51 +1395,29 @@ 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"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
+checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
 dependencies = [
  "bitflags",
 ]
 
 [[package]]
 name = "regex"
-version = "1.8.1"
+version = "1.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af83e617f331cc6ae2da5443c602dfa5af81e517212d9d611a5b3ba1777b5370"
+checksum = "48aaa5748ba571fb95cd2c85c09f629215d3a6ece942baa100950af03a34f733"
 dependencies = [
  "regex-syntax",
 ]
 
 [[package]]
 name = "regex-syntax"
-version = "0.7.1"
+version = "0.6.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5996294f19bd3aae0453a862ad728f60e6600695733dd5df01da90c54363a3c"
+checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
 
 [[package]]
 name = "rfc6979"
@@ -1676,16 +1441,16 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "0.37.15"
+version = "0.36.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0661814f891c57c930a610266415528da53c4933e6dea5fb350cbfe048a9ece"
+checksum = "db4165c9963ab29e422d6c26fbc1d37f15bace6b2810221f9d925023480fcf0e"
 dependencies = [
  "bitflags",
  "errno",
  "io-lifetimes",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.48.0",
+ "windows-sys 0.45.0",
 ]
 
 [[package]]
@@ -1736,12 +1501,6 @@ 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.2.1"
@@ -1749,7 +1508,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08da66b8b0965a5555b6bd6639e68ccba85e1e2506f5fbb089e93f8a04e1a2d1"
 dependencies = [
  "der",
- "generic-array 0.14.7",
+ "generic-array 0.14.6",
  "pkcs8",
  "subtle 2.4.1",
  "zeroize",
@@ -1763,9 +1522,9 @@ checksum = "bebd363326d05ec3e2f532ab7660680f3b02130d780c299bca73469d521bc0ed"
 
 [[package]]
 name = "serde"
-version = "1.0.160"
+version = "1.0.158"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb2f3770c8bce3bcda7e149193a069a0f4365bda1fa5cd88e03bca26afc1216c"
+checksum = "771d4d9c4163ee138805e12c710dd365e4f44be8be0503cb1bb9eb989425d9c9"
 dependencies = [
  "serde_derive",
 ]
@@ -1781,13 +1540,13 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.160"
+version = "1.0.158"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "291a097c63d8497e00160b166a967a4a79c64f3facdd01cbd7502231688d77df"
+checksum = "e801c1712f48475582b7696ac71e0ca34ebb30e09338425384269d9717c62cad"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.15",
+ "syn 2.0.3",
 ]
 
 [[package]]
@@ -1803,9 +1562,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.96"
+version = "1.0.94"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "057d394a50403bcac12672b2b18fb387ab6d289d957dab67dd201875391e52f1"
+checksum = "1c533a59c9d8a93a09c6ab31f0fd5e5f4dd1b8fc9434804029839884765d04ea"
 dependencies = [
  "itoa",
  "ryu",
@@ -1820,7 +1579,7 @@ checksum = "bcec881020c684085e55a25f7fd888954d56609ef363479dc5a1305eb0d40cab"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.15",
+ "syn 2.0.3",
 ]
 
 [[package]]
@@ -1829,7 +1588,7 @@ version = "0.9.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4d58a1e1bf39749807d89cf2d98ac2dfa0ff1cb3faa38fbb64dd88ac8013d800"
 dependencies = [
- "block-buffer 0.9.0",
+ "block-buffer",
  "cfg-if",
  "cpufeatures",
  "digest 0.9.0",
@@ -1920,9 +1679,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.15"
+version = "2.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a34fcf3e8b60f57e6a14301a2e916d323af98b0ea63c599441eec8558660c822"
+checksum = "e8234ae35e70582bfa0f1fedffa6daa248e41dd045310b19800c4a36382c8f60"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1930,16 +1689,28 @@ dependencies = [
 ]
 
 [[package]]
-name = "tempfile"
-version = "3.5.0"
+name = "synstructure"
+version = "0.12.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9fbec84f381d5795b08656e4912bec604d162bff9291d6189a78f4c8ab87998"
+checksum = "f36bdaa60a83aca3921b5259d5400cbf5e90fc51931376a9bd4a0eb79aa7210f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "unicode-xid",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af18f7ae1acd354b992402e9ec5864359d693cd8a79dcbef59f76891701c1e95"
 dependencies = [
  "cfg-if",
  "fastrand",
  "redox_syscall",
  "rustix",
- "windows-sys 0.45.0",
+ "windows-sys 0.42.0",
 ]
 
 [[package]]
@@ -1959,7 +1730,7 @@ checksum = "f9456a42c5b0d803c8cd86e73dd7cc9edd429499f37a3550d286d5e86720569f"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.15",
+ "syn 2.0.3",
 ]
 
 [[package]]
@@ -2024,9 +1795,9 @@ dependencies = [
 
 [[package]]
 name = "unicode-bidi"
-version = "0.3.13"
+version = "0.3.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92888ba5573ff080736b3648696b70cafad7d250551175acbaa4e0385b3e1460"
+checksum = "7d502c968c6a838ead8e69b2ee18ec708802f99db92a0d156705ec9ef801993b"
 
 [[package]]
 name = "unicode-ident"
@@ -2044,14 +1815,10 @@ dependencies = [
 ]
 
 [[package]]
-name = "universal-hash"
-version = "0.5.0"
+name = "unicode-xid"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d3160b73c9a19f7e2939a2fdad446c57c1bbbbf4d919d3213ff1267a580d8b5"
-dependencies = [
- "crypto-common",
- "subtle 2.4.1",
-]
+checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
 
 [[package]]
 name = "url"
@@ -2168,22 +1935,50 @@ version = "0.2.84"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0046fef7e28c3804e5e38bfa31ea2a0f73905319b677e57ebe37e49358989b5d"
 
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-sys"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.45.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
 dependencies = [
- "windows-targets 0.42.2",
-]
-
-[[package]]
-name = "windows-sys"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
-dependencies = [
- "windows-targets 0.48.0",
+ "windows-targets",
 ]
 
 [[package]]
@@ -2192,28 +1987,13 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
 dependencies = [
- "windows_aarch64_gnullvm 0.42.2",
- "windows_aarch64_msvc 0.42.2",
- "windows_i686_gnu 0.42.2",
- "windows_i686_msvc 0.42.2",
- "windows_x86_64_gnu 0.42.2",
- "windows_x86_64_gnullvm 0.42.2",
- "windows_x86_64_msvc 0.42.2",
-]
-
-[[package]]
-name = "windows-targets"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b1eb6f0cd7c80c79759c929114ef071b87354ce476d9d94271031c0497adfd5"
-dependencies = [
- "windows_aarch64_gnullvm 0.48.0",
- "windows_aarch64_msvc 0.48.0",
- "windows_i686_gnu 0.48.0",
- "windows_i686_msvc 0.48.0",
- "windows_x86_64_gnu 0.48.0",
- "windows_x86_64_gnullvm 0.48.0",
- "windows_x86_64_msvc 0.48.0",
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
 ]
 
 [[package]]
@@ -2222,89 +2002,47 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
 
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc"
-
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
 
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3"
-
 [[package]]
 name = "windows_i686_gnu"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
 
-[[package]]
-name = "windows_i686_gnu"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241"
-
 [[package]]
 name = "windows_i686_msvc"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
 
-[[package]]
-name = "windows_i686_msvc"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00"
-
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
 
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1"
-
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
 
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953"
-
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
 
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
-
 [[package]]
 name = "x25519-dalek"
-version = "1.1.1"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a0c105152107e3b96f6a00a65e86ce82d9b125230e1c4302940eca58ff71f4f"
+checksum = "2392b6b94a576b4e2bf3c5b2757d63f10ada8020a2e4d08ac849ebcf6ea8e077"
 dependencies = [
  "curve25519-dalek",
  "rand_core 0.5.1",
@@ -2313,20 +2051,21 @@ dependencies = [
 
 [[package]]
 name = "zeroize"
-version = "1.6.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a0956f1ba7c7909bfb66c2e9e4124ab6f6482560f6628b5aaeba39207c9aad9"
+checksum = "4756f7db3f7b5574938c3eb1c117038b8e07f95ee6718c0efad4ac21508f1efd"
 dependencies = [
  "zeroize_derive",
 ]
 
 [[package]]
 name = "zeroize_derive"
-version = "1.4.2"
+version = "1.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
+checksum = "44bf07cb3e50ea2003396695d58bf46bc9887a1f362260446fad6bc4e79bd36c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.15",
+ "syn 1.0.109",
+ "synstructure",
 ]

gateway/gateway-requests/src/types.rs

@@ -5,7 +5,6 @@ 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;
@@ -291,13 +290,7 @@ impl BinaryRequest {
     pub fn into_encrypted_tagged_bytes(self, shared_key: &SharedKeys) -> Vec<u8> {
         match self {
             BinaryRequest::ForwardSphinx(mix_packet) => {
-                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![];
-                    }
-                };
+                let forwarding_data = mix_packet.into_bytes();
 
                 // 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.packet().len() as i64;
+        let consumed_bandwidth = mix_packet.sphinx_packet().len() as i64;
 
         let available_bandwidth = self.get_available_bandwidth().await?;
 

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::NymCodec;
-use nym_sphinx::framing::packet::FramedNymPacket;
+use nym_sphinx::framing::codec::SphinxCodec;
+use nym_sphinx::framing::packet::FramedSphinxPacket;
 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: FramedNymPacket) {
+    async fn handle_received_packet(&mut self, framed_sphinx_packet: FramedSphinxPacket) {
         //
         // 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, NymCodec);
+        let mut framed_conn = Framed::new(conn, SphinxCodec);
         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::FramedNymPacket;
+use nym_sphinx::framing::packet::FramedSphinxPacket;
 use thiserror::Error;
 
 #[derive(Error, Debug)]
@@ -32,7 +32,7 @@ impl PacketProcessor {
 
     pub(crate) fn process_received(
         &self,
-        received: FramedNymPacket,
+        received: FramedSphinxPacket,
     ) -> Result<ProcessedFinalHop, GatewayProcessingError> {
         match self.inner_processor.process_received(received)? {
             MixProcessingResult::ForwardHop(..) => {

mixnode/Cargo.toml

@@ -57,7 +57,6 @@ nym-types = { path = "../common/types" }
 nym-topology = { path = "../common/topology" }
 nym-validator-client = { path = "../common/client-libs/validator-client" }
 nym-bin-common = { path = "../common/bin-common", features = ["output_format"] }
-cpu-cycles = { path = "../cpu-cycles", optional = true }
 
 [dev-dependencies]
 tokio = { version = "1.21.2", features = [

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::NymCodec;
-use nym_sphinx::framing::packet::FramedNymPacket;
+use nym_sphinx::framing::codec::SphinxCodec;
+use nym_sphinx::framing::packet::FramedSphinxPacket;
 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: FramedNymPacket) {
+    fn handle_received_packet(&self, framed_sphinx_packet: FramedSphinxPacket) {
         //
         // 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, NymCodec);
+        let mut framed_conn = Framed::new(conn, SphinxCodec);
         while !shutdown.is_shutdown() {
             tokio::select! {
                 biased;

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::FramedNymPacket;
+use nym_sphinx::framing::packet::FramedSphinxPacket;
 
 // 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: FramedNymPacket,
+        received: FramedSphinxPacket,
     ) -> 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_type = packet.packet_type();
-        let packet = packet.into_packet();
+        let packet_mode = packet.packet_mode();
+        let sphinx_packet = packet.into_sphinx_packet();
 
-        if let Err(err) = self
-            .mixnet_client
-            .send_without_response(next_hop, packet, packet_type)
+        if let Err(err) =
+            self.mixnet_client
+                .send_without_response(next_hop, sphinx_packet, packet_mode)
         {
             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::PacketType;
+    use nym_sphinx_params::PacketMode;
+    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,
+        SphinxPacket, DESTINATION_ADDRESS_LENGTH, IDENTIFIER_LENGTH, NODE_ADDRESS_LENGTH,
     };
 
     #[derive(Default)]
     struct TestClient {
-        pub packets_sent: Arc<Mutex<Vec<(NymNodeRoutingAddress, NymPacket, PacketType)>>>,
+        pub packets_sent: Arc<Mutex<Vec<(NymNodeRoutingAddress, SphinxPacket, PacketMode)>>>,
     }
 
     impl nym_mixnet_client::SendWithoutResponse for TestClient {
         fn send_without_response(
             &mut self,
             address: NymNodeRoutingAddress,
-            packet: NymPacket,
-            packet_type: PacketType,
+            packet: SphinxPacket,
+            packet_mode: PacketMode,
         ) -> io::Result<()> {
             self.packets_sent
                 .lock()
                 .unwrap()
-                .push((address, packet, packet_type));
+                .push((address, packet, packet_mode));
             Ok(())
         }
     }
 
-    fn make_valid_sphinx_packet(size: PacketSize) -> NymPacket {
+    fn make_valid_sphinx_packet(size: PacketSize) -> SphinxPacket {
         let (_, node1_pk) = crypto::keygen();
         let node1 = Node::new(
             NodeAddressBytes::from_bytes([5u8; NODE_ADDRESS_LENGTH]),
@@ -192,7 +192,9 @@ mod tests {
             SphinxDelay::new_from_nanos(42),
             SphinxDelay::new_from_nanos(42),
         ];
-        NymPacket::sphinx_build(size.payload_size(), b"foomp", &route, &destination, &delays)
+        SphinxPacketBuilder::new()
+            .with_payload_size(size.payload_size())
+            .build_packet(b"foomp", &route, &destination, &delays)
             .unwrap()
     }
 
@@ -217,7 +219,7 @@ mod tests {
         let mix_packet = MixPacket::new(
             next_hop,
             make_valid_sphinx_packet(PacketSize::default()),
-            PacketType::default(),
+            PacketMode::default(),
         );
         let forward_instant = None;
         packet_sender

nym-api/src/network_monitor/chunker.rs

@@ -3,7 +3,7 @@
 
 use nym_sphinx::forwarding::packet::MixPacket;
 use nym_sphinx::message::NymMessage;
-use nym_sphinx::params::{PacketSize, PacketType};
+use nym_sphinx::params::PacketSize;
 use nym_sphinx::{
     acknowledgements::AckKey, addressing::clients::Recipient, preparer::MessagePreparer,
 };
@@ -43,13 +43,12 @@ impl Chunker {
         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)
+        self.prepare_packets(message, topology, packet_sender)
     }
 
     fn prepare_packets(
@@ -57,7 +56,6 @@ impl Chunker {
         message: Vec<u8>,
         topology: &NymTopology,
         packet_sender: Recipient,
-        packet_type: PacketType,
     ) -> Vec<MixPacket> {
         let ack_key: AckKey = AckKey::new(&mut self.rng);
 
@@ -70,13 +68,7 @@ impl Chunker {
             // 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,
-                )
+                .prepare_chunk_for_sending(message_chunk, topology, &ack_key, &packet_sender)
                 .unwrap();
 
             mix_packets.push(prepared_fragment.mix_packet);

nym-api/src/network_monitor/mod.rs

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

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

@@ -10,7 +10,6 @@ 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};
@@ -45,8 +44,6 @@ 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> {
@@ -57,7 +54,6 @@ 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,
@@ -72,7 +68,6 @@ 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,
         }
     }
 
@@ -127,11 +122,8 @@ 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,
-                self.packet_type,
-            );
+            let gateway_packets = packet_preparer
+                .prepare_test_route_viability_packets(&route, self.route_test_packets);
             packets.push(gateway_packets);
         }
 
@@ -238,7 +230,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, self.packet_type)
+            .prepare_test_packets(self.test_nonce, routes)
             .await;
 
         let total_sent = prepared_packets

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

@@ -11,7 +11,6 @@ use nym_crypto::asymmetric::{encryption, identity};
 use nym_mixnet_contract_common::{Addr, GatewayBond, Layer, MixId, MixNodeBond};
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::forwarding::packet::MixPacket;
-use nym_sphinx::params::PacketType;
 use nym_topology::{gateway, mix, NymTopology};
 use rand::seq::SliceRandom;
 use rand::{thread_rng, Rng};
@@ -171,7 +170,6 @@ impl PacketPreparer {
         packet: &TestPacket,
         topology: &NymTopology,
         packet_recipient: Recipient,
-        packet_type: PacketType,
     ) -> MixPacket {
         // this should be done only once. We can't really do it at construction time
         // as there's no sane Default for Recipient
@@ -182,7 +180,6 @@ impl PacketPreparer {
             packet.to_bytes(),
             topology,
             packet_recipient,
-            packet_type,
         );
         assert_eq!(
             mix_packets.len(),
@@ -371,14 +368,12 @@ impl PacketPreparer {
         &mut self,
         route: &TestRoute,
         num: usize,
-        packet_type: PacketType,
     ) -> GatewayPackets {
         let mut mix_packets = Vec::with_capacity(num);
         let test_packet = route.self_test_packet();
         let recipient = self.create_packet_sender(route.gateway());
         for _ in 0..num {
-            let mix_packet =
-                self.wrap_test_packet(&test_packet, route.topology(), recipient, packet_type);
+            let mix_packet = self.wrap_test_packet(&test_packet, route.topology(), recipient);
             mix_packets.push(mix_packet)
         }
 
@@ -433,7 +428,6 @@ impl PacketPreparer {
         &mut self,
         test_nonce: u64,
         test_routes: &[TestRoute],
-        packet_type: PacketType,
     ) -> PreparedPackets {
         // only test mixnodes that are rewarded, i.e. that will be rewarded in this interval.
         // (remember that "idle" nodes are still part of that set)
@@ -468,8 +462,7 @@ impl PacketPreparer {
                 let topology = test_route.substitute_mix(mixnode);
                 // produce n mix packets
                 for _ in 0..self.per_node_test_packets {
-                    let mix_packet =
-                        self.wrap_test_packet(&test_packet, &topology, recipient, packet_type);
+                    let mix_packet = self.wrap_test_packet(&test_packet, &topology, recipient);
                     mix_packets.push(mix_packet);
                 }
             }
@@ -489,8 +482,7 @@ impl PacketPreparer {
                 let topology = test_route.substitute_gateway(gateway);
                 // produce n mix packets
                 for _ in 0..self.per_node_test_packets {
-                    let mix_packet =
-                        self.wrap_test_packet(&test_packet, &topology, recipient, packet_type);
+                    let mix_packet = self.wrap_test_packet(&test_packet, &topology, recipient);
                     gateway_mix_packets.push(mix_packet);
                 }
 

nym-connect/desktop/Cargo.lock

@@ -3565,9 +3565,8 @@ dependencies = [
  "chacha20poly1305",
  "curve25519-dalek",
  "getrandom 0.2.8",
- "rand 0.7.3",
  "rayon",
- "sphinx-packet",
+ "sphinx-packet 0.1.0 (git+https://github.com/nymtech/sphinx.git)",
  "thiserror",
  "zeroize",
 ]
@@ -3742,7 +3741,6 @@ dependencies = [
  "nym-sphinx-addressing",
  "nym-sphinx-params",
  "nym-sphinx-types",
- "thiserror",
 ]
 
 [[package]]
@@ -3770,9 +3768,7 @@ dependencies = [
 name = "nym-sphinx-types"
 version = "0.2.0"
 dependencies = [
- "nym-outfox",
- "sphinx-packet",
- "thiserror",
+ "sphinx-packet 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -5381,6 +5377,29 @@ dependencies = [
  "subtle 2.4.1",
 ]
 
+[[package]]
+name = "sphinx-packet"
+version = "0.1.0"
+source = "git+https://github.com/nymtech/sphinx.git#ca107d94360cdf8bbfbdb12fe5320ed74f80e40c"
+dependencies = [
+ "aes 0.7.5",
+ "arrayref",
+ "blake2",
+ "bs58",
+ "byteorder",
+ "chacha",
+ "curve25519-dalek",
+ "digest 0.9.0",
+ "hkdf 0.11.0",
+ "hmac 0.11.0",
+ "lioness",
+ "log",
+ "rand 0.7.3",
+ "rand_distr",
+ "sha2 0.9.9",
+ "subtle 2.4.1",
+]
+
 [[package]]
 name = "spin"
 version = "0.5.2"

nym-outfox/Cargo.toml

@@ -15,8 +15,9 @@ chacha20poly1305 = "0.10.1"
 # Need this star over here to pull in js into getrandom
 getrandom = { version = "*", features = ["js"] }
 thiserror = "1"
-sphinx-packet = "0.1.0"
-rand = "0.7.3"
+
+sphinx-packet = { git = "https://github.com/nymtech/sphinx.git" }
+
 
 [dev-dependencies]
 criterion = "0.4"

nym-outfox/src/constants.rs

@@ -1,19 +0,0 @@
-pub const GROUPELEMENTBYTES: u8 = 32;
-pub const TAGBYTES: u8 = 16;
-pub const MIX_PARAMS_LEN: usize = 6;
-pub const MIN_MESSAGE_LEN: usize = 24 * 2;
-pub(crate) const CONTEXT: &str = "LIONKEYS";
-pub(crate) const TAG_LEN: usize = 24;
-pub const DEFAULT_ROUTING_INFO_SIZE: u8 = 32;
-pub const DEFAULT_HOPS: usize = 4;
-
-pub const OUTFOX_PACKET_OVERHEAD: usize = MIX_PARAMS_LEN
-    + (groupelementbytes() + tagbytes() + DEFAULT_ROUTING_INFO_SIZE as usize) * DEFAULT_HOPS;
-
-pub const fn groupelementbytes() -> usize {
-    GROUPELEMENTBYTES as usize
-}
-
-pub const fn tagbytes() -> usize {
-    TAGBYTES as usize
-}

nym-outfox/src/error.rs

@@ -1,11 +1,10 @@
 use std::array::TryFromSliceError;
 
-use crate::constants::MIN_MESSAGE_LEN;
-use crate::constants::MIX_PARAMS_LEN;
+use crate::lion::MIN_MESSAGE_LEN;
 use chacha20::cipher::InvalidLength;
 use thiserror::Error;
 
-#[derive(Debug, Error, Clone)]
+#[derive(Debug, Error)]
 pub enum OutfoxError {
     #[error("Lengths mismatch, expected: {expected}, got: {got}")]
     LenMismatch { expected: usize, got: usize },
@@ -21,10 +20,8 @@ pub enum OutfoxError {
     #[error("Message length must be greater then {MIN_MESSAGE_LEN} bytes")]
     InvalidMessageLength,
     #[error("{source}")]
-    TryFromSlice {
+    TryFromSluce {
         #[from]
         source: TryFromSliceError,
     },
-    #[error("Header length must be {MIX_PARAMS_LEN}, got {0}")]
-    InvalidHeaderLength(usize),
 }

nym-outfox/src/format.rs

@@ -66,77 +66,44 @@ use sphinx_packet::route::Node;
 
 use std::convert::TryInto;
 
+const GROUPELEMENTBYTES: usize = 32;
+const TAGBYTES: usize = 16;
+
 use std::ops::Range;
 use std::u8;
 
-use crate::constants::groupelementbytes;
-use crate::constants::tagbytes;
-use crate::constants::DEFAULT_HOPS;
-use crate::constants::DEFAULT_ROUTING_INFO_SIZE;
-use crate::constants::GROUPELEMENTBYTES;
-use crate::constants::MIX_PARAMS_LEN;
-use crate::constants::TAGBYTES;
 use crate::error::OutfoxError;
 use crate::lion::*;
-use std::convert::TryFrom;
 
 /// A structure that holds mix packet construction parameters. These incluse the length
 /// of the routing information at each hop, the number of hops, and the payload length.
-#[derive(Eq, PartialEq, Debug)]
 pub struct MixCreationParameters {
     /// The routing length is inner first, so \[0\] is the innermost routing length, etc (in bytes)
-    /// In our stratified topology this will always be 4
-    pub routing_information_length_by_stage: [u8; DEFAULT_HOPS],
+    pub routing_information_length_by_stage: Vec<usize>,
     /// The payload length (in bytes)
-    pub payload_length_bytes: u16,
-}
-
-impl TryFrom<&[u8]> for MixCreationParameters {
-    type Error = OutfoxError;
-
-    fn try_from(v: &[u8]) -> Result<Self, Self::Error> {
-        if v.len() != MIX_PARAMS_LEN {
-            return Err(OutfoxError::InvalidHeaderLength(v.len()));
-        }
-        let (routing, payload) = v.split_at(DEFAULT_HOPS);
-        Ok(MixCreationParameters {
-            routing_information_length_by_stage: routing.try_into()?,
-            payload_length_bytes: u16::from_le_bytes(payload.try_into()?),
-        })
-    }
+    pub payload_length_bytes: usize,
 }
 
 impl MixCreationParameters {
-    pub fn to_bytes(&self) -> Vec<u8> {
-        let mut bytes = Vec::with_capacity(5);
-        bytes.extend_from_slice(self.routing_information_length_by_stage.as_slice());
-        bytes.extend_from_slice(&self.payload_length_bytes.to_le_bytes());
-        bytes
-    }
-
-    pub fn payload_length_bytes(&self) -> usize {
-        self.payload_length_bytes as usize
-    }
-
     /// Create a set of parameters for a mix packet format.
-    pub fn new(payload_length_bytes: u16) -> MixCreationParameters {
+    pub fn new(payload_length_bytes: usize) -> MixCreationParameters {
         MixCreationParameters {
-            routing_information_length_by_stage: [DEFAULT_ROUTING_INFO_SIZE; DEFAULT_HOPS],
+            routing_information_length_by_stage: Vec::new(),
             payload_length_bytes,
         }
     }
 
     /// Add another outer layer containing some byte length of routing data.
-    // pub fn add_outer_layer(&mut self, routing_information_length_bytes: usize) {
-    //     self.routing_information_length_by_stage
-    //         .push(routing_information_length_bytes);
-    // }
+    pub fn add_outer_layer(&mut self, routing_information_length_bytes: usize) {
+        self.routing_information_length_by_stage
+            .push(routing_information_length_bytes);
+    }
 
     /// The length of the buffer needed to build a packet.
     pub fn total_packet_length(&self) -> usize {
-        let mut len = self.payload_length_bytes();
+        let mut len = self.payload_length_bytes;
         for stage_len in &self.routing_information_length_by_stage {
-            len += *stage_len as usize + groupelementbytes() + tagbytes()
+            len += stage_len + GROUPELEMENTBYTES + TAGBYTES
         }
         len
     }
@@ -159,7 +126,7 @@ impl MixCreationParameters {
 
                 return (total_size - inner_size..total_size, params);
             } else {
-                remaining_header_length_bytes += (stage_len + GROUPELEMENTBYTES + TAGBYTES) as u16;
+                remaining_header_length_bytes += stage_len + GROUPELEMENTBYTES + TAGBYTES;
             }
         }
 
@@ -170,59 +137,47 @@ impl MixCreationParameters {
 /// A structure representing the parameters of a single stage of mixing.
 pub struct MixStageParameters {
     /// The routing information length for this stage of mixing
-    pub routing_information_length_bytes: u8,
+    pub routing_information_length_bytes: usize,
     /// The reamining header length for this stage of mixing
-    pub remaining_header_length_bytes: u16,
+    pub remaining_header_length_bytes: usize,
     /// The payload length
-    pub payload_length_bytes: u16,
+    pub payload_length_bytes: usize,
 }
 
 impl MixStageParameters {
-    pub fn routing_information_length_bytes(&self) -> usize {
-        self.routing_information_length_bytes as usize
-    }
-
-    pub fn remaining_header_length_bytes(&self) -> usize {
-        self.remaining_header_length_bytes as usize
-    }
-
-    pub fn payload_length_bytes(&self) -> usize {
-        self.payload_length_bytes as usize
-    }
-
     pub fn incoming_packet_length(&self) -> usize {
-        groupelementbytes() + tagbytes() + self.outgoing_packet_length()
+        GROUPELEMENTBYTES + TAGBYTES + self.outgoing_packet_length()
     }
 
     pub fn outgoing_packet_length(&self) -> usize {
-        self.routing_information_length_bytes()
-            + self.remaining_header_length_bytes()
-            + self.payload_length_bytes()
+        self.routing_information_length_bytes
+            + self.remaining_header_length_bytes
+            + self.payload_length_bytes
     }
 
     pub fn pub_element_range(&self) -> Range<usize> {
-        0..groupelementbytes()
+        0..GROUPELEMENTBYTES
     }
 
     pub fn tag_range(&self) -> Range<usize> {
-        groupelementbytes()..groupelementbytes() + tagbytes()
+        GROUPELEMENTBYTES..GROUPELEMENTBYTES + TAGBYTES
     }
 
     pub fn routing_data_range(&self) -> Range<usize> {
-        groupelementbytes() + tagbytes()
-            ..groupelementbytes() + tagbytes() + self.routing_information_length_bytes()
+        GROUPELEMENTBYTES + TAGBYTES
+            ..GROUPELEMENTBYTES + TAGBYTES + self.routing_information_length_bytes
     }
 
     pub fn header_range(&self) -> Range<usize> {
-        groupelementbytes() + tagbytes()
-            ..groupelementbytes()
-                + tagbytes()
-                + self.routing_information_length_bytes()
-                + self.remaining_header_length_bytes()
+        GROUPELEMENTBYTES + TAGBYTES
+            ..GROUPELEMENTBYTES
+                + TAGBYTES
+                + self.routing_information_length_bytes
+                + self.remaining_header_length_bytes
     }
 
     pub fn payload_range(&self) -> Range<usize> {
-        self.incoming_packet_length() - self.payload_length_bytes()..self.incoming_packet_length()
+        self.incoming_packet_length() - self.payload_length_bytes..self.incoming_packet_length()
     }
 
     pub fn encode_mix_layer(
@@ -242,10 +197,10 @@ impl MixStageParameters {
             });
         }
 
-        if routing_data.len() != self.routing_information_length_bytes() {
+        if routing_data.len() != self.routing_information_length_bytes {
             return Err(OutfoxError::LenMismatch {
                 expected: routing_data.len(),
-                got: self.routing_information_length_bytes(),
+                got: self.routing_information_length_bytes,
             });
         }
 
@@ -317,25 +272,3 @@ impl MixStageParameters {
         Ok(shared_key)
     }
 }
-
-#[cfg(test)]
-mod test {
-    use super::MixCreationParameters;
-    use std::convert::TryFrom;
-
-    #[test]
-    fn test_to_bytes() {
-        let mix_params = MixCreationParameters::new(1024);
-        assert_eq!(mix_params.to_bytes(), vec![32, 32, 32, 32, 0, 4])
-    }
-
-    #[test]
-    fn test_from_bytes() {
-        let params_bytes = vec![32, 32, 32, 32, 0, 4];
-        let mix_params = MixCreationParameters::new(1024);
-        assert_eq!(
-            mix_params,
-            MixCreationParameters::try_from(params_bytes.as_slice()).unwrap()
-        )
-    }
-}

nym-outfox/src/lib.rs

@@ -1,4 +1,3 @@
-pub mod constants;
 pub mod error;
 pub mod format;
 pub mod lion;

nym-outfox/src/lion.rs

@@ -36,9 +36,12 @@ use chacha20::XChaCha20;
 use chacha20::XNonce;
 use zeroize::Zeroize;
 
-use crate::constants::{CONTEXT, MIN_MESSAGE_LEN, TAG_LEN};
 use crate::error::OutfoxError;
 
+pub const MIN_MESSAGE_LEN: usize = 24 * 2;
+const CONTEXT: &str = "LIONKEYS";
+const TAG_LEN: usize = 24;
+
 /// The lion transform encryption function.
 ///
 /// The `key` must be 32 bytes, and the `message` >= 48. The message is

nym-outfox/src/packet.rs

@@ -1,65 +1,38 @@
-use std::{convert::TryFrom, ops::Range};
+use std::ops::Range;
 
 use crate::{
-    constants::{DEFAULT_HOPS, MIX_PARAMS_LEN},
     error::OutfoxError,
     format::{MixCreationParameters, MixStageParameters},
 };
 
-use rand::{rngs::OsRng, RngCore};
 use sphinx_packet::{packet::builder::DEFAULT_PAYLOAD_SIZE, route::Node};
 
-#[derive(Debug)]
 pub struct OutfoxPacket {
     mix_params: MixCreationParameters,
     payload: Vec<u8>,
 }
 
-impl TryFrom<&[u8]> for OutfoxPacket {
-    type Error = OutfoxError;
-
-    fn try_from(v: &[u8]) -> Result<Self, Self::Error> {
-        let (header, payload) = v.split_at(MIX_PARAMS_LEN);
-        Ok(OutfoxPacket {
-            mix_params: MixCreationParameters::try_from(header)?,
-            payload: payload.to_vec(),
-        })
-    }
-}
+pub const DEFAULT_ROUTING_INFO_SIZE: usize = 32;
 
 impl OutfoxPacket {
-    pub fn len(&self) -> usize {
-        self.mix_params().total_packet_length()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    pub fn to_bytes(&self) -> Result<Vec<u8>, OutfoxError> {
-        let mut bytes = vec![];
-        bytes.extend(self.mix_params.to_bytes());
-        bytes.extend(self.payload.as_slice());
-        Ok(bytes)
-    }
-
-    pub fn build<M: AsRef<[u8]>>(
-        payload: M,
-        route: &[Node; 4],
-        packet_size: Option<usize>,
+    pub fn build(
+        payload: &[u8],
+        route: &[Node; 3],
+        user_secret_key: &[u8],
     ) -> Result<OutfoxPacket, OutfoxError> {
-        let mut secret_key = [0; 32];
-        OsRng.fill_bytes(&mut secret_key);
-        let packet_size = packet_size.unwrap_or(DEFAULT_PAYLOAD_SIZE);
-        let mix_params = MixCreationParameters::new(packet_size as u16);
+        let mut mix_params = MixCreationParameters::new(DEFAULT_PAYLOAD_SIZE);
 
-        let padding = mix_params.total_packet_length() - payload.as_ref().len();
+        for node in route.iter() {
+            mix_params.add_outer_layer(node.address.as_bytes_ref().len());
+        }
+
+        let padding = mix_params.total_packet_length() - payload.len();
         let mut buffer = vec![0; padding];
-        buffer.extend_from_slice(payload.as_ref());
+        buffer.extend_from_slice(payload);
 
         for (idx, node) in route.iter().rev().enumerate() {
             let (range, stage_params) = mix_params.get_stage_params(idx);
-            stage_params.encode_mix_layer(&mut buffer[range], &secret_key, node)?;
+            stage_params.encode_mix_layer(&mut buffer[range], user_secret_key, node)?;
         }
 
         Ok(OutfoxPacket {
@@ -81,7 +54,7 @@ impl OutfoxPacket {
     }
 
     pub fn payload_range(&self) -> Range<usize> {
-        self.stage_params(DEFAULT_HOPS - 1).1.payload_range()
+        self.stage_params(2).1.payload_range()
     }
 
     pub fn payload_mut(&mut self) -> &mut [u8] {

nym-outfox/tests/unittests.rs

@@ -3,25 +3,25 @@ extern crate nym_outfox;
 #[cfg(test)]
 mod tests {
 
-    use std::iter::repeat_with;
-
-    pub fn randombytes(n: usize) -> Vec<u8> {
-        repeat_with(|| fastrand::u8(..)).take(n).collect()
-    }
-
     use curve25519_dalek::constants::ED25519_BASEPOINT_TABLE;
     use curve25519_dalek::scalar::Scalar;
     use nym_outfox::packet::OutfoxPacket;
     use sphinx_packet::constants::NODE_ADDRESS_LENGTH;
     use sphinx_packet::crypto::PublicKey;
+    use sphinx_packet::packet::builder::DEFAULT_PAYLOAD_SIZE;
     use sphinx_packet::route::Node;
     use sphinx_packet::route::NodeAddressBytes;
-    use std::convert::TryFrom;
     use std::convert::TryInto;
 
     use nym_outfox::format::*;
     use nym_outfox::lion::*;
 
+    use std::iter::repeat_with;
+
+    pub fn randombytes(n: usize) -> Vec<u8> {
+        repeat_with(|| fastrand::u8(..)).take(n).collect()
+    }
+
     #[test]
     fn test_encode_decode() {
         let mix_params = MixStageParameters {
@@ -81,6 +81,8 @@ mod tests {
 
     #[test]
     fn test_packet_params() {
+        let user_secret = randombytes(32);
+
         let (node1_pk, node1_pub) = sphinx_packet::crypto::keygen();
         let node1 = Node::new(
             NodeAddressBytes::from_bytes([0u8; NODE_ADDRESS_LENGTH]),
@@ -97,30 +99,15 @@ mod tests {
             node3_pub,
         );
 
-        let (node4_pk, node4_pub) = sphinx_packet::crypto::keygen();
-        let node4 = Node::new(
-            NodeAddressBytes::from_bytes([3u8; NODE_ADDRESS_LENGTH]),
-            node4_pub,
-        );
+        let route = [node1, node2, node3];
 
-        let route = [node1, node2, node3, node4];
+        let payload = randombytes(DEFAULT_PAYLOAD_SIZE);
 
-        let payload = randombytes(2048);
+        let mut packet = OutfoxPacket::build(&payload, &route, &user_secret).unwrap();
 
-        let packet = OutfoxPacket::build(&payload, &route, Some(2048)).unwrap();
-        let packet_bytes = packet.to_bytes().unwrap();
-        println!(
-            "packet bytes length, {}, declared {}",
-            packet_bytes.len(),
-            packet.len()
-        );
-
-        let mut packet = OutfoxPacket::try_from(packet_bytes.as_slice()).unwrap();
-
-        packet.decode_mix_layer(3, &node1_pk.to_bytes()).unwrap();
-        packet.decode_mix_layer(2, &node2_pk.to_bytes()).unwrap();
-        packet.decode_mix_layer(1, &node3_pk.to_bytes()).unwrap();
-        packet.decode_mix_layer(0, &node4_pk.to_bytes()).unwrap();
+        packet.decode_mix_layer(2, &node1_pk.to_bytes()).unwrap();
+        packet.decode_mix_layer(1, &node2_pk.to_bytes()).unwrap();
+        packet.decode_mix_layer(0, &node3_pk.to_bytes()).unwrap();
 
         assert_eq!(payload, &packet.payload()[packet.payload_range()]);
     }

nym-wallet/Cargo.lock

@@ -23,16 +23,6 @@ dependencies = [
  "generic-array 0.14.6",
 ]
 
-[[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"
@@ -40,7 +30,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9e8b47f52ea9bae42228d07ec09eb676433d7c4ed1ebdf0f1d1c29ed446f1ab8"
 dependencies = [
  "cfg-if",
- "cipher 0.3.0",
+ "cipher",
  "cpufeatures",
  "ctr",
  "opaque-debug 0.3.0",
@@ -52,9 +42,9 @@ version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df5f85a83a7d8b0442b6aa7b504b8212c1733da07b98aae43d4bc21b2cb3cdf6"
 dependencies = [
- "aead 0.4.3",
+ "aead",
  "aes",
- "cipher 0.3.0",
+ "cipher",
  "ctr",
  "ghash",
  "subtle 2.4.1",
@@ -129,12 +119,6 @@ version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544"
 
-[[package]]
-name = "arrayvec"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
-
 [[package]]
 name = "async-trait"
 version = "0.1.64"
@@ -304,20 +288,6 @@ dependencies = [
  "digest 0.10.6",
 ]
 
-[[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.6",
-]
-
 [[package]]
 name = "block"
 version = "0.1.6"
@@ -526,30 +496,6 @@ 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 0.5.2",
- "chacha20",
- "cipher 0.4.4",
- "poly1305",
- "zeroize",
-]
-
 [[package]]
 name = "cipher"
 version = "0.3.0"
@@ -559,17 +505,6 @@ 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 = "clap"
 version = "4.1.4"
@@ -701,12 +636,6 @@ version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e4c78c047431fee22c1a7bb92e00ad095a02a983affe4d8a72e2a2c62c1b94f3"
 
-[[package]]
-name = "constant_time_eq"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13418e745008f7349ec7e449155f419a61b92b58a99cc3616942b926825ec76b"
-
 [[package]]
 name = "convert_case"
 version = "0.4.0"
@@ -853,30 +782,6 @@ dependencies = [
  "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 0.8.0",
- "scopeguard",
-]
-
 [[package]]
 name = "crossbeam-utils"
 version = "0.8.14"
@@ -911,7 +816,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
  "generic-array 0.14.6",
- "rand_core 0.6.4",
  "typenum",
 ]
 
@@ -987,7 +891,7 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "049bb91fb4aaf0e3c7efa6cd5ef877dbbbd15b39dad06d9948de4ec8a75761ea"
 dependencies = [
- "cipher 0.3.0",
+ "cipher",
 ]
 
 [[package]]
@@ -1438,7 +1342,7 @@ version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e1c54951450cbd39f3dbcf1005ac413b49487dabf18a720ad2383eccfeffb92"
 dependencies = [
- "memoffset 0.6.5",
+ "memoffset",
  "rustc_version 0.3.3",
 ]
 
@@ -2335,15 +2239,6 @@ dependencies = [
  "cfb",
 ]
 
-[[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"
@@ -2678,15 +2573,6 @@ dependencies = [
  "autocfg",
 ]
 
-[[package]]
-name = "memoffset"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d61c719bcfbcf5d62b3a09efa6088de8c54bc0bfcd3ea7ae39fcc186108b8de1"
-dependencies = [
- "autocfg",
-]
-
 [[package]]
 name = "mime"
 version = "0.3.16"
@@ -3073,22 +2959,6 @@ dependencies = [
  "url",
 ]
 
-[[package]]
-name = "nym-outfox"
-version = "0.1.0"
-dependencies = [
- "blake3",
- "chacha20",
- "chacha20poly1305",
- "curve25519-dalek",
- "getrandom 0.2.8",
- "rand 0.7.3",
- "rayon",
- "sphinx-packet",
- "thiserror",
- "zeroize",
-]
-
 [[package]]
 name = "nym-pemstore"
 version = "0.2.0"
@@ -3100,9 +2970,7 @@ dependencies = [
 name = "nym-sphinx-types"
 version = "0.2.0"
 dependencies = [
- "nym-outfox",
  "sphinx-packet",
- "thiserror",
 ]
 
 [[package]]
@@ -3774,17 +3642,6 @@ dependencies = [
  "miniz_oxide",
 ]
 
-[[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 0.5.0",
-]
-
 [[package]]
 name = "polyval"
 version = "0.5.3"
@@ -3794,7 +3651,7 @@ dependencies = [
  "cfg-if",
  "cpufeatures",
  "opaque-debug 0.3.0",
- "universal-hash 0.4.1",
+ "universal-hash",
 ]
 
 [[package]]
@@ -4037,28 +3894,6 @@ dependencies = [
  "cty",
 ]
 
-[[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.2.16"
@@ -5606,16 +5441,6 @@ dependencies = [
  "subtle 2.4.1",
 ]
 
-[[package]]
-name = "universal-hash"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d3160b73c9a19f7e2939a2fdad446c57c1bbbbf4d919d3213ff1267a580d8b5"
-dependencies = [
- "crypto-common",
- "subtle 2.4.1",
-]
-
 [[package]]
 name = "untrusted"
 version = "0.7.1"

nym-wallet/src-tauri/src/error.rs

@@ -94,12 +94,6 @@ pub enum BackendError {
     WalletFileAlreadyExists,
     #[error("The wallet file is not found")]
     WalletFileNotFound,
-    #[error("Invalid update pledge request, the new bond amount is the same as the current one")]
-    WalletPledgeUpdateNoOp,
-    #[error(
-        "Invalid update pledge request, the new bond is a different currency from the current one"
-    )]
-    WalletPledgeUpdateInvalidCurrency,
     #[error("The wallet file has a malformed name")]
     WalletFileMalformedFilename,
     #[error("Unable to archive wallet file")]

nym-wallet/src-tauri/src/main.rs

@@ -58,7 +58,6 @@ fn main() {
             mixnet::admin::update_contract_settings,
             mixnet::bond::bond_gateway,
             mixnet::bond::bond_mixnode,
-            mixnet::bond::update_pledge,
             mixnet::bond::pledge_more,
             mixnet::bond::decrease_pledge,
             mixnet::bond::gateway_bond_details,
@@ -115,7 +114,6 @@ fn main() {
             vesting::rewards::vesting_claim_operator_reward,
             vesting::bond::vesting_bond_gateway,
             vesting::bond::vesting_bond_mixnode,
-            vesting::bond::vesting_update_pledge,
             vesting::bond::vesting_pledge_more,
             vesting::bond::vesting_decrease_pledge,
             vesting::bond::vesting_unbond_gateway,
@@ -154,7 +152,6 @@ fn main() {
             simulate::mixnet::simulate_bond_gateway,
             simulate::mixnet::simulate_unbond_gateway,
             simulate::mixnet::simulate_bond_mixnode,
-            simulate::mixnet::simulate_update_pledge,
             simulate::mixnet::simulate_pledge_more,
             simulate::mixnet::simulate_unbond_mixnode,
             simulate::mixnet::simulate_update_mixnode_config,
@@ -167,7 +164,6 @@ fn main() {
             simulate::vesting::simulate_vesting_bond_gateway,
             simulate::vesting::simulate_vesting_unbond_gateway,
             simulate::vesting::simulate_vesting_bond_mixnode,
-            simulate::vesting::simulate_vesting_update_pledge,
             simulate::vesting::simulate_vesting_pledge_more,
             simulate::vesting::simulate_vesting_unbond_mixnode,
             simulate::vesting::simulate_vesting_update_mixnode_config,

nym-wallet/src-tauri/src/operations/mixnet/bond.rs

@@ -17,7 +17,6 @@ use nym_types::transaction::TransactionExecuteResult;
 use nym_validator_client::nyxd::traits::{MixnetQueryClient, MixnetSigningClient};
 use nym_validator_client::nyxd::Fee;
 use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
 use std::time::Duration;
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -134,55 +133,6 @@ pub async fn bond_mixnode(
     )?)
 }
 
-#[tauri::command]
-pub async fn update_pledge(
-    current_pledge: DecCoin,
-    new_pledge: DecCoin,
-    fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
-) -> Result<TransactionExecuteResult, BackendError> {
-    let guard = state.read().await;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
-    let dec_delta = guard.calculate_coin_delta(&current_pledge, &new_pledge)?;
-    let delta = guard.attempt_convert_to_base_coin(dec_delta.clone())?;
-    log::info!(
-        ">>> Pledge update, current pledge {}, new pledge {}",
-        &current_pledge,
-        &new_pledge,
-    );
-
-    let res = match new_pledge.amount.cmp(&current_pledge.amount) {
-        Ordering::Greater => {
-            log::info!(
-                "Pledge increase, calculated additional pledge {}, fee = {:?}",
-                &dec_delta,
-                fee,
-            );
-            guard.current_client()?.nyxd.pledge_more(delta, fee).await?
-        }
-        Ordering::Less => {
-            log::info!(
-                "Pledge reduction, calculated reduction pledge {}, fee = {:?}",
-                &dec_delta,
-                fee,
-            );
-            guard
-                .current_client()?
-                .nyxd
-                .decrease_pledge(delta, fee)
-                .await?
-        }
-        Ordering::Equal => return Err(BackendError::WalletPledgeUpdateNoOp),
-    };
-
-    log::info!("<<< tx hash = {}", res.transaction_hash);
-    log::trace!("<<< {:?}", res);
-
-    Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
-    )?)
-}
-
 #[tauri::command]
 pub async fn pledge_more(
     fee: Option<Fee>,

nym-wallet/src-tauri/src/operations/simulate/mixnet.rs

@@ -1,8 +1,6 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use std::cmp::Ordering;
-
 use crate::error::BackendError;
 use crate::operations::simulate::FeeDetails;
 use crate::WalletState;
@@ -95,48 +93,6 @@ pub async fn simulate_pledge_more(
     simulate_mixnet_operation(ExecuteMsg::PledgeMore {}, Some(additional_pledge), &state).await
 }
 
-#[tauri::command]
-pub async fn simulate_update_pledge(
-    current_pledge: DecCoin,
-    new_pledge: DecCoin,
-    state: tauri::State<'_, WalletState>,
-) -> Result<FeeDetails, BackendError> {
-    let guard = state.read().await;
-    let dec_delta = guard.calculate_coin_delta(&current_pledge, &new_pledge)?;
-    log::info!(
-        ">>> Simulate pledge update, current pledge {}, new pledge {}",
-        &current_pledge,
-        &new_pledge,
-    );
-
-    match new_pledge.amount.cmp(&current_pledge.amount) {
-        Ordering::Greater => {
-            log::info!(
-                "Simulate pledge increase, calculated additional pledge {}",
-                dec_delta,
-            );
-            simulate_mixnet_operation(ExecuteMsg::PledgeMore {}, Some(dec_delta), &state).await
-        }
-        Ordering::Less => {
-            log::info!(
-                "Simulate pledge reduction, calculated reduction pledge {}",
-                dec_delta,
-            );
-            simulate_mixnet_operation(
-                ExecuteMsg::DecreasePledge {
-                    decrease_by: guard
-                        .attempt_convert_to_base_coin(dec_delta.clone())?
-                        .into(),
-                },
-                Some(dec_delta),
-                &state,
-            )
-            .await
-        }
-        Ordering::Equal => Err(BackendError::WalletPledgeUpdateNoOp),
-    }
-}
-
 #[tauri::command]
 pub async fn simulate_unbond_mixnode(
     state: tauri::State<'_, WalletState>,

nym-wallet/src-tauri/src/operations/simulate/vesting.rs

@@ -1,8 +1,6 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use std::cmp::Ordering;
-
 use crate::error::BackendError;
 use crate::operations::simulate::FeeDetails;
 use crate::WalletState;
@@ -94,59 +92,6 @@ pub async fn simulate_vesting_bond_mixnode(
     .await
 }
 
-#[tauri::command]
-pub async fn simulate_vesting_update_pledge(
-    current_pledge: DecCoin,
-    new_pledge: DecCoin,
-    state: tauri::State<'_, WalletState>,
-) -> Result<FeeDetails, BackendError> {
-    let guard = state.read().await;
-
-    match new_pledge.amount.cmp(&current_pledge.amount) {
-        Ordering::Greater => {
-            let additional_pledge = guard
-                .attempt_convert_to_base_coin(DecCoin {
-                    amount: new_pledge.amount - current_pledge.amount,
-                    denom: current_pledge.denom,
-                })?
-                .into();
-            log::info!(
-                ">>> Simulate pledge more, calculated additional pledge {}",
-                additional_pledge,
-            );
-            simulate_vesting_operation(
-                ExecuteMsg::PledgeMore {
-                    amount: additional_pledge,
-                },
-                None,
-                &state,
-            )
-            .await
-        }
-        Ordering::Less => {
-            let decrease_pledge = guard
-                .attempt_convert_to_base_coin(DecCoin {
-                    amount: current_pledge.amount - new_pledge.amount,
-                    denom: current_pledge.denom,
-                })?
-                .into();
-            log::info!(
-                ">>> Simulate decrease pledge, calculated decrease pledge {}",
-                decrease_pledge,
-            );
-            simulate_vesting_operation(
-                ExecuteMsg::DecreasePledge {
-                    amount: decrease_pledge,
-                },
-                None,
-                &state,
-            )
-            .await
-        }
-        Ordering::Equal => Err(BackendError::WalletPledgeUpdateNoOp),
-    }
-}
-
 #[tauri::command]
 pub async fn simulate_vesting_pledge_more(
     additional_pledge: DecCoin,

nym-wallet/src-tauri/src/operations/vesting/bond.rs

@@ -1,5 +1,3 @@
-use std::cmp::Ordering;
-
 use crate::error::BackendError;
 use crate::nyxd_client;
 use crate::state::WalletState;
@@ -126,59 +124,6 @@ pub async fn vesting_bond_mixnode(
     )?)
 }
 
-#[tauri::command]
-pub async fn vesting_update_pledge(
-    current_pledge: DecCoin,
-    new_pledge: DecCoin,
-    fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
-) -> Result<TransactionExecuteResult, BackendError> {
-    let guard = state.read().await;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
-    let dec_delta = guard.calculate_coin_delta(&current_pledge, &new_pledge)?;
-    let delta = guard.attempt_convert_to_base_coin(dec_delta.clone())?;
-    log::info!(
-        ">>> Pledge update, current pledge {}, new pledge {}",
-        &current_pledge,
-        &new_pledge,
-    );
-
-    let res = match new_pledge.amount.cmp(&current_pledge.amount) {
-        Ordering::Greater => {
-            log::info!(
-                "Pledge increase with locked tokens, calculated additional pledge {}, fee = {:?}",
-                dec_delta,
-                fee,
-            );
-            guard
-                .current_client()?
-                .nyxd
-                .vesting_pledge_more(delta, fee)
-                .await?
-        }
-        Ordering::Less => {
-            log::info!(
-                "Pledge reduction with locked tokens, calculated reduction pledge {}, fee = {:?}",
-                dec_delta,
-                fee,
-            );
-            guard
-                .current_client()?
-                .nyxd
-                .vesting_decrease_pledge(delta, fee)
-                .await?
-        }
-        Ordering::Equal => return Err(BackendError::WalletPledgeUpdateNoOp),
-    };
-
-    log::info!("<<< tx hash = {}", res.transaction_hash);
-    log::trace!("<<< {:?}", res);
-
-    Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
-    )?)
-}
-
 #[tauri::command]
 pub async fn vesting_pledge_more(
     fee: Option<Fee>,

nym-wallet/src-tauri/src/state.rs

@@ -449,34 +449,6 @@ impl WalletStateInner {
     pub fn remove_validator_url(&mut self, url: config::ValidatorConfigEntry, network: Network) {
         self.config.remove_validator_url(url, network)
     }
-
-    pub fn calculate_coin_delta(
-        &self,
-        coin1: &DecCoin,
-        coin2: &DecCoin,
-    ) -> Result<DecCoin, BackendError> {
-        if coin1.denom != coin2.denom {
-            return Err(BackendError::WalletPledgeUpdateInvalidCurrency);
-        }
-
-        match coin1.amount.cmp(&coin2.amount) {
-            std::cmp::Ordering::Greater => {
-                let delta = DecCoin {
-                    amount: coin1.amount - coin2.amount,
-                    denom: coin1.denom.clone(),
-                };
-                Ok(delta)
-            }
-            std::cmp::Ordering::Less => {
-                let delta = DecCoin {
-                    amount: coin2.amount - coin1.amount,
-                    denom: coin1.denom.clone(),
-                };
-                Ok(delta)
-            }
-            std::cmp::Ordering::Equal => Ok(coin1.to_owned()),
-        }
-    }
 }
 
 async fn fetch_status_for_urls(

nym-wallet/src/components/Bonding/BondedMixnodeActions.tsx

@@ -3,16 +3,16 @@ import { Typography } from '@mui/material';
 import { ActionsMenu, ActionsMenuItem } from 'src/components/ActionsMenu';
 import { Unbond as UnbondIcon, Bond as BondIcon } from '../../svg-icons';
 
-export type TBondedMixnodeActions = 'nodeSettings' | 'updateBond' | 'unbond' | 'redeem';
+export type TBondedMixnodeActions = 'nodeSettings' | 'bondMore' | 'unbond' | 'redeem';
 
 export const BondedMixnodeActions = ({
   onActionSelect,
   disabledRedeemAndCompound,
-  disabledUpdateBond,
+  disabledBondMore,
 }: {
   onActionSelect: (action: TBondedMixnodeActions) => void;
   disabledRedeemAndCompound: boolean;
-  disabledUpdateBond?: boolean;
+  disabledBondMore?: boolean;
 }) => {
   const [isOpen, setIsOpen] = useState(false);
 
@@ -26,11 +26,11 @@ export const BondedMixnodeActions = ({
 
   return (
     <ActionsMenu open={isOpen} onOpen={handleOpen} onClose={handleClose}>
-      {!disabledUpdateBond && (
+      {!disabledBondMore && (
         <ActionsMenuItem
-          title="Change bond amount"
+          title="Bond More"
           Icon={<BondIcon fontSize="inherit" />}
-          onClick={() => handleActionClick('updateBond')}
+          onClick={() => handleActionClick('bondMore')}
         />
       )}
       <ActionsMenuItem

nym-wallet/src/components/Bonding/modals/BondMoreModal.tsx

@@ -0,0 +1,116 @@
+import React, { useEffect, useState } from 'react';
+import { Box, Stack } from '@mui/material';
+import { CurrencyFormField } from '@nymproject/react/currency/CurrencyFormField';
+import { ModalListItem } from 'src/components/Modals/ModalListItem';
+import { SimpleModal } from 'src/components/Modals/SimpleModal';
+import { DecCoin } from '@nymproject/types';
+import { TPoolOption } from 'src/components/TokenPoolSelector';
+import { ConfirmTx } from 'src/components/ConfirmTX';
+import { useGetFee } from 'src/hooks/useGetFee';
+import { validateAmount } from 'src/utils';
+import { simulateBondMore, simulateVestingBondMore } from 'src/requests';
+import { TBondMoreArgs } from 'src/types';
+import { TBondedMixnode } from 'src/context';
+
+export const BondMoreModal = ({
+  node,
+  userBalance,
+  onBondMore,
+  onClose,
+  onError,
+}: {
+  node: TBondedMixnode;
+  userBalance?: string;
+  onBondMore: (data: TBondMoreArgs, tokenPool: TPoolOption) => Promise<void>;
+  onClose: () => void;
+  onError: (e: string) => void;
+}) => {
+  const { bond: currentBond, proxy } = node;
+  const { fee, getFee, resetFeeState, feeError } = useGetFee();
+  const [additionalBond, setAdditionalBond] = useState<DecCoin>({ amount: '0', denom: currentBond.denom });
+  const [errorAmount, setErrorAmount] = useState(false);
+
+  useEffect(() => {
+    if (feeError) {
+      onError(feeError);
+    }
+  }, [feeError]);
+
+  const handleConfirm = async () => {
+    const data = { additionalPledge: additionalBond };
+    const tokenPool = proxy ? 'locked' : 'balance';
+    await onBondMore(data, tokenPool);
+  };
+
+  const handleAmountChanged = async (value: DecCoin) => {
+    setAdditionalBond(value);
+    const { amount } = value;
+
+    if (!amount) {
+      setErrorAmount(true);
+    } else {
+      const validAmount = await validateAmount(amount, '1');
+      if (!validAmount) {
+        setErrorAmount(true);
+        return;
+      }
+      setErrorAmount(false);
+    }
+  };
+
+  const handleOnOk = async () => {
+    if (!proxy) {
+      await getFee<TBondMoreArgs>(simulateBondMore, { additionalPledge: additionalBond });
+    } else {
+      await getFee<TBondMoreArgs>(simulateVestingBondMore, { additionalPledge: additionalBond });
+    }
+  };
+
+  if (fee)
+    return (
+      <ConfirmTx
+        open
+        header="Bond more details"
+        fee={fee}
+        onClose={onClose}
+        onPrev={resetFeeState}
+        onConfirm={handleConfirm}
+      >
+        <ModalListItem label="Current bond" value={`${currentBond.amount} ${currentBond.denom}`} divider />
+        <ModalListItem label="Additional bond" value={`${additionalBond?.amount} ${additionalBond?.denom}`} divider />
+      </ConfirmTx>
+    );
+
+  return (
+    <SimpleModal
+      open
+      header="Bond more"
+      subHeader="Bond more tokens on your node and receive more rewards"
+      okLabel="Next"
+      onOk={handleOnOk}
+      okDisabled={errorAmount}
+      onClose={onClose}
+    >
+      <Stack gap={3}>
+        <Box display="flex" gap={1}>
+          <CurrencyFormField
+            autoFocus
+            label="Bond amount"
+            denom={currentBond.denom}
+            onChanged={(value) => {
+              handleAmountChanged(value);
+            }}
+            fullWidth
+            validationError={errorAmount ? 'Please enter a valid amount' : undefined}
+          />
+        </Box>
+
+        <Box>
+          <ModalListItem label="Account balance" value={userBalance?.toUpperCase() || '-'} divider />
+          <ModalListItem label="Current bond" value={`${currentBond.amount} ${currentBond.denom}`} divider />
+          <ModalListItem label="Est. fee for this operation will be calculated in the next page" value="" divider />
+        </Box>
+      </Stack>
+    </SimpleModal>
+  );
+};

nym-wallet/src/components/Bonding/modals/BondOversaturatedModal.tsx

@@ -12,8 +12,8 @@ export const BondOversaturatedModal: FCWithChildren<{
     open={open}
     onClose={onClose}
     onOk={async () => onContinue?.()}
-    header="Change bond amount"
-    okLabel="Change bond"
+    header="Bond More"
+    okLabel="Bond More"
     buttonFullWidth
   >
     <Stack spacing={3} marginBottom={3}>

nym-wallet/src/components/Bonding/modals/UpdateBondAmountModal.tsx

@@ -1,157 +0,0 @@
-import React, { useContext, useEffect, useState } from 'react';
-import { Box, Stack } from '@mui/material';
-import Big from 'big.js';
-import { CurrencyFormField } from '@nymproject/react/currency/CurrencyFormField';
-import { ModalListItem } from 'src/components/Modals/ModalListItem';
-import { SimpleModal } from 'src/components/Modals/SimpleModal';
-import { DecCoin } from '@nymproject/types';
-import { ConfirmTx } from 'src/components/ConfirmTX';
-import { useGetFee } from 'src/hooks/useGetFee';
-import { decCoinToDisplay, validateAmount } from 'src/utils';
-import { simulateUpdateBond, simulateVestingUpdateBond } from 'src/requests';
-import { TSimulateUpdateBondArgs, TUpdateBondArgs } from 'src/types';
-import { AppContext, TBondedMixnode } from 'src/context';
-import { TPoolOption } from '../../TokenPoolSelector';
-
-export const UpdateBondAmountModal = ({
-  node,
-  onUpdateBond,
-  onClose,
-  onError,
-}: {
-  node: TBondedMixnode;
-  onUpdateBond: (data: TUpdateBondArgs, tokenPool: TPoolOption) => Promise<void>;
-  onClose: () => void;
-  onError: (e: string) => void;
-}) => {
-  const { bond: currentBond, proxy, stakeSaturation, uncappedStakeSaturation } = node;
-
-  const { fee, getFee, resetFeeState, feeError } = useGetFee();
-  const [newBond, setNewBond] = useState<DecCoin | undefined>();
-  const [errorAmount, setErrorAmount] = useState(false);
-
-  const { printBalance, printVestedBalance } = useContext(AppContext);
-
-  useEffect(() => {
-    if (feeError) {
-      onError(feeError);
-    }
-  }, [feeError]);
-
-  const handleConfirm = async () => {
-    if (!newBond) {
-      return;
-    }
-    const tokenPool = proxy ? 'locked' : 'balance';
-    await onUpdateBond(
-      {
-        currentPledge: currentBond,
-        newPledge: newBond,
-        fee: fee?.fee,
-      },
-      tokenPool,
-    );
-  };
-
-  const handleAmountChanged = async (value: DecCoin) => {
-    const { amount } = value;
-    setNewBond(value);
-    if (!amount || !Number(amount)) {
-      setErrorAmount(true);
-    } else if (Big(amount).eq(currentBond.amount)) {
-      setErrorAmount(true);
-    } else {
-      const validAmount = await validateAmount(amount, '1');
-      if (!validAmount) {
-        setErrorAmount(true);
-        return;
-      }
-      setErrorAmount(false);
-    }
-  };
-
-  const handleOnOk = async () => {
-    if (!newBond) {
-      return;
-    }
-    if (!proxy) {
-      await getFee<TSimulateUpdateBondArgs>(simulateUpdateBond, {
-        currentPledge: currentBond,
-        newPledge: newBond,
-      });
-    } else {
-      await getFee<TSimulateUpdateBondArgs>(simulateVestingUpdateBond, {
-        currentPledge: currentBond,
-        newPledge: newBond,
-      });
-    }
-  };
-
-  const newBondToDisplay = () => {
-    const coin = decCoinToDisplay(newBond as DecCoin);
-    return `${coin.amount} ${coin.denom}`;
-  };
-
-  if (fee)
-    return (
-      <ConfirmTx
-        open
-        header="Change bond details"
-        fee={fee}
-        onClose={onClose}
-        onPrev={resetFeeState}
-        onConfirm={handleConfirm}
-      >
-        <ModalListItem label="New bond details" value={newBondToDisplay()} divider />
-        <ModalListItem label="Change bond details" value={`${currentBond.amount} ${currentBond.denom}`} divider />
-      </ConfirmTx>
-    );
-
-  return (
-    <SimpleModal
-      open
-      header="Change bond amount"
-      subHeader="Add or reduce amount of tokens on your node"
-      okLabel="Next"
-      onOk={handleOnOk}
-      okDisabled={errorAmount || !newBond}
-      onClose={onClose}
-    >
-      <Stack gap={3}>
-        <Box display="flex" gap={1}>
-          <CurrencyFormField
-            autoFocus
-            label="New bond amount"
-            denom={currentBond.denom}
-            onChanged={(value) => {
-              handleAmountChanged(value);
-            }}
-            fullWidth
-            validationError={errorAmount ? 'Please enter a valid amount' : undefined}
-          />
-        </Box>
-
-        <Box>
-          <ModalListItem
-            fontWeight={600}
-            label={proxy ? 'Locked account balance' : 'Account balance'}
-            value={proxy ? printVestedBalance || '-' : printBalance}
-            divider
-          />
-          <ModalListItem label="Current bond amount" value={`${currentBond.amount} ${currentBond.denom}`} divider />
-          {uncappedStakeSaturation ? (
-            <ModalListItem
-              label="Node saturation"
-              value={`${uncappedStakeSaturation}%`}
-              sxValue={{ color: 'error.main' }}
-              divider
-            />
-          ) : (
-            <ModalListItem label="Node saturation" value={`${stakeSaturation}%`} divider />
-          )}
-          <ModalListItem label="Est. fee for this operation will be calculated in the next page" value="" divider />
-        </Box>
-      </Stack>
-    </SimpleModal>
-  );
-};

nym-wallet/src/components/Settings/AppVersion.tsx

@@ -40,7 +40,7 @@ const AppVersion = () => {
         <Typography variant="caption" sx={{ color: 'nym.text.muted' }}>
           Installed version
         </Typography>
-        <Typography>{`Nym Wallet v${appVersion}`}</Typography>
+        <Typography>{`Nym Wallet ${appVersion}`}</Typography>
       </Stack>
       {updateAvailable && (
         <Button variant="text" onClick={() => updateHandler()}>

nym-wallet/src/context/bonding.tsx

@@ -6,7 +6,6 @@ import {
   TransactionExecuteResult,
   decimalToPercentage,
   SelectionChance,
-  decimalToFloatApproximation,
 } from '@nymproject/types';
 import React, { createContext, useCallback, useContext, useEffect, useMemo, useState } from 'react';
 import Big from 'big.js';
@@ -18,7 +17,7 @@ import {
   TBondGatewaySignatureArgs,
   TBondMixNodeArgs,
   TBondMixnodeSignatureArgs,
-  TUpdateBondArgs,
+  TBondMoreArgs,
 } from 'src/types';
 import { Console } from 'src/utils/console';
 import {
@@ -29,6 +28,8 @@ import {
   getMixnodeBondDetails,
   unbondGateway as unbondGatewayRequest,
   unbondMixNode as unbondMixnodeRequest,
+  bondMore as bondMoreRequest,
+  vestingBondMore,
   vestingBondGateway,
   vestingBondMixNode,
   vestingUnbondGateway,
@@ -49,8 +50,6 @@ import {
   generateMixnodeMsgPayload as generateMixnodeMsgPayloadReq,
   vestingGenerateGatewayMsgPayload as vestingGenerateGatewayMsgPayloadReq,
   generateGatewayMsgPayload as generateGatewayMsgPayloadReq,
-  updateBond as updateBondReq,
-  vestingUpdateBond as vestingUpdateBondReq,
 } from '../requests';
 import { useCheckOwnership } from '../hooks/useCheckOwnership';
 import { AppContext } from './main';
@@ -70,7 +69,6 @@ export type TBondedMixnode = {
   stake: DecCoin;
   bond: DecCoin;
   stakeSaturation: string;
-  uncappedStakeSaturation?: number;
   profitMargin: string;
   operatorRewards?: DecCoin;
   delegators: number;
@@ -119,7 +117,7 @@ export type TBondingContext = {
   bondMixnode: (data: TBondMixNodeArgs, tokenPool: TokenPool) => Promise<TransactionExecuteResult | undefined>;
   bondGateway: (data: TBondGatewayArgs, tokenPool: TokenPool) => Promise<TransactionExecuteResult | undefined>;
   unbond: (fee?: FeeDetails) => Promise<TransactionExecuteResult | undefined>;
-  updateBondAmount: (data: TUpdateBondArgs, tokenPool: TokenPool) => Promise<TransactionExecuteResult | undefined>;
+  bondMore: (data: TBondMoreArgs, tokenPool: TokenPool) => Promise<TransactionExecuteResult | undefined>;
   redeemRewards: (fee?: FeeDetails) => Promise<TransactionExecuteResult | undefined>;
   updateMixnode: (pm: string, fee?: FeeDetails) => Promise<TransactionExecuteResult | undefined>;
   checkOwnership: () => Promise<void>;
@@ -140,7 +138,7 @@ export const BondingContext = createContext<TBondingContext>({
   unbond: async () => {
     throw new Error('Not implemented');
   },
-  updateBondAmount: async () => {
+  bondMore: async () => {
     throw new Error('Not implemented');
   },
   redeemRewards: async () => {
@@ -191,7 +189,6 @@ export const BondingContextProvider: FCWithChildren = ({ children }): JSX.Elemen
       stakeSaturation: string;
       estimatedRewards?: DecCoin;
       uptime: number;
-      uncappedSaturation?: number;
     } = {
       status: 'not_found',
       stakeSaturation: '0',
@@ -210,11 +207,6 @@ export const BondingContextProvider: FCWithChildren = ({ children }): JSX.Elemen
     try {
       const stakeSaturationResponse = await getMixnodeStakeSaturation(mixId);
       additionalDetails.stakeSaturation = decimalToPercentage(stakeSaturationResponse.saturation);
-
-      const rawUncappedSaturation = decimalToFloatApproximation(stakeSaturationResponse.uncapped_saturation);
-      if (rawUncappedSaturation && rawUncappedSaturation > 1) {
-        additionalDetails.uncappedSaturation = Math.round(rawUncappedSaturation * 100);
-      }
     } catch (e) {
       Console.log('getMixnodeStakeSaturation fails', e);
     }
@@ -285,7 +277,6 @@ export const BondingContextProvider: FCWithChildren = ({ children }): JSX.Elemen
 
   const refresh = useCallback(async () => {
     setIsLoading(true);
-    setError(undefined);
 
     if (ownership.hasOwnership && ownership.nodeType === EnumNodeType.mixnode && clientDetails) {
       try {
@@ -307,13 +298,7 @@ export const BondingContextProvider: FCWithChildren = ({ children }): JSX.Elemen
             bond_information: { mix_id },
           } = data;
 
-          const {
-            status,
-            stakeSaturation,
-            uncappedSaturation: uncappedStakeSaturation,
-            estimatedRewards,
-            uptime,
-          } = await getAdditionalMixnodeDetails(mix_id);
+          const { status, stakeSaturation, estimatedRewards, uptime } = await getAdditionalMixnodeDetails(mix_id);
           const setProbabilities = await getSetProbabilities(mix_id);
           const nodeDescription = await getNodeDescription(
             bond_information.mix_node.host,
@@ -337,7 +322,6 @@ export const BondingContextProvider: FCWithChildren = ({ children }): JSX.Elemen
             uptime,
             status,
             stakeSaturation,
-            uncappedStakeSaturation,
             operatorCost: decCoinToDisplay(rewarding_details.cost_params.interval_operating_cost),
             host: bond_information.mix_node.host.replace(/\s/g, ''),
             routingScore,
@@ -493,16 +477,16 @@ export const BondingContextProvider: FCWithChildren = ({ children }): JSX.Elemen
     return tx;
   };
 
-  const updateBondAmount = async (data: TUpdateBondArgs, tokenPool: TokenPool) => {
+  const bondMore = async (data: TBondMoreArgs, tokenPool: TokenPool) => {
     let tx: TransactionExecuteResult | undefined;
     setIsLoading(true);
     try {
       if (tokenPool === 'balance') {
-        tx = await updateBondReq(data);
+        tx = await bondMoreRequest(data);
         await userBalance.fetchBalance();
       }
       if (tokenPool === 'locked') {
-        tx = await vestingUpdateBondReq(data);
+        tx = await vestingBondMore(data);
         await userBalance.fetchTokenAllocation();
       }
 
@@ -563,7 +547,7 @@ export const BondingContextProvider: FCWithChildren = ({ children }): JSX.Elemen
       updateMixnode,
       refresh,
       redeemRewards,
-      updateBondAmount,
+      bondMore,
       checkOwnership,
       generateMixnodeMsgPayload,
       generateGatewayMsgPayload,

nym-wallet/src/context/main.tsx

@@ -17,7 +17,6 @@ import {
   switchAccount,
 } from '../requests';
 import { Console } from '../utils/console';
-import { toDisplay } from '../utils';
 
 export const urls = (networkName?: Network) =>
   networkName === 'MAINNET'
@@ -63,8 +62,6 @@ export type TAppContext = {
   handleShowTerminal: () => void;
   signInWithPassword: (password: string) => void;
   logOut: () => void;
-  printBalance: string;
-  printVestedBalance?: string; // spendable vested token
 };
 
 export const AppContext = createContext({} as TAppContext);
@@ -85,8 +82,6 @@ export const AppProvider: FCWithChildren = ({ children }) => {
   const [isAdminAddress, setIsAdminAddress] = useState<boolean>(false);
   const [showSendModal, setShowSendModal] = useState(false);
   const [showReceiveModal, setShowReceiveModal] = useState(false);
-  const [printBalance, setPrintBalance] = useState<string>('-');
-  const [printVestedBalance, setPrintVestedBalance] = useState<string | undefined>();
 
   const userBalance = useGetBalance(clientDetails);
   const navigate = useNavigate();
@@ -168,18 +163,6 @@ export const AppProvider: FCWithChildren = ({ children }) => {
     }
   }, [network]);
 
-  useEffect(() => {
-    const currency = clientDetails?.display_mix_denom.toUpperCase() || 'NYM';
-    if (userBalance.originalVesting) {
-      setPrintVestedBalance(`${toDisplay(userBalance.tokenAllocation?.spendableVestedCoins || 0)} ${currency}`);
-    }
-    if (userBalance?.balance?.amount) {
-      setPrintBalance(`${toDisplay(userBalance.balance.amount.amount)} ${currency}`);
-    } else {
-      setPrintBalance(`${toDisplay(0)} ${currency}`);
-    }
-  }, [userBalance, clientDetails]);
-
   useEffect(() => {
     let newValue = false;
     if (network && appEnv?.ADMIN_ADDRESS && clientDetails?.client_address) {
@@ -290,8 +273,6 @@ export const AppProvider: FCWithChildren = ({ children }) => {
       handleShowSendModal,
       handleShowReceiveModal,
       handleSwitchMode,
-      printBalance,
-      printVestedBalance,
     }),
     [
       appVersion,

nym-wallet/src/context/mocks/bonding.tsx

@@ -154,7 +154,7 @@ export const MockBondingContextProvider = ({
     return TxResultMock;
   };
 
-  const updateBondAmount = async (): Promise<TransactionExecuteResult> => {
+  const bondMore = async (): Promise<TransactionExecuteResult> => {
     setIsLoading(true);
     await mockSleep(SLEEP_MS);
     triggerStateUpdate();
@@ -202,7 +202,7 @@ export const MockBondingContextProvider = ({
       getFee,
       resetFeeState,
       updateMixnode,
-      updateBondAmount,
+      bondMore,
       checkOwnership,
       generateMixnodeMsgPayload,
       generateGatewayMsgPayload,

nym-wallet/src/context/mocks/main.tsx

@@ -56,7 +56,6 @@ export const MockMainContextProvider: FCWithChildren = ({ children }) => {
       handleShowSettings: () => undefined,
       handleShowSendModal: () => undefined,
       handleShowReceiveModal: () => undefined,
-      printBalance: '100.0000 NYMT',
     }),
     [],
   );

nym-wallet/src/pages/bonding/Bonding.tsx

@@ -1,6 +1,6 @@
-import React, { useContext, useEffect, useState } from 'react';
+import React, { useContext, useState } from 'react';
 import { useNavigate } from 'react-router-dom';
-import { FeeDetails } from '@nymproject/types';
+import { FeeDetails, decimalToFloatApproximation } from '@nymproject/types';
 import { Box } from '@mui/material';
 import { TPoolOption } from 'src/components';
 import { Bond } from 'src/components/Bonding/Bond';
@@ -8,122 +8,122 @@ import { BondedMixnode } from 'src/components/Bonding/BondedMixnode';
 import { TBondedMixnodeActions } from 'src/components/Bonding/BondedMixnodeActions';
 import { BondGatewayModal } from 'src/components/Bonding/modals/BondGatewayModal';
 import { BondMixnodeModal } from 'src/components/Bonding/modals/BondMixnodeModal';
-import { UpdateBondAmountModal } from 'src/components/Bonding/modals/UpdateBondAmountModal';
+import { BondMoreModal } from 'src/components/Bonding/modals/BondMoreModal';
 import { BondOversaturatedModal } from 'src/components/Bonding/modals/BondOversaturatedModal';
 import { ConfirmationDetailProps, ConfirmationDetailsModal } from 'src/components/Bonding/modals/ConfirmationModal';
 import { ErrorModal } from 'src/components/Modals/ErrorModal';
 import { LoadingModal } from 'src/components/Modals/LoadingModal';
 import { AppContext, urls } from 'src/context/main';
-import { isGateway, isMixnode, TBondGatewayArgs, TBondMixNodeArgs, TUpdateBondArgs } from 'src/types';
+import { isGateway, isMixnode, TBondGatewayArgs, TBondMixNodeArgs, TBondMoreArgs } from 'src/types';
 import { BondedGateway } from 'src/components/Bonding/BondedGateway';
 import { RedeemRewardsModal } from 'src/components/Bonding/modals/RedeemRewardsModal';
+import { Console } from 'src/utils/console';
 import { BondingContextProvider, useBondingContext } from '../../context';
+import { getMixnodeStakeSaturation } from '../../requests';
 
 const Bonding = () => {
   const [showModal, setShowModal] = useState<
-    'bond-mixnode' | 'bond-gateway' | 'update-bond' | 'update-bond-oversaturated' | 'unbond' | 'redeem'
+    'bond-mixnode' | 'bond-gateway' | 'bond-more' | 'bond-more-oversaturated' | 'unbond' | 'redeem'
   >();
   const [confirmationDetails, setConfirmationDetails] = useState<ConfirmationDetailProps>();
-  const [uncappedSaturation, setUncappedSaturation] = useState<number | undefined>();
+  const [saturationPercentage, setSaturationPercentage] = useState<string | undefined>();
 
   const {
     network,
     clientDetails,
-    userBalance: { originalVesting },
+    userBalance: { originalVesting, balance },
   } = useContext(AppContext);
 
   const navigate = useNavigate();
 
-  const {
-    bondedNode,
-    bondMixnode,
-    bondGateway,
-    redeemRewards,
-    isLoading,
-    checkOwnership,
-    updateBondAmount,
-    error,
-    refresh,
-  } = useBondingContext();
-
-  useEffect(() => {
-    if (bondedNode && isMixnode(bondedNode) && bondedNode.uncappedStakeSaturation) {
-      setUncappedSaturation(bondedNode.uncappedStakeSaturation);
-    }
-  }, [bondedNode]);
+  const { bondedNode, bondMixnode, bondGateway, redeemRewards, isLoading, checkOwnership, bondMore } =
+    useBondingContext();
 
   const handleCloseModal = async () => {
     setShowModal(undefined);
     await checkOwnership();
   };
 
-  const handleError = (err: string) => {
+  const handleError = (error: string) => {
     setShowModal(undefined);
     setConfirmationDetails({
       status: 'error',
       title: 'An error occurred',
-      subtitle: err,
+      subtitle: error,
     });
   };
 
   const handleBondMixnode = async (data: TBondMixNodeArgs, tokenPool: TPoolOption) => {
     setShowModal(undefined);
     const tx = await bondMixnode(data, tokenPool);
-    if (tx) {
-      setConfirmationDetails({
-        status: 'success',
-        title: 'Bond successful',
-        txUrl: `${urls(network).blockExplorer}/transaction/${tx?.transaction_hash}`,
-      });
-    }
+    setConfirmationDetails({
+      status: 'success',
+      title: 'Bond successful',
+      txUrl: `${urls(network).blockExplorer}/transaction/${tx?.transaction_hash}`,
+    });
     return undefined;
   };
 
   const handleBondGateway = async (data: TBondGatewayArgs, tokenPool: TPoolOption) => {
     setShowModal(undefined);
     const tx = await bondGateway(data, tokenPool);
-    if (tx) {
-      setConfirmationDetails({
-        status: 'success',
-        title: 'Bond successful',
-        txUrl: `${urls(network).blockExplorer}/transaction/${tx?.transaction_hash}`,
-      });
-    }
+    setConfirmationDetails({
+      status: 'success',
+      title: 'Bond successful',
+      txUrl: `${urls(network).blockExplorer}/transaction/${tx?.transaction_hash}`,
+    });
   };
 
-  const handleUpdateBond = async (data: TUpdateBondArgs, tokenPool: TPoolOption) => {
+  const handleBondMore = async (data: TBondMoreArgs, tokenPool: TPoolOption) => {
     setShowModal(undefined);
-
-    const tx = await updateBondAmount(data, tokenPool);
-    if (tx) {
-      setConfirmationDetails({
-        status: 'success',
-        title: 'Bond amount changed successfully',
-        txUrl: `${urls(network).blockExplorer}/transaction/${tx?.transaction_hash}`,
-      });
-    }
+    const tx = await bondMore(data, tokenPool);
+    setConfirmationDetails({
+      status: 'success',
+      title: 'Bond More successful',
+      txUrl: `${urls(network).blockExplorer}/transaction/${tx?.transaction_hash}`,
+    });
   };
 
   const handleRedeemReward = async (fee?: FeeDetails) => {
     setShowModal(undefined);
     const tx = await redeemRewards(fee);
-    if (tx) {
-      setConfirmationDetails({
-        status: 'success',
-        title: 'Rewards redeemed successfully',
-        txUrl: `${urls(network).blockExplorer}/transaction/${tx?.transaction_hash}`,
-      });
+    setConfirmationDetails({
+      status: 'success',
+      title: 'Rewards redeemed successfully',
+      txUrl: `${urls(network).blockExplorer}/transaction/${tx?.transaction_hash}`,
+    });
+  };
+
+  const handleCheckStakeSaturation = async (newMixId: number) => {
+    try {
+      const newSaturation = decimalToFloatApproximation(
+        (await getMixnodeStakeSaturation(newMixId)).uncapped_saturation,
+      );
+      if (newSaturation && newSaturation > 1) {
+        const newSaturationPercentage = Math.round(newSaturation * 100);
+        return { isOverSaturated: true, saturationPercentage: newSaturationPercentage };
+      }
+      return { isOverSaturated: false, saturationPercentage: undefined };
+    } catch (e) {
+      Console.error('Error fetching the saturation, error:', e);
+      return { isOverSaturated: false, saturationPercentage: undefined };
     }
   };
 
   const handleBondedMixnodeAction = async (action: TBondedMixnodeActions) => {
     switch (action) {
-      case 'updateBond': {
-        if (uncappedSaturation) {
-          setShowModal('update-bond-oversaturated');
-        } else {
-          setShowModal('update-bond');
+      case 'bondMore': {
+        if (bondedNode && isMixnode(bondedNode)) {
+          const { isOverSaturated, saturationPercentage: newSaturationPercentage } = await handleCheckStakeSaturation(
+            bondedNode.mixId,
+          );
+          if (isOverSaturated && newSaturationPercentage) {
+            setShowModal('bond-more-oversaturated');
+            setSaturationPercentage(newSaturationPercentage.toString());
+            break;
+          }
         }
+        setShowModal('bond-more');
         break;
       }
       case 'unbond': {
@@ -141,10 +141,6 @@ const Bonding = () => {
     return undefined;
   };
 
-  if (error) {
-    return <ErrorModal open message="An error occured, please check logs for details" onClose={() => refresh()} />;
-  }
-
   return (
     <Box sx={{ mt: 4 }}>
       {!bondedNode && <Bond disabled={isLoading} onBond={() => setShowModal('bond-mixnode')} />}
@@ -183,19 +179,20 @@ const Bonding = () => {
         />
       )}
 
-      {showModal === 'update-bond-oversaturated' && uncappedSaturation && (
+      {showModal === 'bond-more-oversaturated' && saturationPercentage && (
         <BondOversaturatedModal
           open
           onClose={() => setShowModal(undefined)}
-          onContinue={() => setShowModal('update-bond')}
-          saturationPercentage={uncappedSaturation.toString()}
+          onContinue={() => setShowModal('bond-more')}
+          saturationPercentage={saturationPercentage}
         />
       )}
 
-      {showModal === 'update-bond' && bondedNode && isMixnode(bondedNode) && (
-        <UpdateBondAmountModal
+      {showModal === 'bond-more' && bondedNode && isMixnode(bondedNode) && (
+        <BondMoreModal
           node={bondedNode}
-          onUpdateBond={handleUpdateBond}
+          userBalance={balance?.printable_balance}
+          onBondMore={handleBondMore}
           onClose={() => setShowModal(undefined)}
           onError={handleError}
         />

nym-wallet/src/requests/actions.ts

@@ -13,7 +13,8 @@ import {
   TBondGatewaySignatureArgs,
   TBondMixNodeArgs,
   TBondMixnodeSignatureArgs,
-  TUpdateBondArgs,
+  TBondMoreArgs,
+  TDecreaseBondArgs,
 } from '../types';
 import { invokeWrapper } from './wrapper';
 
@@ -50,5 +51,7 @@ export const unbond = async (type: EnumNodeType) => {
   return unbondGateway();
 };
 
-export const updateBond = async (args: TUpdateBondArgs) =>
-  invokeWrapper<TransactionExecuteResult>('update_pledge', args);
+export const bondMore = async (args: TBondMoreArgs) => invokeWrapper<TransactionExecuteResult>('pledge_more', args);
+
+export const decreaseBond = async (args: TDecreaseBondArgs) =>
+  invokeWrapper<TransactionExecuteResult>('decrease_pledge', args);

nym-wallet/src/requests/simulate.ts

@@ -6,7 +6,7 @@ import {
   MixNodeConfigUpdate,
   GatewayConfigUpdate,
 } from '@nymproject/types';
-import { TBondGatewayArgs, TBondMixNodeArgs, TSimulateUpdateBondArgs } from 'src/types';
+import { TBondGatewayArgs, TBondMixNodeArgs } from 'src/types';
 import { invokeWrapper } from './wrapper';
 
 export const simulateBondGateway = async (args: TBondGatewayArgs) =>
@@ -80,8 +80,7 @@ export const simulateClaimOperatorReward = async () => invokeWrapper<FeeDetails>
 export const simulateVestingClaimOperatorReward = async () =>
   invokeWrapper<FeeDetails>('simulate_vesting_claim_operator_reward');
 
-export const simulateUpdateBond = async (args: TSimulateUpdateBondArgs) =>
-  invokeWrapper<FeeDetails>('simulate_update_pledge', args);
+export const simulateBondMore = async (args: any) => invokeWrapper<FeeDetails>('simulate_pledge_more', args);
 
-export const simulateVestingUpdateBond = async (args: TSimulateUpdateBondArgs) =>
-  invokeWrapper<FeeDetails>('simulate_vesting_update_pledge', args);
+export const simulateVestingBondMore = async (args: any) =>
+  invokeWrapper<FeeDetails>('simulate_vesting_pledge_more', args);

nym-wallet/src/requests/vesting.ts

@@ -14,7 +14,7 @@ import {
 } from '@nymproject/types';
 import { Fee } from '@nymproject/types/dist/types/rust/Fee';
 import { invokeWrapper } from './wrapper';
-import { TBondGatewaySignatureArgs, TBondMixnodeSignatureArgs, TUpdateBondArgs } from '../types';
+import { TBondGatewaySignatureArgs, TBondMixnodeSignatureArgs } from '../types';
 
 export const getLockedCoins = async (): Promise<DecCoin> => invokeWrapper<DecCoin>('locked_coins');
 
@@ -121,5 +121,14 @@ export const vestingClaimOperatorReward = async (fee?: Fee) =>
 export const vestingClaimDelegatorRewards = async (mixId: number) =>
   invokeWrapper<TransactionExecuteResult>('vesting_claim_delegator_reward', { mixId });
 
-export const vestingUpdateBond = async (args: TUpdateBondArgs) =>
-  invokeWrapper<TransactionExecuteResult>('vesting_update_pledge', args);
+export const vestingBondMore = async ({ fee, additionalPledge }: { fee?: Fee; additionalPledge: DecCoin }) =>
+  invokeWrapper<TransactionExecuteResult>('vesting_pledge_more', {
+    fee,
+    additionalPledge,
+  });
+
+export const vestingDecreaseBond = async ({ fee, decreaseBy }: { fee?: Fee; decreaseBy: DecCoin }) =>
+  invokeWrapper<TransactionExecuteResult>('vesting_decrease_pledge', {
+    fee,
+    decreaseBy,
+  });

nym-wallet/src/types/global.ts

@@ -54,13 +54,15 @@ export type TBondGatewaySignatureArgs = {
   tokenPool: 'balance' | 'locked';
 };
 
-export type TUpdateBondArgs = {
-  currentPledge: DecCoin;
-  newPledge: DecCoin;
+export type TBondMoreArgs = {
+  additionalPledge: DecCoin;
   fee?: Fee;
 };
 
-export type TSimulateUpdateBondArgs = Omit<TUpdateBondArgs, 'fee'>;
+export type TDecreaseBondArgs = {
+  decreaseBy: DecCoin;
+  fee?: Fee;
+};
 
 export type TNodeDescription = {
   name: string;

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

@@ -507,7 +507,6 @@ where
             .clone()
             .ok_or(Error::Socks5Config { set: false })?;
         let debug_config = self.config.debug_config;
-        let packet_type = self.config.packet_type();
         let (mut started_client, nym_address) = self.connect_to_mixnet_common().await?;
         let (socks5_status_tx, mut socks5_status_rx) = mpsc::channel(128);
 
@@ -523,7 +522,6 @@ where
             client_state.clone(),
             nym_address,
             started_client.task_manager.subscribe(),
-            packet_type,
         );
         started_client
             .task_manager
@@ -594,7 +592,6 @@ where
             client_state,
             reconstructed_receiver,
             task_manager: started_client.task_manager,
-            packet_type: None,
         })
     }
 }

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

@@ -1,6 +1,5 @@
 use nym_client_core::config::DebugConfig;
 use nym_network_defaults::NymNetworkDetails;
-use nym_sphinx::params::PacketType;
 
 /// Config struct for [`crate::mixnet::MixnetClient`]
 #[derive(Default)]
@@ -17,12 +16,4 @@ pub struct Config {
     /// Flags controlling all sorts of internal client behaviour.
     /// Changing these risk compromising network anonymity!
     pub debug_config: DebugConfig,
-
-    pub packet_type: PacketType,
-}
-
-impl Config {
-    pub fn packet_type(&self) -> PacketType {
-        self.packet_type
-    }
 }

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

@@ -6,7 +6,6 @@ use nym_client_core::client::{
 };
 use nym_sphinx::{
     addressing::clients::{ClientIdentity, Recipient},
-    params::PacketType,
     receiver::ReconstructedMessage,
 };
 use nym_task::{
@@ -46,7 +45,6 @@ pub struct MixnetClient {
 
     /// The task manager that controlls all the spawned tasks that the clients uses to do it's job.
     pub(crate) task_manager: TaskManager,
-    pub(crate) packet_type: Option<PacketType>,
 }
 
 impl MixnetClient {
@@ -165,11 +163,9 @@ impl MixnetClient {
         let lane = TransmissionLane::General;
         let input_msg = match surbs {
             IncludedSurbs::Amount(surbs) => {
-                InputMessage::new_anonymous(address, message, surbs, lane, self.packet_type)
-            }
-            IncludedSurbs::ExposeSelfAddress => {
-                InputMessage::new_regular(address, message, lane, self.packet_type)
+                InputMessage::new_anonymous(address, message, surbs, lane)
             }
+            IncludedSurbs::ExposeSelfAddress => InputMessage::new_regular(address, message, lane),
         };
         self.send(input_msg).await
     }