Move const to wireguard types

.dockerignore

@@ -1,7 +0,0 @@
-.git
-.github
-.gitignore
-**/node_modules
-**/target
-dist
-documentation

.gitignore

@@ -48,7 +48,4 @@ foxyfox.env
 
 .next
 ppa-private-key.b64
-ppa-private-key.asc
-nym-network-monitor/topology.json
-nym-network-monitor/__pycache__
-nym-network-monitor/*.key
+ppa-private-key.asc

Cargo.lock

@@ -347,14 +347,6 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
 
-[[package]]
-name = "autodoc"
-version = "0.1.0"
-dependencies = [
- "env_logger 0.11.5",
- "log",
-]
-
 [[package]]
 name = "axum"
 version = "0.6.20"
@@ -1866,7 +1858,6 @@ dependencies = [
  "lock_api",
  "once_cell",
  "parking_lot_core 0.9.10",
- "serde",
 ]
 
 [[package]]
@@ -2193,16 +2184,6 @@ dependencies = [
  "cfg-if",
 ]
 
-[[package]]
-name = "env_filter"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f2c92ceda6ceec50f43169f9ee8424fe2db276791afde7b2cd8bc084cb376ab"
-dependencies = [
- "log",
- "regex",
-]
-
 [[package]]
 name = "env_logger"
 version = "0.7.1"
@@ -2226,19 +2207,6 @@ dependencies = [
  "regex",
 ]
 
-[[package]]
-name = "env_logger"
-version = "0.11.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e13fa619b91fb2381732789fc5de83b45675e882f66623b7d8cb4f643017018d"
-dependencies = [
- "anstream",
- "anstyle",
- "env_filter",
- "humantime 2.1.0",
- "log",
-]
-
 [[package]]
 name = "equivalent"
 version = "1.0.1"
@@ -2429,12 +2397,6 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
-[[package]]
-name = "fixedbitset"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
-
 [[package]]
 name = "flate2"
 version = "1.0.30"
@@ -4291,7 +4253,6 @@ dependencies = [
  "nym-sphinx",
  "nym-task",
  "nym-topology",
- "nym-types",
  "nym-validator-client",
  "nym-vesting-contract-common",
  "okapi",
@@ -4618,7 +4579,6 @@ dependencies = [
  "nym-topology",
  "nym-validator-client",
  "rand 0.8.5",
- "rand_chacha 0.3.1",
  "serde",
  "serde_json",
  "sha2 0.10.8",
@@ -5450,36 +5410,6 @@ dependencies = [
  "url",
 ]
 
-[[package]]
-name = "nym-network-monitor"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "axum 0.7.5",
- "clap 4.5.7",
- "dashmap",
- "futures",
- "log",
- "nym-bin-common",
- "nym-crypto",
- "nym-network-defaults",
- "nym-sdk",
- "nym-sphinx",
- "nym-topology",
- "nym-types",
- "nym-validator-client",
- "petgraph",
- "rand 0.8.5",
- "rand_chacha 0.3.1",
- "reqwest 0.12.4",
- "serde",
- "serde_json",
- "tokio",
- "tokio-util",
- "utoipa",
- "utoipa-swagger-ui",
-]
-
 [[package]]
 name = "nym-network-requester"
 version = "1.1.40"
@@ -5645,7 +5575,6 @@ dependencies = [
  "nym-task",
  "nym-topology",
  "rand 0.8.5",
- "rand_chacha 0.3.1",
  "serde",
  "serde_json",
  "thiserror",
@@ -5929,7 +5858,6 @@ version = "0.1.0"
 dependencies = [
  "log",
  "nym-crypto",
- "nym-metrics",
  "nym-mixnet-contract-common",
  "nym-sphinx-acknowledgements",
  "nym-sphinx-addressing",
@@ -5943,7 +5871,6 @@ dependencies = [
  "nym-sphinx-types",
  "nym-topology",
  "rand 0.8.5",
- "rand_chacha 0.3.1",
  "rand_distr",
  "thiserror",
  "tokio",
@@ -6000,17 +5927,12 @@ dependencies = [
 name = "nym-sphinx-chunking"
 version = "0.1.0"
 dependencies = [
- "dashmap",
  "log",
- "nym-crypto",
- "nym-metrics",
  "nym-sphinx-addressing",
  "nym-sphinx-params",
  "nym-sphinx-types",
  "rand 0.8.5",
- "serde",
  "thiserror",
- "utoipa",
 ]
 
 [[package]]
@@ -6124,7 +6046,6 @@ dependencies = [
  "nym-sphinx-routing",
  "nym-sphinx-types",
  "rand 0.8.5",
- "reqwest 0.12.4",
  "semver 0.11.0",
  "serde",
  "serde_json",
@@ -6321,6 +6242,7 @@ name = "nym-wireguard-types"
 version = "0.1.0"
 dependencies = [
  "base64 0.21.7",
+ "dashmap",
  "hmac",
  "log",
  "nym-config",
@@ -6761,16 +6683,6 @@ dependencies = [
  "sha2 0.10.8",
 ]
 
-[[package]]
-name = "petgraph"
-version = "0.6.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
-dependencies = [
- "fixedbitset",
- "indexmap 2.2.6",
-]
-
 [[package]]
 name = "pin-project"
 version = "1.1.5"

Cargo.toml

@@ -14,6 +14,7 @@ panic = "abort"
 opt-level = 3
 
 [workspace]
+
 resolver = "2"
 members = [
     "clients/native",
@@ -93,7 +94,6 @@ members = [
     "common/wasm/utils",
     "common/wireguard",
     "common/wireguard-types",
-    "documentation/autodoc",
     "explorer-api",
     "explorer-api/explorer-api-requests",
     "explorer-api/explorer-client",
@@ -106,7 +106,6 @@ members = [
     "service-providers/common",
     "service-providers/ip-packet-router",
     "service-providers/network-requester",
-    "nym-network-monitor",
     "nym-api",
     "nym-browser-extension/storage",
     "nym-api/nym-api-requests",
@@ -160,7 +159,6 @@ homepage = "https://nymtech.net"
 documentation = "https://nymtech.net"
 edition = "2021"
 license = "Apache-2.0"
-rust-version = "1.80"
 
 [workspace.dependencies]
 addr = "0.15.6"

clients/native/src/websocket/handler.rs

@@ -422,7 +422,7 @@ impl Handler {
     ) {
         // We don't want a crash in the connection handler to trigger a shutdown of the whole
         // process.
-        task_client.disarm();
+        task_client.mark_as_success();
 
         let ws_stream = match accept_async(socket).await {
             Ok(ws_stream) => ws_stream,

common/client-core/Cargo.toml

@@ -19,7 +19,6 @@ futures = { workspace = true }
 humantime-serde = { workspace = true }
 log = { workspace = true }
 rand = { workspace = true }
-rand_chacha = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 sha2 = { workspace = true }

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

@@ -455,7 +455,7 @@ where
                 Err(ClientCoreError::CustomGatewaySelectionExpected)
             } else {
                 // and make sure to invalidate the task client so we wouldn't cause premature shutdown
-                shutdown.disarm();
+                shutdown.mark_as_success();
                 custom_gateway_transceiver.set_packet_router(packet_router)?;
                 Ok(custom_gateway_transceiver)
             };
@@ -562,7 +562,7 @@ where
         if topology_config.disable_refreshing {
             // if we're not spawning the refresher, don't cause shutdown immediately
             info!("The topology refesher is not going to be started");
-            shutdown.disarm();
+            shutdown.mark_as_success();
         } else {
             // don't spawn the refresher if we don't want to be refreshing the topology.
             // only use the initial values obtained

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

@@ -458,7 +458,7 @@ impl PacketStatisticsControl {
 
     fn report_rates(&self) {
         if let Some((_, rates)) = self.rates.back() {
-            log::debug!("{}", rates.summary());
+            log::info!("{}", rates.summary());
             log::debug!("{}", rates.detailed_summary());
         }
     }
@@ -486,7 +486,7 @@ impl PacketStatisticsControl {
             // Check what the number of retransmissions was during the recording window
             if let Some((_, start_stats)) = self.history.front() {
                 let delta = self.stats.clone() - start_stats.clone();
-                log::debug!(
+                log::info!(
                     "mix packet retransmissions/real mix packets: {}/{}",
                     delta.retransmissions_queued,
                     delta.real_packets_queued,

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

@@ -453,7 +453,6 @@ where
 
         let mut pending_acks = Vec::with_capacity(fragments.len());
         let mut real_messages = Vec::with_capacity(fragments.len());
-        debug!("Splitting message into {} fragments", fragments.len());
         for fragment in fragments {
             // we need to clone it because we need to keep it in memory in case we had to retransmit
             // it. And then we'd need to recreate entire ACK again.

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

@@ -474,6 +474,13 @@ where
             Poll::Ready(Some((real_messages, conn_id))) => {
                 log::trace!("handling real_messages: size: {}", real_messages.len());
 
+                // This is the last step in the pipeline where we know the type of the message, so
+                // lets count the number of retransmissions here.
+                if conn_id == TransmissionLane::Retransmission {
+                    self.stats_tx
+                        .report(PacketStatisticsEvent::RetransmissionQueued);
+                }
+
                 // First store what we got for the given connection id
                 self.transmission_buffer.store(&conn_id, real_messages);
                 let real_next = self.pop_next_message().expect("we just added one");

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

@@ -46,34 +46,13 @@ const MEASUREMENTS: usize = 3;
 const CONN_TIMEOUT: Duration = Duration::from_millis(1500);
 const PING_TIMEOUT: Duration = Duration::from_millis(1000);
 
-// The abstraction that some of these helpers use
-pub trait ConnectableGateway {
-    fn identity(&self) -> &identity::PublicKey;
-    fn clients_address(&self) -> String;
-    fn is_wss(&self) -> bool;
-}
-
-impl ConnectableGateway for gateway::Node {
-    fn identity(&self) -> &identity::PublicKey {
-        self.identity()
-    }
-
-    fn clients_address(&self) -> String {
-        self.clients_address()
-    }
-
-    fn is_wss(&self) -> bool {
-        self.clients_wss_port.is_some()
-    }
-}
-
-struct GatewayWithLatency<'a, G: ConnectableGateway> {
-    gateway: &'a G,
+struct GatewayWithLatency<'a> {
+    gateway: &'a gateway::Node,
     latency: Duration,
 }
 
-impl<'a, G: ConnectableGateway> GatewayWithLatency<'a, G> {
-    fn new(gateway: &'a G, latency: Duration) -> Self {
+impl<'a> GatewayWithLatency<'a> {
+    fn new(gateway: &'a gateway::Node, latency: Duration) -> Self {
         GatewayWithLatency { gateway, latency }
     }
 }
@@ -151,14 +130,11 @@ async fn connect(endpoint: &str) -> Result<WsConn, ClientCoreError> {
     JSWebsocket::new(endpoint).map_err(|_| ClientCoreError::GatewayJsConnectionFailure)
 }
 
-async fn measure_latency<G>(gateway: &G) -> Result<GatewayWithLatency<G>, ClientCoreError>
-where
-    G: ConnectableGateway,
-{
+async fn measure_latency(gateway: &gateway::Node) -> Result<GatewayWithLatency, ClientCoreError> {
     let addr = gateway.clients_address();
     trace!(
         "establishing connection to {} ({addr})...",
-        gateway.identity(),
+        gateway.identity_key,
     );
     let mut stream = connect(&addr).await?;
 
@@ -201,7 +177,7 @@ where
     let count = results.len() as u64;
     if count == 0 {
         return Err(ClientCoreError::NoGatewayMeasurements {
-            identity: gateway.identity().to_base58_string(),
+            identity: gateway.identity_key.to_base58_string(),
         });
     }
 
@@ -211,11 +187,11 @@ where
     Ok(GatewayWithLatency::new(gateway, avg))
 }
 
-pub async fn choose_gateway_by_latency<'a, R: Rng, G: ConnectableGateway + Clone>(
+pub async fn choose_gateway_by_latency<R: Rng>(
     rng: &mut R,
-    gateways: &[G],
+    gateways: &[gateway::Node],
     must_use_tls: bool,
-) -> Result<G, ClientCoreError> {
+) -> Result<gateway::Node, ClientCoreError> {
     let gateways = filter_by_tls(gateways, must_use_tls)?;
 
     info!(
@@ -247,19 +223,21 @@ pub async fn choose_gateway_by_latency<'a, R: Rng, G: ConnectableGateway + Clone
 
     info!(
         "chose gateway {} with average latency of {:?}",
-        chosen.gateway.identity(),
-        chosen.latency
+        chosen.gateway.identity_key, chosen.latency
     );
 
     Ok(chosen.gateway.clone())
 }
 
-fn filter_by_tls<G: ConnectableGateway>(
-    gateways: &[G],
+fn filter_by_tls(
+    gateways: &[gateway::Node],
     must_use_tls: bool,
-) -> Result<Vec<&G>, ClientCoreError> {
+) -> Result<Vec<&gateway::Node>, ClientCoreError> {
     if must_use_tls {
-        let filtered = gateways.iter().filter(|g| g.is_wss()).collect::<Vec<_>>();
+        let filtered = gateways
+            .iter()
+            .filter(|g| g.clients_wss_port.is_some())
+            .collect::<Vec<_>>();
 
         if filtered.is_empty() {
             return Err(ClientCoreError::NoWssGateways);

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

@@ -70,8 +70,8 @@ impl PacketRouter {
         Ok(())
     }
 
-    pub fn disarm(&mut self) {
-        self.shutdown.disarm();
+    pub fn mark_as_success(&mut self) {
+        self.shutdown.mark_as_success();
     }
 }
 

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

@@ -113,8 +113,8 @@ impl PartiallyDelegatedRouter {
         let return_res = match ret {
             Err(err) => self.stream_return.send(Err(err)),
             Ok(_) => {
-                self.packet_router.disarm();
-                task_client.disarm();
+                self.packet_router.mark_as_success();
+                task_client.mark_as_success();
                 self.stream_return.send(Ok(split_stream))
             }
         };

common/client-libs/validator-client/Cargo.toml

@@ -90,6 +90,4 @@ default = ["http-client"]
 http-client = ["cosmrs/rpc"]
 generate-ts = []
 contract-testing = ["nym-mixnet-contract-common/contract-testing"]
-# Features below are added to make clippy happy, it seems like they're unused we should remove them
-tendermint-rpc-http-client = ["tendermint-rpc/http-client"]
-tendermint-rpc-websocket-client = ["tendermint-rpc/websocket-client"]
+

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

@@ -49,7 +49,5 @@ pub const COMPUTE_REWARD_ESTIMATION: &str = "compute-reward-estimation";
 pub const AVG_UPTIME: &str = "avg_uptime";
 pub const STAKE_SATURATION: &str = "stake-saturation";
 pub const INCLUSION_CHANCE: &str = "inclusion-probability";
-pub const SUBMIT_GATEWAY: &str = "submit-gateway-monitoring-results";
-pub const SUBMIT_NODE: &str = "submit-node-monitoring-results";
 
 pub const SERVICE_PROVIDERS: &str = "services";

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

@@ -300,8 +300,8 @@ where
     }
 
     #[cfg(any(
-        feature = "tendermint-rpc-http-client",
-        feature = "tendermint-rpc-websocket-client"
+        feature = "tendermint-rpc/http-client",
+        feature = "tendermint-rpc/websocket-client"
     ))]
     async fn wait_until_healthy<T>(&self, timeout: T) -> Result<(), Error>
     where

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

@@ -820,8 +820,8 @@ where
     }
 
     #[cfg(any(
-        feature = "tendermint-rpc-http-client",
-        feature = "tendermint-rpc-websocket-client"
+        feature = "tendermint-rpc/http-client",
+        feature = "tendermint-rpc/websocket-client"
     ))]
     async fn wait_until_healthy<T>(&self, timeout: T) -> Result<(), Error>
     where

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

@@ -300,8 +300,8 @@ pub trait TendermintRpcClient {
     }
 
     #[cfg(any(
-        feature = "tendermint-rpc-http-client",
-        feature = "tendermint-rpc-websocket-client"
+        feature = "tendermint-rpc/http-client",
+        feature = "tendermint-rpc/websocket-client"
     ))]
     /// Poll the `/health` endpoint until it returns a successful result or
     /// the given `timeout` has elapsed.
@@ -518,8 +518,8 @@ mod non_wasm {
         }
 
         #[cfg(any(
-            feature = "tendermint-rpc-http-client",
-            feature = "tendermint-rpc-websocket-client"
+            feature = "tendermint-rpc/http-client",
+            feature = "tendermint-rpc/websocket-client"
         ))]
         async fn wait_until_healthy<T>(&self, timeout: T) -> Result<(), Error>
         where

common/gateway-storage/src/lib.rs

@@ -22,7 +22,7 @@ use tracing::{debug, error};
 pub mod bandwidth;
 pub mod error;
 mod inboxes;
-pub mod models;
+pub(crate) mod models;
 mod shared_keys;
 mod tickets;
 #[cfg(feature = "wireguard")]

common/mixnode-common/src/verloc/listener.rs

@@ -57,7 +57,7 @@ impl PacketListener {
             // cloning the arc as each accepted socket is handled in separate task
             let connection_handler = Arc::clone(&self.connection_handler);
             let mut handler_shutdown_listener = self.shutdown.clone();
-            handler_shutdown_listener.disarm();
+            handler_shutdown_listener.mark_as_success();
 
             tokio::select! {
                 socket = listener.accept() => {

common/mixnode-common/src/verloc/mod.rs

@@ -245,7 +245,7 @@ impl VerlocMeasurer {
         }
 
         let mut shutdown_listener = self.shutdown_listener.clone().named("VerlocMeasurement");
-        shutdown_listener.disarm();
+        shutdown_listener.mark_as_success();
 
         for chunk in nodes_to_test.chunks(self.config.tested_nodes_batch_size) {
             let mut chunk_results = Vec::with_capacity(chunk.len());

common/mixnode-common/src/verloc/sender.rs

@@ -84,7 +84,7 @@ impl PacketSender {
         tested_node: TestedNode,
     ) -> Result<VerlocMeasurement, RttError> {
         let mut shutdown_listener = self.shutdown_listener.fork(tested_node.address.to_string());
-        shutdown_listener.disarm();
+        shutdown_listener.mark_as_success();
 
         let mut conn = match tokio::time::timeout(
             self.connection_timeout,

common/node-tester-utils/Cargo.toml

@@ -9,12 +9,11 @@ license.workspace = true
 [dependencies]
 futures = { workspace = true }
 rand = { workspace = true }
-rand_chacha = { workspace = true }
 
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
-tokio = { workspace = true, features = ["macros"] }
+tokio = { workspace = true, features = ["macros"]}
 
 nym-crypto = { path = "../crypto", features = ["asymmetric"] }
 nym-task = { path = "../task" }

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

@@ -294,8 +294,4 @@ impl<R: CryptoRng + Rng> FragmentPreparer for NodeTester<R> {
     fn average_ack_delay(&self) -> Duration {
         self.average_ack_delay
     }
-
-    fn nonce(&self) -> i32 {
-        1
-    }
 }

common/nymsphinx/Cargo.toml

@@ -11,7 +11,6 @@ repository = { workspace = true }
 log = { workspace = true }
 rand = { workspace = true }
 rand_distr = { workspace = true }
-rand_chacha = { workspace = true }
 thiserror = { workspace = true }
 
 nym-sphinx-acknowledgements = { path = "acknowledgements" }
@@ -28,13 +27,10 @@ nym-sphinx-types = { path = "types" }
 # to separate crate?
 nym-crypto = { path = "../crypto", version = "0.4.0" }
 nym-topology = { path = "../topology" }
-nym-metrics = { path = "../nym-metrics" }
 
 [dev-dependencies]
 nym-mixnet-contract-common = { path = "../cosmwasm-smart-contracts/mixnet-contract" }
-nym-crypto = { path = "../crypto", version = "0.4.0", features = [
-    "asymmetric",
-] }
+nym-crypto = { path = "../crypto", version = "0.4.0", features = ["asymmetric"] }
 
 # do not include this when compiling into wasm as it somehow when combined together with reqwest, it will require
 # net2 via tokio-util -> tokio -> mio -> net2
@@ -47,13 +43,5 @@ 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",
-]
+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/chunking/Cargo.toml

@@ -13,14 +13,7 @@ repository = { workspace = true }
 log = { workspace = true }
 rand = { workspace = true }
 thiserror = { workspace = true }
-dashmap = { workspace = true, features = ["serde"] }
-serde = { workspace = true, features = ["derive"] }
-utoipa = { workspace = true }
 
 nym-sphinx-addressing = { path = "../addressing" }
 nym-sphinx-params = { path = "../params" }
 nym-sphinx-types = { path = "../types" }
-nym-metrics = { path = "../../nym-metrics" }
-nym-crypto = { path = "../../crypto", version = "0.4.0", features = [
-    "asymmetric",
-] }

common/nymsphinx/chunking/src/fragment.rs

@@ -3,8 +3,6 @@
 
 use crate::ChunkingError;
 use nym_sphinx_params::{SerializedFragmentIdentifier, FRAG_ID_LEN};
-use serde::Serialize;
-use utoipa::ToSchema;
 
 use std::fmt::{self, Debug, Formatter};
 
@@ -60,7 +58,7 @@ pub const COVER_FRAG_ID: FragmentIdentifier = FragmentIdentifier {
 /// and u8 position of the `Fragment` in the set.
 // TODO: this should really be redesigned, especially how cover and reply messages are really
 // "abusing" this. They should work with it natively instead.
-#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq, Ord, PartialOrd, Serialize)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq, Ord, PartialOrd)]
 pub struct FragmentIdentifier {
     set_id: i32,
     fragment_position: u8,
@@ -77,10 +75,6 @@ impl fmt::Display for FragmentIdentifier {
 }
 
 impl FragmentIdentifier {
-    pub fn set_id(&self) -> i32 {
-        self.set_id
-    }
-
     pub fn to_bytes(self) -> SerializedFragmentIdentifier {
         debug_assert_eq!(FRAG_ID_LEN, 5);
 
@@ -131,10 +125,6 @@ impl Debug for Fragment {
 }
 
 impl Fragment {
-    pub fn header(&self) -> FragmentHeader {
-        self.header.clone()
-    }
-
     /// Tries to encapsulate provided payload slice and metadata into a `Fragment`.
     /// It can fail if payload would not fully fit in a single `Fragment` or some of the metadata
     /// is malformed or self-contradictory, for example if current_fragment > total_fragments.
@@ -226,10 +216,6 @@ impl Fragment {
         }
     }
 
-    pub fn seed(&self) -> i32 {
-        self.header().seed()
-    }
-
     /// Gets the size of payload contained in this `Fragment`.
     pub fn payload_size(&self) -> usize {
         self.payload.len()
@@ -311,8 +297,8 @@ impl Fragment {
 /// there is 7 bytes of overhead inside each sphinx packet sent
 /// and for the longest messages, without upper bound, there is usually also only 7 bytes
 /// of overhead apart from first and last fragments in each set that instead have 10 bytes of overhead.
-#[derive(PartialEq, Clone, Debug, Serialize, ToSchema)]
-pub struct FragmentHeader {
+#[derive(PartialEq, Clone, Debug)]
+pub(crate) struct FragmentHeader {
     /// ID associated with `FragmentSet` to which this particular `Fragment` belongs.
     /// Its value is restricted to (0, i32::MAX].
     /// Note that it *excludes* 0, but *includes* i32::MAX.
@@ -338,20 +324,6 @@ pub struct FragmentHeader {
 }
 
 impl FragmentHeader {
-    pub fn seed(&self) -> i32 {
-        let mut seed = self.id;
-        seed = seed.wrapping_mul(self.total_fragments as i32);
-        seed = seed.wrapping_mul(self.current_fragment as i32);
-        seed
-    }
-
-    pub fn total_fragments(&self) -> u8 {
-        self.total_fragments
-    }
-
-    pub fn current_fragment(&self) -> u8 {
-        self.current_fragment
-    }
     /// Tries to create a new `FragmentHeader` using provided metadata. Bunch of logical
     /// checks are performed to see if the data is not self-contradictory,
     /// for example if current_fragment > total_fragments.

common/nymsphinx/chunking/src/lib.rs

@@ -1,16 +1,9 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use std::sync::LazyLock;
-
 use crate::fragment::{linked_fragment_payload_max_len, unlinked_fragment_payload_max_len};
-use dashmap::DashMap;
-use fragment::{Fragment, FragmentHeader};
-use nym_crypto::asymmetric::ed25519::PublicKey;
-use serde::Serialize;
 pub use set::split_into_sets;
 use thiserror::Error;
-use utoipa::ToSchema;
 
 pub const MIN_PADDING_OVERHEAD: usize = 1;
 
@@ -29,118 +22,6 @@ pub mod fragment;
 pub mod reconstruction;
 pub mod set;
 
-#[derive(Debug, Clone)]
-pub struct FragmentMixParams {
-    destination: PublicKey,
-    hops: u8,
-}
-
-impl FragmentMixParams {
-    pub fn destination(&self) -> &PublicKey {
-        &self.destination
-    }
-
-    pub fn hops(&self) -> u8 {
-        self.hops
-    }
-}
-
-#[derive(Debug, Clone, Serialize, ToSchema)]
-pub struct SentFragment {
-    header: FragmentHeader,
-    at: u64,
-    client_nonce: i32,
-    #[serde(skip)]
-    mixnet_params: FragmentMixParams,
-}
-
-impl SentFragment {
-    fn new(
-        header: FragmentHeader,
-        at: u64,
-        client_nonce: i32,
-        destination: PublicKey,
-        hops: u8,
-    ) -> Self {
-        let mixnet_params = FragmentMixParams { destination, hops };
-        SentFragment {
-            header,
-            at,
-            client_nonce,
-            mixnet_params,
-        }
-    }
-
-    pub fn header(&self) -> FragmentHeader {
-        self.header.clone()
-    }
-
-    pub fn at(&self) -> u64 {
-        self.at
-    }
-
-    pub fn client_nonce(&self) -> i32 {
-        self.client_nonce
-    }
-
-    pub fn seed(&self) -> i32 {
-        self.header().seed().wrapping_mul(self.client_nonce())
-    }
-
-    pub fn mixnet_params(&self) -> FragmentMixParams {
-        self.mixnet_params.clone()
-    }
-}
-
-#[derive(Debug, Clone, Serialize, ToSchema)]
-pub struct ReceivedFragment {
-    header: FragmentHeader,
-    at: u64,
-}
-
-impl ReceivedFragment {
-    fn new(header: FragmentHeader, at: u64) -> Self {
-        ReceivedFragment { header, at }
-    }
-
-    pub fn header(&self) -> FragmentHeader {
-        self.header.clone()
-    }
-
-    pub fn at(&self) -> u64 {
-        self.at
-    }
-}
-
-pub static FRAGMENTS_RECEIVED: LazyLock<DashMap<i32, Vec<ReceivedFragment>>> =
-    LazyLock::new(DashMap::new);
-
-pub static FRAGMENTS_SENT: LazyLock<DashMap<i32, Vec<SentFragment>>> = LazyLock::new(DashMap::new);
-
-#[macro_export]
-macro_rules! now {
-    () => {
-        match std::time::SystemTime::now().duration_since(std::time::SystemTime::UNIX_EPOCH) {
-            Ok(n) => n.as_secs(),
-            Err(_) => 0,
-        }
-    };
-}
-
-pub fn fragment_received(fragment: &Fragment) {
-    let id = fragment.fragment_identifier().set_id();
-    let mut entry = FRAGMENTS_RECEIVED.entry(id).or_default();
-    let r = ReceivedFragment::new(fragment.header(), now!());
-    entry.push(r);
-}
-
-pub fn fragment_sent(fragment: &Fragment, client_nonce: i32, destination: PublicKey, hops: u8) {
-    let id = fragment.fragment_identifier().set_id();
-    let mut entry = FRAGMENTS_SENT.entry(id).or_default();
-    let s = SentFragment::new(fragment.header(), now!(), client_nonce, destination, hops);
-    entry.push(s);
-}
-
 /// The idea behind the process of chunking is to incur as little data overhead as possible due
 /// to very computationally costly sphinx encapsulation procedure.
 ///

common/nymsphinx/chunking/src/reconstruction.rs

@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 use crate::fragment::Fragment;
-use crate::{fragment_received, ChunkingError};
+use crate::ChunkingError;
 use log::*;
 use std::collections::HashMap;
 
@@ -66,12 +66,6 @@ impl ReconstructionBuffer {
         // if the set is complete.
         debug_assert!(self.is_complete);
 
-        debug!(
-            "Got {} fragments for set id {}",
-            self.fragments.len(),
-            self.fragments[0].as_ref().unwrap().id()
-        );
-
         self.fragments
             .into_iter()
             .map(|fragment| fragment.unwrap().extract_payload())
@@ -110,8 +104,6 @@ impl ReconstructionBuffer {
             }
         });
 
-        fragment_received(&fragment);
-
         let fragment_index = fragment.current_fragment() as usize - 1;
         if self.fragments[fragment_index].is_some() {
             // TODO: what to do in that case? give up on the message? overwrite it? panic?

common/nymsphinx/src/preparer/mod.rs

@@ -3,7 +3,6 @@
 
 use crate::message::{NymMessage, ACK_OVERHEAD, OUTFOX_ACK_OVERHEAD};
 use crate::NymPayloadBuilder;
-use log::debug;
 use nym_crypto::asymmetric::encryption;
 use nym_crypto::Digest;
 use nym_sphinx_acknowledgements::surb_ack::SurbAck;
@@ -12,14 +11,12 @@ use nym_sphinx_addressing::clients::Recipient;
 use nym_sphinx_addressing::nodes::NymNodeRoutingAddress;
 use nym_sphinx_anonymous_replies::reply_surb::ReplySurb;
 use nym_sphinx_chunking::fragment::{Fragment, FragmentIdentifier};
-use nym_sphinx_chunking::fragment_sent;
 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_types::{Delay, NymPacket};
 use nym_topology::{NymTopology, NymTopologyError};
-use rand::{CryptoRng, Rng, SeedableRng};
-use rand_chacha::ChaCha20Rng;
+use rand::{CryptoRng, Rng};
 
 use std::time::Duration;
 
@@ -52,7 +49,6 @@ pub trait FragmentPreparer {
     type Rng: CryptoRng + Rng;
 
     fn rng(&mut self) -> &mut Self::Rng;
-    fn nonce(&self) -> i32;
     fn num_mix_hops(&self) -> u8;
     fn average_packet_delay(&self) -> Duration;
     fn average_ack_delay(&self) -> Duration;
@@ -196,18 +192,9 @@ pub trait FragmentPreparer {
         packet_type: PacketType,
         mix_hops: Option<u8>,
     ) -> Result<PreparedFragment, NymTopologyError> {
-        debug!("Preparing chunk for sending");
         // each plain or repliable packet (i.e. not a reply) attaches an ephemeral public key so that the recipient
         // could perform diffie-hellman with its own keys followed by a kdf to re-derive
         // the packet encryption key
-
-        let seed = fragment.seed().wrapping_mul(self.nonce());
-        let mut rng = ChaCha20Rng::seed_from_u64(seed as u64);
-
-        let destination = packet_recipient.gateway();
-        let hops = mix_hops.unwrap_or(self.num_mix_hops());
-        fragment_sent(&fragment, self.nonce(), *destination, hops);
-
         let non_reply_overhead = encryption::PUBLIC_KEY_SIZE;
         let expected_plaintext = match packet_type {
             PacketType::Outfox => {
@@ -241,8 +228,10 @@ pub trait FragmentPreparer {
         };
 
         // generate pseudorandom route for the packet
+        let hops = mix_hops.unwrap_or(self.num_mix_hops());
         log::trace!("Preparing chunk for sending with {} mix hops", hops);
-        let route = topology.random_route_to_gateway(&mut rng, hops, destination)?;
+        let route =
+            topology.random_route_to_gateway(self.rng(), hops, packet_recipient.gateway())?;
         let destination = packet_recipient.as_sphinx_destination();
 
         // including set of delays
@@ -324,8 +313,6 @@ pub struct MessagePreparer<R> {
     /// Number of mix hops each packet ('real' message, ack, reply) is expected to take.
     /// Note that it does not include gateway hops.
     num_mix_hops: u8,
-
-    nonce: i32,
 }
 
 impl<R> MessagePreparer<R>
@@ -338,15 +325,12 @@ where
         average_packet_delay: Duration,
         average_ack_delay: Duration,
     ) -> Self {
-        let mut rng = rng;
-        let nonce = rng.gen();
         MessagePreparer {
             rng,
             sender_address,
             average_packet_delay,
             average_ack_delay,
             num_mix_hops: DEFAULT_NUM_MIX_HOPS,
-            nonce,
         }
     }
 
@@ -470,10 +454,6 @@ impl<R: CryptoRng + Rng> FragmentPreparer for MessagePreparer<R> {
     fn average_ack_delay(&self) -> Duration {
         self.average_ack_delay
     }
-
-    fn nonce(&self) -> i32 {
-        self.nonce
-    }
 }
 
 /*

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

@@ -218,7 +218,7 @@ impl SocksClient {
         packet_type: Option<PacketType>,
     ) -> Self {
         // If this task fails and exits, we don't want to send shutdown signal
-        shutdown_listener.disarm();
+        shutdown_listener.mark_as_success();
 
         let connection_id = Self::generate_random();
 
@@ -294,7 +294,7 @@ impl SocksClient {
             .shutdown()
             .await
             .map_err(|source| SocksProxyError::SocketShutdownFailure { source })?;
-        self.shutdown_listener.disarm();
+        self.shutdown_listener.mark_as_success();
         Ok(())
     }
 

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

@@ -172,6 +172,6 @@ where
     trace!("{} - inbound closed", connection_id);
     shutdown_notify.notify_one();
 
-    shutdown_listener.disarm();
+    shutdown_listener.mark_as_success();
     reader
 }

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

@@ -148,7 +148,7 @@ where
     }
 
     pub fn into_inner(mut self) -> (TcpStream, ConnectionReceiver) {
-        self.shutdown_listener.disarm();
+        self.shutdown_listener.mark_as_success();
         (
             self.socket.take().unwrap(),
             self.mix_receiver.take().unwrap(),

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

@@ -60,7 +60,7 @@ pub(super) async fn run_outbound(
 
     loop {
         select! {
-            connection_message = mix_receiver.next() => {
+            connection_message = &mut mix_receiver.next() => {
                 if let Some(connection_message) = connection_message {
                     if deal_with_message(connection_message, &mut writer, &local_destination_address, &remote_source_address, connection_id).await {
                         break;
@@ -90,6 +90,6 @@ pub(super) async fn run_outbound(
     trace!("{} - outbound closed", connection_id);
     shutdown_notify.notify_one();
 
-    shutdown_listener.disarm();
+    shutdown_listener.mark_as_success();
     (writer, mix_receiver)
 }

common/task/src/manager.rs

@@ -470,10 +470,14 @@ impl TaskClient {
     // This listener should to *not* notify the ShutdownNotifier to shutdown when dropped. For
     // example when we clone the listener for a task handling connections, we often want to drop
     // without signal failure.
-    pub fn disarm(&mut self) {
+    pub fn mark_as_success(&mut self) {
         self.mode.set_should_not_signal_on_drop();
     }
 
+    pub fn disarm(&mut self) {
+        self.mark_as_success();
+    }
+
     pub fn send_we_stopped(&mut self, err: SentError) {
         if self.mode.is_dummy() {
             return;

common/topology/Cargo.toml

@@ -5,6 +5,7 @@ edition = { workspace = true }
 authors = { workspace = true }
 license = { workspace = true }
 repository = { workspace = true }
+readme = { workspace = true }
 homepage = { workspace = true }
 documentation = { workspace = true }
 
@@ -14,10 +15,9 @@ documentation = { workspace = true }
 bs58 = { workspace = true }
 log = { workspace = true }
 rand = { workspace = true }
-reqwest = { workspace = true, features = ["json"] }
 thiserror = { workspace = true }
 async-trait = { workspace = true, optional = true }
-semver = { version = "0.11" }
+semver = "0.11"
 
 # 'serializable' feature
 serde = { workspace = true, features = ["derive"], optional = true }
@@ -28,22 +28,20 @@ tsify = { workspace = true, features = ["js"], optional = true }
 wasm-bindgen = { workspace = true, optional = true }
 
 ## internal
-nym-bin-common = { path = "../bin-common" }
-nym-config = { path = "../config" }
 nym-crypto = { path = "../crypto", features = ["sphinx", "outfox"] }
 nym-mixnet-contract-common = { path = "../cosmwasm-smart-contracts/mixnet-contract" }
 nym-sphinx-addressing = { path = "../nymsphinx/addressing" }
-nym-sphinx-types = { path = "../nymsphinx/types", features = [
-    "sphinx",
-    "outfox",
-] }
+nym-sphinx-types = { path = "../nymsphinx/types", features = ["sphinx", "outfox"] }
 nym-sphinx-routing = { path = "../nymsphinx/routing" }
-
+nym-bin-common = { path = "../bin-common" }
 
 # I'm not sure how to feel about pulling in this dependency here...
 nym-api-requests = { path = "../../nym-api/nym-api-requests" }
 
 
+# 'serializable' feature
+nym-config = { path = "../config", optional = true }
+
 # 'wasm-serde-types' feature
 wasm-utils = { path = "../wasm/utils", default-features = false, optional = true }
 
@@ -51,5 +49,4 @@ wasm-utils = { path = "../wasm/utils", default-features = false, optional = true
 default = ["provider-trait"]
 provider-trait = ["async-trait"]
 wasm-serde-types = ["tsify", "wasm-bindgen", "wasm-utils"]
-serializable = ["serde", "serde_json"]
-outfox = []
+serializable = ["serde", "nym-config", "serde_json"]

common/topology/src/error.rs

@@ -51,16 +51,4 @@ pub enum NymTopologyError {
 
     #[error("{0}")]
     PacketError(#[from] NymPacketError),
-
-    #[error("{0}")]
-    ReqwestError(#[from] reqwest::Error),
-
-    #[error("{0}")]
-    MixnodeConversionError(#[from] crate::mix::MixnodeConversionError),
-
-    #[error("{0}")]
-    GatewayConversionError(#[from] crate::gateway::GatewayConversionError),
-
-    #[error("{0}")]
-    VarError(#[from] std::env::VarError),
 }

common/topology/src/lib.rs

@@ -6,9 +6,7 @@
 
 use crate::filter::VersionFilterable;
 pub use error::NymTopologyError;
-use log::{debug, info, warn};
-use mix::Node;
-use nym_config::defaults::var_names::NYM_API;
+use log::{debug, warn};
 use nym_mixnet_contract_common::mixnode::MixNodeDetails;
 use nym_mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixId};
 use nym_sphinx_addressing::nodes::NodeIdentity;
@@ -118,40 +116,13 @@ impl Display for NetworkAddress {
 
 pub type MixLayer = u8;
 
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 pub struct NymTopology {
     mixes: BTreeMap<MixLayer, Vec<mix::Node>>,
     gateways: Vec<gateway::Node>,
 }
 
 impl NymTopology {
-    pub async fn new_from_env() -> Result<Self, NymTopologyError> {
-        let api_url = std::env::var(NYM_API)?;
-
-        info!("Generating topology from {}", api_url);
-
-        let mixnodes = reqwest::get(&format!("{}/v1/mixnodes", api_url))
-            .await?
-            .json::<Vec<MixNodeDetails>>()
-            .await?
-            .into_iter()
-            .map(|details| details.bond_information)
-            .map(mix::Node::try_from)
-            .filter(Result::is_ok)
-            .collect::<Result<Vec<_>, _>>()?;
-
-        let gateways = reqwest::get(&format!("{}/v1/gateways", api_url))
-            .await?
-            .json::<Vec<GatewayBond>>()
-            .await?
-            .into_iter()
-            .map(gateway::Node::try_from)
-            .filter(Result::is_ok)
-            .collect::<Result<Vec<_>, _>>()?;
-        let topology = NymTopology::new_unordered(mixnodes, gateways);
-        Ok(topology)
-    }
-
     pub fn new(mixes: BTreeMap<MixLayer, Vec<mix::Node>>, gateways: Vec<gateway::Node>) -> Self {
         NymTopology { mixes, gateways }
     }
@@ -299,7 +270,7 @@ impl NymTopology {
         &self,
         rng: &mut R,
         num_mix_hops: u8,
-    ) -> Result<Vec<Node>, NymTopologyError>
+    ) -> Result<Vec<SphinxNode>, NymTopologyError>
     where
         R: Rng + CryptoRng + ?Sized,
     {
@@ -324,32 +295,12 @@ impl NymTopology {
             let random_mix = layer_mixes
                 .choose(rng)
                 .ok_or(NymTopologyError::EmptyMixLayer { layer })?;
-            route.push(random_mix.clone());
+            route.push(random_mix.into());
         }
 
         Ok(route)
     }
 
-    pub fn random_path_to_gateway<R>(
-        &self,
-        rng: &mut R,
-        num_mix_hops: u8,
-        gateway_identity: &NodeIdentity,
-    ) -> Result<(Vec<mix::Node>, gateway::Node), NymTopologyError>
-    where
-        R: Rng + CryptoRng + ?Sized,
-    {
-        let gateway = self.get_gateway(gateway_identity).ok_or(
-            NymTopologyError::NonExistentGatewayError {
-                identity_key: gateway_identity.to_base58_string(),
-            },
-        )?;
-
-        let path = self.random_mix_route(rng, num_mix_hops)?;
-
-        Ok((path, gateway.clone()))
-    }
-
     /// Tries to create a route to the specified gateway, such that it goes through mixnode on layer 1,
     /// mixnode on layer2, .... mixnode on layer n and finally the target gateway
     pub fn random_route_to_gateway<R>(
@@ -370,7 +321,6 @@ impl NymTopology {
         Ok(self
             .random_mix_route(rng, num_mix_hops)?
             .into_iter()
-            .map(|node| SphinxNode::from(&node))
             .chain(std::iter::once(gateway.into()))
             .collect())
     }

common/types/Cargo.toml

@@ -4,7 +4,7 @@ version = "1.0.0"
 description = "Nym common types"
 authors.workspace = true
 edition = "2021"
-rust-version.workspace = true
+rust-version = "1.58"
 license.workspace = true
 
 [dependencies]

common/types/src/lib.rs

@@ -11,7 +11,6 @@ pub mod gas;
 pub mod gateway;
 pub mod helpers;
 pub mod mixnode;
-pub mod monitoring;
 pub mod pending_events;
 pub mod transaction;
 pub mod vesting;

common/types/src/monitoring.rs

@@ -1,131 +0,0 @@
-use std::{collections::HashSet, sync::LazyLock, time::SystemTime};
-
-use nym_crypto::asymmetric::identity::{PrivateKey, PublicKey, Signature};
-use nym_mixnet_contract_common::MixId;
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-
-static NETWORK_MONITORS: LazyLock<HashSet<String>> = LazyLock::new(|| {
-    let mut nm = HashSet::new();
-    nm.insert("5VsPyLbsBCq9PAMWmjKkToteVAKNabNqex6QwDf5fWzt".to_string());
-    nm
-});
-
-#[derive(Debug, Serialize, Deserialize, JsonSchema, Clone)]
-pub struct NodeResult {
-    pub node_id: MixId,
-    pub identity: String,
-    pub reliability: u8,
-}
-
-#[derive(Debug, Serialize, Deserialize, JsonSchema, Clone)]
-pub struct MixnodeResult {
-    pub mix_id: MixId,
-    pub identity: String,
-    pub owner: String,
-    pub reliability: u8,
-}
-
-impl MixnodeResult {
-    pub fn new(mix_id: MixId, identity: String, owner: String, reliability: u8) -> Self {
-        MixnodeResult {
-            mix_id,
-            identity,
-            owner,
-            reliability,
-        }
-    }
-}
-
-#[derive(Debug, Deserialize, Serialize, JsonSchema, Clone)]
-pub struct GatewayResult {
-    pub identity: String,
-    pub owner: String,
-    pub reliability: u8,
-    pub mix_id: MixId,
-}
-
-impl GatewayResult {
-    pub fn new(identity: String, owner: String, reliability: u8) -> Self {
-        GatewayResult {
-            identity,
-            owner,
-            reliability,
-            mix_id: 0,
-        }
-    }
-}
-
-#[derive(Serialize, Deserialize, JsonSchema)]
-#[serde(untagged)]
-pub enum MonitorResults {
-    Mixnode(Vec<MixnodeResult>),
-    Gateway(Vec<GatewayResult>),
-}
-
-#[derive(Serialize, Deserialize, JsonSchema)]
-pub struct MonitorMessage {
-    results: Vec<NodeResult>,
-    signature: String,
-    signer: String,
-    timestamp: i64,
-}
-
-impl MonitorMessage {
-    fn message_to_sign(results: &[NodeResult], timestamp: i64) -> Vec<u8> {
-        let mut msg = match serde_json::to_vec(results) {
-            Ok(msg) => msg,
-            Err(_) => Vec::new(),
-        };
-        msg.extend_from_slice(&timestamp.to_le_bytes());
-        msg
-    }
-
-    pub fn timely(&self) -> bool {
-        let now = SystemTime::now()
-            .duration_since(SystemTime::UNIX_EPOCH)
-            .expect("Time went backwards")
-            .as_secs() as i64;
-
-        now - self.timestamp < 5
-    }
-
-    pub fn new(results: Vec<NodeResult>, private_key: &PrivateKey) -> Self {
-        let timestamp = SystemTime::now()
-            .duration_since(SystemTime::UNIX_EPOCH)
-            .expect("Time went backwards")
-            .as_secs() as i64;
-
-        let msg = Self::message_to_sign(&results, timestamp);
-        let signature = private_key.sign(&msg);
-        let public_key = private_key.public_key();
-
-        MonitorMessage {
-            results,
-            signature: signature.to_base58_string(),
-            signer: public_key.to_base58_string(),
-            timestamp,
-        }
-    }
-
-    pub fn from_allowed(&self) -> bool {
-        NETWORK_MONITORS.contains(&self.signer)
-    }
-
-    pub fn results(&self) -> &[NodeResult] {
-        &self.results
-    }
-
-    pub fn verify(&self) -> bool {
-        let msg = Self::message_to_sign(&self.results, self.timestamp);
-
-        let signature = match Signature::from_base58_string(&self.signature) {
-            Ok(sig) => sig,
-            Err(_) => return false,
-        };
-
-        PublicKey::from_base58_string(&self.signer)
-            .map(|pk| pk.verify(msg, &signature).is_ok())
-            .unwrap_or(false)
-    }
-}

common/wasm/utils/Cargo.toml

@@ -30,9 +30,13 @@ workspace = true
 optional = true
 
 [features]
-default = ["sleep"]
+default = ["sleep", "console_error_panic_hook"]
 sleep = ["web-sys", "web-sys/Window"]
-websocket = ["getrandom", "tungstenite", "gloo-net"]
+websocket = [
+    "getrandom",
+    "tungstenite",
+    "gloo-net"
+]
 crypto = [
     "web-sys",
     "web-sys/Crypto",

common/wireguard-types/Cargo.toml

@@ -12,6 +12,7 @@ license.workspace = true
 
 [dependencies]
 base64 = { workspace = true }
+dashmap = { workspace = true }
 log = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 thiserror = { workspace = true }
@@ -34,7 +35,7 @@ x25519-dalek = { workspace = true, features = ["static_secrets"] }
 
 [dev-dependencies]
 rand = "0.8.5"
-nym-crypto = { path = "../crypto", features = ["rand"] }
+nym-crypto = { path = "../crypto", features = ["rand"]}
 
 
 [features]

common/wireguard-types/src/registration.rs

@@ -4,8 +4,8 @@
 use crate::error::Error;
 use crate::PeerPublicKey;
 use base64::{engine::general_purpose, Engine};
+use dashmap::DashMap;
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
 use std::net::IpAddr;
 use std::time::SystemTime;
 use std::{fmt, ops::Deref, str::FromStr};
@@ -17,8 +17,8 @@ use nym_crypto::asymmetric::encryption::PrivateKey;
 #[cfg(feature = "verify")]
 use sha2::Sha256;
 
-pub type PendingRegistrations = HashMap<PeerPublicKey, RegistrationData>;
-pub type PrivateIPs = HashMap<IpAddr, Taken>;
+pub type PendingRegistrations = DashMap<PeerPublicKey, RegistrationData>;
+pub type PrivateIPs = DashMap<IpAddr, Taken>;
 
 #[cfg(feature = "verify")]
 pub type HmacSha256 = Hmac<Sha256>;

common/wireguard/src/lib.rs

@@ -84,7 +84,6 @@ pub struct WireguardData {
 #[cfg(target_os = "linux")]
 pub async fn start_wireguard<St: nym_gateway_storage::Storage + 'static>(
     storage: St,
-    all_peers: Vec<nym_gateway_storage::models::WireguardPeer>,
     task_client: nym_task::TaskClient,
     wireguard_data: WireguardData,
     control_tx: UnboundedSender<peer_controller::PeerControlResponse>,
@@ -96,7 +95,7 @@ pub async fn start_wireguard<St: nym_gateway_storage::Storage + 'static>(
 
     let mut peers = vec![];
     let mut suspended_peers = vec![];
-    for storage_peer in all_peers {
+    for storage_peer in storage.get_all_wireguard_peers().await? {
         let suspended = storage_peer.suspended;
         let peer = Peer::try_from(storage_peer)?;
         if suspended {

documentation/README.md

@@ -1,27 +1,30 @@
-# Nym Docs v2
-
-This is v2 of the nym docs, condensed from various mdbooks projects that we had previously.
-
-These docs are hosted at [nymtech.net/docs](www.nymtech.net/docs).
+# Documentation
 
 ## Doc projects
-`docs/pages/` contains several subdirs, each hosting a subsection of the docs:
-* `network` contains key concepts, cryptosystems, architecture.
-* `developers` contains key concepts for developers, required architecture, and Rust/Typescript SDK docs.
-* `operators` contains node setup and maintenance guides.
+Each directory contains a readme with more information about running and contributing to the projects. Each is built with [`mdbook`](https://rust-lang.github.io/mdBook/index.html) - use `mdbook serve` to build and serve them (defaults to `localhost:3000`).
+* `docs` contains technical documentation hosted at [https://nymtech.net/docs](https://nymtech.net/docs)
+* `dev-portal` contains developer documentation hosted at [https://nymtech.net/developers](https://nymtech.net/developers)
+* `operators` contains node setup and maintenance guides hosted at [https://nymtech.net/operators](https://nymtech.net/operators)
 
-## Contribution
-* If you wish to add to the documentation please create a PR against this repo, with a `patch` against `develop`.
+> If you are looking for the Typescript SDK documentation located at [sdk.nymtech.net](https://sdk.nymtech.net) this can be found in `../sdk/typescript/docs/`
 
-## Scripts
-* There are several autogenerated command files for clients and binaries. These are generated with `generate:commands`, which runs the `autodoc` rust binary, moves the files to their required places, and then if there is an update, commits them to git. This is for remote deployments.
-* TODO
+## Contribution 
+* If you wish to add to the documentation please create a PR against this repo. 
+* If you are **adding a plugin dependency** make sure to also **add that to the list of plugins in `install_mdbook_deps.sh` line 12**. 
 
-### Autodoc
-`autodoc` is a script that generates markdown files containing commands and their output (both command and `--help` output). For the moment the binaries and their commands are manually configured in the script.
+## Scripts 
+* `bump_versions.sh` allows you to update the ~~`platform_release_version` and~~ `wallet_release_version` variable~~s~~ in the `book.toml` of each mdbook project at once. You can also optionally update the `minimum_rust_version` as well. Helpful for lazy-updating when cutting a new version of the docs. 
 
-## CI/CD
-TODO
+* The following scripts are used by the `ci-dev.yml` and `cd-dev.yml` scripts (located in `../.github/workflows/`):
+  * `build_all_to_dist.sh` is used for building all mdbook projects and moving the rendered html to `../dist/` to be rsynced with various servers. 
+  * `install_mdbook_deps.sh` checks for an existing install of mdbook (and plugins), uninstalls them, and then installs them on a clean slate. This is to avoid weird dependency clashes if relying on an existing mdbook version. 
+  * `post_process.sh` is used to post process CSS/image/href links for serving several mdbooks from a subdirectory. 
+  * `removed_existing_config.sh` is used to check for existing nym client/node config files on the CI/CD server and remove it if it exists. This is to mitigate issues with `mdbook-cmdrun` where e.g. a node is already initialised, and the command fails.   
+
+## CI/CD 
+Deployment of the docs is partially automated and partially manual. 
+* `ci-docs.yml` will run on pushes to all branches **apart from `master`**
+* `cd-docs.yml` must be run manually. This pushes to a staging branch which then must be manually promoted to production. 
 
 ## Licensing and copyright information
 This is a monorepo and components that make up Nym as a system are licensed individually, so for accurate information, please check individual files.
@@ -33,3 +36,4 @@ As a general approach, licensing is as follows this pattern:
 * Nym applications and binaries are [GPL-3.0-only](https://www.gnu.org/licenses/)
 
 * Used libraries and different components are [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0.html) or [MIT](https://mit-license.org/)
+

documentation/autodoc/.gitignore

@@ -1 +0,0 @@
-/autodoc-generated-markdown/*

documentation/autodoc/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "autodoc"
-version = "0.1.0"
-authors.workspace = true
-repository.workspace = true
-homepage.workspace = true
-documentation.workspace = true
-edition.workspace = true
-license.workspace = true
-
-[dependencies]
-env_logger = "0.11.3"
-log.workspace = true

documentation/autodoc/README.md

@@ -1,4 +0,0 @@
-# `autodoc`
-
-Command output documentation generator WIP 
-

documentation/autodoc/src/main.rs

@@ -1,259 +0,0 @@
-use log::{debug, info};
-use std::fs::File;
-use std::io::{self, Write};
-use std::process::{Command, Output};
-use std::{fs, vec};
-
-const WRITE_PATH: &str = "./autodoc-generated-markdown/";
-
-fn main() -> io::Result<()> {
-    env_logger::init();
-
-    // TODO if this balloons write automated way of grabbing commands from crates.
-    let commands_with_subcommands = vec![
-        (
-            "../../target/release/nym-api",
-            vec!["init", "run", "build-info"],
-        ),
-        (
-            "../../target/release/nym-client",
-            vec![
-                "init",
-                "run",
-                "import-credential",
-                "list-gateways",
-                "switch-gateway",
-                "build-info",
-                "completions",
-                "generate-fig-spec",
-            ],
-        ),
-        (
-            "../../target/release/nym-socks5-client",
-            vec![
-                "init",
-                "run",
-                "import-credential",
-                "list-gateways",
-                "add-gateway",
-                "build-info",
-                "completions",
-                "generate-fig-spec",
-            ],
-        ),
-        (
-            "../../target/release/nym-node",
-            vec![
-                "build-info",
-                "bonding-information",
-                "node-details",
-                "migrate",
-                "run",
-                "sign",
-            ],
-        ),
-        (
-            "../../target/release/nymvisor",
-            vec![
-                "init",
-                "run",
-                "build-info",
-                "daemon-build-info",
-                "add-upgrade",
-                "config",
-            ],
-        ),
-    ];
-
-    let commands_with_subsubcommands = vec![(
-        "../../target/release/nym-cli",
-        vec![
-            (
-                "account",
-                vec!["create", "balance", "pub-key", "send", "send-multiple"],
-            ),
-            ("signature", vec!["sign", "verify"]),
-            (
-                "ecash",
-                vec![
-                    "issue-ticket-book",
-                    "recover-ticket-book",
-                    "import-ticket-book",
-                ],
-            ),
-            (
-                "coconut",
-                vec![
-                    "generate-freepass",
-                    "issue-credentials",
-                    "recover-credentials",
-                    "import-credential",
-                ],
-            ),
-            ("block", vec!["get", "time", "current-height"]),
-            (
-                "cosmwasm",
-                vec![
-                    "upload",
-                    "init",
-                    "generate-init-message",
-                    "migrate",
-                    "execute",
-                ],
-            ),
-            ("tx", vec!["get", "query"]),
-            (
-                "vesting-schedule",
-                vec!["create", "query", "vested-balance", "withdraw-vested"],
-            ),
-            ("mixnet", vec!["query", "delegators", "operators"]),
-            ("generate-fig", vec![""]),
-        ],
-    )];
-
-    for (main_command, subcommands) in commands_with_subcommands {
-        let last_word = get_last_word_from_filepath(main_command);
-        debug!("now running {last_word:#?}");
-
-        if !fs::metadata(WRITE_PATH)
-            .map(|metadata| metadata.is_dir())
-            .unwrap_or(false)
-        {
-            fs::create_dir_all(WRITE_PATH)?;
-        }
-
-        let mut file = File::create(format!("{}/{}-commands.md", WRITE_PATH, last_word.unwrap()))?;
-        writeln!(
-            file,
-            "# {} Binary Commands (Autogenerated)",
-            format!("`{}`", last_word.unwrap())
-        )?;
-        writeln!(
-            file,
-            "\nThese docs are autogenerated by the [`autodocs`](https://github.com/nymtech/nym/tree/max/new-docs-framework/documentation/autodoc) script."
-        )?;
-        let output = Command::new(main_command).arg("--help").output()?;
-        write_output_to_file(&mut file, output)?;
-
-        for subcommand in subcommands {
-            execute_command(&mut file, main_command, subcommand, None)?;
-        }
-    }
-
-    // nym-cli has subsubcommands so needs its own loop
-    for (main_command, subcommands) in &commands_with_subsubcommands {
-        let last_word = get_last_word_from_filepath(main_command);
-        debug!("now running {last_word:#?}");
-        let mut file = File::create(format!("{}/{}-commands.md", WRITE_PATH, last_word.unwrap()))?;
-        writeln!(
-            file,
-            "# {} Binary Commands (Autogenerated)",
-            format!("`{}`", last_word.unwrap())
-        )?;
-        writeln!(
-            file,
-            "\nThese docs are autogenerated by the [`autodocs`](https://github.com/nymtech/nym/tree/max/new-docs-framework/documentation/autodoc) script."
-        )?;
-        let output = Command::new(main_command).arg("--help").output()?;
-
-        write_output_to_file(&mut file, output)?;
-
-        for (subcommand, subsubcommands) in subcommands {
-            writeln!(file, "\n## `{}` ", subcommand)?;
-            let output = Command::new(main_command)
-                .arg(subcommand)
-                .arg("--help")
-                .output()?;
-            if !output.stdout.is_empty() {
-                write_output_to_file(&mut file, output)?;
-            } else {
-                debug!("empty stdout - nothing to write");
-            }
-            for subsubcommand in subsubcommands {
-                execute_command(&mut file, main_command, subcommand, Some(subsubcommand))?;
-            }
-        }
-    }
-    Ok(())
-}
-
-fn get_last_word_from_filepath(filepath: &str) -> Option<&str> {
-    let parts: Vec<&str> = filepath.split('/').collect();
-    parts.last().copied()
-}
-
-fn execute_command(
-    file: &mut File,
-    main_command: &str,
-    subcommand: &str,
-    subsubcommand: Option<&str>,
-) -> io::Result<()> {
-    // checking for the nym-cli subsubcommands
-    if subsubcommand.is_some() {
-        writeln!(file, "\n### `{} {}`", subcommand, subsubcommand.unwrap())?;
-
-        info!("executing {} {} --help ", main_command, subcommand);
-        let output = Command::new(main_command)
-            .arg(subcommand)
-            .arg(subsubcommand.unwrap())
-            .arg("--help")
-            .output()?;
-        if !output.stdout.is_empty() {
-            write_output_to_file(file, output)?;
-        } else {
-            debug!("empty stdout - nothing to write");
-        }
-    // just subcommands
-    } else {
-        writeln!(file, "\n### `{}`", subcommand)?;
-
-        // execute help
-        let output = Command::new(main_command)
-            .arg(subcommand)
-            .arg("--help")
-            .output()?;
-        if !output.stdout.is_empty() {
-            write_output_to_file(file, output)?;
-        } else {
-            debug!("empty stdout - nothing to write");
-        }
-
-        // then execute w/out help: the majority of functions will fail since you're not passing
-        // required params but thats fine as we can just not render stderr into the final file.
-        //
-        // this check is basically checking for the rare commands (rn just one) that start a process with no params
-        // perhaps if this list grows we could just add a timeout and shunt the running and writing
-        // into a thread with a timeout or something but for right now its fine / thats overkill
-        if get_last_word_from_filepath(main_command).unwrap() == "nym-node"
-            || get_last_word_from_filepath(main_command).unwrap() == "nym-api"
-            || get_last_word_from_filepath(main_command).unwrap() == "nymvisor"
-                && subcommand == "run"
-        {
-            info!("SKIPPING {} {}", main_command, subcommand);
-        } else {
-            info!("executing {} {}", main_command, subcommand);
-            let output = Command::new(main_command).arg(subcommand).output()?;
-            if !output.stdout.is_empty() {
-                writeln!(file, "Example output:")?;
-                write_output_to_file(file, output)?;
-            } else {
-                debug!("empty stdout - nothing to write");
-                if !&output.stderr.is_empty() {
-                    debug!("stderr: {:#?}", String::from_utf8_lossy(&output.stderr));
-                }
-            }
-        }
-    }
-    Ok(())
-}
-
-fn write_output_to_file(file: &mut File, output: Output) -> io::Result<()> {
-    writeln!(file, "```sh")?;
-    file.write_all(&output.stdout)?;
-    writeln!(file, "```")?;
-
-    if !&output.stderr.is_empty() {
-        debug!("stderr: {:#?}", String::from_utf8_lossy(&output.stderr));
-    }
-    Ok(())
-}

documentation/build_all_to_dist.sh

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+
+set -o errexit
+set -o nounset
+set -o pipefail
+
+# this is a script called by the github CI and CD workflows to build all 3 docs projects
+# and move them to /dist/ in the root of the monorepo. They are rsynced to various servers
+# from there by subsequent workflow tasks.
+
+# array of project dirs
+declare -a projects=("docs" "dev-portal" "operators")
+
+# check you're calling from the right place
+if [ $(pwd | awk -F/ '{print $NF}') != "documentation" ]
+then
+  echo "failure: please run script from documentation/"
+else
+   for i in "${projects[@]}"
+   do
+      # cd to project dir
+      cd "./$i" &&
+      # little sanity checks
+      echo $(pwd) && echo $(mdbook --version) &&
+      # clean old book
+      echo "cleaning old book"
+      rm -rf ./book/
+      # build book
+      # mdbook test || true
+      mdbook build
+      # check for destination, if ! then mkdir & check again else echo thumbs up
+      if [ ! -d ../../dist/docs/$i ]; then
+        echo "dest doesn't exist: creating dir"
+        mkdir -p ../../dist/docs/$i
+      fi
+      if [ -d ../../dist/docs/$i ]; then
+        echo "cp destination exists, all good"
+      fi
+      # clean old dist/$i
+      rm -rf ../../dist/docs/$i
+      # move newly rendered book/ to dist
+      rsync -r ./book/html/ ../../dist/docs/$i
+      # sanity check
+      ls -laF ../../dist/docs/
+      # cd back to ../documentation/
+      cd ../
+   done
+   # rename for server paths
+   rm -rf ../dist/docs/developers
+   mv ../dist/docs/dev-portal ../dist/docs/developers
+fi

documentation/bump_versions.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+
+set -o errexit
+set -o nounset
+set -o pipefail
+
+# takes one manadatory arg and one optional arg: wallet release and minimum rust versions
+# it then uses sed to bump them in the three book.toml files.
+#
+# e.g if the upcoming wallet release version was 1.2.9 you'd run this as:
+# `./bump_versions.sh "1.2.9"`
+#
+# you can also set the minumum rust version by passing an optional additional argument:
+# `./bump_versions.sh "1.2.9" "1.67"`
+
+# array of project dirs
+declare -a projects=("docs" "dev-portal" "operators")
+
+# check number of args passed
+if [ "$#" -lt 1 ] || [ "$#" -gt 2 ];
+then
+    echo "failure: please pass at least 1 and at most 2 args: "
+    echo "./bump_version.sh <new wallet_release_version> [OPTIONAL]<new minimum_rust_version>"
+    exit 0
+fi
+
+# check you're calling from the right place
+if [ $(pwd | awk -F/ '{print $NF}') != "documentation" ]
+then
+  echo "failure: please run script from documentation/"
+  exit 0
+else
+  ## now loop through the above array sed-ing the variable values in the book.toml files
+  for i in "${projects[@]}"
+  do
+    # sed the vars in the book.toml file for each project
+    echo "setting wallet version in $i/"
+    sed -i 's/wallet_release_version =.*/wallet_release_version = "'$2'"/' "$i"/book.toml
+    if [ "$3" ]
+    then
+      echo "setting minimum rust version in $i/"
+      sed -i 's/minimum_rust_version = .*/minimum_rust_version = "'$3'"/' "$i"/book.toml
+    fi
+  done
+fi

