Fix orphan !

* use updated sphinx crate

* updated outfox usage of keygen in tests

* use x25519 in outfox

* remove redundant constructor

* adjusted key convertion traits

Cargo.toml

@@ -322,7 +322,7 @@ serde_with = "3.9.0"
 serde_yaml = "0.9.25"
 sha2 = "0.10.8"
 si-scale = "0.2.3"
-sphinx-packet = "0.1.1"
+sphinx-packet = "0.3.1"
 sqlx = "0.7.4"
 strum = "0.26"
 strum_macros = "0.26"

common/crypto/Cargo.toml

@@ -37,11 +37,10 @@ nym-pemstore = { path = "../../common/pemstore", version = "0.3.0" }
 rand_chacha = { workspace = true }
 
 [features]
-default = ["sphinx"]
+default = []
 aead = ["dep:aead", "aead/std", "aes-gcm-siv", "generic-array"]
 serde = ["dep:serde", "serde_bytes", "ed25519-dalek/serde", "x25519-dalek/serde"]
 asymmetric = ["x25519-dalek", "ed25519-dalek", "zeroize"]
 hashing = ["blake3", "digest", "hkdf", "hmac", "generic-array", "sha2"]
 stream_cipher = ["aes", "ctr", "cipher", "generic-array"]
-sphinx = ["nym-sphinx-types/sphinx"]
-outfox = ["nym-sphinx-types/outfox"]
+sphinx = ["nym-sphinx-types/sphinx"]

common/crypto/src/asymmetric/encryption/mod.rs

@@ -202,6 +202,18 @@ impl PemStorableKey for PublicKey {
     }
 }
 
+impl From<x25519_dalek::PublicKey> for PublicKey {
+    fn from(public_key: x25519_dalek::PublicKey) -> Self {
+        PublicKey(public_key)
+    }
+}
+
+impl From<PublicKey> for x25519_dalek::PublicKey {
+    fn from(public_key: PublicKey) -> Self {
+        public_key.0
+    }
+}
+
 #[derive(Zeroize, ZeroizeOnDrop)]
 pub struct PrivateKey(x25519_dalek::StaticSecret);
 
@@ -308,109 +320,15 @@ impl PemStorableKey for PrivateKey {
     }
 }
 
