refresh older imported text from archive

.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",
@@ -6761,16 +6682,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"

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/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-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/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/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;

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/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