documentation/dev-portal/book.toml

@@ -113,6 +113,3 @@ warning-policy = "warn"
 "/faq/general-faq.html" = "https://nymtech.net/developers/faq/integrations-faq.html"
 "/tutorials/simple-service-provider/user-client.html" = "https://nymtech.net/developers/examples/custom-services.html"
 "/quickstart/socks-proxy.html" = "https://nymtech.net/developers/clients/socks5/setup.html"
-"/tutorials/matrix.html" = "https://nymtech.net/developers/archive/nym-connect.html#matrix-element-via-nymconnect"
-"/tutorials/monero.html" = "https://nymtech.net/developers/archive/nym-connect.html#monero-wallet-via-nymconnect"
-"/tutorials/telegram.html" = "https://nymtech.net/developers/archive/nym-connect.html#telegram-via-nymconnect"

documentation/dev-portal/src/clients/socks5-client.md

@@ -60,7 +60,7 @@ There are 2 pieces of software that work together to send SOCKS traffic through
 The `nym-socks5-client` allows you to do the following from your local machine:
 * Take a TCP data stream from a application that can send traffic via SOCKS5.
 * Chop up the TCP stream into multiple Sphinx packets, assigning sequence numbers to them, while leaving the TCP connection open for more data
-* Send the Sphinx packets through the Nym Network. Packets are shuffled and mixed as they transit the mixnet.
+* Send the Sphinx packets through the mixnet to a [network requester](https://nymtech.net/operators/nodes/network-requester.md). Packets are shuffled and mixed as they transit the mixnet.
 
 The `nym-network-requester` then reassembles the original TCP stream using the packets' sequence numbers, and make the intended request. It will then chop up the response into Sphinx packets and send them back through the mixnet to your  `nym-socks5-client`. The application will then receive its data, without even noticing that it wasn't talking to a "normal" SOCKS5 proxy!
 

documentation/dev-portal/src/clients/websocket/usage.md

@@ -58,7 +58,7 @@ In some applications, e.g. where people are chatting with friends who they know,
 
 **If that fits your security model, good. However, will probably be the case that you want to send anonymous replies using Single Use Reply Blocks (SURBs)**.
 
-You can read more about SURBs [here](https://nymtech.net/docs/architecture/traffic-flow.html#private-replies-using-surbs) but in short they are ways for the receiver of this message to anonymously reply to you - the sender - **without them having to know your client address**.
+You can read more about SURBs [here](https://nymtech.net/docs/architecture/traffic-flow.md#private-replies-using-surbs) but in short they are ways for the receiver of this message to anonymously reply to you - the sender - **without them having to know your client address**.
 
 Your client will send along a number of `replySurbs` to the recipient of the message. These are pre-addressed Sphinx packets that the recipient can write to the payload of (i.e. write response data to), but not view the final destination of. If the recipient is unable to fit the response data into the bucket of SURBs sent to it, it will use a SURB to request more SURBs be sent to it from your client.
 

documentation/dev-portal/src/examples/using-nrs.md

@@ -5,20 +5,13 @@ If you are sending 'normal' application traffic, and/or don't require and custom
 
 > Nym will soon be switching from a whitelist-based approach to a blocklist-based approach to filtering traffic. As such, it will soon be even easier for developers to utilise the mixnet, as they will not have to run their own NRs or have to add their domains to the whitelist
 
-
-> Nym will soon be switching from a whitelist-based approach to a blocklist-based approach to filtering traffic. As such, it will soon be even easier for developers to utilise the mixnet, as they will not have to run their own NRs or have to add their domains to the whitelist 
- 
-<!-- I DON't THINK THIS WORKS NOW, NEED RESEARCH AND UPGRADE
 - DarkFi over Nym leverages Nym’s mixnet as a pluggable transport for DarkIRC, their p2p IRC variant. Users can anonymously connect to peers over the network, ensuring secure and private communication within the DarkFi ecosystem. Written in **Rust**.
   - [Docs](https://darkrenaissance.github.io/darkfi/clients/nym_outbound.html?highlight=nym#3--run)
-  - [Github](https://github.com/darkrenaissance/darkfi/tree/master/doc) 
--->
-
+  - [Github](https://github.com/darkrenaissance/darkfi/tree/master/doc)
 
 - MiniBolt is a complete guide to building a Bitcoin & Lightning full node on a personal computer. It has the capacity to run network traffic (transactions and syncing) over the mixnet, so you can privately sync your node and not expose your home IP to the wider world when interacting with the rest of the network!
   - [Docs](https://v2.minibolt.info/bonus-guides/system/nym-mixnet#proxying-bitcoin-core)
   - [Codebase](https://github.com/minibolt-guide/minibolt)
 
-
 - Email over Nym is a set of configuration options to set up a Network Requester to send and recieve emails over Nym, using something like Thunderbird.
   - [Codebase](https://github.com/dial0ut/nymstr-email)