-// compatibility with sphinx keys:
-#[cfg(feature = "sphinx")]
-impl From<PublicKey> for nym_sphinx_types::PublicKey {
-    fn from(key: PublicKey) -> Self {
-        nym_sphinx_types::PublicKey::from(key.to_bytes())
+impl From<x25519_dalek::StaticSecret> for PrivateKey {
+    fn from(secret: x25519_dalek::StaticSecret) -> Self {
+        PrivateKey(secret)
     }
 }
 
-#[cfg(feature = "sphinx")]
-impl<'a> From<&'a PublicKey> for nym_sphinx_types::PublicKey {
-    fn from(key: &'a PublicKey) -> Self {
-        nym_sphinx_types::PublicKey::from((*key).to_bytes())
-    }
-}
-
-#[cfg(feature = "sphinx")]
-impl From<nym_sphinx_types::PublicKey> for PublicKey {
-    fn from(pub_key: nym_sphinx_types::PublicKey) -> Self {
-        Self(x25519_dalek::PublicKey::from(*pub_key.as_bytes()))
-    }
-}
-
-#[cfg(feature = "sphinx")]
-impl From<PrivateKey> for nym_sphinx_types::PrivateKey {
-    fn from(key: PrivateKey) -> Self {
-        nym_sphinx_types::PrivateKey::from(key.to_bytes())
-    }
-}
-
-#[cfg(feature = "sphinx")]
-impl<'a> From<&'a PrivateKey> for nym_sphinx_types::PrivateKey {
-    fn from(key: &'a PrivateKey) -> Self {
-        nym_sphinx_types::PrivateKey::from(key.to_bytes())
-    }
-}
-
-#[cfg(feature = "sphinx")]
-impl From<nym_sphinx_types::PrivateKey> for PrivateKey {
-    fn from(private_key: nym_sphinx_types::PrivateKey) -> Self {
-        let private_key_bytes = private_key.to_bytes();
-        assert_eq!(private_key_bytes.len(), PRIVATE_KEY_SIZE);
-        Self::from_bytes(&private_key_bytes).unwrap()
-    }
-}
-
-#[cfg(test)]
-mod sphinx_key_conversion {
-    use super::*;
-    use rand_chacha::rand_core::SeedableRng;
-    use rand_chacha::ChaCha20Rng;
-
-    pub(super) fn test_rng() -> ChaCha20Rng {
-        let dummy_seed = [42u8; 32];
-        ChaCha20Rng::from_seed(dummy_seed)
-    }
-
-    const NUM_ITERATIONS: usize = 100;
-
-    #[test]
-    fn works_for_forward_conversion() {
-        let mut rng = test_rng();
-
-        for _ in 0..NUM_ITERATIONS {
-            let keys = KeyPair::new(&mut rng);
-            let private = &keys.private_key;
-            let public = &keys.public_key;
-
-            let dummy_remote = KeyPair::new(&mut rng);
-            let dh1 = private.diffie_hellman(&dummy_remote.public_key);
-
-            let public_bytes = public.to_bytes();
-
-            let sphinx_private: nym_sphinx_types::PrivateKey = private.into();
-            let recovered_private = PrivateKey::from(sphinx_private);
-
-            let dh2 = recovered_private.diffie_hellman(&dummy_remote.public_key);
-
-            let sphinx_public: nym_sphinx_types::PublicKey = public.into();
-            let recovered_public = PublicKey::from(sphinx_public);
-            assert_eq!(public_bytes, recovered_public.to_bytes());
-
-            // even though the byte representation of the private key changed, the resultant DH is the same
-            // which is what matters
-            assert_eq!(dh1, dh2);
-        }
-    }
-
-    #[test]
-    fn works_for_backward_conversion() {
-        for _ in 0..NUM_ITERATIONS {
-            let (sphinx_private, sphinx_public) = nym_sphinx_types::crypto::keygen();
-
-            let private_bytes = sphinx_private.to_bytes();
-            let public_bytes = sphinx_public.as_bytes();
-
-            let private: PrivateKey = sphinx_private.into();
-            let recovered_sphinx_private: nym_sphinx_types::PrivateKey = private.into();
-
-            let public: PublicKey = sphinx_public.into();
-            let recovered_sphinx_public: nym_sphinx_types::PublicKey = public.into();
-            assert_eq!(private_bytes, recovered_sphinx_private.to_bytes());
-            assert_eq!(public_bytes, recovered_sphinx_public.as_bytes());
-        }
+impl AsRef<x25519_dalek::StaticSecret> for PrivateKey {
+    fn as_ref(&self) -> &x25519_dalek::StaticSecret {
+        &self.0
     }
 }
 

common/nymsphinx/Cargo.toml

@@ -48,12 +48,10 @@ features = ["sync"]
 [features]
 default = ["sphinx"]
 sphinx = [
-    "nym-crypto/sphinx",
     "nym-sphinx-params/sphinx",
     "nym-sphinx-types/sphinx",
 ]
 outfox = [
-    "nym-crypto/outfox",
     "nym-sphinx-params/outfox",
     "nym-sphinx-types/outfox",
 ]

common/nymsphinx/addressing/Cargo.toml

@@ -8,7 +8,7 @@ license = { workspace = true }
 repository = { workspace = true }
 
 [dependencies]
-nym-crypto = { path = "../../crypto", features = ["asymmetric"] } # all addresses are expressed in terms on their crypto keys
+nym-crypto = { path = "../../crypto", features = ["asymmetric", "sphinx"] } # all addresses are expressed in terms on their crypto keys
 nym-sphinx-types = { path = "../types", features = ["sphinx"] } # we need to be able to refer to some types defined inside sphinx crate
 serde = { workspace = true } # implementing serialization/deserialization for some types, like `Recipient`
 thiserror = { workspace = true }

common/nymsphinx/anonymous-replies/Cargo.toml

@@ -12,6 +12,7 @@ rand = { workspace = true }
 bs58 = { workspace = true }
 serde = { workspace = true }
 thiserror = { workspace = true }
+sphinx-packet = { workspace = true }
 
 nym-crypto = { path = "../../crypto", features = ["stream_cipher", "rand"] }
 nym-sphinx-addressing = { path = "../addressing" }

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

@@ -7,11 +7,12 @@ 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};
-use nym_sphinx_types::{NymPacket, SURBMaterial, SphinxError, SURB};
+use nym_sphinx_types::{Destination, NymPacket, SURBMaterial, SphinxError, SURB};
 use nym_topology::{NymRouteProvider, NymTopologyError};
 use rand::{CryptoRng, RngCore};
 use serde::de::{Error as SerdeError, Visitor};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use sphinx_packet::route::Node;
 
 use std::fmt::{self, Formatter};
 use std::time;
@@ -83,6 +84,25 @@ impl ReplySurb {
         packet_size.plaintext_size() - ack_overhead - ReplySurbKeyDigestAlgorithm::output_size() - 1
     }
 
+    pub fn construct_with_route<R>(
+        rng: &mut R,
+        destination: Destination,
+        average_delay: time::Duration,
+        route: &[Node],
+    ) -> Result<Self, NymTopologyError>
+    where
+        R: RngCore + CryptoRng,
+    {
+        let delays = nym_sphinx_routing::generate_hop_delays(average_delay, route.len());
+        let surb_material = SURBMaterial::new(route.to_vec(), delays, destination);
+
+        // this can't fail as we know we have a valid route to gateway and have correct number of delays
+        Ok(ReplySurb {
+            surb: surb_material.construct_SURB().unwrap(),
+            encryption_key: SurbEncryptionKey::new(rng),
+        })
+    }
+
     // TODO: should this return `ReplySURBError` for consistency sake
     // or keep `NymTopologyError` because it's the only error it can actually return?
     pub fn construct<R>(
@@ -123,11 +143,15 @@ impl ReplySurb {
 
     pub fn to_bytes(&self) -> Vec<u8> {
         // KEY || SURB_BYTES
-        self.encryption_key
+        let bytes: Vec<u8> = self.encryption_key
             .to_bytes()
             .into_iter()
             .chain(self.surb.to_bytes())
-            .collect()
+            .collect();
+
+        assert_eq!(bytes.len(), ReplySurb::serialized_len());
+
+        bytes
     }
 
     pub fn from_bytes(bytes: &[u8]) -> Result<Self, ReplySurbError> {

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

@@ -170,6 +170,7 @@ impl RepliableMessage {
     }
 
     pub fn try_from_bytes(bytes: &[u8]) -> Result<Self, InvalidReplyRequestError> {
+        // println!("Trying to deserialize message: {} bytes", bytes.len());
         if bytes.len() < SENDER_TAG_SIZE + 1 {
             return Err(InvalidReplyRequestError::RequestTooShortToDeserialize);
         }
@@ -559,7 +560,7 @@ mod tests {
             let mut address_bytes = [0; NODE_ADDRESS_LENGTH];
             rng.fill_bytes(&mut address_bytes);
 
-            let dummy_private = PrivateKey::new_with_rng(rng);
+            let dummy_private = PrivateKey::random_from_rng(rng);
             let pub_key = (&dummy_private).into();
             Node {
                 address: NodeAddressBytes::from_bytes(address_bytes),

common/nymsphinx/framing/Cargo.toml

@@ -9,6 +9,7 @@ repository = { workspace = true }
 
 [dependencies]
 bytes = { workspace = true }
+cfg-if = { workspace = true }
 tokio-util = { workspace = true, features = ["codec"] }
 thiserror = { workspace = true }
 log = { workspace = true }
@@ -20,5 +21,8 @@ nym-metrics = { path = "../../nym-metrics" }
 nym-sphinx-addressing = { path = "../addressing" }
 nym-sphinx-acknowledgements = { path = "../acknowledgements" }
 
+[features]
+no-acks = []
+
 [dev-dependencies]
 tokio = { workspace = true, features = ["full"] }

common/nymsphinx/framing/src/codec.rs

@@ -130,28 +130,33 @@ impl Decoder for NymCodec {
 mod packet_encoding {
     use super::*;
     use nym_sphinx_types::{
-        crypto, Delay as SphinxDelay, Destination, DestinationAddressBytes, Node, NodeAddressBytes,
-        DESTINATION_ADDRESS_LENGTH, IDENTIFIER_LENGTH, NODE_ADDRESS_LENGTH,
+        Delay as SphinxDelay, Destination, DestinationAddressBytes, Node, NodeAddressBytes,
+        PrivateKey, DESTINATION_ADDRESS_LENGTH, IDENTIFIER_LENGTH, NODE_ADDRESS_LENGTH,
     };
 
+    fn random_pubkey() -> nym_sphinx_types::PublicKey {
+        let private_key = PrivateKey::random();
+        (&private_key).into()
+    }
+
     fn make_valid_outfox_packet(size: PacketSize) -> NymPacket {
-        let (_, node1_pk) = crypto::keygen();
+        let node1_pk = random_pubkey();
         let node1 = Node::new(
             NodeAddressBytes::from_bytes([5u8; NODE_ADDRESS_LENGTH]),
             node1_pk,
         );
-        let (_, node2_pk) = crypto::keygen();
+        let node2_pk = random_pubkey();
         let node2 = Node::new(
             NodeAddressBytes::from_bytes([4u8; NODE_ADDRESS_LENGTH]),
             node2_pk,
         );
-        let (_, node3_pk) = crypto::keygen();
+        let node3_pk = random_pubkey();
         let node3 = Node::new(
             NodeAddressBytes::from_bytes([2u8; NODE_ADDRESS_LENGTH]),
             node3_pk,
         );
 
-        let (_, node4_pk) = crypto::keygen();
+        let node4_pk = random_pubkey();
         let node4 = Node::new(
             NodeAddressBytes::from_bytes([2u8; NODE_ADDRESS_LENGTH]),
             node4_pk,
@@ -170,17 +175,17 @@ mod packet_encoding {
     }
 
     fn make_valid_sphinx_packet(size: PacketSize) -> NymPacket {
-        let (_, node1_pk) = crypto::keygen();
+        let node1_pk = random_pubkey();
         let node1 = Node::new(
             NodeAddressBytes::from_bytes([5u8; NODE_ADDRESS_LENGTH]),
             node1_pk,
         );
-        let (_, node2_pk) = crypto::keygen();
+        let node2_pk = random_pubkey();
         let node2 = Node::new(
             NodeAddressBytes::from_bytes([4u8; NODE_ADDRESS_LENGTH]),
             node2_pk,
         );
-        let (_, node3_pk) = crypto::keygen();
+        let node3_pk = random_pubkey();
         let node3 = Node::new(
             NodeAddressBytes::from_bytes([2u8; NODE_ADDRESS_LENGTH]),
             node3_pk,

common/nymsphinx/framing/src/processing.rs

@@ -4,8 +4,10 @@ use nym_sphinx_addressing::nodes::{NymNodeRoutingAddress, NymNodeRoutingAddressE
 use nym_sphinx_params::{PacketSize, PacketType};
 use nym_sphinx_types::{
     Delay as SphinxDelay, DestinationAddressBytes, NodeAddressBytes, NymPacket, NymPacketError,
-    NymProcessedPacket, OutfoxError, PrivateKey, ProcessedPacket, SphinxError,
+    NymProcessedPacket, OutfoxError, PrivateKey, ProcessedPacketData, SphinxError,
+    Version as SphinxPacketVersion,
 };
+use std::fmt::Display;
 use thiserror::Error;
 
 use crate::packet::FramedNymPacket;
@@ -13,12 +15,38 @@ use nym_metrics::nanos;
 use nym_sphinx_forwarding::packet::MixPacket;
 
 #[derive(Debug)]
-pub enum MixProcessingResult {
+pub enum MixProcessingResultData {
     /// Contains unwrapped data that should first get delayed before being sent to next hop.
-    ForwardHop(MixPacket, Option<SphinxDelay>),
+    ForwardHop {
+        packet: MixPacket,
+        delay: Option<SphinxDelay>,
+    },
 
     /// Contains all data extracted out of the final hop packet that could be forwarded to the destination.
-    FinalHop(ProcessedFinalHop),
+    FinalHop { final_hop_data: ProcessedFinalHop },
+}
+
+#[derive(Debug, Copy, Clone)]
+pub enum MixPacketVersion {
+    Outfox,
+    Sphinx(SphinxPacketVersion),
+}
+
+impl Display for MixPacketVersion {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        match self {
+            MixPacketVersion::Outfox => "outfox".fmt(f),
+            MixPacketVersion::Sphinx(sphinx_version) => {
+                write!(f, "sphinx-{}", sphinx_version.value())
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct MixProcessingResult {
+    pub packet_version: MixPacketVersion,
+    pub processing_data: MixProcessingResultData,
 }
 
 type ForwardAck = MixPacket;
@@ -107,37 +135,63 @@ fn perform_final_processing(
 ) -> Result<MixProcessingResult, PacketProcessingError> {
     match packet {
         NymProcessedPacket::Sphinx(packet) => {
-            match packet {
-                ProcessedPacket::ForwardHop(packet, address, delay) => {
-                    process_forward_hop(NymPacket::Sphinx(*packet), address, delay, packet_type)
-                }
+            let processing_data = match packet.data {
+                ProcessedPacketData::ForwardHop {
+                    next_hop_packet,
+                    next_hop_address,
+                    delay,
+                } => process_forward_hop(
+                    NymPacket::Sphinx(next_hop_packet),
+                    next_hop_address,
+                    delay,
+                    packet_type,
+                ),
                 // right now there's no use for the surb_id included in the header - probably it should get removed from the
                 // sphinx all together?
-                ProcessedPacket::FinalHop(destination, _, payload) => process_final_hop(
+                ProcessedPacketData::FinalHop {
+                    destination,
+                    identifier: _,
+                    payload,
+                } => process_final_hop(
                     destination,
                     payload.recover_plaintext()?,
                     packet_size,
                     packet_type,
                 ),
-            }
+            }?;
+
+            Ok(MixProcessingResult {
+                packet_version: MixPacketVersion::Sphinx(packet.version),
+                processing_data,
+            })
         }
         NymProcessedPacket::Outfox(packet) => {
             let next_address = *packet.next_address();
             let packet = packet.into_packet();
             if packet.is_final_hop() {
-                process_final_hop(
+                let processing_data = process_final_hop(
                     DestinationAddressBytes::from_bytes(next_address),
                     packet.recover_plaintext()?.to_vec(),
                     packet_size,
                     packet_type,
-                )
+                )?;
+                Ok(MixProcessingResult {
+                    packet_version: MixPacketVersion::Outfox,
+                    processing_data,
+                })
             } else {
-                let mix_packet = MixPacket::new(
+                let packet = MixPacket::new(
                     NymNodeRoutingAddress::try_from_bytes(&next_address)?,
                     NymPacket::Outfox(packet),
                     PacketType::Outfox,
                 );
-                Ok(MixProcessingResult::ForwardHop(mix_packet, None))
+                Ok(MixProcessingResult {
+                    packet_version: MixPacketVersion::Outfox,
+                    processing_data: MixProcessingResultData::ForwardHop {
+                        packet,
+                        delay: None,
+                    },
+                })
             }
         }
     }
@@ -148,14 +202,16 @@ fn process_final_hop(
     payload: Vec<u8>,
     packet_size: PacketSize,
     packet_type: PacketType,
-) -> Result<MixProcessingResult, PacketProcessingError> {
+) -> Result<MixProcessingResultData, PacketProcessingError> {
     let (forward_ack, message) = split_into_ack_and_message(payload, packet_size, packet_type)?;
 
-    Ok(MixProcessingResult::FinalHop(ProcessedFinalHop {
-        destination,
-        forward_ack,
-        message,
-    }))
+    Ok(MixProcessingResultData::FinalHop {
+        final_hop_data: ProcessedFinalHop {
+            destination,
+            forward_ack,
+            message,
+        },
+    })
 }
 
 fn split_into_ack_and_message(
@@ -174,8 +230,12 @@ fn split_into_ack_and_message(
         | PacketSize::ExtendedPacket32
         | PacketSize::OutfoxRegularPacket => {
             trace!("received a normal packet!");
-            let (ack_data, message) = split_hop_data_into_ack_and_message(data, packet_type)?;
-            let (ack_first_hop, ack_packet) =
+            cfg_if::cfg_if! {
+                if #[cfg(feature = "no-acks")] {
+                    return Ok((None, data));
+                } else {
+                    let (ack_data, message) = split_hop_data_into_ack_and_message(data, packet_type)?;
+                    let (ack_first_hop, ack_packet) =
                 match SurbAck::try_recover_first_hop_packet(&ack_data, packet_type) {
                     Ok((first_hop, packet)) => (first_hop, packet),
                     Err(err) => {
@@ -183,8 +243,10 @@ fn split_into_ack_and_message(
                         return Err(err.into());
                     }
                 };
-            let forward_ack = MixPacket::new(ack_first_hop, ack_packet, packet_type);
-            Ok((Some(forward_ack), message))
+                    let forward_ack = MixPacket::new(ack_first_hop, ack_packet, packet_type);
+                    Ok((Some(forward_ack), message))
+                }
+            }
         }
     }
 }
@@ -211,11 +273,14 @@ fn process_forward_hop(
     forward_address: NodeAddressBytes,
     delay: SphinxDelay,
     packet_type: PacketType,
-) -> Result<MixProcessingResult, PacketProcessingError> {
+) -> Result<MixProcessingResultData, PacketProcessingError> {
     let next_hop_address = NymNodeRoutingAddress::try_from(forward_address)?;
 
-    let mix_packet = MixPacket::new(next_hop_address, packet, packet_type);
-    Ok(MixProcessingResult::ForwardHop(mix_packet, Some(delay)))
+    let packet = MixPacket::new(next_hop_address, packet, packet_type);
+    Ok(MixProcessingResultData::ForwardHop {
+        packet,
+        delay: Some(delay),
+    })
 }
 
 // TODO: what more could we realistically test here?

common/nymsphinx/params/Cargo.toml

@@ -16,5 +16,5 @@ nym-sphinx-types = { path = "../types" }
 
 [features]
 default = ["sphinx"]
-sphinx = ["nym-crypto/sphinx", "nym-sphinx-types/outfox"]
-outfox = ["nym-crypto/outfox", "nym-sphinx-types/outfox"]
+sphinx = ["nym-sphinx-types/outfox"]
+outfox = ["nym-sphinx-types/outfox"]

common/nymsphinx/types/src/lib.rs

@@ -1,14 +1,22 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+use std::{array::TryFromSliceError, fmt};
+use thiserror::Error;
+
+#[cfg(feature = "outfox")]
+use nym_outfox::packet::{OutfoxPacket, OutfoxProcessedPacket};
+
+#[cfg(feature = "sphinx")]
+use sphinx_packet::{SphinxPacket, SphinxPacketBuilder};
+
 #[cfg(feature = "outfox")]
 pub use nym_outfox::{
     constants::MIN_PACKET_SIZE, constants::MIX_PARAMS_LEN, constants::OUTFOX_PACKET_OVERHEAD,
     error::OutfoxError,
 };
 // re-exporting types and constants available in sphinx
-#[cfg(feature = "outfox")]
-use nym_outfox::packet::{OutfoxPacket, OutfoxProcessedPacket};
+
 #[cfg(feature = "sphinx")]
 pub use sphinx_packet::{
     constants::{
@@ -21,12 +29,10 @@ pub use sphinx_packet::{
     payload::{Payload, PAYLOAD_OVERHEAD_SIZE},
     route::{Destination, DestinationAddressBytes, Node, NodeAddressBytes, SURBIdentifier},
     surb::{SURBMaterial, SURB},
-    Error as SphinxError, ProcessedPacket,
+    version::Version,
+    version::UPDATED_LEGACY_VERSION,
+    Error as SphinxError, ProcessedPacket, ProcessedPacketData,
 };
-#[cfg(feature = "sphinx")]
-use sphinx_packet::{SphinxPacket, SphinxPacketBuilder};
-use std::{array::TryFromSliceError, fmt};
-use thiserror::Error;
 
 #[derive(Error, Debug)]
 pub enum NymPacketError {
@@ -85,8 +91,12 @@ impl NymPacket {
         destination: &Destination,
         delays: &[Delay],
     ) -> Result<NymPacket, NymPacketError> {
+        // FIXME:
+        // for now explicitly use the legacy version until sufficient number of nodes
+        // understand both variants
         Ok(NymPacket::Sphinx(
             SphinxPacketBuilder::new()
+                .with_version(UPDATED_LEGACY_VERSION)
                 .with_payload_size(size)
                 .build_packet(message, route, destination, delays)?,
         ))

common/topology/Cargo.toml

@@ -27,7 +27,7 @@ wasm-bindgen = { workspace = true, optional = true }
 
 ## internal
 nym-config = { path = "../config" }
-nym-crypto = { path = "../crypto", features = ["sphinx", "outfox"] }
+nym-crypto = { path = "../crypto" }
 nym-mixnet-contract-common = { path = "../cosmwasm-smart-contracts/mixnet-contract" }
 nym-sphinx-addressing = { path = "../nymsphinx/addressing" }
 nym-sphinx-types = { path = "../nymsphinx/types", features = [

common/topology/src/node.rs

@@ -105,7 +105,7 @@ impl<'a> From<&'a RoutingNode> for SphinxNode {
             .try_into()
             .unwrap();
 
-        SphinxNode::new(node_address_bytes, (&node.sphinx_key).into())
+        SphinxNode::new(node_address_bytes, node.sphinx_key.into())
     }
 }
 

documentation/docs/vercel.json

@@ -0,0 +1,7 @@
+{
+  "git": {
+    "deploymentEnabled": {
+      "master": false
+    }
+  }
+}

nym-node-status-api/nym-node-status-agent/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "nym-node-status-agent"
-version = "1.0.0-rc.1"
+version = "1.0.0-rc.2"
 authors.workspace = true
 repository.workspace = true
 homepage.workspace = true

nym-node-status-api/nym-node-status-agent/run.sh

@@ -1,9 +1,9 @@
 #!/bin/bash
 
 set -eu
-export ENVIRONMENT=${ENVIRONMENT:-"sandbox"}
+export ENVIRONMENT=${ENVIRONMENT:-"mainnet"}
 
-probe_git_ref="nym-vpn-core-v1.1.0"
+probe_git_ref="nym-vpn-core-v1.3.2"
 
 crate_root=$(dirname $(realpath "$0"))
 monorepo_root=$(realpath "${crate_root}/../..")
@@ -21,6 +21,7 @@ export NODE_STATUS_AGENT_SERVER_ADDRESS="http://127.0.0.1"
 export NODE_STATUS_AGENT_SERVER_PORT="8000"
 export NODE_STATUS_AGENT_PROBE_PATH="$crate_root/nym-gateway-probe"
 export NODE_STATUS_AGENT_AUTH_KEY="BjyC9SsHAZUzPRkQR4sPTvVrp4GgaquTh5YfSJksvvWT"
+export NODE_STATUS_AGENT_PROBE_EXTRA_ARGS="netstack-download-timeout-sec=30,netstack-num-ping=2,netstack-send-timeout-sec=1,netstack-recv-timeout-sec=1"
 
 workers=${1:-1}
 echo "Running $workers workers in parallel"
@@ -54,7 +55,7 @@ function swarm() {
     echo "All agents completed"
 }
 
-# copy_gw_probe
+copy_gw_probe
 build_agent
 
 swarm $workers

nym-node-status-api/nym-node-status-agent/src/cli/mod.rs

@@ -35,6 +35,13 @@ pub(crate) enum Command {
         /// path of binary to run
         #[arg(long, env = "NODE_STATUS_AGENT_PROBE_PATH")]
         probe_path: String,
+
+        #[arg(
+            long,
+            env = "NODE_STATUS_AGENT_PROBE_EXTRA_ARGS",
+            value_delimiter = ','
+        )]
+        probe_extra_args: Vec<String>,
     },
 
     GenerateKeypair {
@@ -51,11 +58,13 @@ impl Args {
                 server_port,
                 ns_api_auth_key,
                 probe_path,
+                probe_extra_args,
             } => run_probe::run_probe(
                 server_address,
                 server_port.to_owned(),
                 ns_api_auth_key,
                 probe_path,
+                probe_extra_args,
             )
             .await
             .inspect_err(|err| {

nym-node-status-api/nym-node-status-agent/src/cli/run_probe.rs

@@ -7,6 +7,7 @@ pub(crate) async fn run_probe(
     server_port: u16,
     ns_api_auth_key: &str,
     probe_path: &str,
+    probe_extra_args: &Vec<String>,
 ) -> anyhow::Result<()> {
     let auth_key = PrivateKey::from_base58_string(ns_api_auth_key)
         .context("Couldn't parse auth key, exiting")?;
@@ -19,7 +20,7 @@ pub(crate) async fn run_probe(
     tracing::info!("Probe version:\n{}", version);
 
     if let Some(testrun) = ns_api_client.request_testrun().await? {
-        let log = probe.run_and_get_log(&Some(testrun.gateway_identity_key));
+        let log = probe.run_and_get_log(&Some(testrun.gateway_identity_key), probe_extra_args);
 
         ns_api_client
             .submit_results(testrun.testrun_id, log, testrun.assigned_at_utc)

nym-node-status-api/nym-node-status-agent/src/probe.rs

@@ -29,7 +29,11 @@ impl GwProbe {
         }
     }
 
-    pub(crate) fn run_and_get_log(&self, gateway_key: &Option<String>) -> String {
+    pub(crate) fn run_and_get_log(
+        &self,
+        gateway_key: &Option<String>,
+        probe_extra_args: &Vec<String>,
+    ) -> String {
         let mut command = std::process::Command::new(&self.path);
         command.stdout(std::process::Stdio::piped());
 
@@ -37,6 +41,16 @@ impl GwProbe {
             command.arg("--gateway").arg(gateway_id);
         }
 
+        tracing::info!("Extra args for the probe:");
+        for arg in probe_extra_args {
+            let mut split = arg.splitn(2, '=');
+            let name = split.next().unwrap_or_default();
+            let value = split.next().unwrap_or_default();
+            tracing::info!("{} {}", name, value);
+
+            command.arg(format!("--{name}")).arg(value);
+        }
+
         match command.spawn() {
             Ok(child) => {
                 if let Ok(output) = child.wait_with_output() {

nym-node-status-api/nym-node-status-api/launch_node_status_api.sh

@@ -3,7 +3,7 @@
 set -e
 
 user_rust_log_preference=$RUST_LOG
-export ENVIRONMENT=${ENVIRONMENT:-"sandbox"}
+export ENVIRONMENT=${ENVIRONMENT:-"mainnet"}
 export NYM_API_CLIENT_TIMEOUT=60
 export EXPLORER_CLIENT_TIMEOUT=60
 export NODE_STATUS_API_TESTRUN_REFRESH_INTERVAL=120

nym-node/nym-node-metrics/src/mixnet.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use dashmap::DashMap;
+use std::fmt::Display;
 use std::net::{IpAddr, SocketAddr};
 use std::sync::atomic::{AtomicI64, AtomicUsize, Ordering};
 use time::OffsetDateTime;
@@ -52,7 +53,7 @@ impl MixingStats {
         self.ingress.senders.entry(source).or_default().malformed += 1;
     }
 
-    pub fn ingress_received_forward_packet(&self, source: IpAddr) {
+    pub fn ingress_received_forward_packet(&self, source: IpAddr, version: PacketKind) {
         self.ingress
             .forward_hop_packets_received
             .fetch_add(1, Ordering::Relaxed);
@@ -62,9 +63,10 @@ impl MixingStats {
             .or_default()
             .forward_packets
             .received += 1;
+        *self.ingress.received_versions.entry(version).or_default() += 1;
     }
 
-    pub fn ingress_received_final_hop_packet(&self, source: IpAddr) {
+    pub fn ingress_received_final_hop_packet(&self, source: IpAddr, version: PacketKind) {
         self.ingress
             .final_hop_packets_received
             .fetch_add(1, Ordering::Relaxed);
@@ -74,6 +76,7 @@ impl MixingStats {
             .or_default()
             .final_hop_packets
             .received += 1;
+        *self.ingress.received_versions.entry(version).or_default() += 1;
     }
 
     pub fn ingress_excessive_delay_packet(&self) {
@@ -196,8 +199,30 @@ pub struct IngressRecipientStats {
     pub malformed: usize,
 }
 
+#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum PacketKind {
+    #[default]
+    Unknown,
+    Outfox,
+    Sphinx(u16),
+}
+
+impl Display for PacketKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        match self {
+            PacketKind::Unknown => "unknown".fmt(f),
+            PacketKind::Outfox => "outfox".fmt(f),
+            PacketKind::Sphinx(sphinx_version) => {
+                write!(f, "sphinx-{sphinx_version}")
+            }
+        }
+    }
+}
+
 #[derive(Default)]
 pub struct IngressMixingStats {
+    received_versions: DashMap<PacketKind, i64>,
+
     // forward hop packets (i.e. to mixnode)
     forward_hop_packets_received: AtomicUsize,
 
@@ -248,6 +273,10 @@ impl IngressMixingStats {
         &self.senders
     }
 
+    pub fn packet_versions(&self) -> &DashMap<PacketKind, i64> {
+        &self.received_versions
+    }
+
     pub fn remove_stale_sender(&self, sender: IpAddr) {
         self.senders.remove(&sender);
     }

nym-node/nym-node-metrics/src/prometheus_wrapper.rs

@@ -1,6 +1,7 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: GPL-3.0-only
 
+use crate::mixnet::PacketKind;
 use nym_metrics::{metrics_registry, HistogramTimer, Metric};
 use std::sync::LazyLock;
 use strum::{Display, EnumCount, EnumIter, EnumProperty, IntoEnumIterator};
@@ -28,6 +29,10 @@ const CLIENT_SESSION_DURATION_BUCKETS: &[f64] = &[
 pub enum PrometheusMetric {
     // # MIXNET
     // ## INGRESS
+    #[strum(to_string = "mixnet_ingress_packet_version_{kind}")]
+    #[strum(props(help = "The number of ingress packets received with the particular version"))]
+    MixnetIngressPacketVersion { kind: PacketKind },
+
     #[strum(props(help = "The number of ingress forward hop sphinx packets received"))]
     MixnetIngressForwardPacketsReceived,
 
@@ -178,7 +183,11 @@ impl PrometheusMetric {
     }
 
     fn is_complex(&self) -> bool {
-        matches!(self, PrometheusMetric::EntryClientSessionsDurations { .. })
+        matches!(
+            self,
+            PrometheusMetric::EntryClientSessionsDurations { .. }
+                | PrometheusMetric::MixnetIngressPacketVersion { .. }
+        )
         // match self {
         //     PrometheusMetric::EntryClientSessionsDurations { .. } => true,
         //     _ => false,
@@ -190,6 +199,9 @@ impl PrometheusMetric {
         let help = self.help();
 
         match self {
+            PrometheusMetric::MixnetIngressPacketVersion { .. } => {
+                Metric::new_int_gauge(&name, help)
+            }
             PrometheusMetric::MixnetIngressForwardPacketsReceived => {
                 Metric::new_int_gauge(&name, help)
             }
@@ -364,7 +376,7 @@ mod tests {
         // a sanity check for anyone adding new metrics. if this test fails,
         // make sure any methods on `PrometheusMetric` enum don't need updating
         // or require custom Display impl
-        assert_eq!(37, PrometheusMetric::COUNT)
+        assert_eq!(38, PrometheusMetric::COUNT)
     }
 
     #[test]
@@ -385,6 +397,24 @@ mod tests {
         assert_eq!(
             "nym_node_entry_client_sessions_durations_vpn",
             parameterised
-        )
+        );
+
+        let parameterised = PrometheusMetric::MixnetIngressPacketVersion {
+            kind: PacketKind::Outfox,
+        }
+        .to_string();
+        assert_eq!(
+            "nym_node_mixnet_ingress_packet_version_outfox",
+            parameterised
+        );
+
+        let parameterised = PrometheusMetric::MixnetIngressPacketVersion {
+            kind: PacketKind::Sphinx(42),
+        }
+        .to_string();
+        assert_eq!(
+            "nym_node_mixnet_ingress_packet_version_sphinx-42",
+            parameterised
+        );
     }
 }

nym-node/src/node/metrics/handler/global_prometheus_updater/mod.rs

@@ -43,6 +43,15 @@ impl OnUpdateMetricsHandler for PrometheusGlobalNodeMetricsRegistryUpdater {
 
         // # MIXNET
         // ## INGRESS
+        for version_entry in self.metrics.mixnet.ingress.packet_versions() {
+            self.prometheus_wrapper.set(
+                MixnetIngressPacketVersion {
+                    kind: *version_entry.key(),
+                },
+                *version_entry.value(),
+            )
+        }
+
         self.prometheus_wrapper.set(
             MixnetIngressForwardPacketsReceived,
             self.metrics.mixnet.ingress.forward_hop_packets_received() as i64,

nym-node/src/node/mixnet/handler.rs

@@ -8,7 +8,7 @@ use nym_sphinx_forwarding::packet::MixPacket;
 use nym_sphinx_framing::codec::NymCodec;
 use nym_sphinx_framing::packet::FramedNymPacket;
 use nym_sphinx_framing::processing::{
-    process_framed_packet, MixProcessingResult, ProcessedFinalHop,
+    process_framed_packet, MixProcessingResultData, ProcessedFinalHop,
 };
 use nym_sphinx_types::Delay;
 use std::net::SocketAddr;
@@ -44,7 +44,7 @@ impl ConnectionHandler {
         ConnectionHandler {
             shared: SharedData {
                 processing_config: shared.processing_config,
-                sphinx_key: shared.sphinx_key.clone(),
+                sphinx_keys: shared.sphinx_keys.clone(),
                 mixnet_forwarder: shared.mixnet_forwarder.clone(),
                 final_hop: shared.final_hop.clone(),
                 metrics: shared.metrics.clone(),
@@ -135,7 +135,8 @@ impl ConnectionHandler {
 
         nanos!("handle_received_nym_packet", {
             // 1. attempt to unwrap the packet
-            let unwrapped_packet = process_framed_packet(packet, &self.shared.sphinx_key);
+            let unwrapped_packet =
+                process_framed_packet(packet, self.shared.sphinx_keys.private_key().as_ref());
 
             // 2. increment our favourite metrics stats
             self.shared
@@ -144,12 +145,14 @@ impl ConnectionHandler {
             // 3. forward the packet to the relevant sink (if enabled)
             match unwrapped_packet {
                 Err(err) => trace!("failed to process received mix packet: {err}"),
-                Ok(MixProcessingResult::ForwardHop(forward_packet, delay)) => {
-                    self.handle_forward_packet(forward_packet, delay);
-                }
-                Ok(MixProcessingResult::FinalHop(final_hop_data)) => {
-                    self.handle_final_hop(final_hop_data).await;
-                }
+                Ok(processed_packet) => match processed_packet.processing_data {
+                    MixProcessingResultData::ForwardHop { packet, delay } => {
+                        self.handle_forward_packet(packet, delay);
+                    }
+                    MixProcessingResultData::FinalHop { final_hop_data } => {
+                        self.handle_final_hop(final_hop_data).await;
+                    }
+                },
             }
         })
     }

nym-node/src/node/mixnet/shared/mod.rs

@@ -7,9 +7,12 @@ use crate::node::mixnet::SharedFinalHopData;
 use nym_crypto::asymmetric::x25519;
 use nym_gateway::node::GatewayStorageError;
 use nym_mixnet_client::forwarder::{MixForwardingSender, PacketToForward};
+use nym_node_metrics::mixnet::PacketKind;
 use nym_node_metrics::NymNodeMetrics;
 use nym_sphinx_forwarding::packet::MixPacket;
-use nym_sphinx_framing::processing::{MixProcessingResult, PacketProcessingError};
+use nym_sphinx_framing::processing::{
+    MixPacketVersion, MixProcessingResult, MixProcessingResultData, PacketProcessingError,
+};
 use nym_sphinx_types::DestinationAddressBytes;
 use nym_task::ShutdownToken;
 use std::io;
@@ -45,8 +48,7 @@ impl ProcessingConfig {
 // explicitly do NOT derive clone as we want to manually apply relevant suffixes to the task clients
 pub(crate) struct SharedData {
     pub(super) processing_config: ProcessingConfig,
-    // TODO: this type is not `Zeroize` : (
-    pub(super) sphinx_key: Arc<nym_sphinx_types::PrivateKey>,
+    pub(super) sphinx_keys: Arc<x25519::KeyPair>,
 
     // used for FORWARD mix packets and FINAL ack packets
     pub(super) mixnet_forwarder: MixForwardingSender,
@@ -58,10 +60,17 @@ pub(crate) struct SharedData {
     pub(super) shutdown: ShutdownToken,
 }
 
+fn convert_to_metrics_version(processed: MixPacketVersion) -> PacketKind {
+    match processed {
+        MixPacketVersion::Outfox => PacketKind::Outfox,
+        MixPacketVersion::Sphinx(sphinx_version) => PacketKind::Sphinx(sphinx_version.value()),
+    }
+}
+
 impl SharedData {
     pub(crate) fn new(
         processing_config: ProcessingConfig,
-        x25519_key: &x25519::PrivateKey,
+        x25519_keys: Arc<x25519::KeyPair>,
         mixnet_forwarder: MixForwardingSender,
         final_hop: SharedFinalHopData,
         metrics: NymNodeMetrics,
@@ -69,7 +78,7 @@ impl SharedData {
     ) -> Self {
         SharedData {
             processing_config,
-            sphinx_key: Arc::new(x25519_key.into()),
+            sphinx_keys: x25519_keys,
             mixnet_forwarder,
             final_hop,
             metrics,
@@ -99,10 +108,18 @@ impl SharedData {
         processing_result: &Result<MixProcessingResult, PacketProcessingError>,
         source: IpAddr,
     ) {
-        match processing_result {
-            Err(_) => self.metrics.mixnet.ingress_malformed_packet(source),
-            Ok(MixProcessingResult::ForwardHop(_, delay)) => {
-                self.metrics.mixnet.ingress_received_forward_packet(source);
+        let Ok(processing_result) = processing_result else {
+            self.metrics.mixnet.ingress_malformed_packet(source);
+            return;
+        };
+
+        let packet_version = convert_to_metrics_version(processing_result.packet_version);
+
+        match processing_result.processing_data {
+            MixProcessingResultData::ForwardHop { delay, .. } => {
+                self.metrics
+                    .mixnet
+                    .ingress_received_forward_packet(source, packet_version);
 
                 // check if the delay wasn't excessive
                 if let Some(delay) = delay {
@@ -111,10 +128,10 @@ impl SharedData {
                     }
                 }
             }
-            Ok(MixProcessingResult::FinalHop(_)) => {
+            MixProcessingResultData::FinalHop { .. } => {
                 self.metrics
                     .mixnet
-                    .ingress_received_final_hop_packet(source);
+                    .ingress_received_final_hop_packet(source, packet_version);
             }
         }
     }

nym-node/src/node/mod.rs

@@ -993,7 +993,7 @@ impl NymNode {
 
         let shared = mixnet::SharedData::new(
             processing_config,
-            self.x25519_sphinx_keys.private_key(),
+            self.x25519_sphinx_keys.clone(),
             mix_packet_sender.clone(),
             final_hop_data,
             self.metrics.clone(),

nym-outfox/Cargo.toml

@@ -14,7 +14,7 @@ rayon = { workspace = true }
 blake3 = { workspace = true }
 zeroize = { workspace = true }
 chacha20 = { workspace = true, features = ["std"] }
-curve25519-dalek = { workspace = true }
+x25519-dalek = { workspace = true }
 chacha20poly1305 = { workspace = true }
 getrandom = { workspace = true, features = ["js"] }
 thiserror = { workspace = true }

nym-outfox/src/format.rs

@@ -54,17 +54,6 @@
 //! routing data for the layer, and the remaining Header; separately the master key is used to lion encrypt
 //! the payload. The process is repeated for each layer (from last to first) to construct the full message.
 
-use chacha20poly1305::AeadInPlace;
-use chacha20poly1305::ChaCha20Poly1305;
-use chacha20poly1305::KeyInit;
-
-use chacha20poly1305::Tag;
-use curve25519_dalek::constants::ED25519_BASEPOINT_TABLE;
-use curve25519_dalek::montgomery::MontgomeryPoint;
-use curve25519_dalek::scalar::Scalar;
-
-use std::ops::Range;
-
 use crate::constants::groupelementbytes;
 use crate::constants::tagbytes;
 use crate::constants::DEFAULT_HOPS;
@@ -75,6 +64,11 @@ use crate::constants::ROUTING_INFORMATION_LENGTH_BY_STAGE;
 use crate::constants::TAGBYTES;
 use crate::error::OutfoxError;
 use crate::lion::*;
+use chacha20poly1305::AeadInPlace;
+use chacha20poly1305::ChaCha20Poly1305;
+use chacha20poly1305::KeyInit;
+use chacha20poly1305::Tag;
+use std::ops::Range;
 
 /// 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.
@@ -218,13 +212,11 @@ impl MixStageParameters {
     pub fn encode_mix_layer(
         &self,
         buffer: &mut [u8],
-        user_secret_key: &[u8],
-        node_pub_key: &[u8],
+        user_secret_key: &x25519_dalek::StaticSecret,
+        mix_public_key: x25519_dalek::PublicKey,
         destination: &[u8; 32],
-    ) -> Result<MontgomeryPoint, OutfoxError> {
+    ) -> Result<x25519_dalek::SharedSecret, OutfoxError> {
         let routing_data = destination;
-        let mix_public_key = MontgomeryPoint(node_pub_key.try_into()?);
-        let user_secret_key = Scalar::from_bytes_mod_order(user_secret_key.try_into()?);
 
         if buffer.len() != self.incoming_packet_length() {
             return Err(OutfoxError::LenMismatch {
@@ -240,14 +232,14 @@ impl MixStageParameters {
             });
         }
 
-        let user_public_key = (ED25519_BASEPOINT_TABLE * &user_secret_key).to_montgomery();
-        let shared_key = user_secret_key * mix_public_key;
+        let user_public_key = x25519_dalek::PublicKey::from(user_secret_key);
+        let shared_key = user_secret_key.diffie_hellman(&mix_public_key);
 
         // Copy rounting data into buffer
         buffer[self.routing_data_range()].copy_from_slice(routing_data);
 
         // Perform the AEAD
-        let header_aead_key = ChaCha20Poly1305::new_from_slice(&shared_key.0[..])?;
+        let header_aead_key = ChaCha20Poly1305::new_from_slice(shared_key.as_bytes())?;
         let nonce = [0u8; 12];
 
         let tag = header_aead_key
@@ -258,10 +250,10 @@ impl MixStageParameters {
         buffer[self.tag_range()].copy_from_slice(&tag[..]);
 
         // Copy own public key into buffer
-        buffer[self.pub_element_range()].copy_from_slice(&user_public_key.0[..]);
+        buffer[self.pub_element_range()].copy_from_slice(user_public_key.as_bytes());
 
         // Do a round of LION on the payload
-        lion_transform_encrypt(&mut buffer[self.payload_range()], &shared_key.0)?;
+        lion_transform_encrypt(&mut buffer[self.payload_range()], shared_key.as_bytes())?;
 
         Ok(shared_key)
     }
@@ -269,12 +261,9 @@ impl MixStageParameters {
     pub fn decode_mix_layer(
         &self,
         buffer: &mut [u8],
-        mix_secret_key: &[u8],
+        mix_secret_key: &x25519_dalek::StaticSecret,
     ) -> Result<Vec<u8>, OutfoxError> {
         // Check the length of the incoming buffer is correct.
-
-        let mix_secret_key = Scalar::from_bytes_mod_order(mix_secret_key.try_into()?);
-
         if buffer.len() != self.incoming_packet_length() {
             return Err(OutfoxError::LenMismatch {
                 expected: buffer.len(),
@@ -283,11 +272,12 @@ impl MixStageParameters {
         }
 
         // Derive the shared key for this packet
-        let user_public_key = MontgomeryPoint(buffer[self.pub_element_range()].try_into()?);
-        let shared_key = mix_secret_key * user_public_key;
+        let user_public_key_bytes: [u8; 32] = buffer[self.pub_element_range()].try_into()?;
+        let user_public_key = x25519_dalek::PublicKey::from(user_public_key_bytes);
+        let shared_key = mix_secret_key.diffie_hellman(&user_public_key);
 
         // Compute the AEAD and check the Tag, if wrong return Err
-        let header_aead_key = ChaCha20Poly1305::new_from_slice(&shared_key.0[..])?;
+        let header_aead_key = ChaCha20Poly1305::new_from_slice(shared_key.as_bytes())?;
         let nonce = [0; 12];
 
         let tag_bytes = buffer[self.tag_range()].to_vec();
@@ -304,7 +294,7 @@ impl MixStageParameters {
 
         let routing_data = buffer[self.routing_data_range()].to_vec();
         // Do a round of LION on the payload
-        lion_transform_decrypt(&mut buffer[self.payload_range()], &shared_key.0)?;
+        lion_transform_decrypt(&mut buffer[self.payload_range()], shared_key.as_bytes())?;
 
         Ok(routing_data)
     }

nym-outfox/src/packet.rs

@@ -1,17 +1,14 @@
-use std::{array::TryFromSliceError, collections::VecDeque, ops::Range};
-
 use crate::{
     constants::{DEFAULT_HOPS, MAGIC_SLICE, MIN_PACKET_SIZE, MIX_PARAMS_LEN},
     error::OutfoxError,
     format::{MixCreationParameters, MixStageParameters},
 };
-
-use rand::{rngs::OsRng, RngCore};
 use sphinx_packet::{
     crypto::PrivateKey,
     packet::builder::DEFAULT_PAYLOAD_SIZE,
     route::{Destination, Node},
 };
+use std::{array::TryFromSliceError, collections::VecDeque, ops::Range};
 
 #[derive(Debug)]
 pub struct OutfoxPacket {
@@ -90,8 +87,7 @@ impl OutfoxPacket {
         destination: &Destination,
         packet_size: Option<usize>,
     ) -> Result<OutfoxPacket, OutfoxError> {
-        let mut secret_key = [0; 32];
-        OsRng.fill_bytes(&mut secret_key);
+        let secret_key = x25519_dalek::StaticSecret::random();
         let packet_size = packet_size.unwrap_or(DEFAULT_PAYLOAD_SIZE);
         let packet_size = if packet_size < MIN_PACKET_SIZE {
             MIN_PACKET_SIZE
@@ -110,7 +106,7 @@ impl OutfoxPacket {
         stage_params.encode_mix_layer(
             &mut buffer[range],
             &secret_key,
-            route.last().unwrap().pub_key.as_bytes(),
+            route.last().unwrap().pub_key,
             destination.address.as_bytes_ref(),
         )?;
 
@@ -130,11 +126,11 @@ impl OutfoxPacket {
             // We know that we'll always get 4 nodes, so we can unwrap here
             let processing_node = nodes.last().unwrap();
             let destination_node = nodes.first().unwrap();
-            OsRng.fill_bytes(&mut secret_key);
+            let secret_key = x25519_dalek::StaticSecret::random();
             stage_params.encode_mix_layer(
                 &mut buffer[range],
                 &secret_key,
-                processing_node.pub_key.as_bytes(),
+                processing_node.pub_key,
                 destination_node.address.as_bytes_ref(),
             )?;
         }
@@ -168,7 +164,7 @@ impl OutfoxPacket {
     pub fn decode_mix_layer(
         &mut self,
         layer: usize,
-        mix_secret_key: &[u8; 32],
+        mix_secret_key: &x25519_dalek::StaticSecret,
     ) -> Result<Vec<u8>, OutfoxError> {
         let (range, params) = self.stage_params(layer);
         let routing_data =
@@ -198,7 +194,6 @@ impl OutfoxPacket {
         &mut self,
         mix_secret_key: &PrivateKey,
     ) -> Result<[u8; 32], OutfoxError> {
-        let mix_secret_key = mix_secret_key.to_bytes();
         let routing_lenght_by_stage = self
             .mix_params()
             .routing_information_length_by_stage
@@ -210,7 +205,7 @@ impl OutfoxPacket {
                 break;
             }
         }
-        self.decode_mix_layer(layer, &mix_secret_key)?;
+        self.decode_mix_layer(layer, mix_secret_key)?;
         self.update_routing_information(layer)?;
         let (range, stage_params) = self.mix_params().get_stage_params(layer);
         let routing_bytes = &self.payload()[range][stage_params.routing_data_range()];

nym-outfox/tests/unittests.rs

@@ -9,11 +9,9 @@ mod tests {
         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::crypto::{PrivateKey, PublicKey};
     use sphinx_packet::route::Destination;
     use sphinx_packet::route::DestinationAddressBytes;
     use sphinx_packet::route::Node;
@@ -22,6 +20,12 @@ mod tests {
     use nym_outfox::format::*;
     use nym_outfox::lion::*;
 
+    pub fn keygen() -> (PrivateKey, PublicKey) {
+        let private_key = PrivateKey::random();
+        let public_key = PublicKey::from(&private_key);
+        (private_key, public_key)
+    }
+
     #[test]
     fn test_encode_decode() {
         let mix_params = MixStageParameters {
@@ -30,11 +34,9 @@ mod tests {
             payload_length_bytes: 1024, // 1kb
         };
 
-        let user_secret = randombytes(32);
-        let mix_secret = randombytes(32);
-        let mix_secret_scalar =
-            Scalar::from_bytes_mod_order(mix_secret.clone().try_into().unwrap());
-        let mix_public_key = (ED25519_BASEPOINT_TABLE * &mix_secret_scalar).to_montgomery();
+        let user_secret = x25519_dalek::StaticSecret::random();
+        let mix_secret = x25519_dalek::StaticSecret::random();
+        let mix_public_key = x25519_dalek::PublicKey::from(&mix_secret);
 
         let routing = [0; 32];
         let destination = [0; 32];
@@ -52,7 +54,7 @@ mod tests {
             .encode_mix_layer(
                 &mut new_buffer[..],
                 &user_secret,
-                node.pub_key.as_bytes(),
+                node.pub_key,
                 &destination,
             )
             .unwrap();
@@ -93,23 +95,23 @@ mod tests {
 
     #[test]
     fn test_packet_params_short() {
-        let (node1_pk, node1_pub) = sphinx_packet::crypto::keygen();
+        let (node1_pk, node1_pub) = keygen();
         let node1 = Node::new(
             NodeAddressBytes::from_bytes([0u8; NODE_ADDRESS_LENGTH]),
             node1_pub,
         );
-        let (node2_pk, node2_pub) = sphinx_packet::crypto::keygen();
+        let (node2_pk, node2_pub) = keygen();
         let node2 = Node::new(
             NodeAddressBytes::from_bytes([1u8; NODE_ADDRESS_LENGTH]),
             node2_pub,
         );
-        let (node3_pk, node3_pub) = sphinx_packet::crypto::keygen();
+        let (node3_pk, node3_pub) = keygen();
         let node3 = Node::new(
             NodeAddressBytes::from_bytes([2u8; NODE_ADDRESS_LENGTH]),
             node3_pub,
         );
 
-        let (gateway_pk, gateway_pub) = sphinx_packet::crypto::keygen();
+        let (gateway_pk, gateway_pub) = keygen();
         let gateway = Node::new(
             NodeAddressBytes::from_bytes([3u8; NODE_ADDRESS_LENGTH]),
             gateway_pub,
@@ -149,23 +151,23 @@ mod tests {
 
     #[test]
     fn test_packet_params_long() {
-        let (node1_pk, node1_pub) = sphinx_packet::crypto::keygen();
+        let (node1_pk, node1_pub) = keygen();
         let node1 = Node::new(
             NodeAddressBytes::from_bytes([0u8; NODE_ADDRESS_LENGTH]),
             node1_pub,
         );
-        let (node2_pk, node2_pub) = sphinx_packet::crypto::keygen();
+        let (node2_pk, node2_pub) = keygen();
         let node2 = Node::new(
             NodeAddressBytes::from_bytes([1u8; NODE_ADDRESS_LENGTH]),
             node2_pub,
         );
-        let (node3_pk, node3_pub) = sphinx_packet::crypto::keygen();
+        let (node3_pk, node3_pub) = keygen();
         let node3 = Node::new(
             NodeAddressBytes::from_bytes([2u8; NODE_ADDRESS_LENGTH]),
             node3_pub,
         );
 
-        let (gateway_pk, gateway_pub) = sphinx_packet::crypto::keygen();
+        let (gateway_pk, gateway_pub) = keygen();
         let gateway = Node::new(
             NodeAddressBytes::from_bytes([3u8; NODE_ADDRESS_LENGTH]),
             gateway_pub,

nym-wallet/Cargo.lock

@@ -30,7 +30,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
 dependencies = [
  "crypto-common",
- "generic-array 0.14.7",
+ "generic-array",
 ]
 
 [[package]]
@@ -55,7 +55,7 @@ dependencies = [
  "cipher",
  "ctr",
  "ghash",
- "subtle 2.5.0",
+ "subtle",
 ]
 
 [[package]]
@@ -154,16 +154,23 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b2e554a8638bdc1e4eae9984845306cc95f8a9208ba8d49c3859fd958b46774d"
 dependencies = [
  "base64ct",
- "blake2 0.10.6",
+ "blake2",
  "cpufeatures",
  "password-hash",
 ]
 
 [[package]]
-name = "arrayref"
-version = "0.3.7"
+name = "async-compression"
+version = "0.4.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b4930d2cb77ce62f89ee5d5289b4ac049559b1c45539271f5ed4fdc7db34545"
+checksum = "df895a515f70646414f4b45c0b79082783b80552b373a68283012928df56f522"
+dependencies = [
+ "flate2",
+ "futures-core",
+ "memchr",
+ "pin-project-lite",
+ "tokio",
+]
 
 [[package]]
 name = "async-trait"
@@ -306,7 +313,7 @@ dependencies = [
  "ripemd",
  "secp256k1",
  "sha2 0.10.8",
- "subtle 2.5.0",
+ "subtle",
  "zeroize",
 ]
 
@@ -342,18 +349,6 @@ version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4682ae6287fcf752ecaabbfcc7b6f9b72aa33933dc23a554d853aea8eea8635"
 
-[[package]]
-name = "blake2"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94cb07b0da6a73955f8fb85d24c466778e70cda767a568229b104f0264089330"
-dependencies = [
- "byte-tools",
- "crypto-mac",
- "digest 0.8.1",
- "opaque-debug 0.2.3",
-]
-
 [[package]]
 name = "blake2"
 version = "0.10.6"
@@ -375,7 +370,7 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
 dependencies = [
- "generic-array 0.14.7",
+ "generic-array",
 ]
 
 [[package]]
@@ -384,7 +379,7 @@ version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
 dependencies = [
- "generic-array 0.14.7",
+ "generic-array",
 ]
 
 [[package]]
@@ -399,7 +394,7 @@ dependencies = [
  "rand_core 0.6.4",
  "serde",
  "serdect 0.3.0-pre.0",
- "subtle 2.5.0",
+ "subtle",
  "zeroize",
 ]
 
@@ -456,12 +451,6 @@ version = "3.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a3e2c3daef883ecc1b5d58c15adae93470a91d425f3532ba1695849656af3fc1"
 
-[[package]]
-name = "byte-tools"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
-
 [[package]]
 name = "bytemuck"
 version = "1.13.1"
@@ -560,9 +549,9 @@ dependencies = [
 
 [[package]]
 name = "celes"
-version = "2.4.0"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39b9a21273925d7cc9e8a9a5f068122341336813c607014f5ef64f82b6acba58"
+checksum = "54441489dce7026efc8f01d1aa996c23fa39dd615a953d0e934433a42f61dd30"
 dependencies = [
  "serde",
 ]
@@ -608,16 +597,6 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
-[[package]]
-name = "chacha"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddf3c081b5fba1e5615640aae998e0fbd10c24cbd897ee39ed754a77601a4862"
-dependencies = [
- "byteorder",
- "keystream",
-]
-
 [[package]]
 name = "cipher"
 version = "0.4.4"
@@ -724,13 +703,12 @@ dependencies = [
 
 [[package]]
 name = "colored"
-version = "2.0.4"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2674ec482fbc38012cf31e6c42ba0177b431a0cb6f15fe40efa5aab1bda516f6"
+checksum = "117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c"
 dependencies = [
- "is-terminal",
  "lazy_static",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -973,9 +951,9 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf4c2f4e1afd912bc40bfd6fed5d9dc1f288e0ba01bfcc835cc5bc3eb13efe15"
 dependencies = [
- "generic-array 0.14.7",
+ "generic-array",
  "rand_core 0.6.4",
- "subtle 2.5.0",
+ "subtle",
  "zeroize",
 ]
 
@@ -985,21 +963,11 @@ version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
- "generic-array 0.14.7",
+ "generic-array",
  "rand_core 0.6.4",
  "typenum",
 ]
 
-[[package]]
-name = "crypto-mac"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4434400df11d95d556bac068ddfedd482915eb18fe8bea89bc80b6e4b1c179e5"
-dependencies = [
- "generic-array 0.12.4",
- "subtle 1.0.0",
-]
-
 [[package]]
 name = "cssparser"
 version = "0.27.2"
@@ -1055,7 +1023,7 @@ dependencies = [
  "byteorder",
  "digest 0.9.0",
  "rand_core 0.5.1",
- "subtle 2.5.0",
+ "subtle",
  "zeroize",
 ]
 
@@ -1073,7 +1041,7 @@ dependencies = [
  "platforms",
  "rustc_version",
  "serde",
- "subtle 2.5.0",
+ "subtle",
  "zeroize",
 ]
 
@@ -1283,22 +1251,13 @@ dependencies = [
  "syn 1.0.109",
 ]
 
-[[package]]
-name = "digest"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"
-dependencies = [
- "generic-array 0.12.4",
-]
-
 [[package]]
 name = "digest"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
 dependencies = [
- "generic-array 0.14.7",
+ "generic-array",
 ]
 
 [[package]]
@@ -1310,7 +1269,7 @@ dependencies = [
  "block-buffer 0.10.4",
  "const-oid",
  "crypto-common",
- "subtle 2.5.0",
+ "subtle",
 ]
 
 [[package]]
@@ -1475,7 +1434,7 @@ dependencies = [
  "rand_core 0.6.4",
  "serde",
  "sha2 0.10.8",
- "subtle 2.5.0",
+ "subtle",
  "zeroize",
 ]
 
@@ -1510,13 +1469,13 @@ dependencies = [
  "crypto-bigint",
  "digest 0.10.7",
  "ff",
- "generic-array 0.14.7",
+ "generic-array",
  "group",
  "pkcs8",
  "rand_core 0.6.4",
  "sec1",
  "serdect 0.2.0",
- "subtle 2.5.0",
+ "subtle",
  "zeroize",
 ]
 
@@ -1629,7 +1588,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
 dependencies = [
  "rand_core 0.6.4",
- "subtle 2.5.0",
+ "subtle",
 ]
 
 [[package]]
@@ -1909,15 +1868,6 @@ dependencies = [
  "windows 0.48.0",
 ]
 
-[[package]]
-name = "generic-array"
-version = "0.12.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffdf9f34f1447443d37393cc6c2b8313aebddcd96906caf34e54c68d8e57d7bd"
-dependencies = [
- "typenum",
-]
-
 [[package]]
 name = "generic-array"
 version = "0.14.7"
@@ -1971,7 +1921,7 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d930750de5717d2dd0b8c0d42c076c0e884c81a73e6cab859bbd2339c71e3e40"
 dependencies = [
- "opaque-debug 0.3.0",
+ "opaque-debug",
  "polyval",
 ]
 
@@ -2094,7 +2044,7 @@ checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
 dependencies = [
  "ff",
  "rand_core 0.6.4",
- "subtle 2.5.0",
+ "subtle",
 ]
 
 [[package]]
@@ -2322,15 +2272,6 @@ dependencies = [
  "webpki-roots 0.25.4",
 ]
 
-[[package]]
-name = "hkdf"
-version = "0.12.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7"
-dependencies = [
- "hmac",
-]
-
 [[package]]
 name = "hmac"
 version = "0.12.1"
@@ -2813,7 +2754,7 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5"
 dependencies = [
- "generic-array 0.14.7",
+ "generic-array",
 ]
 
 [[package]]
@@ -2970,12 +2911,6 @@ dependencies = [
  "signature",
 ]
 
-[[package]]
-name = "keystream"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c33070833c9ee02266356de0c43f723152bd38bd96ddf52c82b3af10c9138b28"
-
 [[package]]
 name = "kuchiki"
 version = "0.8.1"
@@ -3000,12 +2935,6 @@ version = "0.2.169"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"
 
-[[package]]
-name = "libm"
-version = "0.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7012b1bbb0719e1097c47611d3898568c546d597c2e74d66f6087edd5233ff4"
-
 [[package]]
 name = "line-wrap"
 version = "0.1.1"
@@ -3027,18 +2956,6 @@ version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57bcfdad1b858c2db7c38303a6d2ad4dfaf5eb53dfeb0910128b2c26d6158503"
 
-[[package]]
-name = "lioness"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ae926706ba42c425c9457121178330d75e273df2e82e28b758faf3de3a9acb9"
-dependencies = [
- "arrayref",
- "blake2 0.8.1",
- "chacha",
- "keystream",
-]
-
 [[package]]
 name = "litemap"
 version = "0.7.4"
@@ -3309,7 +3226,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f30b0abd723be7e2ffca1272140fac1a2f084c77ec3e123c192b66af1ee9e6c2"
 dependencies = [
  "autocfg",
- "libm",
 ]
 
 [[package]]
@@ -3424,7 +3340,7 @@ dependencies = [
  "rand 0.8.5",
  "serde",
  "sha2 0.9.9",
- "subtle 2.5.0",
+ "subtle",
  "thiserror 2.0.11",
  "zeroize",
 ]
@@ -3645,7 +3561,6 @@ dependencies = [
 name = "nym-sphinx-types"
 version = "0.2.0"
 dependencies = [
- "sphinx-packet",
  "thiserror 2.0.11",
 ]
 
@@ -3655,7 +3570,7 @@ version = "0.1.0"
 dependencies = [
  "aes-gcm",
  "argon2",
- "generic-array 0.14.7",
+ "generic-array",
  "getrandom 0.2.10",
  "rand 0.8.5",
  "serde",
@@ -3715,7 +3630,7 @@ dependencies = [
  "base64 0.22.1",
  "bip32",
  "bip39",
- "colored 2.0.4",
+ "colored 2.2.0",
  "cosmrs 0.21.1",
  "cosmwasm-std",
  "cw-controllers",
@@ -3823,7 +3738,7 @@ dependencies = [
  "base64 0.13.1",
  "bip39",
  "cfg-if",
- "colored 2.0.4",
+ "colored 2.2.0",
  "cosmrs 0.21.1",
  "cosmwasm-std",
  "dirs 4.0.0",
@@ -3921,12 +3836,6 @@ version = "1.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "945462a4b81e43c4e3ba96bd7b49d834c6f61198356aa858733bc4acf3cbe62e"
 
-[[package]]
-name = "opaque-debug"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
-
 [[package]]
 name = "opaque-debug"
 version = "0.3.0"
@@ -4064,7 +3973,7 @@ checksum = "346f04948ba92c43e8469c1ee6736c7563d71012b17d40745260fe106aac2166"
 dependencies = [
  "base64ct",
  "rand_core 0.6.4",
- "subtle 2.5.0",
+ "subtle",
 ]
 
 [[package]]
@@ -4354,7 +4263,7 @@ checksum = "d52cff9d1d4dee5fe6d03729099f4a310a41179e0a10dbf542039873f2e826fb"
 dependencies = [
  "cfg-if",
  "cpufeatures",
- "opaque-debug 0.3.0",
+ "opaque-debug",
  "universal-hash",
 ]
 
@@ -4605,16 +4514,6 @@ dependencies = [
  "getrandom 0.2.10",
 ]
 
-[[package]]
-name = "rand_distr"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32cb0b9bc82b0a0876c2dd994a7e7a2683d3e7390ca40e6886785ef0c7e3ee31"
-dependencies = [
- "num-traits",
- "rand 0.8.5",
-]
-
 [[package]]
 name = "rand_hc"
 version = "0.2.0"
@@ -4758,6 +4657,7 @@ version = "0.12.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "566cafdd92868e0939d3fb961bd0dc25fcfaaed179291093b3d43e6b3150ea10"
 dependencies = [
+ "async-compression",
  "base64 0.22.1",
  "bytes",
  "encoding_rs",
@@ -4790,6 +4690,7 @@ dependencies = [
  "tokio",
  "tokio-native-tls",
  "tokio-rustls 0.25.0",
+ "tokio-util",
  "tower-service",
  "url",
  "wasm-bindgen",
@@ -4816,7 +4717,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
 dependencies = [
  "hmac",
- "subtle 2.5.0",
+ "subtle",
 ]
 
 [[package]]
@@ -4925,7 +4826,7 @@ dependencies = [
  "ring",
  "rustls-pki-types",
  "rustls-webpki 0.102.4",
- "subtle 2.5.0",
+ "subtle",
  "zeroize",
 ]
 
@@ -5078,10 +4979,10 @@ checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
 dependencies = [
  "base16ct",
  "der",
- "generic-array 0.14.7",
+ "generic-array",
  "pkcs8",
  "serdect 0.2.0",
- "subtle 2.5.0",
+ "subtle",
  "zeroize",
 ]
 
@@ -5332,7 +5233,7 @@ dependencies = [
  "cfg-if",
  "cpufeatures",
  "digest 0.9.0",
- "opaque-debug 0.3.0",
+ "opaque-debug",
 ]
 
 [[package]]
@@ -5449,31 +5350,6 @@ dependencies = [
  "system-deps 5.0.0",
 ]
 
-[[package]]
-name = "sphinx-packet"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dabeca95bf5fd0563d6be7ebcb1c6a9fcb135746a0ba9050c47dc68c8607e595"
-dependencies = [
- "aes",
- "arrayref",
- "blake2 0.8.1",
- "bs58",
- "byteorder",
- "chacha",
- "ctr",
- "curve25519-dalek 4.1.2",
- "digest 0.10.7",
- "hkdf",
- "hmac",
- "lioness",
- "log",
- "rand 0.8.5",
- "rand_distr",
- "sha2 0.10.8",
- "subtle 2.5.0",
-]
-
 [[package]]
 name = "spin"
 version = "0.9.8"
@@ -5581,12 +5457,6 @@ dependencies = [
  "syn 2.0.96",
 ]
 
-[[package]]
-name = "subtle"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d67a5a62ba6e01cb2192ff309324cb4875d0c451d55fe2319433abe7a05a8ee"
-
 [[package]]
 name = "subtle"
 version = "2.5.0"
@@ -5977,7 +5847,7 @@ dependencies = [
  "serde_repr",
  "sha2 0.10.8",
  "signature",
- "subtle 2.5.0",
+ "subtle",
  "subtle-encoding",
  "tendermint-proto 0.34.0",
  "time",
@@ -6007,7 +5877,7 @@ dependencies = [
  "serde_repr",
  "sha2 0.10.8",
  "signature",
- "subtle 2.5.0",
+ "subtle",
  "subtle-encoding",
  "tendermint-proto 0.40.1",
  "time",
@@ -6080,7 +5950,7 @@ dependencies = [
  "serde",
  "serde_bytes",
  "serde_json",
- "subtle 2.5.0",
+ "subtle",
  "subtle-encoding",
  "tendermint 0.40.1",
  "tendermint-config",
@@ -6544,7 +6414,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
 dependencies = [
  "crypto-common",
- "subtle 2.5.0",
+ "subtle",
 ]
 
 [[package]]

wasm/zknym-lib/src/generic_scheme/coconut/types.rs

@@ -156,15 +156,3 @@ pub struct UnblindableShare {
     pub issuer_key_bs58: String,
     pub blinded_share_bs58: String,
 }
-
-#[wasm_bindgen]
-impl UnblindableShare {
-    #[wasm_bindgen(constructor)]
-    pub fn new(issuer_index: u64, issuer_key_bs58: String, blinded_share_bs58: String) -> Self {
-        UnblindableShare {
-            issuer_index,
-            issuer_key_bs58,
-            blinded_share_bs58,
-        }
-    }
-}