cargo lock

* initialise nym versin of good-bad isps by tor community

* syntax edit

* finalise csv2md

* initialise isp-list page

* add last update info

* add python3 plugis to ci/cd runnners

* remove argparse installation

* python3 syntax edit

* pip install attempt

* pip install attempt

* change python version in cmdrun command

* fix python modules installation

* correct command python version

* workflows python env update

* add probe guide, clean FnF pages

* fix typos

.github/workflows/cd-docs.yml

@@ -9,7 +9,11 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get install -y build-essential curl wget libssl-dev libudev-dev squashfs-tools protobuf-compiler
+        run: sudo apt-get update && sudo apt-get install -y build-essential curl wget libssl-dev libudev-dev squashfs-tools protobuf-compiler git python3 && sudo apt-get update --fix-missing
+      - name: Install pip3
+        run: sudo apt install -y python3-pip  
+      - name: Install Python3 modules
+        run: sudo pip3 install pandas tabulate
       - name: Install rsync
         run: sudo apt-get install rsync
       - uses: rlespinasse/github-slug-action@v3.x
@@ -30,9 +34,24 @@ jobs:
       - name: Remove existing Nym config directory (`~/.nym/`)
         run: cd documentation && ./remove_existing_config.sh
         continue-on-error: false
-      - name: Build all projects in documentation/ & move to ~/dist/docs/
+# This is the original flow
+#      - name: Build all projects in documentation/ & move to ~/dist/docs/
+#        run: cd documentation && ./build_all_to_dist.sh
+
+# This is a workaround replacement which builds on the last working commit b332a6b55668f60988e36961f3f62a794ba82ddb and then on current branch
+      - name: Save current branch to ~/current_branch
+        run: git rev-parse --abbrev-ref HEAD > ~/current_branch
+      - name: Git pull & switch to b332a6b55668f60988e36961f3f62a794ba82ddb
+        run: git pull && git checkout b332a6b55668f60988e36961f3f62a794ba82ddb
+      - name: Build all projects in documentation/ & move to ~/dist/docs/ from b332a6b55668f60988e36961f3f62a794ba82ddb
         run: cd documentation && ./build_all_to_dist.sh
-        continue-on-error: false
+
+      - name: Switch to current branch
+        run: git checkout $echo "$(cat ~/current_branch)"
+      - name: Build all projects in documentation/ & move to ~/dist/docs/ on current branch
+        run: cd documentation && ./build_all_to_dist.sh && rm ~/current_branch
+
+# End of replacemet
 
       - name: Post process
         run: cd documentation && ./post_process.sh

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

@@ -112,6 +112,7 @@ jobs:
             target/release/nym-network-statistics
             target/release/nym-cli
             target/release/nymvisor
+            target/release/nym-node
           retention-days: 30
 
       # If this was a pull_request or nightly, upload to build server
@@ -130,6 +131,7 @@ jobs:
           cp target/release/nym-network-requester $OUTPUT_DIR
           cp target/release/nym-network-statistics $OUTPUT_DIR
           cp target/release/nymvisor $OUTPUT_DIR
+          cp target/release/nym-node $OUTPUT_DIR
           cp target/release/nym-cli $OUTPUT_DIR
           cp target/release/explorer-api $OUTPUT_DIR
           if [ ${{ github.event_name == 'workflow_dispatch' && inputs.enable_deb == true }} = true ]; then

.github/workflows/ci-docs.yml

@@ -13,7 +13,11 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get install -y build-essential curl wget libssl-dev libudev-dev squashfs-tools protobuf-compiler
+        run: sudo apt-get update && sudo apt-get install -y build-essential curl wget libssl-dev libudev-dev squashfs-tools protobuf-compiler git python3 && sudo apt-get update --fix-missing
+      - name: Install pip3
+        run: sudo apt install -y python3-pip  
+      - name: Install Python3 modules
+        run: sudo pip3 install pandas tabulate
       - name: Install rsync
         run: sudo apt-get install rsync
       - uses: rlespinasse/github-slug-action@v3.x
@@ -34,9 +38,25 @@ jobs:
       - name: Remove existing Nym config directory (`~/.nym/`)
         run: cd documentation && ./remove_existing_config.sh
         continue-on-error: false
-      - name: Build all projects in documentation/ & move to ~/dist/docs/
+
+# This is the original flow
+#      - name: Build all projects in documentation/ & move to ~/dist/docs/
+#        run: cd documentation && ./build_all_to_dist.sh
+
+# This is a workaround replacement which builds on the last working commit b332a6b55668f60988e36961f3f62a794ba82ddb and then on current branch
+      - name: Save current branch to ~/current_branch
+        run: git rev-parse --abbrev-ref HEAD > ~/current_branch
+      - name: Git pull & switch to b332a6b55668f60988e36961f3f62a794ba82ddb
+        run: git pull && git checkout b332a6b55668f60988e36961f3f62a794ba82ddb
+      - name: Build all projects in documentation/ & move to ~/dist/docs/ from b332a6b55668f60988e36961f3f62a794ba82ddb
         run: cd documentation && ./build_all_to_dist.sh
-        continue-on-error: false
+
+      - name: Switch to current branch
+        run: git checkout $echo "$(cat ~/current_branch)"
+      - name: Build all projects in documentation/ & move to ~/dist/docs/ on current branch
+        run: cd documentation && ./build_all_to_dist.sh && rm ~/current_branch
+
+# End of replacemet
 
       - name: Deploy branch to CI www
         continue-on-error: true

.github/workflows/publish-nym-binaries.yml

@@ -30,6 +30,7 @@ jobs:
       mixnode_hash: ${{ steps.binary-hashes.outputs.mixnode_hash }}
       gateway_hash: ${{ steps.binary-hashes.outputs.gateway_hash }}
       nymvisor_hash: ${{ steps.binary-hashes.outputs.nymvisor_hash }}
+      nymnode_hash: ${{ steps.binary-hashes.outputs.nymnode_hash }}
       socks5_hash: ${{ steps.binary-hashes.outputs.socks5_hash }}
       netreq_hash: ${{ steps.binary-hashes.outputs.netreq_hash }}
       cli_hash: ${{ steps.binary-hashes.outputs.cli_hash }}
@@ -38,6 +39,7 @@ jobs:
       mixnode_version: ${{ steps.binary-versions.outputs.mixnode_version }}
       gateway_version: ${{ steps.binary-versions.outputs.gateway_version }}
       nymvisor_version: ${{ steps.binary-versions.outputs.nymvisor_version }}
+      nymnode_version: ${{ steps.binary-versions.outputs.nymnode_version }}
       socks5_version: ${{ steps.binary-versions.outputs.socks5_version }}
       netreq_version: ${{ steps.binary-versions.outputs.netreq_version }}
       cli_version: ${{ steps.binary-versions.outputs.cli_version }}
@@ -81,6 +83,7 @@ jobs:
             target/release/nym-network-statistics
             target/release/nym-cli
             target/release/nymvisor
+            target/release/nym-node
           retention-days: 30
 
       - id: create-release
@@ -99,6 +102,7 @@ jobs:
             target/release/nym-network-statistics
             target/release/nym-cli
             target/release/nymvisor
+            target/release/nym-node
 
   push-release-data-client:
     if: ${{ (startsWith(github.ref, 'refs/tags/nym-binaries-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}

.github/workflows/publish-nym-wallet-macos.yml

@@ -102,6 +102,18 @@ jobs:
             nym-wallet/target/release/bundle/dmg/*.dmg
             nym-wallet/target/release/bundle/macos/*.app.tar.gz*
 
+      - name: Deploy artifacts to CI www
+        continue-on-error: true
+        uses: easingthemes/ssh-deploy@main
+        env:
+          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+          ARGS: "-avzr"
+          SOURCE: "nym-wallet/target/release/bundle/macos/nym-wallet.app.tar.gz"
+          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/builds/${{ github.ref_name }}/nym-wallet
+          EXCLUDE: "/dist/, /node_modules/"            
+
   push-release-data:
     if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
     uses: ./.github/workflows/release-calculate-hash.yml

.github/workflows/publish-nym-wallet-ubuntu.yml

@@ -77,6 +77,18 @@ jobs:
             nym-wallet/target/release/bundle/appimage/*.AppImage
             nym-wallet/target/release/bundle/appimage/*.AppImage.tar.gz*
 
+      - name: Deploy artifacts to CI www
+        continue-on-error: true
+        uses: easingthemes/ssh-deploy@main
+        env:
+          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+          ARGS: "-avzr"
+          SOURCE: "nym-wallet/target/release/bundle/appimage/nym-wallet*.AppImage.tar.gz"
+          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/builds/${{ github.ref_name }}/nym-wallet
+          EXCLUDE: "/dist/, /node_modules/"               
+
   push-release-data:
     if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
     uses: ./.github/workflows/release-calculate-hash.yml

.github/workflows/publish-nym-wallet-win10.yml

@@ -97,6 +97,18 @@ jobs:
             nym-wallet/target/release/bundle/msi/*.msi
             nym-wallet/target/release/bundle/msi/*.msi.zip*
 
+      - name: Deploy artifacts to CI www
+        continue-on-error: true
+        uses: easingthemes/ssh-deploy@main
+        env:
+          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+          ARGS: "-avzr"
+          SOURCE: "nym-wallet/target/release/bundle/msi/nym-wallet_1.*.msi"
+          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/builds/${{ github.ref_name }}/nym-wallet
+          EXCLUDE: "/dist/, /node_modules/"            
+
   push-release-data:
     if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
     uses: ./.github/workflows/release-calculate-hash.yml

CHANGELOG.md

@@ -4,6 +4,30 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 
 ## [Unreleased]
 
+## [2024.4-nutella] (2024-05-08)
+
+- [fix] apply disable_poisson_rate from internal NR/IPR cfgs ([#4579])
+- updating sign commands to include nym-node ([#4578])
+- changed nym-node redirects from 308 'Permanent Redirect' to 303: 'See Other' ([#4572])
+
+[#4579]: https://github.com/nymtech/nym/pull/4579
+[#4578]: https://github.com/nymtech/nym/pull/4578
+[#4572]: https://github.com/nymtech/nym/pull/4572
+
+## [2024.3-eclipse] (2024-04-22)
+
+- Initial release of the first iteration of the Nym Node
+- Improvements to gateway functionality
+- IPR development
+- Removal of allow list in favour of implementing an exit policy
+- Explorer delegation: enables direct delegation to nodes via the Nym Explorer
+
+
+## [2024.2-fast-and-furious] (2024-03-25)
+
+- Internal testing pre-release 
+
+
 ## [2024.1-marabou] (2024-02-15)
 
 **New Features:**

Cargo.toml

@@ -24,6 +24,7 @@ members = [
     "common/bandwidth-controller",
     "common/bin-common",
     "common/client-core",
+    "common/client-core/config-types",
     "common/client-core/surb-storage",
     "common/client-core/gateways-storage",
     "common/client-libs/gateway-client",
@@ -41,6 +42,7 @@ members = [
     "common/cosmwasm-smart-contracts/name-service",
     "common/cosmwasm-smart-contracts/service-provider-directory",
     "common/cosmwasm-smart-contracts/vesting-contract",
+    "common/country-group",
     "common/credential-storage",
     "common/credentials",
     "common/credential-utils",
@@ -50,6 +52,7 @@ members = [
     "common/execute",
     "common/exit-policy",
     "common/http-api-client",
+    "common/http-api-common",
     "common/inclusion-probability",
     "common/ip-packet-requests",
     "common/ledger",
@@ -104,6 +107,7 @@ members = [
     "nym-browser-extension/storage",
     "nym-api/nym-api-requests",
     "nym-node",
+    "nym-node/nym-node-http-api",
     "nym-node/nym-node-requests",
     "nym-outfox",
     "nym-validator-rewarder",
@@ -118,7 +122,6 @@ members = [
     #    "wasm/full-nym-wasm",
     "wasm/mix-fetch",
     "wasm/node-tester",
-    "common/nym-metrics",
 ]
 
 default-members = [
@@ -132,6 +135,7 @@ default-members = [
     "tools/nymvisor",
     "explorer-api",
     "nym-validator-rewarder",
+    "nym-node"
 ]
 
 exclude = [
@@ -156,7 +160,8 @@ license = "Apache-2.0"
 [workspace.dependencies]
 anyhow = "1.0.71"
 async-trait = "0.1.68"
-axum = "0.6.20"
+axum = "0.7.5"
+axum-extra = "0.9.3"
 base64 = "0.21.4"
 bs58 = "0.5.0"
 bip39 = { version = "2.0.0", features = ["zeroize"] }
@@ -167,14 +172,16 @@ dotenvy = "0.15.6"
 futures = "0.3.28"
 generic-array = "0.14.7"
 getrandom = "0.2.10"
-hyper = "0.14.27"
+headers = "0.4.0"
+humantime-serde = "1.1.1"
+hyper = "1.3.1"
 k256 = "0.13"
 lazy_static = "1.4.0"
 log = "0.4"
 once_cell = "1.7.2"
 parking_lot = "0.12.1"
 rand = "0.8.5"
-reqwest = { version = "0.11.22", default-features = false }
+reqwest = { version = "0.12.4", default-features = false }
 schemars = "0.8.1"
 serde = "1.0.152"
 serde_json = "1.0.91"
@@ -188,8 +195,8 @@ tokio-tungstenite = { version = "0.20.1" }
 tracing = "0.1.37"
 tungstenite = { version = "0.20.1", default-features = false }
 ts-rs = "7.0.0"
-utoipa = "3.5.0"
-utoipa-swagger-ui = "3.1.5"
+utoipa = "4.2.0"
+utoipa-swagger-ui = "6.0.0"
 url = "2.4"
 zeroize = "1.6.0"
 

clients/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.33"
+version = "1.1.34"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -25,7 +25,7 @@ bs58 = { workspace = true }
 clap = { workspace = true, features = ["cargo", "derive"] }
 dirs = "4.0"
 log = { workspace = true } # self explanatory
-rand = { version = "0.7.3", features = ["wasm-bindgen"] } # rng-related traits + some rng implementation to use
+rand = { workspace = true }
 serde = { workspace = true, features = ["derive"] } # for config serialization/deserialization
 serde_json = { workspace = true }
 thiserror = { workspace = true }

clients/native/src/commands/import_credential.rs

@@ -8,5 +8,7 @@ use nym_client_core::cli_helpers::client_import_credential::{
 };
 
 pub(crate) async fn execute(args: CommonClientImportCredentialArgs) -> Result<(), ClientError> {
-    import_credential::<CliNativeClient, _>(args).await
+    import_credential::<CliNativeClient, _>(args).await?;
+    println!("successfully imported credential!");
+    Ok(())
 }

clients/native/src/error.rs

@@ -23,6 +23,9 @@ pub enum ClientError {
     #[error("Attempted to start the client in invalid socket mode")]
     InvalidSocketMode,
 
+    #[error(transparent)]
+    ConfigUpgradeFailure(#[from] nym_client_core::config::ConfigUpgradeFailure),
+
     #[error(transparent)]
     NymIdError(#[from] NymIdError),
 }

clients/socks5/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.33"
+version = "1.1.34"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 description = "A SOCKS5 localhost proxy that converts incoming messages to Sphinx and sends them to a Nym address"
 edition = "2021"
@@ -16,7 +16,7 @@ serde_json = { workspace = true }
 tap = "1.0.1"
 thiserror = { workspace = true }
 tokio = { version = "1.24.1", features = ["rt-multi-thread", "net", "signal"] }
-rand = "0.7.3"
+rand = { workspace = true }
 time = { workspace = true }
 url = { workspace = true }
 zeroize = { workspace = true }

clients/socks5/src/commands/import_credential.rs

@@ -10,5 +10,7 @@ use nym_client_core::cli_helpers::client_import_credential::{
 pub(crate) async fn execute(
     args: CommonClientImportCredentialArgs,
 ) -> Result<(), Socks5ClientError> {
-    import_credential::<CliSocks5Client, _>(args).await
+    import_credential::<CliSocks5Client, _>(args).await?;
+    println!("successfully imported credential!");
+    Ok(())
 }

clients/socks5/src/error.rs

@@ -23,6 +23,9 @@ pub enum Socks5ClientError {
     #[error(transparent)]
     ClientCoreError(#[from] ClientCoreError),
 
+    #[error(transparent)]
+    ConfigUpgradeFailure(#[from] nym_client_core::config::ConfigUpgradeFailure),
+
     #[error(transparent)]
     NymIdError(#[from] NymIdError),
 }

common/bandwidth-controller/Cargo.toml

@@ -9,7 +9,7 @@ license.workspace = true
 [dependencies]
 bip39 = { workspace = true }
 log = { workspace = true }
-rand = "0.7.3"
+rand = { workspace = true }
 thiserror = { workspace = true }
 url = { workspace = true }
 zeroize = { workspace = true }

common/bin-common/Cargo.toml

@@ -8,7 +8,6 @@ license = { workspace = true }
 repository = { workspace = true }
 
 [dependencies]
-atty = "0.2"
 const-str = "0.5.6"
 clap = { workspace = true, features = ["derive"] }
 clap_complete = "4.0"

common/bin-common/src/logging/mod.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use serde::{Deserialize, Serialize};
+use std::io::IsTerminal;
 
 #[cfg(feature = "tracing")]
 pub use opentelemetry;
@@ -14,7 +15,7 @@ pub use tracing_subscriber;
 #[cfg(feature = "tracing")]
 pub use tracing_tree;
 
-#[derive(Debug, Default, Clone, Deserialize, PartialEq, Eq, Serialize)]
+#[derive(Debug, Default, Copy, Clone, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct LoggingSettings {
     // well, we need to implement something here at some point...
@@ -120,7 +121,7 @@ pub fn banner(crate_name: &str, crate_version: &str) -> String {
 }
 
 pub fn maybe_print_banner(crate_name: &str, crate_version: &str) {
-    if atty::is(atty::Stream::Stdout) {
+    if std::io::stdout().is_terminal() {
         println!("{}", banner(crate_name, crate_version))
     }
 }

common/client-core/Cargo.toml

@@ -3,7 +3,7 @@ name = "nym-client-core"
 version = "1.1.15"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
-rust-version = "1.66"
+rust-version = "1.70"
 license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -15,9 +15,9 @@ bs58 = { workspace = true }
 cfg-if = "1.0.0"
 clap = { workspace = true, optional = true }
 futures = { workspace = true }
-humantime-serde = "1.0"
+humantime-serde = { workspace = true }
 log = { workspace = true }
-rand = { version = "0.7.3", features = ["wasm-bindgen"] }
+rand = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 sha2 = "0.10.6"
@@ -25,7 +25,6 @@ si-scale = "0.2.2"
 tap = "1.0.1"
 thiserror = { workspace = true }
 url = { workspace = true, features = ["serde"] }
-tungstenite = { workspace = true, default-features = false }
 tokio = { workspace = true, features = ["macros"] }
 time = { workspace = true }
 zeroize = { workspace = true }
@@ -34,6 +33,7 @@ zeroize = { workspace = true }
 nym-id = { path = "../nym-id" }
 nym-bandwidth-controller = { path = "../bandwidth-controller" }
 nym-config = { path = "../config" }
+nym-country-group = { path = "../country-group" }
 nym-crypto = { path = "../crypto" }
 nym-explorer-client = { path = "../../explorer-api/explorer-client" }
 nym-gateway-client = { path = "../client-libs/gateway-client" }
@@ -47,6 +47,7 @@ nym-validator-client = { path = "../client-libs/validator-client", default-featu
 nym-task = { path = "../task" }
 nym-credential-storage = { path = "../credential-storage" }
 nym-network-defaults = { path = "../network-defaults" }
+nym-client-core-config-types = { path = "./config-types", features = ["disk-persistence"] }
 nym-client-core-surb-storage = { path = "./surb-storage" }
 nym-client-core-gateways-storage = { path = "./gateways-storage" }
 
@@ -72,8 +73,17 @@ workspace = true
 features = ["time"]
 
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-tungstenite]
-version = "0.20.1"
-features = ["rustls-tls-native-roots"]
+workspace = true
+features = ["rustls-tls-webpki-roots"]
+
+[target."cfg(not(target_arch = \"wasm32\"))".dependencies.tungstenite]
+workspace = true
+default-features = true
+features = ["rustls-tls-webpki-roots"]
+
+[target."cfg(target_arch = \"wasm32\")".dependencies.tungstenite]
+workspace = true
+default-features = false
 
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen-futures]
 workspace = true

common/client-core/config-types/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "nym-client-core-config-types"
+version = "0.1.0"
+edition = "2021"
+license.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+humantime-serde = { workspace = true }
+serde = { workspace = true, features = ["derive"] }
+thiserror.workspace = true
+url = { workspace = true, features = ["serde"] }
+
+nym-config = { path = "../../config" }
+
+nym-country-group = { path = "../../country-group" }
+nym-pemstore = { path = "../../pemstore", optional = true }
+
+# those are pulling so many deps T.T
+nym-sphinx-params = { path = "../../nymsphinx/params" }
+nym-sphinx-addressing = { path = "../../nymsphinx/addressing" }
+
+
+[features]
+disk-persistence = ["nym-pemstore"]

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

@@ -1,15 +1,53 @@
-// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
 use serde::{Deserialize, Serialize};
 use std::path::{Path, PathBuf};
 
+pub mod old;
+
+// preserve old structure for easier migration
+pub use old::{old_v1_1_20_2, old_v1_1_33};
+
+pub const DEFAULT_REPLY_SURB_DB_FILENAME: &str = "persistent_reply_store.sqlite";
+pub const DEFAULT_CREDENTIALS_DB_FILENAME: &str = "credentials_database.db";
+pub const DEFAULT_GATEWAYS_DETAILS_DB_FILENAME: &str = "gateways_registrations.sqlite";
+
 pub const DEFAULT_PRIVATE_IDENTITY_KEY_FILENAME: &str = "private_identity.pem";
 pub const DEFAULT_PUBLIC_IDENTITY_KEY_FILENAME: &str = "public_identity.pem";
 pub const DEFAULT_PRIVATE_ENCRYPTION_KEY_FILENAME: &str = "private_encryption.pem";
 pub const DEFAULT_PUBLIC_ENCRYPTION_KEY_FILENAME: &str = "public_encryption.pem";
 pub const DEFAULT_ACK_KEY_FILENAME: &str = "ack_key.pem";
 
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct CommonClientPaths {
+    pub keys: ClientKeysPaths,
+
+    /// Path to the file containing information about gateways used by this client,
+    /// i.e. details such as their public keys, owner addresses or the network information.
+    pub gateway_registrations: PathBuf,
+
+    /// Path to the database containing bandwidth credentials of this client.
+    pub credentials_database: PathBuf,
+
+    /// Path to the persistent store for received reply surbs, unused encryption keys and used sender tags.
+    pub reply_surb_database: PathBuf,
+}
+
+impl CommonClientPaths {
+    pub fn new_base<P: AsRef<Path>>(base_data_directory: P) -> Self {
+        let base_dir = base_data_directory.as_ref();
+
+        CommonClientPaths {
+            credentials_database: base_dir.join(DEFAULT_CREDENTIALS_DB_FILENAME),
+            reply_surb_database: base_dir.join(DEFAULT_REPLY_SURB_DB_FILENAME),
+            gateway_registrations: base_dir.join(DEFAULT_GATEWAYS_DETAILS_DB_FILENAME),
+            keys: ClientKeysPaths::new_base(base_data_directory),
+        }
+    }
+}
+
 #[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
 pub struct ClientKeysPaths {
     /// Path to file containing private identity key.

common/client-core/config-types/src/disk_persistence/old/mod.rs

@@ -0,0 +1,9 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+pub mod v1;
+pub mod v2;
+
+// aliases for backwards compatibility
+pub use v1 as old_v1_1_20_2;
+pub use v2 as old_v1_1_33;

common/client-core/config-types/src/disk_persistence/old/v1.rs

@@ -0,0 +1,37 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::disk_persistence::old::v2::{
+    ClientKeysPathsV2, CommonClientPathsV2, DEFAULT_GATEWAY_DETAILS_FILENAME,
+};
+use crate::error::ConfigUpgradeFailure;
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+
+// aliases for backwards compatibility
+pub type CommonClientPathsV1_1_20_2 = CommonClientPathsV1;
+
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct CommonClientPathsV1 {
+    pub keys: ClientKeysPathsV2,
+    pub credentials_database: PathBuf,
+    pub reply_surb_database: PathBuf,
+}
+
+impl CommonClientPathsV1 {
+    pub fn upgrade_default(self) -> Result<CommonClientPathsV2, ConfigUpgradeFailure> {
+        let data_dir = self
+            .reply_surb_database
+            .parent()
+            .ok_or_else(|| ConfigUpgradeFailure {
+                current_version: "1.1.20-2".to_string(),
+            })?;
+        Ok(CommonClientPathsV2 {
+            keys: self.keys,
+            gateway_details: data_dir.join(DEFAULT_GATEWAY_DETAILS_FILENAME),
+            credentials_database: self.credentials_database,
+            reply_surb_database: self.reply_surb_database,
+        })
+    }
+}

common/client-core/config-types/src/disk_persistence/old/v2.rs

@@ -1,16 +1,20 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::config::disk_persistence::keys_paths::ClientKeysPaths;
-use crate::config::disk_persistence::{CommonClientPaths, DEFAULT_GATEWAYS_DETAILS_DB_FILENAME};
-use crate::error::ClientCoreError;
+use crate::disk_persistence::ClientKeysPaths;
+use crate::disk_persistence::{CommonClientPaths, DEFAULT_GATEWAYS_DETAILS_DB_FILENAME};
+use crate::error::ConfigUpgradeFailure;
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 
 pub const DEFAULT_GATEWAY_DETAILS_FILENAME: &str = "gateway_details.json";
 
+// aliases for backwards compatibility
+pub type CommonClientPathsV1_1_33 = CommonClientPathsV2;
+pub type ClientKeysPathsV1_1_33 = ClientKeysPathsV2;
+
 #[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
-pub struct ClientKeysPathsV1_1_33 {
+pub struct ClientKeysPathsV2 {
     /// Path to file containing private identity key.
     pub private_identity_key_file: PathBuf,
 
@@ -32,7 +36,7 @@ pub struct ClientKeysPathsV1_1_33 {
     pub ack_key_file: PathBuf,
 }
 
-impl ClientKeysPathsV1_1_33 {
+impl ClientKeysPathsV2 {
     pub fn upgrade(self) -> ClientKeysPaths {
         ClientKeysPaths {
             private_identity_key_file: self.private_identity_key_file,
@@ -46,8 +50,8 @@ impl ClientKeysPathsV1_1_33 {
 
 #[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
-pub struct CommonClientPathsV1_1_33 {
-    pub keys: ClientKeysPathsV1_1_33,
+pub struct CommonClientPathsV2 {
+    pub keys: ClientKeysPathsV2,
 
     /// Path to the file containing information about gateway used by this client,
     /// i.e. details such as its public key, owner address or the network information.
@@ -60,15 +64,16 @@ pub struct CommonClientPathsV1_1_33 {
     pub reply_surb_database: PathBuf,
 }
 
-impl CommonClientPathsV1_1_33 {
+impl CommonClientPathsV2 {
     // note that during the upgrade process, the caller will need to extract the key and gateway details
     // manually and resave them in the new database
-    pub fn upgrade_default(self) -> Result<CommonClientPaths, ClientCoreError> {
-        let data_dir = self.gateway_details.parent().ok_or_else(|| {
-            ClientCoreError::ConfigFileUpgradeFailure {
+    pub fn upgrade_default(self) -> Result<CommonClientPaths, ConfigUpgradeFailure> {
+        let data_dir = self
+            .gateway_details
+            .parent()
+            .ok_or_else(|| ConfigUpgradeFailure {
                 current_version: "1.1.33".to_string(),
-            }
-        })?;
+            })?;
 
         Ok(CommonClientPaths {
             keys: self.keys.upgrade(),

common/client-core/config-types/src/error.rs

@@ -0,0 +1,19 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+#[error("unable to upgrade config file from `{current_version}`")]
+pub struct ConfigUpgradeFailure {
+    pub current_version: String,
+}
+
+#[derive(Error, Debug)]
+pub enum InvalidTrafficModeFailure {
+    #[error("attempted to set medium toggle traffic mode with fast mode flag")]
+    MediumToggleWithFastMode,
+
+    #[error("attempted to set medium toggle traffic mode with no cover flag")]
+    MediumToggleWithNoCover,
+}

common/client-core/config-types/src/lib.rs

@@ -0,0 +1,662 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use nym_config::defaults::NymNetworkDetails;
+use nym_sphinx_addressing::Recipient;
+use nym_sphinx_params::{PacketSize, PacketType};
+use serde::{Deserialize, Serialize};
+use std::time::Duration;
+use url::Url;
+
+#[cfg(feature = "disk-persistence")]
+pub mod disk_persistence;
+pub mod error;
+pub mod old;
+
+pub use error::ConfigUpgradeFailure;
+
+// 'DEBUG'
+const DEFAULT_ACK_WAIT_MULTIPLIER: f64 = 1.5;
+
+const DEFAULT_ACK_WAIT_ADDITION: Duration = Duration::from_millis(1_500);
+const DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY: Duration = Duration::from_millis(200);
+const DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY: Duration = Duration::from_millis(20);
+const DEFAULT_AVERAGE_PACKET_DELAY: Duration = Duration::from_millis(50);
+const DEFAULT_TOPOLOGY_REFRESH_RATE: Duration = Duration::from_secs(5 * 60); // every 5min
+const DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT: Duration = Duration::from_millis(5_000);
+const DEFAULT_MAX_STARTUP_GATEWAY_WAITING_PERIOD: Duration = Duration::from_secs(70 * 60); // 70min -> full epoch (1h) + a bit of overhead
+
+// Set this to a high value for now, so that we don't risk sporadic timeouts that might cause
+// bought bandwidth tokens to not have time to be spent; Once we remove the gateway from the
+// bandwidth bridging protocol, we can come back to a smaller timeout value
+const DEFAULT_GATEWAY_RESPONSE_TIMEOUT: Duration = Duration::from_secs(5 * 60);
+
+const DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO: f64 = 0.70;
+
+// reply-surbs related:
+
+// define when to request
+// clients/client-core/src/client/replies/reply_storage/surb_storage.rs
+const DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD: usize = 10;
+const DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD: usize = 200;
+
+// define how much to request at once
+// clients/client-core/src/client/replies/reply_controller.rs
+const DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE: u32 = 10;
+const DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE: u32 = 100;
+
+const DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE: u32 = 500;
+
+const DEFAULT_MAXIMUM_REPLY_SURB_REREQUEST_WAITING_PERIOD: Duration = Duration::from_secs(10);
+const DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD: Duration = Duration::from_secs(5 * 60);
+
+// 12 hours
+const DEFAULT_MAXIMUM_REPLY_SURB_AGE: Duration = Duration::from_secs(12 * 60 * 60);
+
+// 24 hours
+const DEFAULT_MAXIMUM_REPLY_KEY_AGE: Duration = Duration::from_secs(24 * 60 * 60);
+
+use crate::error::InvalidTrafficModeFailure;
+pub use nym_country_group::CountryGroup;
+
+#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct Config {
+    pub client: Client,
+
+    #[serde(default)]
+    pub debug: DebugConfig,
+}
+
+impl Config {
+    pub fn new<S1, S2>(id: S1, version: S2) -> Self
+    where
+        S1: Into<String>,
+        S2: Into<String>,
+    {
+        Config {
+            client: Client::new_default(id, version),
+            debug: Default::default(),
+        }
+    }
+
+    pub fn from_client_config(client: Client, debug: DebugConfig) -> Self {
+        Config { client, debug }
+    }
+
+    pub fn validate(&self) -> bool {
+        self.debug.validate()
+    }
+
+    pub fn with_debug_config(mut self, debug: DebugConfig) -> Self {
+        self.debug = debug;
+        self
+    }
+
+    pub fn with_disabled_credentials(mut self, disabled_credentials_mode: bool) -> Self {
+        self.client.disabled_credentials_mode = disabled_credentials_mode;
+        self
+    }
+
+    pub fn with_custom_nyxd(mut self, urls: Vec<Url>) -> Self {
+        self.client.nyxd_urls = urls;
+        self
+    }
+
+    pub fn set_custom_nyxd(&mut self, nyxd_urls: Vec<Url>) {
+        self.client.nyxd_urls = nyxd_urls;
+    }
+
+    pub fn with_custom_nym_apis(mut self, nym_api_urls: Vec<Url>) -> Self {
+        self.client.nym_api_urls = nym_api_urls;
+        self
+    }
+
+    pub fn set_custom_nym_apis(&mut self, nym_api_urls: Vec<Url>) {
+        self.client.nym_api_urls = nym_api_urls;
+    }
+
+    pub fn with_high_default_traffic_volume(mut self, enabled: bool) -> Self {
+        if enabled {
+            self.set_high_default_traffic_volume();
+        }
+        self
+    }
+
+    pub fn with_packet_type(mut self, packet_type: PacketType) -> Self {
+        self.debug.traffic.packet_type = packet_type;
+        self
+    }
+
+    // TODO: this should be refactored properly
+    // as of 12.09.23 the below is true (not sure how this comment will rot in the future)
+    // medium_toggle:
+    // - sets secondary packet size to 16kb
+    // - disables poisson distribution of the main traffic stream
+    // - sets the cover traffic stream to 1 packet / 5s (on average)
+    // - disables per hop delay
+    //
+    // fastmode (to be renamed to `fast-poisson`):
+    // - sets average per hop delay to 10ms
+    // - sets the cover traffic stream to 1 packet / 2000s (on average); for all intents and purposes it disables the stream
+    // - sets the poisson distribution of the main traffic stream to 4ms, i.e. 250 packets / s on average
+    //
+    // no_cover:
+    // - disables poisson distribution of the main traffic stream
+    // - disables the secondary cover traffic stream
+    #[doc(hidden)]
+    pub fn try_apply_traffic_modes(
+        &mut self,
+        disable_poisson_process: bool,
+        medium_toggle: bool,
+        fast_mode: bool,
+        no_cover: bool,
+    ) -> Result<(), InvalidTrafficModeFailure> {
+        if disable_poisson_process {
+            self.set_no_poisson_process()
+        }
+
+        if medium_toggle {
+            if fast_mode {
+                return Err(InvalidTrafficModeFailure::MediumToggleWithFastMode);
+            }
+            if no_cover {
+                return Err(InvalidTrafficModeFailure::MediumToggleWithNoCover);
+            }
+
+            self.set_experimental_medium_toggle();
+        }
+
+        if fast_mode {
+            self.set_high_default_traffic_volume()
+        }
+
+        if no_cover {
+            self.set_no_cover_traffic();
+        }
+
+        Ok(())
+    }
+
+    pub fn set_high_default_traffic_volume(&mut self) {
+        self.debug.traffic.average_packet_delay = Duration::from_millis(10);
+        // basically don't really send cover messages
+        self.debug.cover_traffic.loop_cover_traffic_average_delay =
+            Duration::from_millis(2_000_000);
+        // 250 "real" messages / s
+        self.debug.traffic.message_sending_average_delay = Duration::from_millis(4);
+    }
+
+    /// Enable medium mixnet traffic, for experiments only.
+    /// This includes things like disabling cover traffic, no per hop delays, etc.
+    #[doc(hidden)]
+    pub fn set_experimental_medium_toggle(&mut self) {
+        self.set_no_cover_traffic_with_keepalive();
+        self.set_no_per_hop_delays();
+        self.debug.traffic.secondary_packet_size = Some(PacketSize::ExtendedPacket16);
+    }
+
+    pub fn with_disabled_poisson_process(mut self, disabled: bool) -> Self {
+        if disabled {
+            self.set_no_poisson_process()
+        }
+        self
+    }
+
+    pub fn set_no_poisson_process(&mut self) {
+        self.debug.traffic.disable_main_poisson_packet_distribution = true;
+    }
+
+    pub fn with_disabled_cover_traffic(mut self, disabled: bool) -> Self {
+        if disabled {
+            self.set_no_cover_traffic()
+        }
+        self
+    }
+
+    pub fn set_no_cover_traffic(&mut self) {
+        self.debug.cover_traffic.disable_loop_cover_traffic_stream = true;
+        self.debug.traffic.disable_main_poisson_packet_distribution = true;
+    }
+
+    pub fn with_disabled_cover_traffic_with_keepalive(mut self, disabled: bool) -> Self {
+        if disabled {
+            self.set_no_cover_traffic_with_keepalive()
+        }
+        self
+    }
+    pub fn set_no_cover_traffic_with_keepalive(&mut self) {
+        self.debug.traffic.disable_main_poisson_packet_distribution = true;
+        self.debug.cover_traffic.loop_cover_traffic_average_delay = Duration::from_secs(5);
+    }
+
+    pub fn with_disabled_topology_refresh(mut self, disable_topology_refresh: bool) -> Self {
+        self.debug.topology.disable_refreshing = disable_topology_refresh;
+        self
+    }
+
+    pub fn with_topology_structure(mut self, topology_structure: TopologyStructure) -> Self {
+        self.set_topology_structure(topology_structure);
+        self
+    }
+
+    pub fn set_topology_structure(&mut self, topology_structure: TopologyStructure) {
+        self.debug.topology.topology_structure = topology_structure;
+    }
+
+    pub fn with_no_per_hop_delays(mut self, no_per_hop_delays: bool) -> Self {
+        if no_per_hop_delays {
+            self.set_no_per_hop_delays()
+        }
+        self
+    }
+
+    pub fn set_no_per_hop_delays(&mut self) {
+        self.debug.traffic.average_packet_delay = Duration::ZERO;
+        self.debug.acknowledgements.average_ack_delay = Duration::ZERO;
+    }
+
+    pub fn with_secondary_packet_size(mut self, secondary_packet_size: Option<PacketSize>) -> Self {
+        self.set_secondary_packet_size(secondary_packet_size);
+        self
+    }
+
+    pub fn set_secondary_packet_size(&mut self, secondary_packet_size: Option<PacketSize>) {
+        self.debug.traffic.secondary_packet_size = secondary_packet_size;
+    }
+
+    pub fn set_custom_version(&mut self, version: &str) {
+        self.client.version = version.to_string();
+    }
+
+    pub fn get_id(&self) -> String {
+        self.client.id.clone()
+    }
+
+    pub fn get_disabled_credentials_mode(&self) -> bool {
+        self.client.disabled_credentials_mode
+    }
+
+    pub fn get_validator_endpoints(&self) -> Vec<Url> {
+        self.client.nyxd_urls.clone()
+    }
+
+    pub fn get_nym_api_endpoints(&self) -> Vec<Url> {
+        self.client.nym_api_urls.clone()
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
+// note: the deny_unknown_fields is VITAL here to allow upgrades from v1.1.20_2
+#[serde(deny_unknown_fields)]
+pub struct Client {
+    /// Version of the client for which this configuration was created.
+    pub version: String,
+
+    /// ID specifies the human readable ID of this particular client.
+    pub id: String,
+
+    /// Indicates whether this client is running in a disabled credentials mode, thus attempting
+    /// to claim bandwidth without presenting bandwidth credentials.
+    // TODO: this should be moved to `debug.gateway_connection`
+    #[serde(default)]
+    pub disabled_credentials_mode: bool,
+
+    /// Addresses to nyxd validators via which the client can communicate with the chain.
+    #[serde(alias = "validator_urls")]
+    pub nyxd_urls: Vec<Url>,
+
+    /// Addresses to APIs running on validator from which the client gets the view of the network.
+    #[serde(alias = "validator_api_urls")]
+    pub nym_api_urls: Vec<Url>,
+}
+
+impl Client {
+    pub fn new_default<S1, S2>(id: S1, version: S2) -> Self
+    where
+        S1: Into<String>,
+        S2: Into<String>,
+    {
+        let network = NymNetworkDetails::new_mainnet();
+        let nyxd_urls = network
+            .endpoints
+            .iter()
+            .map(|validator| validator.nyxd_url())
+            .collect();
+        let nym_api_urls = network
+            .endpoints
+            .iter()
+            .filter_map(|validator| validator.api_url())
+            .collect::<Vec<_>>();
+
+        Client {
+            version: version.into(),
+            id: id.into(),
+            disabled_credentials_mode: true,
+            nyxd_urls,
+            nym_api_urls,
+        }
+    }
+
+    pub fn new<S: Into<String>>(
+        id: S,
+        version: S,
+        disabled_credentials_mode: bool,
+        nyxd_urls: Vec<Url>,
+        nym_api_urls: Vec<Url>,
+    ) -> Self {
+        Client {
+            version: version.into(),
+            id: id.into(),
+            disabled_credentials_mode,
+            nyxd_urls,
+            nym_api_urls,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct Traffic {
+    /// The parameter of Poisson distribution determining how long, on average,
+    /// sent packet is going to be delayed at any given mix node.
+    /// So for a packet going through three mix nodes, on average, it will take three times this value
+    /// until the packet reaches its destination.
+    #[serde(with = "humantime_serde")]
+    pub average_packet_delay: Duration,
+
+    /// The parameter of Poisson distribution determining how long, on average,
+    /// it is going to take another 'real traffic stream' message to be sent.
+    /// If no real packets are available and cover traffic is enabled,
+    /// a loop cover message is sent instead in order to preserve the rate.
+    #[serde(with = "humantime_serde")]
+    pub message_sending_average_delay: Duration,
+
+    /// Controls whether the main packet stream constantly produces packets according to the predefined
+    /// poisson distribution.
+    pub disable_main_poisson_packet_distribution: bool,
+
+    /// Specifies the packet size used for sent messages.
+    /// Do not override it unless you understand the consequences of that change.
+    pub primary_packet_size: PacketSize,
+
+    /// Specifies the optional auxiliary packet size for optimizing message streams.
+    /// Note that its use decreases overall anonymity.
+    /// Do not set it it unless you understand the consequences of that change.
+    pub secondary_packet_size: Option<PacketSize>,
+
+    pub packet_type: PacketType,
+}
+
+impl Traffic {
+    pub fn validate(&self) -> bool {
+        if let Some(secondary_packet_size) = self.secondary_packet_size {
+            if secondary_packet_size == PacketSize::AckPacket
+                || secondary_packet_size == self.primary_packet_size
+            {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+impl Default for Traffic {
+    fn default() -> Self {
+        Traffic {
+            average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
+            message_sending_average_delay: DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
+            disable_main_poisson_packet_distribution: false,
+            primary_packet_size: PacketSize::RegularPacket,
+            secondary_packet_size: None,
+            packet_type: PacketType::Mix,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct CoverTraffic {
+    /// The parameter of Poisson distribution determining how long, on average,
+    /// it is going to take for another loop cover traffic message to be sent.
+    #[serde(with = "humantime_serde")]
+    pub loop_cover_traffic_average_delay: Duration,
+
+    /// Specifies the ratio of `primary_packet_size` to `secondary_packet_size` used in cover traffic.
+    /// Only applicable if `secondary_packet_size` is enabled.
+    pub cover_traffic_primary_size_ratio: f64,
+
+    /// Controls whether the dedicated loop cover traffic stream should be enabled.
+    /// (and sending packets, on average, every [Self::loop_cover_traffic_average_delay])
+    pub disable_loop_cover_traffic_stream: bool,
+}
+
+impl Default for CoverTraffic {
+    fn default() -> Self {
+        CoverTraffic {
+            loop_cover_traffic_average_delay: DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY,
+            cover_traffic_primary_size_ratio: DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO,
+            disable_loop_cover_traffic_stream: false,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct GatewayConnection {
+    /// How long we're willing to wait for a response to a message sent to the gateway,
+    /// before giving up on it.
+    #[serde(with = "humantime_serde")]
+    pub gateway_response_timeout: Duration,
+}
+
+impl Default for GatewayConnection {
+    fn default() -> Self {
+        GatewayConnection {
+            gateway_response_timeout: DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct Acknowledgements {
+    /// The parameter of Poisson distribution determining how long, on average,
+    /// sent acknowledgement is going to be delayed at any given mix node.
+    /// So for an ack going through three mix nodes, on average, it will take three times this value
+    /// until the packet reaches its destination.
+    #[serde(with = "humantime_serde")]
+    pub average_ack_delay: Duration,
+
+    /// Value multiplied with the expected round trip time of an acknowledgement packet before
+    /// it is assumed it was lost and retransmission of the data packet happens.
+    /// In an ideal network with 0 latency, this value would have been 1.
+    pub ack_wait_multiplier: f64,
+
+    /// Value added to the expected round trip time of an acknowledgement packet before
+    /// it is assumed it was lost and retransmission of the data packet happens.
+    /// In an ideal network with 0 latency, this value would have been 0.
+    #[serde(with = "humantime_serde")]
+    pub ack_wait_addition: Duration,
+}
+
+impl Default for Acknowledgements {
+    fn default() -> Self {
+        Acknowledgements {
+            average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
+            ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
+            ack_wait_addition: DEFAULT_ACK_WAIT_ADDITION,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct Topology {
+    /// The uniform delay every which clients are querying the directory server
+    /// to try to obtain a compatible network topology to send sphinx packets through.
+    #[serde(with = "humantime_serde")]
+    pub topology_refresh_rate: Duration,
+
+    /// During topology refresh, test packets are sent through every single possible network
+    /// path. This timeout determines waiting period until it is decided that the packet
+    /// did not reach its destination.
+    #[serde(with = "humantime_serde")]
+    pub topology_resolution_timeout: Duration,
+
+    /// Specifies whether the client should not refresh the network topology after obtaining
+    /// the first valid instance.
+    /// Supersedes `topology_refresh_rate_ms`.
+    pub disable_refreshing: bool,
+
+    /// Defines how long the client is going to wait on startup for its gateway to come online,
+    /// before abandoning the procedure.
+    #[serde(with = "humantime_serde")]
+    pub max_startup_gateway_waiting_period: Duration,
+
+    /// Specifies the mixnode topology to be used for sending packets.
+    pub topology_structure: TopologyStructure,
+}
+
+#[allow(clippy::large_enum_variant)]
+#[derive(Default, Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum TopologyStructure {
+    #[default]
+    NymApi,
+    GeoAware(GroupBy),
+}
+
+#[allow(clippy::large_enum_variant)]
+#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum GroupBy {
+    CountryGroup(CountryGroup),
+    NymAddress(Recipient),
+}
+
+impl std::fmt::Display for GroupBy {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            GroupBy::CountryGroup(group) => write!(f, "group: {group}"),
+            GroupBy::NymAddress(address) => write!(f, "address: {address}"),
+        }
+    }
+}
+
+impl Default for Topology {
+    fn default() -> Self {
+        Topology {
+            topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
+            topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
+            disable_refreshing: false,
+            max_startup_gateway_waiting_period: DEFAULT_MAX_STARTUP_GATEWAY_WAITING_PERIOD,
+            topology_structure: TopologyStructure::default(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct ReplySurbs {
+    /// Defines the minimum number of reply surbs the client wants to keep in its storage at all times.
+    /// It can only allow to go below that value if its to request additional reply surbs.
+    pub minimum_reply_surb_storage_threshold: usize,
+
+    /// Defines the maximum number of reply surbs the client wants to keep in its storage at any times.
+    pub maximum_reply_surb_storage_threshold: usize,
+
+    /// Defines the minimum number of reply surbs the client would request.
+    pub minimum_reply_surb_request_size: u32,
+
+    /// Defines the maximum number of reply surbs the client would request.
+    pub maximum_reply_surb_request_size: u32,
+
+    /// Defines the maximum number of reply surbs a remote party is allowed to request from this client at once.
+    pub maximum_allowed_reply_surb_request_size: u32,
+
+    /// Defines maximum amount of time the client is going to wait for reply surbs before explicitly asking
+    /// for more even though in theory they wouldn't need to.
+    #[serde(with = "humantime_serde")]
+    pub maximum_reply_surb_rerequest_waiting_period: Duration,
+
+    /// Defines maximum amount of time the client is going to wait for reply surbs before
+    /// deciding it's never going to get them and would drop all pending messages
+    #[serde(with = "humantime_serde")]
+    pub maximum_reply_surb_drop_waiting_period: Duration,
+
+    /// Defines maximum amount of time given reply surb is going to be valid for.
+    /// This is going to be superseded by key rotation once implemented.
+    #[serde(with = "humantime_serde")]
+    pub maximum_reply_surb_age: Duration,
+
+    /// Defines maximum amount of time given reply key is going to be valid for.
+    /// This is going to be superseded by key rotation once implemented.
+    #[serde(with = "humantime_serde")]
+    pub maximum_reply_key_age: Duration,
+
+    /// Specifies the number of mixnet hops the packet should go through. If not specified, then
+    /// the default value is used.
+    pub surb_mix_hops: Option<u8>,
+}
+
+impl Default for ReplySurbs {
+    fn default() -> Self {
+        ReplySurbs {
+            minimum_reply_surb_storage_threshold: DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD,
+            maximum_reply_surb_storage_threshold: DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD,
+            minimum_reply_surb_request_size: DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE,
+            maximum_reply_surb_request_size: DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE,
+            maximum_allowed_reply_surb_request_size: DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE,
+            maximum_reply_surb_rerequest_waiting_period:
+                DEFAULT_MAXIMUM_REPLY_SURB_REREQUEST_WAITING_PERIOD,
+            maximum_reply_surb_drop_waiting_period: DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD,
+            maximum_reply_surb_age: DEFAULT_MAXIMUM_REPLY_SURB_AGE,
+            maximum_reply_key_age: DEFAULT_MAXIMUM_REPLY_KEY_AGE,
+            surb_mix_hops: None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct DebugConfig {
+    /// Defines all configuration options related to traffic streams.
+    pub traffic: Traffic,
+
+    /// Defines all configuration options related to cover traffic stream(s).
+    pub cover_traffic: CoverTraffic,
+
+    /// Defines all configuration options related to the gateway connection.
+    pub gateway_connection: GatewayConnection,
+
+    /// Defines all configuration options related to acknowledgements, such as delays or wait timeouts.
+    pub acknowledgements: Acknowledgements,
+
+    /// Defines all configuration options related topology, such as refresh rates or timeouts.
+    pub topology: Topology,
+
+    /// Defines all configuration options related to reply SURBs.
+    pub reply_surbs: ReplySurbs,
+}
+
+impl DebugConfig {
+    pub fn validate(&self) -> bool {
+        // no other sections have explicit requirements (yet)
+        self.traffic.validate()
+    }
+}
+
+// it could be derived, sure, but I'd rather have an explicit implementation in case we had to change
+// something manually at some point
+#[allow(clippy::derivable_impls)]
+impl Default for DebugConfig {
+    fn default() -> Self {
+        DebugConfig {
+            traffic: Default::default(),
+            cover_traffic: Default::default(),
+            gateway_connection: Default::default(),
+            acknowledgements: Default::default(),
+            topology: Default::default(),
+            reply_surbs: Default::default(),
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+pub mod v1;
+pub mod v2;
+pub mod v3;
+pub mod v4;
+pub mod v5;
+
+// aliases for backwards compatibility
+pub use v1 as old_config_v1_1_13;
+pub use v2 as old_config_v1_1_20;
+pub use v3 as old_config_v1_1_20_2;
+pub use v4 as old_config_v1_1_30;
+pub use v5 as old_config_v1_1_33;

common/client-core/config-types/src/old/v1.rs

@@ -1,23 +1,28 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::config::old_config_v1_1_20::{
-    AcknowledgementsV1_1_20, ClientV1_1_20, ConfigV1_1_20, CoverTrafficV1_1_20, DebugConfigV1_1_20,
-    GatewayConnectionV1_1_20, LoggingV1_1_20, ReplySurbsV1_1_20, TopologyV1_1_20, TrafficV1_1_20,
-    DEFAULT_ACK_WAIT_ADDITION, DEFAULT_ACK_WAIT_MULTIPLIER, DEFAULT_AVERAGE_PACKET_DELAY,
-    DEFAULT_GATEWAY_RESPONSE_TIMEOUT, DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY,
-    DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE, DEFAULT_MAXIMUM_REPLY_KEY_AGE,
-    DEFAULT_MAXIMUM_REPLY_SURB_AGE, DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD,
-    DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE, DEFAULT_MAXIMUM_REPLY_SURB_REREQUEST_WAITING_PERIOD,
+use crate::old::v2::{
+    AcknowledgementsV2, ClientV2, ConfigV2, CoverTrafficV2, DebugConfigV2, GatewayConnectionV2,
+    LoggingV2, ReplySurbsV2, TopologyV2, TrafficV2, DEFAULT_ACK_WAIT_ADDITION,
+    DEFAULT_ACK_WAIT_MULTIPLIER, DEFAULT_AVERAGE_PACKET_DELAY, DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
+    DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY, DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE,
+    DEFAULT_MAXIMUM_REPLY_KEY_AGE, DEFAULT_MAXIMUM_REPLY_SURB_AGE,
+    DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD, DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE,
+    DEFAULT_MAXIMUM_REPLY_SURB_REREQUEST_WAITING_PERIOD,
     DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD, DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
     DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE, DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD,
     DEFAULT_TOPOLOGY_REFRESH_RATE, DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
 };
-use nym_sphinx::params::PacketSize;
+use nym_sphinx_params::PacketSize;
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
 use std::time::Duration;
 
+// aliases for backwards compatibility
+pub type OldConfigV1_1_13<T> = ConfigV1<T>;
+pub type OldLoggingV1_1_13 = LoggingV1;
+pub type OldDebugConfigV1_1_13 = DebugConfigV1;
+
 #[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "lowercase")]
 pub enum ExtendedPacketSize {
@@ -38,28 +43,28 @@ impl From<ExtendedPacketSize> for PacketSize {
 
 #[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
-pub struct OldConfigV1_1_13<T> {
-    pub client: ClientV1_1_20<T>,
+pub struct ConfigV1<T> {
+    pub client: ClientV2<T>,
 
     #[serde(default)]
-    pub logging: OldLoggingV1_1_13,
+    pub logging: LoggingV1,
     #[serde(default)]
-    pub debug: OldDebugConfigV1_1_13,
+    pub debug: DebugConfigV1,
 }
 
 #[derive(Debug, Clone, Default, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
-pub struct OldLoggingV1_1_13 {}
+pub struct LoggingV1 {}
 
-impl From<OldLoggingV1_1_13> for LoggingV1_1_20 {
-    fn from(_value: OldLoggingV1_1_13) -> Self {
-        LoggingV1_1_20 {}
+impl From<LoggingV1> for LoggingV2 {
+    fn from(_value: LoggingV1) -> Self {
+        LoggingV2 {}
     }
 }
 
 #[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct OldDebugConfigV1_1_13 {
+pub struct DebugConfigV1 {
     #[serde(with = "humantime_serde")]
     pub average_packet_delay: Duration,
 
@@ -114,10 +119,10 @@ pub struct OldDebugConfigV1_1_13 {
     pub maximum_reply_key_age: Duration,
 }
 
-impl From<OldDebugConfigV1_1_13> for DebugConfigV1_1_20 {
-    fn from(value: OldDebugConfigV1_1_13) -> Self {
-        DebugConfigV1_1_20 {
-            traffic: TrafficV1_1_20 {
+impl From<DebugConfigV1> for DebugConfigV2 {
+    fn from(value: DebugConfigV1) -> Self {
+        DebugConfigV2 {
+            traffic: TrafficV2 {
                 average_packet_delay: value.average_packet_delay,
                 message_sending_average_delay: value.message_sending_average_delay,
                 disable_main_poisson_packet_distribution: value
@@ -125,25 +130,25 @@ impl From<OldDebugConfigV1_1_13> for DebugConfigV1_1_20 {
                 primary_packet_size: PacketSize::RegularPacket,
                 secondary_packet_size: value.use_extended_packet_size.map(Into::into),
             },
-            cover_traffic: CoverTrafficV1_1_20 {
+            cover_traffic: CoverTrafficV2 {
                 loop_cover_traffic_average_delay: value.loop_cover_traffic_average_delay,
                 disable_loop_cover_traffic_stream: value.disable_loop_cover_traffic_stream,
-                ..CoverTrafficV1_1_20::default()
+                ..CoverTrafficV2::default()
             },
-            gateway_connection: GatewayConnectionV1_1_20 {
+            gateway_connection: GatewayConnectionV2 {
                 gateway_response_timeout: value.gateway_response_timeout,
             },
-            acknowledgements: AcknowledgementsV1_1_20 {
+            acknowledgements: AcknowledgementsV2 {
                 average_ack_delay: value.average_ack_delay,
                 ack_wait_multiplier: value.ack_wait_multiplier,
                 ack_wait_addition: value.ack_wait_addition,
             },
-            topology: TopologyV1_1_20 {
+            topology: TopologyV2 {
                 topology_refresh_rate: value.topology_refresh_rate,
                 topology_resolution_timeout: value.topology_resolution_timeout,
                 disable_refreshing: false,
             },
-            reply_surbs: ReplySurbsV1_1_20 {
+            reply_surbs: ReplySurbsV2 {
                 minimum_reply_surb_storage_threshold: value.minimum_reply_surb_storage_threshold,
                 maximum_reply_surb_storage_threshold: value.maximum_reply_surb_storage_threshold,
                 minimum_reply_surb_request_size: value.minimum_reply_surb_request_size,
@@ -161,9 +166,9 @@ impl From<OldDebugConfigV1_1_13> for DebugConfigV1_1_20 {
     }
 }
 
-impl Default for OldDebugConfigV1_1_13 {
+impl Default for DebugConfigV1 {
     fn default() -> Self {
-        OldDebugConfigV1_1_13 {
+        DebugConfigV1 {
             average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
             average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
             ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
@@ -190,10 +195,10 @@ impl Default for OldDebugConfigV1_1_13 {
     }
 }
 
-impl<T, U> From<OldConfigV1_1_13<T>> for ConfigV1_1_20<U> {
-    fn from(value: OldConfigV1_1_13<T>) -> Self {
-        ConfigV1_1_20 {
-            client: ClientV1_1_20 {
+impl<T, U> From<ConfigV1<T>> for ConfigV2<U> {
+    fn from(value: ConfigV1<T>) -> Self {
+        ConfigV2 {
+            client: ClientV2 {
                 version: value.client.version,
                 id: value.client.id,
                 disabled_credentials_mode: value.client.disabled_credentials_mode,

common/client-core/config-types/src/old/v2.rs

@@ -1,12 +1,11 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::config::old_config_v1_1_20_2::{
-    AcknowledgementsV1_1_20_2, CoverTrafficV1_1_20_2, DebugConfigV1_1_20_2,
-    GatewayConnectionV1_1_20_2, GatewayEndpointConfigV1_1_20_2, ReplySurbsV1_1_20_2,
-    TopologyV1_1_20_2, TrafficV1_1_20_2,
+use crate::old::v3::{
+    AcknowledgementsV3, CoverTrafficV3, DebugConfigV3, GatewayConnectionV3,
+    GatewayEndpointConfigV3, ReplySurbsV3, TopologyV3, TrafficV3,
 };
-use nym_sphinx::params::{PacketSize, PacketType};
+use nym_sphinx_params::{PacketSize, PacketType};
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
 use std::path::PathBuf;
@@ -54,27 +53,41 @@ pub(crate) const DEFAULT_MAXIMUM_REPLY_SURB_AGE: Duration = Duration::from_secs(
 // 24 hours
 pub(crate) const DEFAULT_MAXIMUM_REPLY_KEY_AGE: Duration = Duration::from_secs(24 * 60 * 60);
 
+// aliases for backwards compatibility
+pub type ConfigV1_1_20<T> = ConfigV2<T>;
+pub type ClientV1_1_20<T> = ClientV2<T>;
+pub type LoggingV1_1_20 = LoggingV2;
+pub type DebugConfigV1_1_20 = DebugConfigV2;
+pub type GatewayEndpointConfigV1_1_20 = GatewayEndpointConfigV2;
+
+pub type TrafficV1_1_20 = TrafficV2;
+pub type CoverTrafficV1_1_20 = CoverTrafficV2;
+pub type GatewayConnectionV1_1_20 = GatewayConnectionV2;
+pub type AcknowledgementsV1_1_20 = AcknowledgementsV2;
+pub type TopologyV1_1_20 = TopologyV2;
+pub type ReplySurbsV1_1_20 = ReplySurbsV2;
+
 #[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
-pub struct ConfigV1_1_20<T> {
-    pub client: ClientV1_1_20<T>,
+pub struct ConfigV2<T> {
+    pub client: ClientV2<T>,
 
     #[serde(default)]
-    pub logging: LoggingV1_1_20,
+    pub logging: LoggingV2,
     #[serde(default)]
-    pub debug: DebugConfigV1_1_20,
+    pub debug: DebugConfigV2,
 }
 
 #[derive(Clone, Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
-pub struct GatewayEndpointConfigV1_1_20 {
+pub struct GatewayEndpointConfigV2 {
     pub gateway_id: String,
     pub gateway_owner: String,
     pub gateway_listener: String,
 }
 
-impl From<GatewayEndpointConfigV1_1_20> for GatewayEndpointConfigV1_1_20_2 {
-    fn from(value: GatewayEndpointConfigV1_1_20) -> Self {
-        GatewayEndpointConfigV1_1_20_2 {
+impl From<GatewayEndpointConfigV2> for GatewayEndpointConfigV3 {
+    fn from(value: GatewayEndpointConfigV2) -> Self {
+        GatewayEndpointConfigV3 {
             gateway_id: value.gateway_id,
             gateway_owner: value.gateway_owner,
             gateway_listener: value.gateway_listener,
@@ -83,7 +96,7 @@ impl From<GatewayEndpointConfigV1_1_20> for GatewayEndpointConfigV1_1_20_2 {
 }
 
 #[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
-pub struct ClientV1_1_20<T> {
+pub struct ClientV2<T> {
     pub version: String,
     pub id: String,
     #[serde(default)]
@@ -98,7 +111,7 @@ pub struct ClientV1_1_20<T> {
     pub public_encryption_key_file: PathBuf,
     pub gateway_shared_key_file: PathBuf,
     pub ack_key_file: PathBuf,
-    pub gateway_endpoint: GatewayEndpointConfigV1_1_20,
+    pub gateway_endpoint: GatewayEndpointConfigV2,
     pub database_path: PathBuf,
     #[serde(default)]
     pub reply_surb_database_path: PathBuf,
@@ -110,11 +123,11 @@ pub struct ClientV1_1_20<T> {
 
 #[derive(Debug, Clone, Default, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
-pub struct LoggingV1_1_20 {}
+pub struct LoggingV2 {}
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default)]
-pub struct TrafficV1_1_20 {
+pub struct TrafficV2 {
     #[serde(with = "humantime_serde")]
     pub average_packet_delay: Duration,
     #[serde(with = "humantime_serde")]
@@ -124,9 +137,9 @@ pub struct TrafficV1_1_20 {
     pub secondary_packet_size: Option<PacketSize>,
 }
 
-impl From<TrafficV1_1_20> for TrafficV1_1_20_2 {
-    fn from(value: TrafficV1_1_20) -> Self {
-        TrafficV1_1_20_2 {
+impl From<TrafficV2> for TrafficV3 {
+    fn from(value: TrafficV2) -> Self {
+        TrafficV3 {
             average_packet_delay: value.average_packet_delay,
             message_sending_average_delay: value.message_sending_average_delay,
             disable_main_poisson_packet_distribution: value
@@ -138,9 +151,9 @@ impl From<TrafficV1_1_20> for TrafficV1_1_20_2 {
     }
 }
 
-impl Default for TrafficV1_1_20 {
+impl Default for TrafficV2 {
     fn default() -> Self {
-        TrafficV1_1_20 {
+        TrafficV2 {
             average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
             message_sending_average_delay: DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
             disable_main_poisson_packet_distribution: false,
@@ -152,16 +165,16 @@ impl Default for TrafficV1_1_20 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct CoverTrafficV1_1_20 {
+pub struct CoverTrafficV2 {
     #[serde(with = "humantime_serde")]
     pub loop_cover_traffic_average_delay: Duration,
     pub cover_traffic_primary_size_ratio: f64,
     pub disable_loop_cover_traffic_stream: bool,
 }
 
-impl From<CoverTrafficV1_1_20> for CoverTrafficV1_1_20_2 {
-    fn from(value: CoverTrafficV1_1_20) -> Self {
-        CoverTrafficV1_1_20_2 {
+impl From<CoverTrafficV2> for CoverTrafficV3 {
+    fn from(value: CoverTrafficV2) -> Self {
+        CoverTrafficV3 {
             loop_cover_traffic_average_delay: value.loop_cover_traffic_average_delay,
             cover_traffic_primary_size_ratio: value.cover_traffic_primary_size_ratio,
             disable_loop_cover_traffic_stream: value.disable_loop_cover_traffic_stream,
@@ -169,9 +182,9 @@ impl From<CoverTrafficV1_1_20> for CoverTrafficV1_1_20_2 {
     }
 }
 
-impl Default for CoverTrafficV1_1_20 {
+impl Default for CoverTrafficV2 {
     fn default() -> Self {
-        CoverTrafficV1_1_20 {
+        CoverTrafficV2 {
             loop_cover_traffic_average_delay: DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY,
             cover_traffic_primary_size_ratio: DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO,
             disable_loop_cover_traffic_stream: false,
@@ -181,22 +194,22 @@ impl Default for CoverTrafficV1_1_20 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct GatewayConnectionV1_1_20 {
+pub struct GatewayConnectionV2 {
     #[serde(with = "humantime_serde")]
     pub gateway_response_timeout: Duration,
 }
 
-impl From<GatewayConnectionV1_1_20> for GatewayConnectionV1_1_20_2 {
-    fn from(value: GatewayConnectionV1_1_20) -> Self {
-        GatewayConnectionV1_1_20_2 {
+impl From<GatewayConnectionV2> for GatewayConnectionV3 {
+    fn from(value: GatewayConnectionV2) -> Self {
+        GatewayConnectionV3 {
             gateway_response_timeout: value.gateway_response_timeout,
         }
     }
 }
 
-impl Default for GatewayConnectionV1_1_20 {
+impl Default for GatewayConnectionV2 {
     fn default() -> Self {
-        GatewayConnectionV1_1_20 {
+        GatewayConnectionV2 {
             gateway_response_timeout: DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
         }
     }
@@ -204,7 +217,7 @@ impl Default for GatewayConnectionV1_1_20 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct AcknowledgementsV1_1_20 {
+pub struct AcknowledgementsV2 {
     #[serde(with = "humantime_serde")]
     pub average_ack_delay: Duration,
     pub ack_wait_multiplier: f64,
@@ -212,9 +225,9 @@ pub struct AcknowledgementsV1_1_20 {
     pub ack_wait_addition: Duration,
 }
 
-impl From<AcknowledgementsV1_1_20> for AcknowledgementsV1_1_20_2 {
-    fn from(value: AcknowledgementsV1_1_20) -> Self {
-        AcknowledgementsV1_1_20_2 {
+impl From<AcknowledgementsV2> for AcknowledgementsV3 {
+    fn from(value: AcknowledgementsV2) -> Self {
+        AcknowledgementsV3 {
             average_ack_delay: value.average_ack_delay,
             ack_wait_multiplier: value.ack_wait_multiplier,
             ack_wait_addition: value.ack_wait_addition,
@@ -222,9 +235,9 @@ impl From<AcknowledgementsV1_1_20> for AcknowledgementsV1_1_20_2 {
     }
 }
 
-impl Default for AcknowledgementsV1_1_20 {
+impl Default for AcknowledgementsV2 {
     fn default() -> Self {
-        AcknowledgementsV1_1_20 {
+        AcknowledgementsV2 {
             average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
             ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
             ack_wait_addition: DEFAULT_ACK_WAIT_ADDITION,
@@ -234,7 +247,7 @@ impl Default for AcknowledgementsV1_1_20 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct TopologyV1_1_20 {
+pub struct TopologyV2 {
     #[serde(with = "humantime_serde")]
     pub topology_refresh_rate: Duration,
     #[serde(with = "humantime_serde")]
@@ -242,9 +255,9 @@ pub struct TopologyV1_1_20 {
     pub disable_refreshing: bool,
 }
 
-impl From<TopologyV1_1_20> for TopologyV1_1_20_2 {
-    fn from(value: TopologyV1_1_20) -> Self {
-        TopologyV1_1_20_2 {
+impl From<TopologyV2> for TopologyV3 {
+    fn from(value: TopologyV2) -> Self {
+        TopologyV3 {
             topology_refresh_rate: value.topology_refresh_rate,
             topology_resolution_timeout: value.topology_resolution_timeout,
             disable_refreshing: value.disable_refreshing,
@@ -252,9 +265,9 @@ impl From<TopologyV1_1_20> for TopologyV1_1_20_2 {
     }
 }
 
-impl Default for TopologyV1_1_20 {
+impl Default for TopologyV2 {
     fn default() -> Self {
-        TopologyV1_1_20 {
+        TopologyV2 {
             topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
             topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
             disable_refreshing: false,
@@ -264,7 +277,7 @@ impl Default for TopologyV1_1_20 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct ReplySurbsV1_1_20 {
+pub struct ReplySurbsV2 {
     pub minimum_reply_surb_storage_threshold: usize,
     pub maximum_reply_surb_storage_threshold: usize,
     pub minimum_reply_surb_request_size: u32,
@@ -280,9 +293,9 @@ pub struct ReplySurbsV1_1_20 {
     pub maximum_reply_key_age: Duration,
 }
 
-impl From<ReplySurbsV1_1_20> for ReplySurbsV1_1_20_2 {
-    fn from(value: ReplySurbsV1_1_20) -> Self {
-        ReplySurbsV1_1_20_2 {
+impl From<ReplySurbsV2> for ReplySurbsV3 {
+    fn from(value: ReplySurbsV2) -> Self {
+        ReplySurbsV3 {
             minimum_reply_surb_storage_threshold: value.minimum_reply_surb_storage_threshold,
             maximum_reply_surb_storage_threshold: value.maximum_reply_surb_storage_threshold,
             minimum_reply_surb_request_size: value.minimum_reply_surb_request_size,
@@ -297,9 +310,9 @@ impl From<ReplySurbsV1_1_20> for ReplySurbsV1_1_20_2 {
     }
 }
 
-impl Default for ReplySurbsV1_1_20 {
+impl Default for ReplySurbsV2 {
     fn default() -> Self {
-        ReplySurbsV1_1_20 {
+        ReplySurbsV2 {
             minimum_reply_surb_storage_threshold: DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD,
             maximum_reply_surb_storage_threshold: DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD,
             minimum_reply_surb_request_size: DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE,
@@ -316,18 +329,18 @@ impl Default for ReplySurbsV1_1_20 {
 
 #[derive(Debug, Default, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct DebugConfigV1_1_20 {
-    pub traffic: TrafficV1_1_20,
-    pub cover_traffic: CoverTrafficV1_1_20,
-    pub gateway_connection: GatewayConnectionV1_1_20,
-    pub acknowledgements: AcknowledgementsV1_1_20,
-    pub topology: TopologyV1_1_20,
-    pub reply_surbs: ReplySurbsV1_1_20,
+pub struct DebugConfigV2 {
+    pub traffic: TrafficV2,
+    pub cover_traffic: CoverTrafficV2,
+    pub gateway_connection: GatewayConnectionV2,
+    pub acknowledgements: AcknowledgementsV2,
+    pub topology: TopologyV2,
+    pub reply_surbs: ReplySurbsV2,
 }
 
-impl From<DebugConfigV1_1_20> for DebugConfigV1_1_20_2 {
-    fn from(value: DebugConfigV1_1_20) -> Self {
-        DebugConfigV1_1_20_2 {
+impl From<DebugConfigV2> for DebugConfigV3 {
+    fn from(value: DebugConfigV2) -> Self {
+        DebugConfigV3 {
             traffic: value.traffic.into(),
             cover_traffic: value.cover_traffic.into(),
             gateway_connection: value.gateway_connection.into(),

common/client-core/config-types/src/old/v3.rs

@@ -1,12 +1,12 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::config::old_config_v1_1_30::{
-    AcknowledgementsV1_1_30, ClientV1_1_30, ConfigV1_1_30, CoverTrafficV1_1_30, DebugConfigV1_1_30,
-    GatewayConnectionV1_1_30, ReplySurbsV1_1_30, TopologyV1_1_30, TrafficV1_1_30,
+use crate::old::v4::{
+    AcknowledgementsV4, ClientV4, ConfigV4, CoverTrafficV4, DebugConfigV4, GatewayConnectionV4,
+    ReplySurbsV4, TopologyV4, TrafficV4,
 };
-use crate::config::old_config_v1_1_33::OldGatewayEndpointConfigV1_1_33;
-use nym_sphinx::params::{PacketSize, PacketType};
+use crate::old::v5::GatewayEndpointConfigV5;
+use nym_sphinx_params::{PacketSize, PacketType};
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
 use url::Url;
@@ -50,18 +50,31 @@ const DEFAULT_MAXIMUM_REPLY_SURB_AGE: Duration = Duration::from_secs(12 * 60 * 6
 // 24 hours
 const DEFAULT_MAXIMUM_REPLY_KEY_AGE: Duration = Duration::from_secs(24 * 60 * 60);
 
+// aliases for backwards compatibility
+pub type ConfigV1_1_20_2 = ConfigV3;
+pub type ClientV1_1_20_2 = ClientV3;
+pub type DebugConfigV1_1_20_2 = DebugConfigV3;
+pub type GatewayEndpointConfigV1_1_20_2 = GatewayEndpointConfigV3;
+
+pub type TrafficV1_1_20_2 = TrafficV3;
+pub type CoverTrafficV1_1_20_2 = CoverTrafficV3;
+pub type GatewayConnectionV1_1_20_2 = GatewayConnectionV3;
+pub type AcknowledgementsV1_1_20_2 = AcknowledgementsV3;
+pub type TopologyV1_1_20_2 = TopologyV3;
+pub type ReplySurbsV1_1_20_2 = ReplySurbsV3;
+
 #[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
-pub struct ConfigV1_1_20_2 {
-    pub client: ClientV1_1_20_2,
+pub struct ConfigV3 {
+    pub client: ClientV3,
 
     #[serde(default)]
-    pub debug: DebugConfigV1_1_20_2,
+    pub debug: DebugConfigV3,
 }
 
-impl From<ConfigV1_1_20_2> for ConfigV1_1_30 {
-    fn from(value: ConfigV1_1_20_2) -> Self {
-        ConfigV1_1_30 {
+impl From<ConfigV3> for ConfigV4 {
+    fn from(value: ConfigV3) -> Self {
+        ConfigV4 {
             client: value.client.into(),
             debug: value.debug.into(),
         }
@@ -69,7 +82,7 @@ impl From<ConfigV1_1_20_2> for ConfigV1_1_30 {
 }
 
 #[derive(Clone, Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
-pub struct GatewayEndpointConfigV1_1_20_2 {
+pub struct GatewayEndpointConfigV3 {
     /// gateway_id specifies ID of the gateway to which the client should send messages.
     /// If initially omitted, a random gateway will be chosen from the available topology.
     pub gateway_id: String,
@@ -81,9 +94,9 @@ pub struct GatewayEndpointConfigV1_1_20_2 {
     pub gateway_listener: String,
 }
 
-impl From<GatewayEndpointConfigV1_1_20_2> for OldGatewayEndpointConfigV1_1_33 {
-    fn from(value: GatewayEndpointConfigV1_1_20_2) -> Self {
-        OldGatewayEndpointConfigV1_1_33 {
+impl From<GatewayEndpointConfigV3> for GatewayEndpointConfigV5 {
+    fn from(value: GatewayEndpointConfigV3) -> Self {
+        GatewayEndpointConfigV5 {
             gateway_id: value.gateway_id,
             gateway_owner: value.gateway_owner,
             gateway_listener: value.gateway_listener,
@@ -92,7 +105,7 @@ impl From<GatewayEndpointConfigV1_1_20_2> for OldGatewayEndpointConfigV1_1_33 {
 }
 
 #[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
-pub struct ClientV1_1_20_2 {
+pub struct ClientV3 {
     pub version: String,
 
     pub id: String,
@@ -105,12 +118,12 @@ pub struct ClientV1_1_20_2 {
 
     #[serde(alias = "validator_api_urls")]
     pub nym_api_urls: Vec<Url>,
-    pub gateway_endpoint: GatewayEndpointConfigV1_1_20_2,
+    pub gateway_endpoint: GatewayEndpointConfigV3,
 }
 
-impl From<ClientV1_1_20_2> for ClientV1_1_30 {
-    fn from(value: ClientV1_1_20_2) -> Self {
-        ClientV1_1_30 {
+impl From<ClientV3> for ClientV4 {
+    fn from(value: ClientV3) -> Self {
+        ClientV4 {
             version: value.version,
             id: value.id,
             disabled_credentials_mode: value.disabled_credentials_mode,
@@ -122,7 +135,7 @@ impl From<ClientV1_1_20_2> for ClientV1_1_30 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default)]
-pub struct TrafficV1_1_20_2 {
+pub struct TrafficV3 {
     #[serde(with = "humantime_serde")]
     pub average_packet_delay: Duration,
     #[serde(with = "humantime_serde")]
@@ -133,9 +146,9 @@ pub struct TrafficV1_1_20_2 {
     pub packet_type: PacketType,
 }
 
-impl From<TrafficV1_1_20_2> for TrafficV1_1_30 {
-    fn from(value: TrafficV1_1_20_2) -> Self {
-        TrafficV1_1_30 {
+impl From<TrafficV3> for TrafficV4 {
+    fn from(value: TrafficV3) -> Self {
+        TrafficV4 {
             average_packet_delay: value.average_packet_delay,
             message_sending_average_delay: value.message_sending_average_delay,
             disable_main_poisson_packet_distribution: value
@@ -147,9 +160,9 @@ impl From<TrafficV1_1_20_2> for TrafficV1_1_30 {
     }
 }
 
-impl Default for TrafficV1_1_20_2 {
+impl Default for TrafficV3 {
     fn default() -> Self {
-        TrafficV1_1_20_2 {
+        TrafficV3 {
             average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
             message_sending_average_delay: DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
             disable_main_poisson_packet_distribution: false,
@@ -162,16 +175,16 @@ impl Default for TrafficV1_1_20_2 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct CoverTrafficV1_1_20_2 {
+pub struct CoverTrafficV3 {
     #[serde(with = "humantime_serde")]
     pub loop_cover_traffic_average_delay: Duration,
     pub cover_traffic_primary_size_ratio: f64,
     pub disable_loop_cover_traffic_stream: bool,
 }
 
-impl From<CoverTrafficV1_1_20_2> for CoverTrafficV1_1_30 {
-    fn from(value: CoverTrafficV1_1_20_2) -> Self {
-        CoverTrafficV1_1_30 {
+impl From<CoverTrafficV3> for CoverTrafficV4 {
+    fn from(value: CoverTrafficV3) -> Self {
+        CoverTrafficV4 {
             loop_cover_traffic_average_delay: value.loop_cover_traffic_average_delay,
             cover_traffic_primary_size_ratio: value.cover_traffic_primary_size_ratio,
             disable_loop_cover_traffic_stream: value.disable_loop_cover_traffic_stream,
@@ -179,9 +192,9 @@ impl From<CoverTrafficV1_1_20_2> for CoverTrafficV1_1_30 {
     }
 }
 
-impl Default for CoverTrafficV1_1_20_2 {
+impl Default for CoverTrafficV3 {
     fn default() -> Self {
-        CoverTrafficV1_1_20_2 {
+        CoverTrafficV3 {
             loop_cover_traffic_average_delay: DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY,
             cover_traffic_primary_size_ratio: DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO,
             disable_loop_cover_traffic_stream: false,
@@ -191,22 +204,22 @@ impl Default for CoverTrafficV1_1_20_2 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct GatewayConnectionV1_1_20_2 {
+pub struct GatewayConnectionV3 {
     #[serde(with = "humantime_serde")]
     pub gateway_response_timeout: Duration,
 }
 
-impl From<GatewayConnectionV1_1_20_2> for GatewayConnectionV1_1_30 {
-    fn from(value: GatewayConnectionV1_1_20_2) -> Self {
-        GatewayConnectionV1_1_30 {
+impl From<GatewayConnectionV3> for GatewayConnectionV4 {
+    fn from(value: GatewayConnectionV3) -> Self {
+        GatewayConnectionV4 {
             gateway_response_timeout: value.gateway_response_timeout,
         }
     }
 }
 
-impl Default for GatewayConnectionV1_1_20_2 {
+impl Default for GatewayConnectionV3 {
     fn default() -> Self {
-        GatewayConnectionV1_1_20_2 {
+        GatewayConnectionV3 {
             gateway_response_timeout: DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
         }
     }
@@ -214,7 +227,7 @@ impl Default for GatewayConnectionV1_1_20_2 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct AcknowledgementsV1_1_20_2 {
+pub struct AcknowledgementsV3 {
     #[serde(with = "humantime_serde")]
     pub average_ack_delay: Duration,
     pub ack_wait_multiplier: f64,
@@ -222,9 +235,9 @@ pub struct AcknowledgementsV1_1_20_2 {
     pub ack_wait_addition: Duration,
 }
 
-impl From<AcknowledgementsV1_1_20_2> for AcknowledgementsV1_1_30 {
-    fn from(value: AcknowledgementsV1_1_20_2) -> Self {
-        AcknowledgementsV1_1_30 {
+impl From<AcknowledgementsV3> for AcknowledgementsV4 {
+    fn from(value: AcknowledgementsV3) -> Self {
+        AcknowledgementsV4 {
             average_ack_delay: value.average_ack_delay,
             ack_wait_multiplier: value.ack_wait_multiplier,
             ack_wait_addition: value.ack_wait_addition,
@@ -232,9 +245,9 @@ impl From<AcknowledgementsV1_1_20_2> for AcknowledgementsV1_1_30 {
     }
 }
 
-impl Default for AcknowledgementsV1_1_20_2 {
+impl Default for AcknowledgementsV3 {
     fn default() -> Self {
-        AcknowledgementsV1_1_20_2 {
+        AcknowledgementsV3 {
             average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
             ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
             ack_wait_addition: DEFAULT_ACK_WAIT_ADDITION,
@@ -244,7 +257,7 @@ impl Default for AcknowledgementsV1_1_20_2 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct TopologyV1_1_20_2 {
+pub struct TopologyV3 {
     #[serde(with = "humantime_serde")]
     pub topology_refresh_rate: Duration,
     #[serde(with = "humantime_serde")]
@@ -252,9 +265,9 @@ pub struct TopologyV1_1_20_2 {
     pub disable_refreshing: bool,
 }
 
-impl Default for TopologyV1_1_20_2 {
+impl Default for TopologyV3 {
     fn default() -> Self {
-        TopologyV1_1_20_2 {
+        TopologyV3 {
             topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
             topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
             disable_refreshing: false,
@@ -262,9 +275,9 @@ impl Default for TopologyV1_1_20_2 {
     }
 }
 
-impl From<TopologyV1_1_20_2> for TopologyV1_1_30 {
-    fn from(value: TopologyV1_1_20_2) -> Self {
-        TopologyV1_1_30 {
+impl From<TopologyV3> for TopologyV4 {
+    fn from(value: TopologyV3) -> Self {
+        TopologyV4 {
             topology_refresh_rate: value.topology_refresh_rate,
             topology_resolution_timeout: value.topology_resolution_timeout,
             disable_refreshing: value.disable_refreshing,
@@ -275,7 +288,7 @@ impl From<TopologyV1_1_20_2> for TopologyV1_1_30 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct ReplySurbsV1_1_20_2 {
+pub struct ReplySurbsV3 {
     pub minimum_reply_surb_storage_threshold: usize,
     pub maximum_reply_surb_storage_threshold: usize,
     pub minimum_reply_surb_request_size: u32,
@@ -291,9 +304,9 @@ pub struct ReplySurbsV1_1_20_2 {
     pub maximum_reply_key_age: Duration,
 }
 
-impl Default for ReplySurbsV1_1_20_2 {
+impl Default for ReplySurbsV3 {
     fn default() -> Self {
-        ReplySurbsV1_1_20_2 {
+        ReplySurbsV3 {
             minimum_reply_surb_storage_threshold: DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD,
             maximum_reply_surb_storage_threshold: DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD,
             minimum_reply_surb_request_size: DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE,
@@ -308,9 +321,9 @@ impl Default for ReplySurbsV1_1_20_2 {
     }
 }
 
-impl From<ReplySurbsV1_1_20_2> for ReplySurbsV1_1_30 {
-    fn from(value: ReplySurbsV1_1_20_2) -> Self {
-        ReplySurbsV1_1_30 {
+impl From<ReplySurbsV3> for ReplySurbsV4 {
+    fn from(value: ReplySurbsV3) -> Self {
+        ReplySurbsV4 {
             minimum_reply_surb_storage_threshold: value.minimum_reply_surb_storage_threshold,
             maximum_reply_surb_storage_threshold: value.maximum_reply_surb_storage_threshold,
             minimum_reply_surb_request_size: value.minimum_reply_surb_request_size,
@@ -327,18 +340,18 @@ impl From<ReplySurbsV1_1_20_2> for ReplySurbsV1_1_30 {
 
 #[derive(Debug, Default, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct DebugConfigV1_1_20_2 {
-    pub traffic: TrafficV1_1_20_2,
-    pub cover_traffic: CoverTrafficV1_1_20_2,
-    pub gateway_connection: GatewayConnectionV1_1_20_2,
-    pub acknowledgements: AcknowledgementsV1_1_20_2,
-    pub topology: TopologyV1_1_20_2,
-    pub reply_surbs: ReplySurbsV1_1_20_2,
+pub struct DebugConfigV3 {
+    pub traffic: TrafficV3,
+    pub cover_traffic: CoverTrafficV3,
+    pub gateway_connection: GatewayConnectionV3,
+    pub acknowledgements: AcknowledgementsV3,
+    pub topology: TopologyV3,
+    pub reply_surbs: ReplySurbsV3,
 }
 
-impl From<DebugConfigV1_1_20_2> for DebugConfigV1_1_30 {
-    fn from(value: DebugConfigV1_1_20_2) -> Self {
-        DebugConfigV1_1_30 {
+impl From<DebugConfigV3> for DebugConfigV4 {
+    fn from(value: DebugConfigV3) -> Self {
+        DebugConfigV4 {
             traffic: value.traffic.into(),
             cover_traffic: value.cover_traffic.into(),
             gateway_connection: value.gateway_connection.into(),

common/client-core/config-types/src/old/v4.rs

@@ -1,16 +1,13 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::client::topology_control::geo_aware_provider::CountryGroup;
-use crate::config::old_config_v1_1_33::{
-    AcknowledgementsV1_1_33, ClientV1_1_33, ConfigV1_1_33, CoverTrafficV1_1_33, DebugConfigV1_1_33,
-    GatewayConnectionV1_1_33, GroupByV1_1_33, ReplySurbsV1_1_33, TopologyStructureV1_1_33,
-    TopologyV1_1_33, TrafficV1_1_33,
-};
-use nym_sphinx::{
-    addressing::clients::Recipient,
-    params::{PacketSize, PacketType},
+use crate::old::v5::{
+    AcknowledgementsV5, ClientV5, ConfigV5, CoverTrafficV5, DebugConfigV5, GatewayConnectionV5,
+    GroupByV5, ReplySurbsV5, TopologyStructureV5, TopologyV5, TrafficV5,
 };
+use crate::CountryGroup;
+use nym_sphinx_addressing::Recipient;
+use nym_sphinx_params::{PacketSize, PacketType};
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
 use url::Url;
@@ -56,27 +53,39 @@ const DEFAULT_MAXIMUM_REPLY_SURB_AGE: Duration = Duration::from_secs(12 * 60 * 6
 // 24 hours
 const DEFAULT_MAXIMUM_REPLY_KEY_AGE: Duration = Duration::from_secs(24 * 60 * 60);
 
+// aliases for backwards compatibility
+pub type ConfigV1_1_30 = ConfigV4;
+pub type ClientV1_1_30 = ClientV4;
+pub type DebugConfigV1_1_30 = DebugConfigV4;
+
+pub type TrafficV1_1_30 = TrafficV4;
+pub type CoverTrafficV1_1_30 = CoverTrafficV4;
+pub type GatewayConnectionV1_1_30 = GatewayConnectionV4;
+pub type AcknowledgementsV1_1_30 = AcknowledgementsV4;
+pub type TopologyV1_1_30 = TopologyV4;
+pub type ReplySurbsV1_1_30 = ReplySurbsV4;
+
 #[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
-pub struct ConfigV1_1_30 {
-    pub client: ClientV1_1_30,
+pub struct ConfigV4 {
+    pub client: ClientV4,
 
     #[serde(default)]
-    pub debug: DebugConfigV1_1_30,
+    pub debug: DebugConfigV4,
 }
 
-impl From<ConfigV1_1_30> for ConfigV1_1_33 {
-    fn from(value: ConfigV1_1_30) -> Self {
-        ConfigV1_1_33 {
-            client: ClientV1_1_33 {
+impl From<ConfigV4> for ConfigV5 {
+    fn from(value: ConfigV4) -> Self {
+        ConfigV5 {
+            client: ClientV5 {
                 version: value.client.version,
                 id: value.client.id,
                 disabled_credentials_mode: value.client.disabled_credentials_mode,
                 nyxd_urls: value.client.nyxd_urls,
                 nym_api_urls: value.client.nym_api_urls,
             },
-            debug: DebugConfigV1_1_33 {
-                traffic: TrafficV1_1_33 {
+            debug: DebugConfigV5 {
+                traffic: TrafficV5 {
                     average_packet_delay: value.debug.traffic.average_packet_delay,
                     message_sending_average_delay: value
                         .debug
@@ -90,7 +99,7 @@ impl From<ConfigV1_1_30> for ConfigV1_1_33 {
                     secondary_packet_size: value.debug.traffic.secondary_packet_size,
                     packet_type: value.debug.traffic.packet_type,
                 },
-                cover_traffic: CoverTrafficV1_1_33 {
+                cover_traffic: CoverTrafficV5 {
                     loop_cover_traffic_average_delay: value
                         .debug
                         .cover_traffic
@@ -104,18 +113,18 @@ impl From<ConfigV1_1_30> for ConfigV1_1_33 {
                         .cover_traffic
                         .disable_loop_cover_traffic_stream,
                 },
-                gateway_connection: GatewayConnectionV1_1_33 {
+                gateway_connection: GatewayConnectionV5 {
                     gateway_response_timeout: value
                         .debug
                         .gateway_connection
                         .gateway_response_timeout,
                 },
-                acknowledgements: AcknowledgementsV1_1_33 {
+                acknowledgements: AcknowledgementsV5 {
                     average_ack_delay: value.debug.acknowledgements.average_ack_delay,
                     ack_wait_multiplier: value.debug.acknowledgements.ack_wait_multiplier,
                     ack_wait_addition: value.debug.acknowledgements.ack_wait_addition,
                 },
-                topology: TopologyV1_1_33 {
+                topology: TopologyV5 {
                     topology_refresh_rate: value.debug.topology.topology_refresh_rate,
                     topology_resolution_timeout: value.debug.topology.topology_resolution_timeout,
                     disable_refreshing: value.debug.topology.disable_refreshing,
@@ -125,7 +134,7 @@ impl From<ConfigV1_1_30> for ConfigV1_1_33 {
                         .max_startup_gateway_waiting_period,
                     topology_structure: value.debug.topology.topology_structure.into(),
                 },
-                reply_surbs: ReplySurbsV1_1_33 {
+                reply_surbs: ReplySurbsV5 {
                     minimum_reply_surb_storage_threshold: value
                         .debug
                         .reply_surbs
@@ -169,7 +178,7 @@ impl From<ConfigV1_1_30> for ConfigV1_1_33 {
 #[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
 // note: the deny_unknown_fields is VITAL here to allow upgrades from v1.1.20_2
 #[serde(deny_unknown_fields)]
-pub struct ClientV1_1_30 {
+pub struct ClientV4 {
     /// Version of the client for which this configuration was created.
     pub version: String,
 
@@ -193,7 +202,7 @@ pub struct ClientV1_1_30 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct TrafficV1_1_30 {
+pub struct TrafficV4 {
     /// The parameter of Poisson distribution determining how long, on average,
     /// sent packet is going to be delayed at any given mix node.
     /// So for a packet going through three mix nodes, on average, it will take three times this value
@@ -224,9 +233,9 @@ pub struct TrafficV1_1_30 {
     pub packet_type: PacketType,
 }
 
-impl Default for TrafficV1_1_30 {
+impl Default for TrafficV4 {
     fn default() -> Self {
-        TrafficV1_1_30 {
+        TrafficV4 {
             average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
             message_sending_average_delay: DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
             disable_main_poisson_packet_distribution: false,
@@ -239,7 +248,7 @@ impl Default for TrafficV1_1_30 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct CoverTrafficV1_1_30 {
+pub struct CoverTrafficV4 {
     /// The parameter of Poisson distribution determining how long, on average,
     /// it is going to take for another loop cover traffic message to be sent.
     #[serde(with = "humantime_serde")]
@@ -254,9 +263,9 @@ pub struct CoverTrafficV1_1_30 {
     pub disable_loop_cover_traffic_stream: bool,
 }
 
-impl Default for CoverTrafficV1_1_30 {
+impl Default for CoverTrafficV4 {
     fn default() -> Self {
-        CoverTrafficV1_1_30 {
+        CoverTrafficV4 {
             loop_cover_traffic_average_delay: DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY,
             cover_traffic_primary_size_ratio: DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO,
             disable_loop_cover_traffic_stream: false,
@@ -266,16 +275,16 @@ impl Default for CoverTrafficV1_1_30 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct GatewayConnectionV1_1_30 {
+pub struct GatewayConnectionV4 {
     /// How long we're willing to wait for a response to a message sent to the gateway,
     /// before giving up on it.
     #[serde(with = "humantime_serde")]
     pub gateway_response_timeout: Duration,
 }
 
-impl Default for GatewayConnectionV1_1_30 {
+impl Default for GatewayConnectionV4 {
     fn default() -> Self {
-        GatewayConnectionV1_1_30 {
+        GatewayConnectionV4 {
             gateway_response_timeout: DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
         }
     }
@@ -283,7 +292,7 @@ impl Default for GatewayConnectionV1_1_30 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct AcknowledgementsV1_1_30 {
+pub struct AcknowledgementsV4 {
     /// The parameter of Poisson distribution determining how long, on average,
     /// sent acknowledgement is going to be delayed at any given mix node.
     /// So for an ack going through three mix nodes, on average, it will take three times this value
@@ -303,9 +312,9 @@ pub struct AcknowledgementsV1_1_30 {
     pub ack_wait_addition: Duration,
 }
 
-impl Default for AcknowledgementsV1_1_30 {
+impl Default for AcknowledgementsV4 {
     fn default() -> Self {
-        AcknowledgementsV1_1_30 {
+        AcknowledgementsV4 {
             average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
             ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
             ack_wait_addition: DEFAULT_ACK_WAIT_ADDITION,
@@ -315,7 +324,7 @@ impl Default for AcknowledgementsV1_1_30 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct TopologyV1_1_30 {
+pub struct TopologyV4 {
     /// The uniform delay every which clients are querying the directory server
     /// to try to obtain a compatible network topology to send sphinx packets through.
     #[serde(with = "humantime_serde")]
@@ -338,23 +347,23 @@ pub struct TopologyV1_1_30 {
     pub max_startup_gateway_waiting_period: Duration,
 
     /// Specifies the mixnode topology to be used for sending packets.
-    pub topology_structure: TopologyStructureV1_1_30,
+    pub topology_structure: TopologyStructureV4,
 }
 
 #[allow(clippy::large_enum_variant)]
 #[derive(Default, Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum TopologyStructureV1_1_30 {
+pub enum TopologyStructureV4 {
     #[default]
     NymApi,
-    GeoAware(GroupByV1_1_30),
+    GeoAware(GroupByV4),
 }
 
-impl From<TopologyStructureV1_1_30> for TopologyStructureV1_1_33 {
-    fn from(value: TopologyStructureV1_1_30) -> Self {
+impl From<TopologyStructureV4> for TopologyStructureV5 {
+    fn from(value: TopologyStructureV4) -> Self {
         match value {
-            TopologyStructureV1_1_30::NymApi => TopologyStructureV1_1_33::NymApi,
-            TopologyStructureV1_1_30::GeoAware(group_by) => {
-                TopologyStructureV1_1_33::GeoAware(group_by.into())
+            TopologyStructureV4::NymApi => TopologyStructureV5::NymApi,
+            TopologyStructureV4::GeoAware(group_by) => {
+                TopologyStructureV5::GeoAware(group_by.into())
             }
         }
     }
@@ -362,44 +371,44 @@ impl From<TopologyStructureV1_1_30> for TopologyStructureV1_1_33 {
 
 #[allow(clippy::large_enum_variant)]
 #[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum GroupByV1_1_30 {
+pub enum GroupByV4 {
     CountryGroup(CountryGroup),
     NymAddress(Recipient),
 }
 
-impl From<GroupByV1_1_30> for GroupByV1_1_33 {
-    fn from(value: GroupByV1_1_30) -> Self {
+impl From<GroupByV4> for GroupByV5 {
+    fn from(value: GroupByV4) -> Self {
         match value {
-            GroupByV1_1_30::CountryGroup(country) => GroupByV1_1_33::CountryGroup(country),
-            GroupByV1_1_30::NymAddress(addr) => GroupByV1_1_33::NymAddress(addr),
+            GroupByV4::CountryGroup(country) => GroupByV5::CountryGroup(country),
+            GroupByV4::NymAddress(addr) => GroupByV5::NymAddress(addr),
         }
     }
 }
 
-impl std::fmt::Display for GroupByV1_1_30 {
+impl std::fmt::Display for GroupByV4 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            GroupByV1_1_30::CountryGroup(group) => write!(f, "group: {}", group),
-            GroupByV1_1_30::NymAddress(address) => write!(f, "address: {}", address),
+            GroupByV4::CountryGroup(group) => write!(f, "group: {}", group),
+            GroupByV4::NymAddress(address) => write!(f, "address: {}", address),
         }
     }
 }
 
-impl Default for TopologyV1_1_30 {
+impl Default for TopologyV4 {
     fn default() -> Self {
-        TopologyV1_1_30 {
+        TopologyV4 {
             topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
             topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
             disable_refreshing: false,
             max_startup_gateway_waiting_period: DEFAULT_MAX_STARTUP_GATEWAY_WAITING_PERIOD,
-            topology_structure: TopologyStructureV1_1_30::default(),
+            topology_structure: TopologyStructureV4::default(),
         }
     }
 }
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct ReplySurbsV1_1_30 {
+pub struct ReplySurbsV4 {
     /// Defines the minimum number of reply surbs the client wants to keep in its storage at all times.
     /// It can only allow to go below that value if its to request additional reply surbs.
     pub minimum_reply_surb_storage_threshold: usize,
@@ -437,9 +446,9 @@ pub struct ReplySurbsV1_1_30 {
     pub maximum_reply_key_age: Duration,
 }
 
-impl Default for ReplySurbsV1_1_30 {
+impl Default for ReplySurbsV4 {
     fn default() -> Self {
-        ReplySurbsV1_1_30 {
+        ReplySurbsV4 {
             minimum_reply_surb_storage_threshold: DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD,
             maximum_reply_surb_storage_threshold: DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD,
             minimum_reply_surb_request_size: DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE,
@@ -456,22 +465,22 @@ impl Default for ReplySurbsV1_1_30 {
 
 #[derive(Debug, Default, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct DebugConfigV1_1_30 {
+pub struct DebugConfigV4 {
     /// Defines all configuration options related to traffic streams.
-    pub traffic: TrafficV1_1_30,
+    pub traffic: TrafficV4,
 
     /// Defines all configuration options related to cover traffic stream(s).
-    pub cover_traffic: CoverTrafficV1_1_30,
+    pub cover_traffic: CoverTrafficV4,
 
     /// Defines all configuration options related to the gateway connection.
-    pub gateway_connection: GatewayConnectionV1_1_30,
+    pub gateway_connection: GatewayConnectionV4,
 
     /// Defines all configuration options related to acknowledgements, such as delays or wait timeouts.
-    pub acknowledgements: AcknowledgementsV1_1_30,
+    pub acknowledgements: AcknowledgementsV4,
 
     /// Defines all configuration options related topology, such as refresh rates or timeouts.
-    pub topology: TopologyV1_1_30,
+    pub topology: TopologyV4,
 
     /// Defines all configuration options related to reply SURBs.
-    pub reply_surbs: ReplySurbsV1_1_30,
+    pub reply_surbs: ReplySurbsV4,
 }

common/client-core/config-types/src/old/v5.rs

@@ -1,15 +1,12 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::client::topology_control::geo_aware_provider::CountryGroup;
-use crate::config::{
-    Acknowledgements, Client, Config, CoverTraffic, DebugConfig, GatewayConnection, GroupBy,
-    ReplySurbs, Topology, TopologyStructure, Traffic,
-};
-use nym_sphinx::{
-    addressing::clients::Recipient,
-    params::{PacketSize, PacketType},
+use crate::{
+    Acknowledgements, Client, Config, CountryGroup, CoverTraffic, DebugConfig, GatewayConnection,
+    GroupBy, ReplySurbs, Topology, TopologyStructure, Traffic,
 };
+use nym_sphinx_addressing::Recipient;
+use nym_sphinx_params::{PacketSize, PacketType};
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
 use url::Url;
@@ -55,8 +52,21 @@ const DEFAULT_MAXIMUM_REPLY_SURB_AGE: Duration = Duration::from_secs(12 * 60 * 6
 // 24 hours
 const DEFAULT_MAXIMUM_REPLY_KEY_AGE: Duration = Duration::from_secs(24 * 60 * 60);
 
+// aliases for backwards compatibility
+pub type ConfigV1_1_33 = ConfigV5;
+pub type ClientV1_1_33 = ClientV5;
+pub type DebugConfigV1_1_33 = DebugConfigV5;
+pub type OldGatewayEndpointConfigV1_1_33 = GatewayEndpointConfigV5;
+
+pub type TrafficV1_1_33 = TrafficV5;
+pub type CoverTrafficV1_1_33 = CoverTrafficV5;
+pub type GatewayConnectionV1_1_33 = GatewayConnectionV5;
+pub type AcknowledgementsV1_1_33 = AcknowledgementsV5;
+pub type TopologyV1_1_33 = TopologyV5;
+pub type ReplySurbsV1_1_33 = ReplySurbsV5;
+
 #[derive(Clone, Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
-pub struct OldGatewayEndpointConfigV1_1_33 {
+pub struct GatewayEndpointConfigV5 {
     /// gateway_id specifies ID of the gateway to which the client should send messages.
     /// If initially omitted, a random gateway will be chosen from the available topology.
     pub gateway_id: String,
@@ -70,15 +80,15 @@ pub struct OldGatewayEndpointConfigV1_1_33 {
 
 #[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
-pub struct ConfigV1_1_33 {
-    pub client: ClientV1_1_33,
+pub struct ConfigV5 {
+    pub client: ClientV5,
 
     #[serde(default)]
-    pub debug: DebugConfigV1_1_33,
+    pub debug: DebugConfigV5,
 }
 
-impl From<ConfigV1_1_33> for Config {
-    fn from(value: ConfigV1_1_33) -> Self {
+impl From<ConfigV5> for Config {
+    fn from(value: ConfigV5) -> Self {
         Config {
             client: Client {
                 version: value.client.version,
@@ -178,7 +188,7 @@ impl From<ConfigV1_1_33> for Config {
 #[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
 // note: the deny_unknown_fields is VITAL here to allow upgrades from v1.1.20_2
 #[serde(deny_unknown_fields)]
-pub struct ClientV1_1_33 {
+pub struct ClientV5 {
     /// Version of the client for which this configuration was created.
     pub version: String,
 
@@ -202,7 +212,7 @@ pub struct ClientV1_1_33 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct TrafficV1_1_33 {
+pub struct TrafficV5 {
     /// The parameter of Poisson distribution determining how long, on average,
     /// sent packet is going to be delayed at any given mix node.
     /// So for a packet going through three mix nodes, on average, it will take three times this value
@@ -233,9 +243,9 @@ pub struct TrafficV1_1_33 {
     pub packet_type: PacketType,
 }
 
-impl Default for TrafficV1_1_33 {
+impl Default for TrafficV5 {
     fn default() -> Self {
-        TrafficV1_1_33 {
+        TrafficV5 {
             average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
             message_sending_average_delay: DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
             disable_main_poisson_packet_distribution: false,
@@ -248,7 +258,7 @@ impl Default for TrafficV1_1_33 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct CoverTrafficV1_1_33 {
+pub struct CoverTrafficV5 {
     /// The parameter of Poisson distribution determining how long, on average,
     /// it is going to take for another loop cover traffic message to be sent.
     #[serde(with = "humantime_serde")]
@@ -263,9 +273,9 @@ pub struct CoverTrafficV1_1_33 {
     pub disable_loop_cover_traffic_stream: bool,
 }
 
-impl Default for CoverTrafficV1_1_33 {
+impl Default for CoverTrafficV5 {
     fn default() -> Self {
-        CoverTrafficV1_1_33 {
+        CoverTrafficV5 {
             loop_cover_traffic_average_delay: DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY,
             cover_traffic_primary_size_ratio: DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO,
             disable_loop_cover_traffic_stream: false,
@@ -275,16 +285,16 @@ impl Default for CoverTrafficV1_1_33 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct GatewayConnectionV1_1_33 {
+pub struct GatewayConnectionV5 {
     /// How long we're willing to wait for a response to a message sent to the gateway,
     /// before giving up on it.
     #[serde(with = "humantime_serde")]
     pub gateway_response_timeout: Duration,
 }
 
-impl Default for GatewayConnectionV1_1_33 {
+impl Default for GatewayConnectionV5 {
     fn default() -> Self {
-        GatewayConnectionV1_1_33 {
+        GatewayConnectionV5 {
             gateway_response_timeout: DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
         }
     }
@@ -292,7 +302,7 @@ impl Default for GatewayConnectionV1_1_33 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct AcknowledgementsV1_1_33 {
+pub struct AcknowledgementsV5 {
     /// The parameter of Poisson distribution determining how long, on average,
     /// sent acknowledgement is going to be delayed at any given mix node.
     /// So for an ack going through three mix nodes, on average, it will take three times this value
@@ -312,9 +322,9 @@ pub struct AcknowledgementsV1_1_33 {
     pub ack_wait_addition: Duration,
 }
 
-impl Default for AcknowledgementsV1_1_33 {
+impl Default for AcknowledgementsV5 {
     fn default() -> Self {
-        AcknowledgementsV1_1_33 {
+        AcknowledgementsV5 {
             average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
             ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
             ack_wait_addition: DEFAULT_ACK_WAIT_ADDITION,
@@ -324,7 +334,7 @@ impl Default for AcknowledgementsV1_1_33 {
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct TopologyV1_1_33 {
+pub struct TopologyV5 {
     /// The uniform delay every which clients are querying the directory server
     /// to try to obtain a compatible network topology to send sphinx packets through.
     #[serde(with = "humantime_serde")]
@@ -347,68 +357,66 @@ pub struct TopologyV1_1_33 {
     pub max_startup_gateway_waiting_period: Duration,
 
     /// Specifies the mixnode topology to be used for sending packets.
-    pub topology_structure: TopologyStructureV1_1_33,
+    pub topology_structure: TopologyStructureV5,
 }
 
 #[allow(clippy::large_enum_variant)]
 #[derive(Default, Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum TopologyStructureV1_1_33 {
+pub enum TopologyStructureV5 {
     #[default]
     NymApi,
-    GeoAware(GroupByV1_1_33),
+    GeoAware(GroupByV5),
 }
 
-impl From<TopologyStructureV1_1_33> for TopologyStructure {
-    fn from(value: TopologyStructureV1_1_33) -> Self {
+impl From<TopologyStructureV5> for TopologyStructure {
+    fn from(value: TopologyStructureV5) -> Self {
         match value {
-            TopologyStructureV1_1_33::NymApi => TopologyStructure::NymApi,
-            TopologyStructureV1_1_33::GeoAware(group_by) => {
-                TopologyStructure::GeoAware(group_by.into())
-            }
+            TopologyStructureV5::NymApi => TopologyStructure::NymApi,
+            TopologyStructureV5::GeoAware(group_by) => TopologyStructure::GeoAware(group_by.into()),
         }
     }
 }
 
 #[allow(clippy::large_enum_variant)]
 #[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum GroupByV1_1_33 {
+pub enum GroupByV5 {
     CountryGroup(CountryGroup),
     NymAddress(Recipient),
 }
 
-impl From<GroupByV1_1_33> for GroupBy {
-    fn from(value: GroupByV1_1_33) -> Self {
+impl From<GroupByV5> for GroupBy {
+    fn from(value: GroupByV5) -> Self {
         match value {
-            GroupByV1_1_33::CountryGroup(country) => GroupBy::CountryGroup(country),
-            GroupByV1_1_33::NymAddress(addr) => GroupBy::NymAddress(addr),
+            GroupByV5::CountryGroup(country) => GroupBy::CountryGroup(country),
+            GroupByV5::NymAddress(addr) => GroupBy::NymAddress(addr),
         }
     }
 }
 
-impl std::fmt::Display for GroupByV1_1_33 {
+impl std::fmt::Display for GroupByV5 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            GroupByV1_1_33::CountryGroup(group) => write!(f, "group: {}", group),
-            GroupByV1_1_33::NymAddress(address) => write!(f, "address: {}", address),
+            GroupByV5::CountryGroup(group) => write!(f, "group: {}", group),
+            GroupByV5::NymAddress(address) => write!(f, "address: {}", address),
         }
     }
 }
 
-impl Default for TopologyV1_1_33 {
+impl Default for TopologyV5 {
     fn default() -> Self {
-        TopologyV1_1_33 {
+        TopologyV5 {
             topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
             topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
             disable_refreshing: false,
             max_startup_gateway_waiting_period: DEFAULT_MAX_STARTUP_GATEWAY_WAITING_PERIOD,
-            topology_structure: TopologyStructureV1_1_33::default(),
+            topology_structure: TopologyStructureV5::default(),
         }
     }
 }
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct ReplySurbsV1_1_33 {
+pub struct ReplySurbsV5 {
     /// Defines the minimum number of reply surbs the client wants to keep in its storage at all times.
     /// It can only allow to go below that value if its to request additional reply surbs.
     pub minimum_reply_surb_storage_threshold: usize,
@@ -450,9 +458,9 @@ pub struct ReplySurbsV1_1_33 {
     pub surb_mix_hops: Option<u8>,
 }
 
-impl Default for ReplySurbsV1_1_33 {
+impl Default for ReplySurbsV5 {
     fn default() -> Self {
-        ReplySurbsV1_1_33 {
+        ReplySurbsV5 {
             minimum_reply_surb_storage_threshold: DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD,
             maximum_reply_surb_storage_threshold: DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD,
             minimum_reply_surb_request_size: DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE,
@@ -470,22 +478,22 @@ impl Default for ReplySurbsV1_1_33 {
 
 #[derive(Debug, Default, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct DebugConfigV1_1_33 {
+pub struct DebugConfigV5 {
     /// Defines all configuration options related to traffic streams.
-    pub traffic: TrafficV1_1_33,
+    pub traffic: TrafficV5,
 
     /// Defines all configuration options related to cover traffic stream(s).
-    pub cover_traffic: CoverTrafficV1_1_33,
+    pub cover_traffic: CoverTrafficV5,
 
     /// Defines all configuration options related to the gateway connection.
-    pub gateway_connection: GatewayConnectionV1_1_33,
+    pub gateway_connection: GatewayConnectionV5,
 
     /// Defines all configuration options related to acknowledgements, such as delays or wait timeouts.
-    pub acknowledgements: AcknowledgementsV1_1_33,
+    pub acknowledgements: AcknowledgementsV5,
 
     /// Defines all configuration options related topology, such as refresh rates or timeouts.
-    pub topology: TopologyV1_1_33,
+    pub topology: TopologyV5,
 
     /// Defines all configuration options related to reply SURBs.
-    pub reply_surbs: ReplySurbsV1_1_33,
+    pub reply_surbs: ReplySurbsV5,
 }

common/client-core/gateways-storage/src/types.rs

@@ -27,6 +27,12 @@ pub struct GatewayRegistration {
     pub registration_timestamp: OffsetDateTime,
 }
 
+impl GatewayRegistration {
+    pub fn gateway_id(&self) -> identity::PublicKey {
+        self.details.gateway_id()
+    }
+}
+
 impl<'a> From<&'a GatewayRegistration> for RawRegisteredGateway {
     fn from(value: &'a GatewayRegistration) -> Self {
         RawRegisteredGateway {
@@ -298,3 +304,12 @@ pub struct CustomGatewayDetails {
     pub gateway_id: identity::PublicKey,
     pub data: Option<Vec<u8>>,
 }
+
+impl CustomGatewayDetails {
+    pub fn new(gateway_id: identity::PublicKey) -> CustomGatewayDetails {
+        Self {
+            gateway_id,
+            data: None,
+        }
+    }
+}

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

@@ -39,7 +39,7 @@ use log::{debug, error, info, warn};
 use nym_bandwidth_controller::BandwidthController;
 use nym_client_core_gateways_storage::{GatewayDetails, GatewaysDetailsStore};
 use nym_credential_storage::storage::Storage as CredentialStorage;
-use nym_crypto::asymmetric::encryption;
+use nym_crypto::asymmetric::{encryption, identity};
 use nym_gateway_client::{
     AcknowledgementReceiver, GatewayClient, GatewayConfig, MixnetMessageReceiver, PacketRouter,
 };
@@ -670,6 +670,7 @@ where
         let self_address = Self::mix_address(&init_res);
         let ack_key = init_res.client_keys.ack_key();
         let encryption_keys = init_res.client_keys.encryption_keypair();
+        let identity_keys = init_res.client_keys.identity_keypair();
 
         // the components are started in very specific order. Unless you know what you are doing,
         // do not change that.
@@ -792,6 +793,7 @@ where
 
         Ok(BaseClient {
             address: self_address,
+            identity_keys,
             client_input: ClientInputStatus::AwaitingProducer {
                 client_input: ClientInput {
                     connection_command_sender: client_connection_tx,
@@ -816,6 +818,7 @@ where
 
 pub struct BaseClient {
     pub address: Recipient,
+    pub identity_keys: Arc<identity::KeyPair>,
     pub client_input: ClientInputStatus,
     pub client_output: ClientOutputStatus,
     pub client_state: ClientState,

common/client-core/src/client/key_manager/persistence.rs

@@ -7,7 +7,7 @@ use std::error::Error;
 use tokio::sync::Mutex;
 
 #[cfg(not(target_arch = "wasm32"))]
-use crate::config::disk_persistence::keys_paths::ClientKeysPaths;
+use crate::config::disk_persistence::ClientKeysPaths;
 #[cfg(not(target_arch = "wasm32"))]
 use nym_crypto::asymmetric::{encryption, identity};
 #[cfg(not(target_arch = "wasm32"))]

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

@@ -1,6 +1,5 @@
-use std::{collections::HashMap, fmt};
-
-use log::{debug, error, info};
+use crate::config::GroupBy;
+use log::{debug, error};
 use nym_explorer_client::{ExplorerClient, PrettyDetailedMixNodeBond};
 use nym_network_defaults::var_names::EXPLORER_API;
 use nym_topology::{
@@ -10,11 +9,11 @@ use nym_topology::{
 };
 use nym_validator_client::client::MixId;
 use rand::{prelude::SliceRandom, thread_rng};
-use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 use tap::TapOptional;
 use url::Url;
 
-use crate::config::GroupBy;
+pub use nym_country_group::CountryGroup;
 
 const MIN_NODES_PER_LAYER: usize = 1;
 
@@ -38,158 +37,6 @@ fn create_explorer_client() -> Option<ExplorerClient> {
     Some(client)
 }
 
-#[derive(Copy, Clone, Hash, PartialEq, Eq, Serialize, Deserialize, Debug)]
-pub enum CountryGroup {
-    Europe,
-    NorthAmerica,
-    SouthAmerica,
-    Oceania,
-    Asia,
-    Africa,
-    Unknown,
-}
-
-impl CountryGroup {
-    // We map contry codes into group, which initially are continent codes to a first approximation,
-    // but we do it manually to reserve the right to tweak this distribution for our purposes.
-    // NOTE: I did this quickly and it's not a complete list of all countries, but only those that
-    // were present in the network at the time. Please add more as needed.
-    fn new(country_code: &str) -> Self {
-        let country_code = country_code.to_uppercase();
-        use CountryGroup::*;
-        match country_code.as_ref() {
-            // Europe
-            "AT" => Europe,
-            "BG" => Europe,
-            "CH" => Europe,
-            "CY" => Europe,
-            "CZ" => Europe,
-            "DE" => Europe,
-            "DK" => Europe,
-            "ES" => Europe,
-            "FI" => Europe,
-            "FR" => Europe,
-            "GB" => Europe,
-            "GR" => Europe,
-            "IE" => Europe,
-            "IT" => Europe,
-            "LT" => Europe,
-            "LU" => Europe,
-            "LV" => Europe,
-            "MD" => Europe,
-            "MT" => Europe,
-            "NL" => Europe,
-            "NO" => Europe,
-            "PL" => Europe,
-            "RO" => Europe,
-            "SE" => Europe,
-            "SK" => Europe,
-            "TR" => Europe,
-            "UA" => Europe,
-
-            // North America
-            "CA" => NorthAmerica,
-            "MX" => NorthAmerica,
-            "US" => NorthAmerica,
-
-            // South America
-            "AR" => SouthAmerica,
-            "BR" => SouthAmerica,
-            "CL" => SouthAmerica,
-            "CO" => SouthAmerica,
-            "CR" => SouthAmerica,
-            "GT" => SouthAmerica,
-
-            // Oceania
-            "AU" => Oceania,
-
-            // Asia
-            "AM" => Asia,
-            "BH" => Asia,
-            "CN" => Asia,
-            "GE" => Asia,
-            "HK" => Asia,
-            "ID" => Asia,
-            "IL" => Asia,
-            "IN" => Asia,
-            "JP" => Asia,
-            "KH" => Asia,
-            "KR" => Asia,
-            "KZ" => Asia,
-            "MY" => Asia,
-            "RU" => Asia,
-            "SG" => Asia,
-            "TH" => Asia,
-            "VN" => Asia,
-
-            // Africa
-            "SC" => Africa,
-            "UG" => Africa,
-            "ZA" => Africa,
-
-            // And group level codes work too
-            "EU" => Europe,
-            "NA" => NorthAmerica,
-            "SA" => SouthAmerica,
-            "OC" => Oceania,
-            "AS" => Asia,
-            "AF" => Africa,
-
-            // And some aliases
-            "EUROPE" => Europe,
-            "NORTHAMERICA" => NorthAmerica,
-            "SOUTHAMERICA" => SouthAmerica,
-            "OCEANIA" => Oceania,
-            "ASIA" => Asia,
-            "AFRICA" => Africa,
-
-            _ => {
-                info!("Unknown country code: {}", country_code);
-                Unknown
-            }
-        }
-    }
-}
-
-impl fmt::Display for CountryGroup {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use CountryGroup::*;
-        match self {
-            Europe => write!(f, "EU"),
-            NorthAmerica => write!(f, "NA"),
-            SouthAmerica => write!(f, "SA"),
-            Oceania => write!(f, "OC"),
-            Asia => write!(f, "AS"),
-            Africa => write!(f, "AF"),
-            Unknown => write!(f, "Unknown"),
-        }
-    }
-}
-
-impl std::str::FromStr for CountryGroup {
-    type Err = ();
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let group = CountryGroup::new(s);
-        if group == CountryGroup::Unknown {
-            Err(())
-        } else {
-            Ok(group)
-        }
-    }
-}
-
-impl CountryGroup {
-    #[allow(unused)]
-    fn known(self) -> Option<CountryGroup> {
-        use CountryGroup::*;
-        match self {
-            Europe | NorthAmerica | SouthAmerica | Oceania | Asia | Africa => Some(self),
-            Unknown => None,
-        }
-    }
-}
-
 fn group_mixnodes_by_country_code(
     mixnodes: Vec<PrettyDetailedMixNodeBond>,
 ) -> HashMap<CountryGroup, Vec<MixId>> {

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

@@ -1,43 +0,0 @@
-// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::config::disk_persistence::keys_paths::ClientKeysPaths;
-use serde::{Deserialize, Serialize};
-use std::path::{Path, PathBuf};
-
-pub mod keys_paths;
-pub mod old_v1_1_20_2;
-pub mod old_v1_1_33;
-
-pub const DEFAULT_REPLY_SURB_DB_FILENAME: &str = "persistent_reply_store.sqlite";
-pub const DEFAULT_CREDENTIALS_DB_FILENAME: &str = "credentials_database.db";
-pub const DEFAULT_GATEWAYS_DETAILS_DB_FILENAME: &str = "gateways_registrations.sqlite";
-
-#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
-#[serde(deny_unknown_fields)]
-pub struct CommonClientPaths {
-    pub keys: ClientKeysPaths,
-
-    /// Path to the file containing information about gateways used by this client,
-    /// i.e. details such as their public keys, owner addresses or the network information.
-    pub gateway_registrations: PathBuf,
-
-    /// Path to the database containing bandwidth credentials of this client.
-    pub credentials_database: PathBuf,
-
-    /// Path to the persistent store for received reply surbs, unused encryption keys and used sender tags.
-    pub reply_surb_database: PathBuf,
-}
-
-impl CommonClientPaths {
-    pub fn new_base<P: AsRef<Path>>(base_data_directory: P) -> Self {
-        let base_dir = base_data_directory.as_ref();
-
-        CommonClientPaths {
-            credentials_database: base_dir.join(DEFAULT_CREDENTIALS_DB_FILENAME),
-            reply_surb_database: base_dir.join(DEFAULT_REPLY_SURB_DB_FILENAME),
-            gateway_registrations: base_dir.join(DEFAULT_GATEWAYS_DETAILS_DB_FILENAME),
-            keys: ClientKeysPaths::new_base(base_data_directory),
-        }
-    }
-}

common/client-core/src/config/disk_persistence/old_v1_1_20_2.rs

@@ -1,33 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::config::disk_persistence::old_v1_1_33::{
-    ClientKeysPathsV1_1_33, CommonClientPathsV1_1_33, DEFAULT_GATEWAY_DETAILS_FILENAME,
-};
-use crate::error::ClientCoreError;
-use serde::{Deserialize, Serialize};
-use std::path::PathBuf;
-
-#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
-#[serde(deny_unknown_fields)]
-pub struct CommonClientPathsV1_1_20_2 {
-    pub keys: ClientKeysPathsV1_1_33,
-    pub credentials_database: PathBuf,
-    pub reply_surb_database: PathBuf,
-}
-
-impl CommonClientPathsV1_1_20_2 {
-    pub fn upgrade_default(self) -> Result<CommonClientPathsV1_1_33, ClientCoreError> {
-        let data_dir = self.reply_surb_database.parent().ok_or_else(|| {
-            ClientCoreError::ConfigFileUpgradeFailure {
-                current_version: "1.1.20-2".to_string(),
-            }
-        })?;
-        Ok(CommonClientPathsV1_1_33 {
-            keys: self.keys,
-            gateway_details: data_dir.join(DEFAULT_GATEWAY_DETAILS_FILENAME),
-            credentials_database: self.credentials_database,
-            reply_surb_database: self.reply_surb_database,
-        })
-    }
-}

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

@@ -1,602 +1,9 @@
-// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::client::topology_control::geo_aware_provider::CountryGroup;
-use nym_config::defaults::NymNetworkDetails;
-use nym_sphinx::{
-    addressing::clients::Recipient,
-    params::{PacketSize, PacketType},
+pub use nym_client_core_config_types::disk_persistence;
+pub use nym_client_core_config_types::old::{
+    old_config_v1_1_13, old_config_v1_1_20, old_config_v1_1_20_2, old_config_v1_1_30,
+    old_config_v1_1_33,
 };
-use serde::{Deserialize, Serialize};
-use std::time::Duration;
-use url::Url;
-
-pub mod disk_persistence;
-pub mod old_config_v1_1_13;
-pub mod old_config_v1_1_20;
-pub mod old_config_v1_1_20_2;
-pub mod old_config_v1_1_30;
-pub mod old_config_v1_1_33;
-
-// 'DEBUG'
-const DEFAULT_ACK_WAIT_MULTIPLIER: f64 = 1.5;
-
-const DEFAULT_ACK_WAIT_ADDITION: Duration = Duration::from_millis(1_500);
-const DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY: Duration = Duration::from_millis(200);
-const DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY: Duration = Duration::from_millis(20);
-const DEFAULT_AVERAGE_PACKET_DELAY: Duration = Duration::from_millis(50);
-const DEFAULT_TOPOLOGY_REFRESH_RATE: Duration = Duration::from_secs(5 * 60); // every 5min
-const DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT: Duration = Duration::from_millis(5_000);
-const DEFAULT_MAX_STARTUP_GATEWAY_WAITING_PERIOD: Duration = Duration::from_secs(70 * 60); // 70min -> full epoch (1h) + a bit of overhead
-
-// Set this to a high value for now, so that we don't risk sporadic timeouts that might cause
-// bought bandwidth tokens to not have time to be spent; Once we remove the gateway from the
-// bandwidth bridging protocol, we can come back to a smaller timeout value
-const DEFAULT_GATEWAY_RESPONSE_TIMEOUT: Duration = Duration::from_secs(5 * 60);
-
-const DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO: f64 = 0.70;
-
-// reply-surbs related:
-
-// define when to request
-// clients/client-core/src/client/replies/reply_storage/surb_storage.rs
-const DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD: usize = 10;
-const DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD: usize = 200;
-
-// define how much to request at once
-// clients/client-core/src/client/replies/reply_controller.rs
-const DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE: u32 = 10;
-const DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE: u32 = 100;
-
-const DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE: u32 = 500;
-
-const DEFAULT_MAXIMUM_REPLY_SURB_REREQUEST_WAITING_PERIOD: Duration = Duration::from_secs(10);
-const DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD: Duration = Duration::from_secs(5 * 60);
-
-// 12 hours
-const DEFAULT_MAXIMUM_REPLY_SURB_AGE: Duration = Duration::from_secs(12 * 60 * 60);
-
-// 24 hours
-const DEFAULT_MAXIMUM_REPLY_KEY_AGE: Duration = Duration::from_secs(24 * 60 * 60);
-
-#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
-#[serde(deny_unknown_fields)]
-pub struct Config {
-    pub client: Client,
-
-    #[serde(default)]
-    pub debug: DebugConfig,
-}
-
-impl Config {
-    pub fn new<S1, S2>(id: S1, version: S2) -> Self
-    where
-        S1: Into<String>,
-        S2: Into<String>,
-    {
-        Config {
-            client: Client::new_default(id, version),
-            debug: Default::default(),
-        }
-    }
-
-    pub fn from_client_config(client: Client, debug: DebugConfig) -> Self {
-        Config { client, debug }
-    }
-
-    pub fn validate(&self) -> bool {
-        self.debug.validate()
-    }
-
-    pub fn with_debug_config(mut self, debug: DebugConfig) -> Self {
-        self.debug = debug;
-        self
-    }
-
-    pub fn with_disabled_credentials(mut self, disabled_credentials_mode: bool) -> Self {
-        self.client.disabled_credentials_mode = disabled_credentials_mode;
-        self
-    }
-
-    pub fn with_custom_nyxd(mut self, urls: Vec<Url>) -> Self {
-        self.client.nyxd_urls = urls;
-        self
-    }
-
-    pub fn set_custom_nyxd(&mut self, nyxd_urls: Vec<Url>) {
-        self.client.nyxd_urls = nyxd_urls;
-    }
-
-    pub fn with_custom_nym_apis(mut self, nym_api_urls: Vec<Url>) -> Self {
-        self.client.nym_api_urls = nym_api_urls;
-        self
-    }
-
-    pub fn set_custom_nym_apis(&mut self, nym_api_urls: Vec<Url>) {
-        self.client.nym_api_urls = nym_api_urls;
-    }
-
-    pub fn with_high_default_traffic_volume(mut self, enabled: bool) -> Self {
-        if enabled {
-            self.set_high_default_traffic_volume();
-        }
-        self
-    }
-
-    pub fn with_packet_type(mut self, packet_type: PacketType) -> Self {
-        self.debug.traffic.packet_type = packet_type;
-        self
-    }
-
-    pub fn set_high_default_traffic_volume(&mut self) {
-        self.debug.traffic.average_packet_delay = Duration::from_millis(10);
-        // basically don't really send cover messages
-        self.debug.cover_traffic.loop_cover_traffic_average_delay =
-            Duration::from_millis(2_000_000);
-        // 250 "real" messages / s
-        self.debug.traffic.message_sending_average_delay = Duration::from_millis(4);
-    }
-
-    pub fn with_disabled_poisson_process(mut self, disabled: bool) -> Self {
-        if disabled {
-            self.set_no_poisson_process()
-        }
-        self
-    }
-
-    pub fn set_no_poisson_process(&mut self) {
-        self.debug.traffic.disable_main_poisson_packet_distribution = true;
-    }
-
-    pub fn with_disabled_cover_traffic(mut self, disabled: bool) -> Self {
-        if disabled {
-            self.set_no_cover_traffic()
-        }
-        self
-    }
-
-    pub fn set_no_cover_traffic(&mut self) {
-        self.debug.cover_traffic.disable_loop_cover_traffic_stream = true;
-        self.debug.traffic.disable_main_poisson_packet_distribution = true;
-    }
-
-    pub fn with_disabled_cover_traffic_with_keepalive(mut self, disabled: bool) -> Self {
-        if disabled {
-            self.set_no_cover_traffic_with_keepalive()
-        }
-        self
-    }
-    pub fn set_no_cover_traffic_with_keepalive(&mut self) {
-        self.debug.traffic.disable_main_poisson_packet_distribution = true;
-        self.debug.cover_traffic.loop_cover_traffic_average_delay = Duration::from_secs(5);
-    }
-
-    pub fn with_disabled_topology_refresh(mut self, disable_topology_refresh: bool) -> Self {
-        self.debug.topology.disable_refreshing = disable_topology_refresh;
-        self
-    }
-
-    pub fn with_topology_structure(mut self, topology_structure: TopologyStructure) -> Self {
-        self.set_topology_structure(topology_structure);
-        self
-    }
-
-    pub fn set_topology_structure(&mut self, topology_structure: TopologyStructure) {
-        self.debug.topology.topology_structure = topology_structure;
-    }
-
-    pub fn with_no_per_hop_delays(mut self, no_per_hop_delays: bool) -> Self {
-        if no_per_hop_delays {
-            self.set_no_per_hop_delays()
-        }
-        self
-    }
-
-    pub fn set_no_per_hop_delays(&mut self) {
-        self.debug.traffic.average_packet_delay = Duration::ZERO;
-        self.debug.acknowledgements.average_ack_delay = Duration::ZERO;
-    }
-
-    pub fn with_secondary_packet_size(mut self, secondary_packet_size: Option<PacketSize>) -> Self {
-        self.set_secondary_packet_size(secondary_packet_size);
-        self
-    }
-
-    pub fn set_secondary_packet_size(&mut self, secondary_packet_size: Option<PacketSize>) {
-        self.debug.traffic.secondary_packet_size = secondary_packet_size;
-    }
-
-    pub fn set_custom_version(&mut self, version: &str) {
-        self.client.version = version.to_string();
-    }
-
-    pub fn get_id(&self) -> String {
-        self.client.id.clone()
-    }
-
-    pub fn get_disabled_credentials_mode(&self) -> bool {
-        self.client.disabled_credentials_mode
-    }
-
-    pub fn get_validator_endpoints(&self) -> Vec<Url> {
-        self.client.nyxd_urls.clone()
-    }
-
-    pub fn get_nym_api_endpoints(&self) -> Vec<Url> {
-        self.client.nym_api_urls.clone()
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
-// note: the deny_unknown_fields is VITAL here to allow upgrades from v1.1.20_2
-#[serde(deny_unknown_fields)]
-pub struct Client {
-    /// Version of the client for which this configuration was created.
-    pub version: String,
-
-    /// ID specifies the human readable ID of this particular client.
-    pub id: String,
-
-    /// Indicates whether this client is running in a disabled credentials mode, thus attempting
-    /// to claim bandwidth without presenting bandwidth credentials.
-    // TODO: this should be moved to `debug.gateway_connection`
-    #[serde(default)]
-    pub disabled_credentials_mode: bool,
-
-    /// Addresses to nyxd validators via which the client can communicate with the chain.
-    #[serde(alias = "validator_urls")]
-    pub nyxd_urls: Vec<Url>,
-
-    /// Addresses to APIs running on validator from which the client gets the view of the network.
-    #[serde(alias = "validator_api_urls")]
-    pub nym_api_urls: Vec<Url>,
-}
-
-impl Client {
-    pub fn new_default<S1, S2>(id: S1, version: S2) -> Self
-    where
-        S1: Into<String>,
-        S2: Into<String>,
-    {
-        let network = NymNetworkDetails::new_mainnet();
-        let nyxd_urls = network
-            .endpoints
-            .iter()
-            .map(|validator| validator.nyxd_url())
-            .collect();
-        let nym_api_urls = network
-            .endpoints
-            .iter()
-            .filter_map(|validator| validator.api_url())
-            .collect::<Vec<_>>();
-
-        Client {
-            version: version.into(),
-            id: id.into(),
-            disabled_credentials_mode: true,
-            nyxd_urls,
-            nym_api_urls,
-        }
-    }
-
-    pub fn new<S: Into<String>>(
-        id: S,
-        disabled_credentials_mode: bool,
-        nyxd_urls: Vec<Url>,
-        nym_api_urls: Vec<Url>,
-    ) -> Self {
-        Client {
-            version: env!("CARGO_PKG_VERSION").to_string(),
-            id: id.into(),
-            disabled_credentials_mode,
-            nyxd_urls,
-            nym_api_urls,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct Traffic {
-    /// The parameter of Poisson distribution determining how long, on average,
-    /// sent packet is going to be delayed at any given mix node.
-    /// So for a packet going through three mix nodes, on average, it will take three times this value
-    /// until the packet reaches its destination.
-    #[serde(with = "humantime_serde")]
-    pub average_packet_delay: Duration,
-
-    /// The parameter of Poisson distribution determining how long, on average,
-    /// it is going to take another 'real traffic stream' message to be sent.
-    /// If no real packets are available and cover traffic is enabled,
-    /// a loop cover message is sent instead in order to preserve the rate.
-    #[serde(with = "humantime_serde")]
-    pub message_sending_average_delay: Duration,
-
-    /// Controls whether the main packet stream constantly produces packets according to the predefined
-    /// poisson distribution.
-    pub disable_main_poisson_packet_distribution: bool,
-
-    /// Specifies the packet size used for sent messages.
-    /// Do not override it unless you understand the consequences of that change.
-    pub primary_packet_size: PacketSize,
-
-    /// Specifies the optional auxiliary packet size for optimizing message streams.
-    /// Note that its use decreases overall anonymity.
-    /// Do not set it it unless you understand the consequences of that change.
-    pub secondary_packet_size: Option<PacketSize>,
-
-    pub packet_type: PacketType,
-}
-
-impl Traffic {
-    pub fn validate(&self) -> bool {
-        if let Some(secondary_packet_size) = self.secondary_packet_size {
-            if secondary_packet_size == PacketSize::AckPacket
-                || secondary_packet_size == self.primary_packet_size
-            {
-                return false;
-            }
-        }
-        true
-    }
-}
-
-impl Default for Traffic {
-    fn default() -> Self {
-        Traffic {
-            average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
-            message_sending_average_delay: DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
-            disable_main_poisson_packet_distribution: false,
-            primary_packet_size: PacketSize::RegularPacket,
-            secondary_packet_size: None,
-            packet_type: PacketType::Mix,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct CoverTraffic {
-    /// The parameter of Poisson distribution determining how long, on average,
-    /// it is going to take for another loop cover traffic message to be sent.
-    #[serde(with = "humantime_serde")]
-    pub loop_cover_traffic_average_delay: Duration,
-
-    /// Specifies the ratio of `primary_packet_size` to `secondary_packet_size` used in cover traffic.
-    /// Only applicable if `secondary_packet_size` is enabled.
-    pub cover_traffic_primary_size_ratio: f64,
-
-    /// Controls whether the dedicated loop cover traffic stream should be enabled.
-    /// (and sending packets, on average, every [Self::loop_cover_traffic_average_delay])
-    pub disable_loop_cover_traffic_stream: bool,
-}
-
-impl Default for CoverTraffic {
-    fn default() -> Self {
-        CoverTraffic {
-            loop_cover_traffic_average_delay: DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY,
-            cover_traffic_primary_size_ratio: DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO,
-            disable_loop_cover_traffic_stream: false,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct GatewayConnection {
-    /// How long we're willing to wait for a response to a message sent to the gateway,
-    /// before giving up on it.
-    #[serde(with = "humantime_serde")]
-    pub gateway_response_timeout: Duration,
-}
-
-impl Default for GatewayConnection {
-    fn default() -> Self {
-        GatewayConnection {
-            gateway_response_timeout: DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct Acknowledgements {
-    /// The parameter of Poisson distribution determining how long, on average,
-    /// sent acknowledgement is going to be delayed at any given mix node.
-    /// So for an ack going through three mix nodes, on average, it will take three times this value
-    /// until the packet reaches its destination.
-    #[serde(with = "humantime_serde")]
-    pub average_ack_delay: Duration,
-
-    /// Value multiplied with the expected round trip time of an acknowledgement packet before
-    /// it is assumed it was lost and retransmission of the data packet happens.
-    /// In an ideal network with 0 latency, this value would have been 1.
-    pub ack_wait_multiplier: f64,
-
-    /// Value added to the expected round trip time of an acknowledgement packet before
-    /// it is assumed it was lost and retransmission of the data packet happens.
-    /// In an ideal network with 0 latency, this value would have been 0.
-    #[serde(with = "humantime_serde")]
-    pub ack_wait_addition: Duration,
-}
-
-impl Default for Acknowledgements {
-    fn default() -> Self {
-        Acknowledgements {
-            average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
-            ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
-            ack_wait_addition: DEFAULT_ACK_WAIT_ADDITION,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct Topology {
-    /// The uniform delay every which clients are querying the directory server
-    /// to try to obtain a compatible network topology to send sphinx packets through.
-    #[serde(with = "humantime_serde")]
-    pub topology_refresh_rate: Duration,
-
-    /// During topology refresh, test packets are sent through every single possible network
-    /// path. This timeout determines waiting period until it is decided that the packet
-    /// did not reach its destination.
-    #[serde(with = "humantime_serde")]
-    pub topology_resolution_timeout: Duration,
-
-    /// Specifies whether the client should not refresh the network topology after obtaining
-    /// the first valid instance.
-    /// Supersedes `topology_refresh_rate_ms`.
-    pub disable_refreshing: bool,
-
-    /// Defines how long the client is going to wait on startup for its gateway to come online,
-    /// before abandoning the procedure.
-    #[serde(with = "humantime_serde")]
-    pub max_startup_gateway_waiting_period: Duration,
-
-    /// Specifies the mixnode topology to be used for sending packets.
-    pub topology_structure: TopologyStructure,
-}
-
-#[allow(clippy::large_enum_variant)]
-#[derive(Default, Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum TopologyStructure {
-    #[default]
-    NymApi,
-    GeoAware(GroupBy),
-}
-
-#[allow(clippy::large_enum_variant)]
-#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum GroupBy {
-    CountryGroup(CountryGroup),
-    NymAddress(Recipient),
-}
-
-impl std::fmt::Display for GroupBy {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            GroupBy::CountryGroup(group) => write!(f, "group: {}", group),
-            GroupBy::NymAddress(address) => write!(f, "address: {}", address),
-        }
-    }
-}
-
-impl Default for Topology {
-    fn default() -> Self {
-        Topology {
-            topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
-            topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
-            disable_refreshing: false,
-            max_startup_gateway_waiting_period: DEFAULT_MAX_STARTUP_GATEWAY_WAITING_PERIOD,
-            topology_structure: TopologyStructure::default(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct ReplySurbs {
-    /// Defines the minimum number of reply surbs the client wants to keep in its storage at all times.
-    /// It can only allow to go below that value if its to request additional reply surbs.
-    pub minimum_reply_surb_storage_threshold: usize,
-
-    /// Defines the maximum number of reply surbs the client wants to keep in its storage at any times.
-    pub maximum_reply_surb_storage_threshold: usize,
-
-    /// Defines the minimum number of reply surbs the client would request.
-    pub minimum_reply_surb_request_size: u32,
-
-    /// Defines the maximum number of reply surbs the client would request.
-    pub maximum_reply_surb_request_size: u32,
-
-    /// Defines the maximum number of reply surbs a remote party is allowed to request from this client at once.
-    pub maximum_allowed_reply_surb_request_size: u32,
-
-    /// Defines maximum amount of time the client is going to wait for reply surbs before explicitly asking
-    /// for more even though in theory they wouldn't need to.
-    #[serde(with = "humantime_serde")]
-    pub maximum_reply_surb_rerequest_waiting_period: Duration,
-
-    /// Defines maximum amount of time the client is going to wait for reply surbs before
-    /// deciding it's never going to get them and would drop all pending messages
-    #[serde(with = "humantime_serde")]
-    pub maximum_reply_surb_drop_waiting_period: Duration,
-
-    /// Defines maximum amount of time given reply surb is going to be valid for.
-    /// This is going to be superseded by key rotation once implemented.
-    #[serde(with = "humantime_serde")]
-    pub maximum_reply_surb_age: Duration,
-
-    /// Defines maximum amount of time given reply key is going to be valid for.
-    /// This is going to be superseded by key rotation once implemented.
-    #[serde(with = "humantime_serde")]
-    pub maximum_reply_key_age: Duration,
-
-    /// Specifies the number of mixnet hops the packet should go through. If not specified, then
-    /// the default value is used.
-    pub surb_mix_hops: Option<u8>,
-}
-
-impl Default for ReplySurbs {
-    fn default() -> Self {
-        ReplySurbs {
-            minimum_reply_surb_storage_threshold: DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD,
-            maximum_reply_surb_storage_threshold: DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD,
-            minimum_reply_surb_request_size: DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE,
-            maximum_reply_surb_request_size: DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE,
-            maximum_allowed_reply_surb_request_size: DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE,
-            maximum_reply_surb_rerequest_waiting_period:
-                DEFAULT_MAXIMUM_REPLY_SURB_REREQUEST_WAITING_PERIOD,
-            maximum_reply_surb_drop_waiting_period: DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD,
-            maximum_reply_surb_age: DEFAULT_MAXIMUM_REPLY_SURB_AGE,
-            maximum_reply_key_age: DEFAULT_MAXIMUM_REPLY_KEY_AGE,
-            surb_mix_hops: None,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct DebugConfig {
-    /// Defines all configuration options related to traffic streams.
-    pub traffic: Traffic,
-
-    /// Defines all configuration options related to cover traffic stream(s).
-    pub cover_traffic: CoverTraffic,
-
-    /// Defines all configuration options related to the gateway connection.
-    pub gateway_connection: GatewayConnection,
-
-    /// Defines all configuration options related to acknowledgements, such as delays or wait timeouts.
-    pub acknowledgements: Acknowledgements,
-
-    /// Defines all configuration options related topology, such as refresh rates or timeouts.
-    pub topology: Topology,
-
-    /// Defines all configuration options related to reply SURBs.
-    pub reply_surbs: ReplySurbs,
-}
-
-impl DebugConfig {
-    pub fn validate(&self) -> bool {
-        // no other sections have explicit requirements (yet)
-        self.traffic.validate()
-    }
-}
-
-// it could be derived, sure, but I'd rather have an explicit implementation in case we had to change
-// something manually at some point
-#[allow(clippy::derivable_impls)]
-impl Default for DebugConfig {
-    fn default() -> Self {
-        DebugConfig {
-            traffic: Default::default(),
-            cover_traffic: Default::default(),
-            gateway_connection: Default::default(),
-            acknowledgements: Default::default(),
-            topology: Default::default(),
-            reply_surbs: Default::default(),
-        }
-    }
-}
+pub use nym_client_core_config_types::*;

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

@@ -14,8 +14,10 @@ futures = { workspace = true }
 log = { workspace = true }
 thiserror = { workspace = true }
 url = { workspace = true }
-rand = { version = "0.7.3", features = ["wasm-bindgen"] }
+rand = { workspace = true }
 tokio = { version = "1.24.1", features = ["macros"] }
+si-scale = "0.2.2"
+time.workspace = true
 
 # internal
 nym-bandwidth-controller = { path = "../../bandwidth-controller" }
@@ -46,10 +48,7 @@ features = ["net", "sync", "time"]
 
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-tungstenite]
 workspace = true
-# the choice of this particular tls feature was arbitrary;
-# if you reckon a different one would be more appropriate, feel free to change it
-# features = ["native-tls"]
-features = ["rustls-tls-native-roots"]
+features = ["rustls-tls-webpki-roots"]
 
 # wasm-only dependencies
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen]

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

@@ -442,7 +442,7 @@ impl<C, St> GatewayClient<C, St> {
         }
 
         debug_assert!(self.connection.is_available());
-        log::trace!("Registering gateway");
+        log::debug!("Registering gateway");
 
         // it's fine to instantiate it here as it's only used once (during authentication or registration)
         // and putting it into the GatewayClient struct would be a hassle
@@ -494,6 +494,7 @@ impl<C, St> GatewayClient<C, St> {
         if !self.connection.is_established() {
             return Err(GatewayClientError::ConnectionNotEstablished);
         }
+        log::debug!("Authenticating with gateway");
 
         // it's fine to instantiate it here as it's only used once (during authentication or registration)
         // and putting it into the GatewayClient struct would be a hassle
@@ -529,6 +530,7 @@ impl<C, St> GatewayClient<C, St> {
                 self.authenticated = status;
                 self.bandwidth_remaining = bandwidth_remaining;
                 self.negotiated_protocol = protocol_version;
+                log::debug!("authenticated: {status}, bandwidth remaining: {bandwidth_remaining}");
                 Ok(())
             }
             ServerResponse::Error { message } => Err(GatewayClientError::GatewayError(message)),
@@ -541,10 +543,11 @@ impl<C, St> GatewayClient<C, St> {
         &mut self,
     ) -> Result<Arc<SharedKeys>, GatewayClientError> {
         if self.authenticated {
+            debug!("Already authenticated");
             return if let Some(shared_key) = &self.shared_key {
                 Ok(Arc::clone(shared_key))
             } else {
-                Err(GatewayClientError::AuthenticationFailure)
+                Err(GatewayClientError::AuthenticationFailureWithPreexistingSharedKey)
             };
         }
 

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

@@ -71,6 +71,9 @@ pub enum GatewayClientError {
     #[error("Authentication failure")]
     AuthenticationFailure,
 
+    #[error("Authentication failure with preexisting shared key")]
+    AuthenticationFailureWithPreexistingSharedKey,
+
     #[error("Timed out")]
     Timeout,
 

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

@@ -10,9 +10,14 @@ use futures::stream::{SplitSink, SplitStream};
 use futures::{SinkExt, StreamExt};
 use log::*;
 use nym_gateway_requests::registration::handshake::SharedKeys;
+use nym_gateway_requests::ServerResponse;
 use nym_task::TaskClient;
+use si_scale::helpers::bibytes2;
 use std::os::raw::c_int as RawFd;
+use std::sync::atomic::{AtomicI64, Ordering};
 use std::sync::Arc;
+use std::time::Duration;
+use time::OffsetDateTime;
 use tungstenite::Message;
 
 #[cfg(unix)]
@@ -48,6 +53,21 @@ pub(crate) fn ws_fd(_conn: &WsConn) -> Option<RawFd> {
     None
 }
 
+// disgusting? absolutely, but does the trick for now
+static LAST_LOGGED_BANDWIDTH_TS: AtomicI64 = AtomicI64::new(0);
+
+fn maybe_log_bandwidth(remaining: i64) {
+    // SAFETY: this value is always populated with valid timestamps
+    let last =
+        OffsetDateTime::from_unix_timestamp(LAST_LOGGED_BANDWIDTH_TS.load(Ordering::Relaxed))
+            .unwrap();
+    let now = OffsetDateTime::now_utc();
+    if last + Duration::from_secs(10) < now {
+        log::info!("remaining bandwidth: {}", bibytes2(remaining as f64));
+        LAST_LOGGED_BANDWIDTH_TS.store(now.unix_timestamp(), Ordering::Relaxed)
+    }
+}
+
 #[derive(Debug)]
 pub(crate) struct PartiallyDelegated {
     sink_half: SplitSink<WsConn, Message>,
@@ -56,7 +76,10 @@ pub(crate) struct PartiallyDelegated {
 }
 
 impl PartiallyDelegated {
-    fn recover_received_plaintexts(ws_msgs: Vec<Message>, shared_key: &SharedKeys) -> Vec<Vec<u8>> {
+    fn recover_received_plaintexts(
+        ws_msgs: Vec<Message>,
+        shared_key: &SharedKeys,
+    ) -> Result<Vec<Vec<u8>>, GatewayClientError> {
         let mut plaintexts = Vec::with_capacity(ws_msgs.len());
         for ws_msg in ws_msgs {
             match ws_msg {
@@ -74,15 +97,32 @@ impl PartiallyDelegated {
                 // TODO: those can return the "send confirmations" - perhaps it should be somehow worked around?
                 Message::Text(text) => {
                     trace!(
-                    "received a text message - probably a response to some previous query! - {}",
-                    text
+                    "received a text message - probably a response to some previous query! - {text}",
                 );
+                    match ServerResponse::try_from(text)
+                        .map_err(|_| GatewayClientError::MalformedResponse)?
+                    {
+                        ServerResponse::Send {
+                            remaining_bandwidth,
+                        } => maybe_log_bandwidth(remaining_bandwidth),
+                        ServerResponse::Error { message } => {
+                            error!("gateway failure: {message}");
+                            return Err(GatewayClientError::GatewayError(message));
+                        }
+                        other => {
+                            warn!(
+                                "received illegal message of type {} in an authenticated client",
+                                other.name()
+                            )
+                        }
+                    }
+
                     continue;
                 }
                 _ => continue,
             }
         }
-        plaintexts
+        Ok(plaintexts)
     }
 
     fn route_socket_messages(
@@ -90,7 +130,7 @@ impl PartiallyDelegated {
         packet_router: &PacketRouter,
         shared_key: &SharedKeys,
     ) -> Result<(), GatewayClientError> {
-        let plaintexts = Self::recover_received_plaintexts(ws_msgs, shared_key);
+        let plaintexts = Self::recover_received_plaintexts(ws_msgs, shared_key)?;
         packet_router.route_received(plaintexts)
     }
 
@@ -130,7 +170,8 @@ impl PartiallyDelegated {
                         };
 
                         if let Err(err) = Self::route_socket_messages(ws_msgs, &packet_router, shared_key.as_ref()) {
-                            log::warn!("Route socket messages failed: {err}");
+                            log::error!("Route socket messages failed: {err}");
+                            break Err(err)
                         }
                     }
                 };

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

@@ -24,7 +24,6 @@ nym-group-contract-common = { path = "../../cosmwasm-smart-contracts/group-contr
 nym-service-provider-directory-common = { path = "../../cosmwasm-smart-contracts/service-provider-directory" }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
-reqwest = { workspace = true, features = ["json"] }
 nym-http-api-client = { path = "../../../common/http-api-client"}
 thiserror = { workspace = true }
 log = { workspace = true }
@@ -67,6 +66,14 @@ cosmwasm-std = { workspace = true }
 workspace = true
 features = ["tokio"]
 
+[target."cfg(target_arch = \"wasm32\")".dependencies.reqwest]
+workspace = true
+features = ["json"]
+
+[target."cfg(not(target_arch = \"wasm32\"))".dependencies.reqwest]
+workspace = true
+features = ["json", "rustls-tls"]
+
 [dev-dependencies]
 bip39 = { workspace = true }
 cosmrs = { workspace = true, features = ["bip32"] }

common/commands/Cargo.toml

@@ -17,7 +17,7 @@ csv = "1.3.0"
 cw-utils = { workspace = true }
 futures = { workspace = true }
 handlebars = "3.0.1"
-humantime-serde = "1.0"
+humantime-serde = { workspace = true }
 inquire = "0.6.2"
 k256 = { workspace = true, features = ["ecdsa", "sha256"] }
 log = { workspace = true }

common/commands/src/coconut/generate_freepass.rs

@@ -148,6 +148,10 @@ pub async fn execute(args: Args, client: SigningClient) -> anyhow::Result<()> {
         bail!("the provided free pass request has too long expiry (expiry is set to on {expiration_date})")
     }
 
+    if expiration_date < now {
+        bail!("the provided free pass expiry is set in the past!")
+    }
+
     // issuance start
     block_until_coconut_is_available(&client).await?;
 

common/commands/src/validator/mixnet/delegators/delegate_to_multiple_mixnodes.rs

@@ -0,0 +1,354 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use std::cmp::Ordering;
+use std::collections::{HashMap, HashSet};
+use std::fs;
+use std::fs::OpenOptions;
+
+use clap::Parser;
+use comfy_table::Table;
+use csv::WriterBuilder;
+use log::info;
+use nym_mixnet_contract_common::ExecuteMsg;
+use nym_mixnet_contract_common::ExecuteMsg::{DelegateToMixnode, UndelegateFromMixnode};
+
+use nym_mixnet_contract_common::PendingEpochEventKind::{Delegate, Undelegate};
+use nym_validator_client::nyxd::contract_traits::{NymContractsProvider, PagedMixnetQueryClient};
+use nym_validator_client::nyxd::Coin;
+
+use crate::context::SigningClient;
+use crate::utils::pretty_coin;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub memo: Option<String>,
+
+    #[clap(
+        long,
+        help = "Input csv files with delegation amounts. Format: (mixID, amount(in NYM))"
+    )]
+    pub input: String,
+
+    #[clap(
+        long,
+        help = "An output file path (CSV format) to create or append a log of results to"
+    )]
+    pub output: Option<String>,
+}
+
+#[derive(Debug)]
+pub struct InputFileRow {
+    pub mix_id: String,
+    pub amount: Coin,
+}
+#[derive(Debug)]
+pub struct InputFileReader {
+    pub rows: Vec<InputFileRow>,
+}
+
+impl InputFileReader {
+    pub fn new(path: &str) -> Result<InputFileReader, anyhow::Error> {
+        let file_contents = fs::read_to_string(path)?;
+        let mut rows = Vec::new();
+        let mut mix_id_set = HashSet::new();
+
+        for line in file_contents
+            .lines()
+            .map(str::trim)
+            .filter(|line| !line.is_empty())
+        {
+            let tokens: Vec<_> = line.split(',').collect();
+            if tokens.len() != 2 {
+                anyhow::bail!("Incorrect format: {}", line);
+            }
+            let mix_id = tokens[0].trim().to_string();
+            let input_amount = tokens[1]
+                .trim()
+                .parse::<u128>()
+                .map_err(|_| anyhow::anyhow!("'{}' has an invalid amount", line))?;
+
+            let micro_nym_amount = input_amount * 1_000_000;
+
+            if !mix_id_set.insert(mix_id.clone()) {
+                anyhow::bail!("Duplicate mix_id found: {}", mix_id);
+            }
+
+            rows.push(InputFileRow {
+                mix_id,
+                amount: Coin {
+                    amount: micro_nym_amount,
+                    denom: "unym".to_string(),
+                },
+            });
+        }
+        Ok(InputFileReader { rows })
+    }
+}
+
+fn write_to_csv(
+    output_details: Vec<[String; 3]>,
+    output_file: Option<String>,
+) -> Result<(), anyhow::Error> {
+    if let Some(file_path) = output_file {
+        // Determine if the file exists and is not empty
+        let file_exists = fs::metadata(&file_path)
+            .map(|metadata| metadata.len() > 0)
+            .unwrap_or(false);
+
+        // Open the file for appending or creation
+        let file = OpenOptions::new()
+            .append(true)
+            .create(true)
+            .open(&file_path)?;
+
+        if !file_exists {
+            let mut wtr = csv::Writer::from_writer(&file);
+            wtr.write_record(["Operation", "Transaction Hash", "Timestamp"])?;
+            wtr.flush()?;
+        }
+
+        let mut wtr = WriterBuilder::new()
+            .has_headers(!file_exists)
+            .from_writer(file);
+
+        // Write the details to the CSV file
+        for detail in output_details {
+            wtr.write_record(&detail)?;
+        }
+        wtr.flush()?;
+        info!("All operations saved to output file");
+    }
+    Ok(())
+}
+
+async fn fetch_delegation_data(
+    client: &SigningClient,
+) -> Result<HashMap<String, Coin>, anyhow::Error> {
+    let address = client.address();
+    // Fetch all delegations for the user
+    let delegations = match client.get_all_delegator_delegations(&address).await {
+        Ok(delegations) => delegations,
+        Err(e) => {
+            anyhow::bail!("Error fetching delegations: {}", e)
+        }
+    };
+
+    // Build a map to make it easier to handle delegation data
+    let mut existing_delegation_map: HashMap<String, Coin> = HashMap::new();
+    let mut pending_delegation_map: HashMap<String, Coin> = HashMap::new();
+
+    for delegation in delegations {
+        existing_delegation_map
+            .insert(delegation.mix_id.to_string(), Coin::from(delegation.amount));
+    }
+
+    // Look for pending delegate / undelegate events which might be of interest to us
+    let pending_events = match client.get_all_pending_epoch_events().await {
+        Ok(events) => events,
+        Err(e) => {
+            anyhow::bail!("Error fetching pending epoch events: {}", e);
+        }
+    };
+
+    for event in pending_events {
+        match event.event.kind {
+            // If a pending undelegate tx is found, remove it from delegation map
+            Undelegate { owner, mix_id, .. } => {
+                if owner == address.as_ref()
+                    && existing_delegation_map.contains_key(&mix_id.to_string())
+                {
+                    existing_delegation_map.remove(&mix_id.to_string());
+                }
+            }
+
+            // If a pending delegation event is found, gather them to consolidate later
+            Delegate {
+                owner,
+                mix_id,
+                amount,
+                ..
+            } => {
+                if owner == address.as_ref() {
+                    let mut amount = Coin::from(amount);
+                    if let Some(pending_record) = pending_delegation_map.get(&mix_id.to_string()) {
+                        amount.amount += pending_record.amount;
+                    }
+                    pending_delegation_map.insert(mix_id.to_string(), amount);
+                }
+            }
+            _ => {}
+        };
+    }
+
+    // Consolidate pending events into delegation map
+    for (mix_id, amount) in pending_delegation_map {
+        existing_delegation_map
+            .entry(mix_id)
+            .and_modify(|e| e.amount += amount.amount)
+            .or_insert(amount);
+    }
+
+    Ok(existing_delegation_map)
+}
+
+pub async fn delegate_to_multiple_mixnodes(args: Args, client: SigningClient) {
+    let records = match InputFileReader::new(&args.input) {
+        Ok(records) => records,
+        Err(e) => {
+            println!("Error reading input file: {}", e);
+            return;
+        }
+    };
+
+    let existing_delegation_map = fetch_delegation_data(&client)
+        .await
+        .expect("Could not fetch existing delegations");
+
+    let mut delegation_table = Table::new();
+    let mut undelegation_table = Table::new();
+    let mut delegation_msgs: Vec<(ExecuteMsg, Vec<Coin>)> = Vec::new();
+    let mut undelegation_msgs: Vec<(ExecuteMsg, Vec<Coin>)> = Vec::new();
+
+    delegation_table.set_header(["Mix ID", "Input Amount", "Adjusted Amount"]);
+    undelegation_table.set_header(["Mix ID"]);
+
+    for row in &records.rows {
+        let input_amount = row.amount.amount;
+        let existing_delegation_amount = existing_delegation_map
+            .get(&row.mix_id)
+            .map_or(0, |coin| coin.amount);
+
+        match existing_delegation_amount.cmp(&input_amount) {
+            Ordering::Equal => continue, // No action needed if amounts are equal
+
+            Ordering::Less => {
+                // Delegate the difference if the existing delegation is less
+                let difference = Coin {
+                    amount: input_amount - existing_delegation_amount,
+                    denom: row.amount.denom.clone(),
+                };
+                let mix_id = row.mix_id.clone().parse::<u32>().unwrap();
+                delegation_msgs.push((DelegateToMixnode { mix_id }, vec![difference.clone()]));
+                delegation_table.add_row(&[
+                    row.mix_id.clone(),
+                    pretty_coin(&row.amount),
+                    pretty_coin(&difference),
+                ]);
+            }
+
+            Ordering::Greater => {
+                let mix_id = row.mix_id.clone().parse::<u32>().unwrap();
+                let coins: Vec<Coin> = vec![];
+                undelegation_msgs.push((UndelegateFromMixnode { mix_id }, coins));
+                undelegation_table.add_row(&[row.mix_id.clone()]);
+
+                if row.amount.amount > 0 {
+                    delegation_msgs.push((DelegateToMixnode { mix_id }, vec![row.amount.clone()]));
+                    delegation_table.add_row(&[
+                        row.mix_id.clone(),
+                        pretty_coin(&row.amount),
+                        pretty_coin(&row.amount),
+                    ]);
+                }
+            }
+        }
+    }
+
+    if delegation_msgs.is_empty() && undelegation_msgs.is_empty() {
+        println!("Nothing to do. Delegations are up-to-date!");
+        return;
+    }
+
+    if !undelegation_msgs.is_empty() {
+        println!("Undelegation records : \n{}\n\n", undelegation_table);
+    }
+
+    if !delegation_msgs.is_empty() {
+        println!("Delegation records : \n{}\n\n", delegation_table);
+    }
+
+    let ans = inquire::Confirm::new("Do you want to continue with the shown operations?")
+        .with_default(false)
+        .with_help_message("You must confirm before the transactions are signed")
+        .prompt();
+
+    if let Err(e) = ans {
+        info!("Aborting, {}...", e);
+        return;
+    }
+
+    if let Ok(false) = ans {
+        info!("Aborting:: User denied proceeding with signing!");
+        return;
+    }
+
+    let mut output_details: Vec<[String; 3]> = Vec::new();
+    let now = time::OffsetDateTime::now_utc();
+    let now = now
+        .format(&time::format_description::well_known::Rfc3339)
+        .unwrap();
+
+    let mixnet_contract = client
+        .mixnet_contract_address()
+        .expect("mixnet contract address is not available");
+
+    // Execute all undelegation transactions
+    if !undelegation_msgs.is_empty() {
+        let res = client
+            .execute_multiple(
+                mixnet_contract,
+                undelegation_msgs.clone(),
+                None,
+                format!(
+                    "Undelegate from {} nodes via nym-cli",
+                    undelegation_msgs.len()
+                ),
+            )
+            .await
+            .expect("Could not undelegate!");
+
+        println!(
+            "Undelegation transaction successful : {}",
+            res.transaction_hash
+        );
+        output_details.push([
+            "Undelegate".to_string(),
+            res.transaction_hash.to_string(),
+            now.clone(),
+        ]);
+    }
+
+    // Execute all  delegation delegations
+    if !delegation_msgs.is_empty() {
+        let res = client
+            .execute_multiple(
+                mixnet_contract,
+                delegation_msgs,
+                None,
+                format!(
+                    "Delegatation to {} nodes via nym-cli",
+                    undelegation_msgs.len()
+                ),
+            )
+            .await
+            .expect("Could not delegate");
+
+        println!(
+            "Delegation transaction successful : {}",
+            res.transaction_hash
+        );
+        output_details.push([
+            "Delegate".to_string(),
+            res.transaction_hash.to_string(),
+            now.clone(),
+        ]);
+    }
+
+    if args.output.is_some() {
+        if let Err(e) = write_to_csv(output_details, args.output) {
+            info!("Failed to write to CSV, {}", e);
+        }
+    }
+}

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

@@ -6,6 +6,7 @@ use clap::{Args, Subcommand};
 pub mod rewards;
 
 pub mod delegate_to_mixnode;
+pub mod delegate_to_multiple_mixnodes;
 pub mod query_for_delegations;
 pub mod undelegate_from_mixnode;
 pub mod vesting_delegate_to_mixnode;
@@ -26,6 +27,8 @@ pub enum MixnetDelegatorsCommands {
     Rewards(rewards::MixnetDelegatorsReward),
     /// Delegate to a mixnode
     Delegate(delegate_to_mixnode::Args),
+    /// Perform bulk delegations from an input file
+    DelegateMulti(delegate_to_multiple_mixnodes::Args),
     /// Undelegate from a mixnode
     Undelegate(undelegate_from_mixnode::Args),
     /// Delegate to a mixnode with locked tokens

common/cosmwasm-smart-contracts/coconut-dkg/src/types.rs

@@ -328,4 +328,8 @@ impl EpochState {
     pub fn is_dealing_exchange(&self) -> bool {
         matches!(self, EpochState::DealingExchange { .. })
     }
+
+    pub fn is_waiting_initialisation(&self) -> bool {
+        matches!(self, EpochState::WaitingInitialisation)
+    }
 }

common/country-group/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "nym-country-group"
+version = "0.1.0"
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+documentation.workspace = true
+edition.workspace = true
+license.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+serde = { workspace = true, features = ["derive"] }
+tracing.workspace = true

common/country-group/src/lib.rs

@@ -0,0 +1,158 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use serde::{Deserialize, Serialize};
+use std::fmt;
+use tracing::info;
+
+#[derive(Copy, Clone, Hash, PartialEq, Eq, Serialize, Deserialize, Debug)]
+pub enum CountryGroup {
+    Europe,
+    NorthAmerica,
+    SouthAmerica,
+    Oceania,
+    Asia,
+    Africa,
+    Unknown,
+}
+
+impl CountryGroup {
+    // We map country codes into group, which initially are continent codes to a first approximation,
+    // but we do it manually to reserve the right to tweak this distribution for our purposes.
+    // NOTE: I did this quickly, and it's not a complete list of all countries, but only those that
+    // were present in the network at the time. Please add more as needed.
+    pub fn new(country_code: &str) -> Self {
+        let country_code = country_code.to_uppercase();
+        use CountryGroup::*;
+        match country_code.as_ref() {
+            // Europe
+            "AT" => Europe,
+            "BG" => Europe,
+            "CH" => Europe,
+            "CY" => Europe,
+            "CZ" => Europe,
+            "DE" => Europe,
+            "DK" => Europe,
+            "ES" => Europe,
+            "FI" => Europe,
+            "FR" => Europe,
+            "GB" => Europe,
+            "GR" => Europe,
+            "IE" => Europe,
+            "IT" => Europe,
+            "LT" => Europe,
+            "LU" => Europe,
+            "LV" => Europe,
+            "MD" => Europe,
+            "MT" => Europe,
+            "NL" => Europe,
+            "NO" => Europe,
+            "PL" => Europe,
+            "RO" => Europe,
+            "SE" => Europe,
+            "SK" => Europe,
+            "TR" => Europe,
+            "UA" => Europe,
+
+            // North America
+            "CA" => NorthAmerica,
+            "MX" => NorthAmerica,
+            "US" => NorthAmerica,
+
+            // South America
+            "AR" => SouthAmerica,
+            "BR" => SouthAmerica,
+            "CL" => SouthAmerica,
+            "CO" => SouthAmerica,
+            "CR" => SouthAmerica,
+            "GT" => SouthAmerica,
+
+            // Oceania
+            "AU" => Oceania,
+
+            // Asia
+            "AM" => Asia,
+            "BH" => Asia,
+            "CN" => Asia,
+            "GE" => Asia,
+            "HK" => Asia,
+            "ID" => Asia,
+            "IL" => Asia,
+            "IN" => Asia,
+            "JP" => Asia,
+            "KH" => Asia,
+            "KR" => Asia,
+            "KZ" => Asia,
+            "MY" => Asia,
+            "RU" => Asia,
+            "SG" => Asia,
+            "TH" => Asia,
+            "VN" => Asia,
+
+            // Africa
+            "SC" => Africa,
+            "UG" => Africa,
+            "ZA" => Africa,
+
+            // And group level codes work too
+            "EU" => Europe,
+            "NA" => NorthAmerica,
+            "SA" => SouthAmerica,
+            "OC" => Oceania,
+            "AS" => Asia,
+            "AF" => Africa,
+
+            // And some aliases
+            "EUROPE" => Europe,
+            "NORTHAMERICA" => NorthAmerica,
+            "SOUTHAMERICA" => SouthAmerica,
+            "OCEANIA" => Oceania,
+            "ASIA" => Asia,
+            "AFRICA" => Africa,
+
+            _ => {
+                info!("Unknown country code: {country_code}");
+                Unknown
+            }
+        }
+    }
+}
+
+impl fmt::Display for CountryGroup {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use CountryGroup::*;
+        match self {
+            Europe => write!(f, "EU"),
+            NorthAmerica => write!(f, "NA"),
+            SouthAmerica => write!(f, "SA"),
+            Oceania => write!(f, "OC"),
+            Asia => write!(f, "AS"),
+            Africa => write!(f, "AF"),
+            Unknown => write!(f, "Unknown"),
+        }
+    }
+}
+
+impl std::str::FromStr for CountryGroup {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let group = CountryGroup::new(s);
+        if group == CountryGroup::Unknown {
+            Err(())
+        } else {
+            Ok(group)
+        }
+    }
+}
+
+impl CountryGroup {
+    #[allow(unused)]
+    fn known(self) -> Option<CountryGroup> {
+        use CountryGroup::*;
+        match self {
+            Europe | NorthAmerica | SouthAmerica | Oceania | Asia | Africa => Some(self),
+            Unknown => None,
+        }
+    }
+}

common/credential-storage/migrations/20241104120000_add_unique.sql

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+ALTER TABLE coconut_credentials
+    RENAME TO old_coconut_credentials;
+
+CREATE TABLE coconut_credentials
+(
+    id                     INTEGER                                                                     NOT NULL PRIMARY KEY AUTOINCREMENT,
+
+--     introduce a way for us to introduce breaking changes in serialization
+    serialization_revision INTEGER                                                                     NOT NULL,
+
+--     the best we can do without enums
+    credential_type        TEXT CHECK ( credential_type IN ('BandwidthVoucher', 'FreeBandwidthPass') ) NOT NULL,
+    credential_data        BLOB                                                                        NOT NULL UNIQUE,
+    epoch_id               INTEGER                                                                     NOT NULL,
+
+--     this field is only really applicable to free passes
+    expired                BOOLEAN                                                                     NOT NULL
+);
+
+ALTER TABLE credential_usage
+    RENAME TO old_credential_usage;
+
+-- for bandwidth vouchers there's going to be only a single entry; for freepasses there can be as many as there are gateways
+CREATE TABLE credential_usage
+(
+    credential_id   INTEGER NOT NULL REFERENCES coconut_credentials (id),
+    gateway_id_bs58 TEXT    NOT NULL,
+
+--     no matter credential type, we can't spend the same credential with the same gateway multiple times
+    UNIQUE (credential_id, gateway_id_bs58)
+);
+
+INSERT INTO coconut_credentials
+SELECT *
+FROM old_coconut_credentials;
+
+
+INSERT INTO credential_usage
+SELECT *
+FROM old_credential_usage;
+
+DROP TABLE old_coconut_credentials;
+DROP TABLE old_credential_usage;

common/credential-storage/src/backends/sqlite.rs

@@ -44,7 +44,7 @@ impl CoconutCredentialManager {
             r#"
                 SELECT * 
                 FROM coconut_credentials
-                WHERE coconut_credentials.credential_type == "FreeBandwidthPass"
+                WHERE coconut_credentials.credential_type == "FreeBandwidthPass" AND coconut_credentials.expired = false
                       AND NOT EXISTS (SELECT 1
                                       FROM   credential_usage
                                       WHERE  credential_usage.credential_id = coconut_credentials.id

common/credential-storage/src/error.rs

@@ -18,4 +18,7 @@ pub enum StorageError {
 
     #[error("No unused credential in database. You need to buy at least one")]
     NoCredential,
+
+    #[error("Database unique constraint violation. Is the credential already imported?")]
+    ConstraintUnique,
 }

common/credential-storage/src/persistent_storage.rs

@@ -69,9 +69,21 @@ impl Storage for PersistentStorage {
                 bandwidth_credential.credential_data,
                 bandwidth_credential.epoch_id,
             )
-            .await?;
-
-        Ok(())
+            .await
+            .map_err(|err| {
+                // There is one error we want to handle specifically.
+                // Check if database_error is `SqliteError` with code 2067 which
+                // means UNIQUE constraint violation
+                if let Some(db_error) = err.as_database_error() {
+                    if db_error.code().map_or(false, |code| code == "2067") {
+                        StorageError::ConstraintUnique
+                    } else {
+                        err.into()
+                    }
+                } else {
+                    err.into()
+                }
+            })
     }
 
     async fn get_next_unspent_credential(

common/credentials-interface/src/lib.rs

@@ -8,11 +8,11 @@ use std::str::FromStr;
 use thiserror::Error;
 
 pub use nym_coconut::{
-    aggregate_signature_shares, aggregate_verification_keys, blind_sign, hash_to_scalar, keygen,
-    prepare_blind_sign, prove_bandwidth_credential, verify_credential, Attribute, Base58,
-    BlindSignRequest, BlindedSerialNumber, BlindedSignature, Bytable, CoconutError, KeyPair,
-    Parameters, PrivateAttribute, PublicAttribute, SecretKey, Signature, SignatureShare,
-    VerificationKey, VerifyCredentialRequest,
+    aggregate_signature_shares, aggregate_signature_shares_and_verify, aggregate_verification_keys,
+    blind_sign, hash_to_scalar, keygen, prepare_blind_sign, prove_bandwidth_credential,
+    verify_credential, Attribute, Base58, BlindSignRequest, BlindedSerialNumber, BlindedSignature,
+    Bytable, CoconutError, KeyPair, Parameters, PrivateAttribute, PublicAttribute, SecretKey,
+    Signature, SignatureShare, VerificationKey, VerifyCredentialRequest,
 };
 
 pub const VOUCHER_INFO_TYPE: &str = "BandwidthVoucher";

common/credentials/Cargo.toml

@@ -23,5 +23,5 @@ nym-api-requests = { path = "../../nym-api/nym-api-requests" }
 nym-validator-client = { path = "../client-libs/validator-client", default-features = false }
 
 [dev-dependencies]
-rand = "0.7.3"
+rand = "0.8.5"
 

common/credentials/src/coconut/bandwidth/freepass.rs

@@ -12,7 +12,8 @@ use serde::{Deserialize, Serialize};
 use time::{Duration, OffsetDateTime, Time};
 use zeroize::{Zeroize, ZeroizeOnDrop};
 
-pub const MAX_FREE_PASS_VALIDITY: Duration = Duration::WEEK; // 1 week
+pub const DEFAULT_FREE_PASS_VALIDITY: Duration = Duration::WEEK; // 1 week
+pub const MAX_FREE_PASS_VALIDITY: Duration = Duration::weeks(12); // 12 weeks
 
 #[derive(Debug, Zeroize, ZeroizeOnDrop, Serialize, Deserialize)]
 pub struct FreePassIssuedData {
@@ -77,9 +78,9 @@ impl FreePassIssuanceData {
     }
 
     pub fn default_expiry_date() -> OffsetDateTime {
-        // set it to furthest midnight in the future such as it's no more than a week away,
+        // set it to the furthest midnight in the future such as it's no more than a week away,
         // i.e. if it's currently for example 9:43 on 2nd March 2024, it will set it to 0:00 on 9th March 2024
-        (OffsetDateTime::now_utc() + MAX_FREE_PASS_VALIDITY).replace_time(Time::MIDNIGHT)
+        (OffsetDateTime::now_utc() + DEFAULT_FREE_PASS_VALIDITY).replace_time(Time::MIDNIGHT)
     }
 
     pub fn expiry_date_attribute(&self) -> &Attribute {

common/credentials/src/coconut/bandwidth/issuance.rs

@@ -10,18 +10,19 @@ use crate::coconut::bandwidth::{
 use crate::coconut::utils::scalar_serde_helper;
 use crate::error::Error;
 use nym_credentials_interface::{
-    aggregate_signature_shares, hash_to_scalar, prepare_blind_sign, Attribute, BlindedSerialNumber,
-    BlindedSignature, Parameters, PrivateAttribute, PublicAttribute, Signature, SignatureShare,
-    VerificationKey,
+    aggregate_signature_shares, aggregate_signature_shares_and_verify, hash_to_scalar,
+    prepare_blind_sign, Attribute, BlindedSerialNumber, BlindedSignature, Parameters,
+    PrivateAttribute, PublicAttribute, Signature, SignatureShare, VerificationKey,
 };
 use nym_crypto::asymmetric::{encryption, identity};
 use nym_validator_client::nym_api::EpochId;
-use nym_validator_client::nyxd::{Coin, Hash};
 use nym_validator_client::signing::AccountData;
 use serde::{Deserialize, Serialize};
 use time::OffsetDateTime;
 use zeroize::{Zeroize, ZeroizeOnDrop};
 
+pub use nym_validator_client::nyxd::{Coin, Hash};
+
 #[derive(Zeroize, ZeroizeOnDrop, Serialize, Deserialize)]
 pub enum BandwidthCredentialIssuanceDataVariant {
     Voucher(BandwidthVoucherIssuanceData),
@@ -265,6 +266,13 @@ impl IssuanceBandwidthCredential {
         self.unblind_signature(validator_vk, &signing_data, blinded_signature)
     }
 
+    pub fn unchecked_aggregate_signature_shares(
+        &self,
+        shares: &[SignatureShare],
+    ) -> Result<Signature, Error> {
+        aggregate_signature_shares(shares).map_err(Error::SignatureAggregationError)
+    }
+
     pub fn aggregate_signature_shares(
         &self,
         verification_key: &VerificationKey,
@@ -279,7 +287,7 @@ impl IssuanceBandwidthCredential {
         attributes.extend_from_slice(&private_attributes);
         attributes.extend_from_slice(&public_attributes);
 
-        aggregate_signature_shares(params, verification_key, &attributes, shares)
+        aggregate_signature_shares_and_verify(params, verification_key, &attributes, shares)
             .map_err(Error::SignatureAggregationError)
     }
 

common/credentials/src/coconut/bandwidth/voucher.rs

@@ -6,7 +6,7 @@ use crate::coconut::utils::scalar_serde_helper;
 use crate::error::Error;
 use nym_api_requests::coconut::BlindSignRequestBody;
 use nym_credentials_interface::{
-    hash_to_scalar, Attribute, BlindSignRequest, BlindedSignature, PublicAttribute,
+    hash_to_scalar, Attribute, BlindSignRequest, BlindedSignature, CredentialType, PublicAttribute,
 };
 use nym_crypto::asymmetric::{encryption, identity};
 use nym_validator_client::nyxd::{Coin, Hash};
@@ -123,6 +123,10 @@ impl BandwidthVoucherIssuanceData {
         &self.value_prehashed
     }
 
+    pub fn typ() -> CredentialType {
+        CredentialType::Voucher
+    }
+
     pub fn tx_hash(&self) -> Hash {
         self.deposit_tx_hash
     }

common/crypto/Cargo.toml

@@ -17,9 +17,9 @@ generic-array = { workspace = true, optional = true }
 hkdf = { version = "0.12.3", optional = true }
 hmac = { version = "0.12.1", optional = true }
 cipher = { version = "0.4.3", optional = true }
-x25519-dalek = { version = "1.1", optional = true }
-ed25519-dalek = { version = "1.0", optional = true }
-rand = { version = "0.7.3", features = ["wasm-bindgen"], optional = true }
+x25519-dalek = { version = "2.0.0", optional = true }
+ed25519-dalek = { version = "2.1", features = ["rand_core"], optional = true }
+rand = { version = "0.8.5", optional = true }
 serde_bytes = { version = "0.11.6", optional = true }
 serde_crate = { version = "1.0", optional = true, default_features = false, features = ["derive"], package = "serde" }
 subtle-encoding = { version = "0.5", features =  ["bech32-preview"]}
@@ -31,7 +31,7 @@ nym-sphinx-types = { path = "../nymsphinx/types", version = "0.2.0", default-fea
 nym-pemstore = { path = "../../common/pemstore", version = "0.3.0" }
 
 [dev-dependencies]
-rand_chacha = "0.2"
+rand_chacha = "0.3"
 
 [features]
 default = ["sphinx"]

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

@@ -56,7 +56,7 @@ pub struct KeyPair {
 impl KeyPair {
     #[cfg(feature = "rand")]
     pub fn new<R: RngCore + CryptoRng>(rng: &mut R) -> Self {
-        let private_key = x25519_dalek::StaticSecret::new(rng);
+        let private_key = x25519_dalek::StaticSecret::random_from_rng(rng);
         let public_key = (&private_key).into();
 
         KeyPair {
@@ -203,7 +203,7 @@ impl<'a> From<&'a PrivateKey> for PublicKey {
 impl PrivateKey {
     #[cfg(feature = "rand")]
     pub fn new<R: RngCore + CryptoRng>(rng: &mut R) -> Self {
-        let x25519_secret = x25519_dalek::StaticSecret::new(rng);
+        let x25519_secret = x25519_dalek::StaticSecret::random_from_rng(rng);
 
         PrivateKey(x25519_secret)
     }
@@ -322,9 +322,7 @@ impl<'a> From<&'a PrivateKey> for nym_sphinx_types::PrivateKey {
 #[cfg(feature = "sphinx")]
 impl From<nym_sphinx_types::PrivateKey> for PrivateKey {
     fn from(private_key: nym_sphinx_types::PrivateKey) -> Self {
-        let private_key_bytes = private_key.to_bytes();
-        assert_eq!(private_key_bytes.len(), PRIVATE_KEY_SIZE);
-        Self::from_bytes(&private_key_bytes).unwrap()
+        Self(private_key)
     }
 }
 
@@ -366,7 +364,7 @@ mod sphinx_key_conversion {
     #[test]
     fn works_for_backward_conversion() {
         for _ in 0..NUM_ITERATIONS {
-            let (sphinx_private, sphinx_public) = nym_sphinx_types::crypto::keygen();
+            let (sphinx_private, sphinx_public) = nym_sphinx_types::test_utils::fixtures::keygen();
 
             let private_bytes = sphinx_private.to_bytes();
             let public_bytes = sphinx_public.as_bytes();

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

@@ -1,8 +1,8 @@
 // Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-pub use ed25519_dalek::ed25519::signature::Signature as SignatureTrait;
 pub use ed25519_dalek::SignatureError;
+use ed25519_dalek::{Signer, SigningKey};
 pub use ed25519_dalek::{Verifier, PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH, SIGNATURE_LENGTH};
 use nym_pemstore::traits::{PemStorableKey, PemStorableKeyPair};
 use std::fmt::{self, Display, Formatter};
@@ -10,6 +10,9 @@ use std::str::FromStr;
 use thiserror::Error;
 use zeroize::{Zeroize, ZeroizeOnDrop};
 
+#[cfg(feature = "serde")]
+pub mod serde_helpers;
+
 #[cfg(feature = "sphinx")]
 use nym_sphinx_types::{DestinationAddressBytes, DESTINATION_ADDRESS_LENGTH};
 
@@ -27,6 +30,9 @@ pub enum Ed25519RecoveryError {
     #[error(transparent)]
     MalformedBytes(#[from] SignatureError),
 
+    #[error(transparent)]
+    BytesLengthError(#[from] std::array::TryFromSliceError),
+
     #[error("the base58 representation of the public key was malformed - {source}")]
     MalformedPublicKeyString {
         #[source]
@@ -61,11 +67,11 @@ pub struct KeyPair {
 impl KeyPair {
     #[cfg(feature = "rand")]
     pub fn new<R: RngCore + CryptoRng>(rng: &mut R) -> Self {
-        let ed25519_keypair = ed25519_dalek::Keypair::generate(rng);
+        let ed25519_signing_key = ed25519_dalek::SigningKey::generate(rng);
 
         KeyPair {
-            private_key: PrivateKey(ed25519_keypair.secret),
-            public_key: PublicKey(ed25519_keypair.public),
+            private_key: PrivateKey(ed25519_signing_key.to_bytes()),
+            public_key: PublicKey(ed25519_signing_key.verifying_key()),
         }
     }
 
@@ -106,7 +112,7 @@ impl PemStorableKeyPair for KeyPair {
 
 /// ed25519 EdDSA Public Key
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub struct PublicKey(ed25519_dalek::PublicKey);
+pub struct PublicKey(ed25519_dalek::VerifyingKey);
 
 impl Display for PublicKey {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
@@ -132,7 +138,9 @@ impl PublicKey {
     }
 
     pub fn from_bytes(b: &[u8]) -> Result<Self, Ed25519RecoveryError> {
-        Ok(PublicKey(ed25519_dalek::PublicKey::from_bytes(b)?))
+        Ok(PublicKey(ed25519_dalek::VerifyingKey::from_bytes(
+            b.try_into()?,
+        )?))
     }
 
     pub fn to_base58_string(self) -> String {
@@ -186,7 +194,7 @@ impl<'d> Deserialize<'d> for PublicKey {
     where
         D: Deserializer<'d>,
     {
-        Ok(PublicKey(ed25519_dalek::PublicKey::deserialize(
+        Ok(PublicKey(ed25519_dalek::VerifyingKey::deserialize(
             deserializer,
         )?))
     }
@@ -220,14 +228,14 @@ impl Display for PrivateKey {
 
 impl<'a> From<&'a PrivateKey> for PublicKey {
     fn from(pk: &'a PrivateKey) -> Self {
-        PublicKey((&pk.0).into())
+        PublicKey(SigningKey::from_bytes(&pk.0).verifying_key())
     }
 }
 
 impl PrivateKey {
     #[cfg(feature = "rand")]
     pub fn new<R: RngCore + CryptoRng>(rng: &mut R) -> Self {
-        let ed25519_secret = ed25519_dalek::SecretKey::generate(rng);
+        let ed25519_secret = ed25519_dalek::SigningKey::generate(rng).to_bytes();
 
         PrivateKey(ed25519_secret)
     }
@@ -237,11 +245,11 @@ impl PrivateKey {
     }
 
     pub fn to_bytes(&self) -> [u8; SECRET_KEY_LENGTH] {
-        self.0.to_bytes()
+        self.0
     }
 
     pub fn from_bytes(b: &[u8]) -> Result<Self, Ed25519RecoveryError> {
-        Ok(PrivateKey(ed25519_dalek::SecretKey::from_bytes(b)?))
+        Ok(PrivateKey(b.try_into()?))
     }
 
     pub fn to_base58_string(&self) -> String {
@@ -256,9 +264,8 @@ impl PrivateKey {
     }
 
     pub fn sign<M: AsRef<[u8]>>(&self, message: M) -> Signature {
-        let expanded_secret_key = ed25519_dalek::ExpandedSecretKey::from(&self.0);
-        let public_key: PublicKey = self.into();
-        let sig = expanded_secret_key.sign(message.as_ref(), &public_key.0);
+        let signing_key: SigningKey = self.0.into();
+        let sig = signing_key.sign(message.as_ref());
         Signature(sig)
     }
 
@@ -327,7 +334,9 @@ impl Signature {
     }
 
     pub fn from_bytes(bytes: &[u8]) -> Result<Self, Ed25519RecoveryError> {
-        Ok(Signature(ed25519_dalek::Signature::from_bytes(bytes)?))
+        Ok(Signature(ed25519_dalek::Signature::from_bytes(
+            bytes.try_into()?,
+        )))
     }
 }
 

common/crypto/src/asymmetric/identity/serde_helpers.rs

@@ -0,0 +1,18 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use super::PublicKey;
+
+pub mod bs58_pubkey {
+    use super::*;
+    use serde_crate::{Deserialize, Deserializer, Serializer};
+
+    pub fn serialize<S: Serializer>(key: &PublicKey, serializer: S) -> Result<S::Ok, S::Error> {
+        serializer.serialize_str(&key.to_base58_string())
+    }
+
+    pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<PublicKey, D::Error> {
+        let s = String::deserialize(deserializer)?;
+        PublicKey::from_base58_string(s).map_err(serde::de::Error::custom)
+    }
+}

common/crypto/src/asymmetric/mod.rs

@@ -3,3 +3,6 @@
 
 pub mod encryption;
 pub mod identity;
+
+pub use encryption as x25519;
+pub use identity as ed25519;

common/crypto/src/shared_key.rs

@@ -3,11 +3,11 @@
 
 use crate::asymmetric::encryption;
 use crate::hkdf;
+#[cfg(feature = "rand")]
+use cipher::crypto_common::rand_core::{CryptoRng, RngCore};
 use cipher::{Key, KeyIvInit, StreamCipher};
 use digest::crypto_common::BlockSizeUser;
 use digest::Digest;
-#[cfg(feature = "rand")]
-use rand::{CryptoRng, RngCore};
 
 /// Generate an ephemeral encryption keypair and perform diffie-hellman to establish
 /// shared key with the remote.

common/dkg/src/bte/proof_chunking.rs

@@ -836,7 +836,7 @@ mod tests {
         let share3 = chunks3.clone().try_into().unwrap();
 
         let shares = vec![share1, share2, share3];
-        let chunks = &[chunks1, chunks2, chunks3];
+        let chunks = [chunks1, chunks2, chunks3];
 
         for (i, pk_i) in pks.iter().enumerate() {
             let mut ciphertext_chunk_i = Vec::with_capacity(NUM_CHUNKS);

common/http-api-common/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "nym-http-api-common"
+version = "0.1.0"
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+documentation.workspace = true
+edition.workspace = true
+license.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+axum.workspace = true
+bytes = "1.5.0"
+mime = "0.3.17"
+serde = { workspace = true, features = ["derive"] }
+serde_json.workspace = true
+serde_yaml = "0.9.25"
+utoipa = { workspace = true }

common/http-api-common/src/lib.rs

@@ -1,32 +1,13 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-License-Identifier: Apache-2.0
 
 use axum::http::{header, HeaderValue, StatusCode};
 use axum::response::{IntoResponse, Response};
-use axum::{Json, Router};
+use axum::Json;
 use bytes::{BufMut, BytesMut};
 use serde::{Deserialize, Serialize};
 use utoipa::{IntoParams, ToSchema};
 
-pub mod v1;
-
-use crate::http::api::v1::gateway::client_interfaces::wireguard::WireguardAppState;
-use crate::http::state::AppState;
-pub use nym_node_requests::api as api_requests;
-use nym_node_requests::routes;
-
-#[derive(Debug, Clone)]
-pub struct Config {
-    pub v1_config: v1::Config,
-}
-
-pub(super) fn routes(config: Config, initial_wg_state: WireguardAppState) -> Router<AppState> {
-    Router::new().nest(
-        routes::api::V1,
-        v1::routes(config.v1_config, initial_wg_state),
-    )
-}
-
 #[derive(Debug, Clone, ToSchema)]
 pub enum FormattedResponse<T> {
     Json(Json<T>),

common/mixnode-common/Cargo.toml

@@ -10,11 +10,11 @@ license.workspace = true
 [dependencies]
 bytes = "1.0"
 futures = { workspace = true }
-humantime-serde = "1.0"
+humantime-serde = { workspace = true }
 log = { workspace = true }
 rand = "0.8"
-serde = { version = "1.0", features = ["derive"] }
-tokio = { version = "1.24.1", features = [
+serde = { workspace = true, features = ["derive"] }
+tokio = { workspace = true, features = [
     "time",
     "macros",
     "rt",
@@ -23,6 +23,7 @@ tokio = { version = "1.24.1", features = [
 ] }
 tokio-util = { workspace = true, features = ["codec"] }
 url = { workspace = true }
+time.workspace = true
 thiserror = { workspace = true }
 
 nym-crypto = { path = "../crypto" }
@@ -37,3 +38,4 @@ nym-task = { path = "../task" }
 nym-validator-client = { path = "../client-libs/validator-client" }
 nym-bin-common = { path = "../bin-common" }
 nym-metrics = { path = "../nym-metrics" }
+nym-node-http-api = { path = "../../nym-node/nym-node-http-api" } 

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

@@ -242,7 +242,7 @@ impl SphinxPacketProcessor {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use nym_sphinx_types::crypto::keygen;
+    use nym_sphinx_types::test_utils::fixtures::keygen;
 
     fn fixture() -> SphinxPacketProcessor {
         let local_keys = keygen();

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

@@ -1,259 +1,35 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use nym_crypto::asymmetric::identity;
-use serde::{Serialize, Serializer};
-use std::cmp::Ordering;
-use std::fmt::{self, Display, Formatter};
-use std::sync::Arc;
-use std::time::Duration;
-use tokio::sync::RwLock;
+use nym_node_http_api::state::metrics::{SharedVerlocStats, VerlocNodeResult};
+use std::mem;
+use time::OffsetDateTime;
 
-#[derive(Clone, Default)]
-pub struct AtomicVerlocResult {
-    inner: Arc<RwLock<VerlocResult>>,
+pub(crate) trait VerlocStatsUpdateExt {
+    async fn start_new_measurements(&self, nodes_to_test: usize);
+
+    async fn append_measurement_results(&self, new_data: Vec<VerlocNodeResult>);
+
+    async fn finish_measurements(&self);
 }
 
-#[derive(Debug, Clone, Serialize, Default)]
-pub struct VerlocResult {
-    total_tested: usize,
-    #[serde(with = "humantime_serde")]
-    run_started: Option<std::time::SystemTime>,
-    #[serde(with = "humantime_serde")]
-    run_finished: Option<std::time::SystemTime>,
-    results: Vec<Verloc>,
-}
-
-impl AtomicVerlocResult {
-    pub(crate) fn new() -> Self {
-        AtomicVerlocResult {
-            inner: Arc::new(RwLock::new(VerlocResult {
-                total_tested: 0,
-                run_started: None,
-                run_finished: None,
-                results: Vec::new(),
-            })),
-        }
+impl VerlocStatsUpdateExt for SharedVerlocStats {
+    async fn start_new_measurements(&self, nodes_to_test: usize) {
+        let mut guard = self.write().await;
+        guard.previous_run_data = mem::take(&mut guard.current_run_data);
+        guard.current_run_data.nodes_tested = nodes_to_test;
     }
 
-    pub(crate) async fn reset_results(&self, new_tested: usize) {
-        let mut write_permit = self.inner.write().await;
-        write_permit.total_tested = new_tested;
-        write_permit.run_started = Some(std::time::SystemTime::now());
-        write_permit.run_finished = None;
-        write_permit.results = Vec::new()
-    }
-
-    pub(crate) async fn append_results(&self, mut new_data: Vec<Verloc>) {
-        let mut write_permit = self.inner.write().await;
-        write_permit.results.append(&mut new_data);
+    async fn append_measurement_results(&self, mut new_data: Vec<VerlocNodeResult>) {
+        let mut write_permit = self.write().await;
+        write_permit.current_run_data.results.append(&mut new_data);
         // make sure the data always stays in order.
         // TODO: considering the front of the results is guaranteed to be sorted, should perhaps
         // a non-default sorting algorithm be used?
-        write_permit.results.sort()
+        write_permit.current_run_data.results.sort()
     }
 
-    pub(crate) async fn finish_measurements(&self) {
-        self.inner.write().await.run_finished = Some(std::time::SystemTime::now());
-    }
-
-    // Considering that on every read we will need to clone data regardless, let's make our
-    // lives simpler and clone it here rather than deal with lifetime of the permit
-    pub async fn clone_data(&self) -> VerlocResult {
-        self.inner.read().await.clone()
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize)]
-pub struct Verloc {
-    #[serde(serialize_with = "serialize_identity_as_string")]
-    pub identity: identity::PublicKey,
-    pub latest_measurement: Option<Measurement>,
-}
-
-fn serialize_identity_as_string<S>(
-    identity: &identity::PublicKey,
-    serializer: S,
-) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    serializer.serialize_str(&identity.to_base58_string())
-}
-
-impl Display for Verloc {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        if let Some(measurement) = self.latest_measurement {
-            write!(f, "{} - {}", self.identity, measurement)
-        } else {
-            write!(f, "{} - COULD NOT MEASURE", self.identity)
-        }
-    }
-}
-
-impl PartialOrd for Verloc {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for Verloc {
-    fn cmp(&self, other: &Self) -> Ordering {
-        // if both have measurement, compare measurements
-        // then if only one have measurement, prefer that one
-        // completely ignore identity as it makes no sense to order by it
-        if let Some(self_measurement) = &self.latest_measurement {
-            if let Some(other_measurement) = &other.latest_measurement {
-                self_measurement.cmp(other_measurement)
-            } else {
-                Ordering::Less
-            }
-        } else if other.latest_measurement.is_some() {
-            Ordering::Greater
-        } else {
-            Ordering::Equal
-        }
-    }
-}
-
-impl Verloc {
-    pub(crate) fn new(
-        identity: identity::PublicKey,
-        latest_measurement: Option<Measurement>,
-    ) -> Self {
-        Verloc {
-            identity,
-            latest_measurement,
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize)]
-pub struct Measurement {
-    #[serde(serialize_with = "humantime_serde::serialize")]
-    pub minimum: Duration,
-    #[serde(serialize_with = "humantime_serde::serialize")]
-    pub mean: Duration,
-    #[serde(serialize_with = "humantime_serde::serialize")]
-    pub maximum: Duration,
-    #[serde(serialize_with = "humantime_serde::serialize")]
-    pub standard_deviation: Duration,
-}
-
-impl Measurement {
-    pub(crate) fn new(raw_results: &[Duration]) -> Self {
-        let minimum = *raw_results.iter().min().expect("didn't get any results!");
-        let maximum = *raw_results.iter().max().expect("didn't get any results!");
-
-        let mean = Self::duration_mean(raw_results);
-        let standard_deviation = Self::duration_standard_deviation(raw_results, mean);
-
-        Measurement {
-            minimum,
-            mean,
-            maximum,
-            standard_deviation,
-        }
-    }
-
-    fn duration_mean(data: &[Duration]) -> Duration {
-        let sum = data.iter().sum::<Duration>();
-        let count = data.len() as u32;
-
-        sum / count
-    }
-
-    fn duration_standard_deviation(data: &[Duration], mean: Duration) -> Duration {
-        let variance_micros = data
-            .iter()
-            .map(|&value| {
-                // make sure we don't underflow
-                let diff = if mean > value {
-                    mean - value
-                } else {
-                    value - mean
-                };
-                // we don't need nanos precision
-                let diff_micros = diff.as_micros();
-                diff_micros * diff_micros
-            })
-            .sum::<u128>()
-            / data.len() as u128;
-
-        // we shouldn't really overflow as our differences shouldn't be larger than couple seconds at the worst possible case scenario
-        let std_deviation_micros = (variance_micros as f64).sqrt() as u64;
-        Duration::from_micros(std_deviation_micros)
-    }
-}
-
-impl Display for Measurement {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "rtt min/avg/max/mdev = {:?} / {:?} / {:?} / {:?}",
-            self.minimum, self.mean, self.maximum, self.standard_deviation
-        )
-    }
-}
-
-impl PartialOrd for Measurement {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for Measurement {
-    fn cmp(&self, other: &Self) -> Ordering {
-        // minimum value is most important, then look at standard deviation, then mean and finally maximum
-        let min_cmp = self.minimum.cmp(&other.minimum);
-        if min_cmp != Ordering::Equal {
-            return min_cmp;
-        }
-        let std_dev_cmp = self.standard_deviation.cmp(&other.standard_deviation);
-        if std_dev_cmp != Ordering::Equal {
-            return std_dev_cmp;
-        }
-        let std_dev_cmp = self.mean.cmp(&other.mean);
-        if std_dev_cmp != Ordering::Equal {
-            return std_dev_cmp;
-        }
-        self.maximum.cmp(&other.maximum)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn sorting_vec_of_verlocs() {
-        let some_identity =
-            identity::PublicKey::from_base58_string("Be9wH7xuXBRJAuV1pC7MALZv6a61RvWQ3SypsNarqTt")
-                .unwrap();
-        let no_measurement = Verloc::new(some_identity, None);
-        let low_min = Verloc::new(
-            some_identity,
-            Some(Measurement {
-                minimum: Duration::from_millis(42),
-                mean: Duration::from_millis(43),
-                maximum: Duration::from_millis(44),
-                standard_deviation: Duration::from_millis(45),
-            }),
-        );
-        let higher_min = Verloc::new(
-            some_identity,
-            Some(Measurement {
-                minimum: Duration::from_millis(420),
-                mean: Duration::from_millis(430),
-                maximum: Duration::from_millis(440),
-                standard_deviation: Duration::from_millis(450),
-            }),
-        );
-
-        let mut vec_verloc = vec![no_measurement, low_min, no_measurement, higher_min];
-        vec_verloc.sort();
-
-        let expected_sorted = vec![low_min, higher_min, no_measurement, no_measurement];
-        assert_eq!(expected_sorted, vec_verloc);
+    async fn finish_measurements(&self) {
+        self.write().await.current_run_data.run_finished = Some(OffsetDateTime::now_utc())
     }
 }

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

@@ -1,4 +1,4 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::verloc::listener::PacketListener;
@@ -9,6 +9,7 @@ use log::*;
 use nym_bin_common::version_checker::{self, parse_version};
 use nym_crypto::asymmetric::identity;
 use nym_network_defaults::mainnet::NYM_API;
+use nym_node_http_api::state::metrics::{SharedVerlocStats, VerlocNodeResult};
 use nym_task::TaskClient;
 use rand::seq::SliceRandom;
 use rand::thread_rng;
@@ -20,7 +21,9 @@ use tokio::task::JoinHandle;
 use tokio::time::sleep;
 use url::Url;
 
-pub use crate::verloc::measurement::{AtomicVerlocResult, Verloc, VerlocResult};
+use measurement::VerlocStatsUpdateExt;
+
+// pub use crate::verloc::measurement::{AtomicVerlocResult, Verloc, VerlocResult};
 
 pub mod error;
 pub(crate) mod listener;
@@ -179,7 +182,7 @@ pub struct VerlocMeasurer {
     // then it definitely cannot be constructed here and probably will need to be passed from outside,
     // as mixnodes/gateways would already be using an instance of said client.
     validator_client: nym_validator_client::NymApiClient,
-    results: AtomicVerlocResult,
+    state: SharedVerlocStats,
 }
 
 impl VerlocMeasurer {
@@ -210,10 +213,14 @@ impl VerlocMeasurer {
                 config.nym_api_urls[0].clone(),
             ),
             config,
-            results: AtomicVerlocResult::new(),
+            state: SharedVerlocStats::default(),
         }
     }
 
+    pub fn set_shared_state(&mut self, state: SharedVerlocStats) {
+        self.state = state;
+    }
+
     fn use_next_nym_api(&mut self) {
         if self.config.nym_api_urls.len() == 1 {
             warn!("There's only a single validator API available - it won't be possible to use a different one");
@@ -225,10 +232,6 @@ impl VerlocMeasurer {
             .change_nym_api(self.config.nym_api_urls[self.currently_used_api].clone())
     }
 
-    pub fn get_verloc_results_pointer(&self) -> AtomicVerlocResult {
-        self.results.clone()
-    }
-
     fn start_listening(&self) -> JoinHandle<()> {
         let packet_listener = Arc::clone(&self.packet_listener);
         tokio::spawn(packet_listener.run())
@@ -270,7 +273,7 @@ impl VerlocMeasurer {
             while !shutdown_listener.is_shutdown() {
                 tokio::select! {
                     measurement_result = measurement_chunk.next() => {
-                        let Some(result) = measurement_result  else {
+                        let Some(result) = measurement_result else {
                             // if the stream has finished, it means we got everything we could have gotten
                             break
                         };
@@ -278,18 +281,16 @@ impl VerlocMeasurer {
                         // if we receive JoinError it means the task failed to get executed, so either there's a bigger issue with tokio
                         // or there was a panic inside the task itself. In either case, we should just terminate ourselves.
                         let execution_result = result.expect("the measurement task panicked!");
+                        let identity = execution_result.1;
+
                         let measurement_result = match execution_result.0 {
                             Err(err) => {
-                                debug!(
-                                    "Failed to perform measurement for {} - {}",
-                                    execution_result.1.to_base58_string(),
-                                    err
-                                );
+                                debug!("Failed to perform measurement for {identity}: {err}");
                                 None
                             }
                             Ok(result) => Some(result),
                         };
-                        chunk_results.push(Verloc::new(execution_result.1, measurement_result));
+                        chunk_results.push(VerlocNodeResult::new(identity, measurement_result));
                     },
                     _ = shutdown_listener.recv() => {
                         trace!("Shutdown received while measuring");
@@ -299,7 +300,7 @@ impl VerlocMeasurer {
             }
 
             // update the results vector with chunks as they become available (by default every 50 nodes)
-            self.results.append_results(chunk_results).await;
+            self.state.append_measurement_results(chunk_results).await;
         }
 
         MeasurementOutcome::Done
@@ -358,7 +359,7 @@ impl VerlocMeasurer {
                 .collect::<Vec<_>>();
 
             // on start of each run remove old results
-            self.results.reset_results(tested_nodes.len()).await;
+            self.state.start_new_measurements(tested_nodes.len()).await;
 
             if let MeasurementOutcome::Shutdown = self.perform_measurement(tested_nodes).await {
                 log::trace!("Shutting down after aborting measurements");
@@ -366,7 +367,7 @@ impl VerlocMeasurer {
             }
 
             // write current time to "run finished" field
-            self.results.finish_measurements().await;
+            self.state.finish_measurements().await;
 
             info!(
                 "Finished performing verloc measurements. The next one will happen in {:?}",

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

@@ -1,11 +1,11 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::verloc::error::RttError;
-use crate::verloc::measurement::Measurement;
 use crate::verloc::packet::{EchoPacket, ReplyPacket};
 use log::*;
 use nym_crypto::asymmetric::identity;
+use nym_node_http_api::state::metrics::VerlocMeasurement;
 use nym_task::TaskClient;
 use rand::{thread_rng, Rng};
 use std::net::SocketAddr;
@@ -82,7 +82,7 @@ impl PacketSender {
     pub(super) async fn send_packets_to_node(
         self: Arc<Self>,
         tested_node: TestedNode,
-    ) -> Result<Measurement, RttError> {
+    ) -> Result<VerlocMeasurement, RttError> {
         let mut shutdown_listener = self.shutdown_listener.fork(tested_node.address.to_string());
         shutdown_listener.mark_as_success();
 
@@ -208,6 +208,6 @@ impl PacketSender {
             sleep(self.delay_between_packets).await;
         }
 
-        Ok(Measurement::new(&results))
+        Ok(VerlocMeasurement::new(&results))
     }
 }

common/network-defaults/src/mainnet.rs

@@ -18,9 +18,12 @@ pub const VESTING_CONTRACT_ADDRESS: &str =
     "n1nc5tatafv6eyq7llkr2gv50ff9e22mnf70qgjlv737ktmt4eswrq73f2nw";
 
 pub const COCONUT_BANDWIDTH_CONTRACT_ADDRESS: &str = "";
-pub const GROUP_CONTRACT_ADDRESS: &str = "";
-pub const MULTISIG_CONTRACT_ADDRESS: &str = "";
-pub const COCONUT_DKG_CONTRACT_ADDRESS: &str = "";
+pub const GROUP_CONTRACT_ADDRESS: &str =
+    "n1e2zq4886zzewpvpucmlw8v9p7zv692f6yck4zjzxh699dkcmlrfqk2knsr";
+pub const MULTISIG_CONTRACT_ADDRESS: &str =
+    "n1txayqfz5g9qww3rlflpg025xd26m9payz96u54x4fe3s2ktz39xqk67gzx";
+pub const COCONUT_DKG_CONTRACT_ADDRESS: &str =
+    "n19604yflqggs9mk2z26mqygq43q2kr3n932egxx630svywd5mpxjsztfpvx";
 pub const EPHEMERA_CONTRACT_ADDRESS: &str = "";
 
 pub const REWARDING_VALIDATOR_ADDRESS: &str = "n10yyd98e2tuwu0f7ypz9dy3hhjw7v772q6287gy";

common/node-tester-utils/Cargo.toml

@@ -8,7 +8,7 @@ license.workspace = true
 
 [dependencies]
 futures = { workspace = true }
-rand = "0.7.3"
+rand = { workspace = true }
 
 serde = { workspace = true }
 serde_json = { workspace = true }

common/nymcoconut/benches/benchmarks.rs

@@ -6,10 +6,10 @@ use criterion::{criterion_group, criterion_main, Criterion};
 use ff::Field;
 use group::{Curve, Group};
 use nym_coconut::{
-    aggregate_signature_shares, aggregate_verification_keys, blind_sign, prepare_blind_sign,
-    prove_bandwidth_credential, random_scalars_refs, setup, ttp_keygen, verify_credential,
-    verify_partial_blind_signature, Attribute, BlindedSignature, Parameters, Signature,
-    SignatureShare, VerificationKey,
+    aggregate_signature_shares_and_verify, aggregate_verification_keys, blind_sign,
+    prepare_blind_sign, prove_bandwidth_credential, random_scalars_refs, setup, ttp_keygen,
+    verify_credential, verify_partial_blind_signature, Attribute, BlindedSignature, Parameters,
+    Signature, SignatureShare, VerificationKey,
 };
 use rand::seq::SliceRandom;
 use std::ops::Neg;
@@ -99,7 +99,7 @@ fn unblind_and_aggregate(
     let mut attributes = vec![];
     attributes.extend_from_slice(private_attributes);
     attributes.extend_from_slice(public_attributes);
-    aggregate_signature_shares(
+    aggregate_signature_shares_and_verify(
         params,
         verification_key,
         &attributes,

common/nymcoconut/src/lib.rs

@@ -4,14 +4,18 @@
 #![warn(clippy::expect_used)]
 #![warn(clippy::unwrap_used)]
 
+pub use bls12_381::Scalar;
 pub use elgamal::elgamal_keygen;
 pub use elgamal::ElGamalKeyPair;
 pub use elgamal::PublicKey;
 pub use error::CoconutError;
+pub use scheme::aggregation::aggregate_key_shares;
 pub use scheme::aggregation::aggregate_signature_shares;
+pub use scheme::aggregation::aggregate_signature_shares_and_verify;
 pub use scheme::aggregation::aggregate_verification_keys;
 pub use scheme::issuance::blind_sign;
 pub use scheme::issuance::prepare_blind_sign;
+pub use scheme::issuance::sign;
 pub use scheme::issuance::verify_partial_blind_signature;
 pub use scheme::issuance::BlindSignRequest;
 pub use scheme::keygen::keygen;
@@ -19,16 +23,19 @@ pub use scheme::keygen::ttp_keygen;
 pub use scheme::keygen::KeyPair;
 pub use scheme::keygen::SecretKey;
 pub use scheme::keygen::VerificationKey;
+pub use scheme::keygen::VerificationKeyShare;
 pub use scheme::setup::setup;
 pub use scheme::setup::Parameters;
 pub use scheme::verification::check_vk_pairing;
 pub use scheme::verification::prove_bandwidth_credential;
+pub use scheme::verification::verify;
 pub use scheme::verification::verify_credential;
 pub use scheme::verification::BlindedSerialNumber;
 pub use scheme::verification::VerifyCredentialRequest;
 pub use scheme::BlindedSignature;
 pub use scheme::Signature;
 pub use scheme::SignatureShare;
+pub use scheme::SignerIndex;
 pub use traits::Base58;
 pub use traits::Bytable;
 pub use utils::hash_to_scalar;

common/nymcoconut/src/scheme/aggregation.rs

@@ -12,7 +12,7 @@ use crate::error::{CoconutError, Result};
 use crate::scheme::verification::check_bilinear_pairing;
 use crate::scheme::{PartialSignature, Signature, SignatureShare, SignerIndex, VerificationKey};
 use crate::utils::perform_lagrangian_interpolation_at_origin;
-use crate::{Attribute, Parameters};
+use crate::{Attribute, Parameters, VerificationKeyShare};
 
 pub(crate) trait Aggregatable: Sized {
     fn aggregate(aggregatable: &[Self], indices: Option<&[SignerIndex]>) -> Result<Self>;
@@ -80,7 +80,23 @@ pub fn aggregate_verification_keys(
     Aggregatable::aggregate(keys, indices)
 }
 
+pub fn aggregate_key_shares(shares: &[VerificationKeyShare]) -> Result<VerificationKey> {
+    let (keys, indices): (Vec<_>, Vec<_>) = shares
+        .iter()
+        .map(|share| (share.key.clone(), share.index))
+        .unzip();
+
+    aggregate_verification_keys(&keys, Some(&indices))
+}
+
 pub fn aggregate_signatures(
+    signatures: &[PartialSignature],
+    indices: Option<&[SignerIndex]>,
+) -> Result<Signature> {
+    Aggregatable::aggregate(signatures, indices)
+}
+
+pub fn aggregate_signatures_and_verify(
     params: &Parameters,
     verification_key: &VerificationKey,
     attributes: &[&Attribute],
@@ -88,11 +104,7 @@ pub fn aggregate_signatures(
     indices: Option<&[SignerIndex]>,
 ) -> Result<Signature> {
     // aggregate the signature
-
-    let signature = match Aggregatable::aggregate(signatures, indices) {
-        Ok(res) => res,
-        Err(err) => return Err(err),
-    };
+    let signature = aggregate_signatures(signatures, indices)?;
 
     // Verify the signature
     let alpha = verification_key.alpha;
@@ -116,7 +128,16 @@ pub fn aggregate_signatures(
     Ok(signature)
 }
 
-pub fn aggregate_signature_shares(
+pub fn aggregate_signature_shares(shares: &[SignatureShare]) -> Result<Signature> {
+    let (signatures, indices): (Vec<_>, Vec<_>) = shares
+        .iter()
+        .map(|share| (*share.signature(), share.index()))
+        .unzip();
+
+    aggregate_signatures(&signatures, Some(&indices))
+}
+
+pub fn aggregate_signature_shares_and_verify(
     params: &Parameters,
     verification_key: &VerificationKey,
     attributes: &[&Attribute],
@@ -127,7 +148,7 @@ pub fn aggregate_signature_shares(
         .map(|share| (*share.signature(), share.index()))
         .unzip();
 
-    aggregate_signatures(
+    aggregate_signatures_and_verify(
         params,
         verification_key,
         attributes,
@@ -210,7 +231,7 @@ mod tests {
 
     #[test]
     fn signature_aggregation_works_for_any_subset_of_signatures() {
-        let mut params = Parameters::new(2).unwrap();
+        let params = Parameters::new(2).unwrap();
         random_scalars_refs!(attributes, params, 2);
 
         let keypairs = ttp_keygen(&params, 3, 5).unwrap();
@@ -227,12 +248,12 @@ mod tests {
 
         let sigs = sks
             .iter()
-            .map(|sk| sign(&mut params, sk, &attributes).unwrap())
+            .map(|sk| sign(&params, sk, &attributes).unwrap())
             .collect::<Vec<_>>();
 
         // aggregating (any) threshold works
         let aggr_vk_1 = aggregate_verification_keys(&vks[..3], Some(&[1, 2, 3])).unwrap();
-        let aggr_sig1 = aggregate_signatures(
+        let aggr_sig1 = aggregate_signatures_and_verify(
             &params,
             &aggr_vk_1,
             &attributes,
@@ -242,7 +263,7 @@ mod tests {
         .unwrap();
 
         let aggr_vk_2 = aggregate_verification_keys(&vks[2..], Some(&[3, 4, 5])).unwrap();
-        let aggr_sig2 = aggregate_signatures(
+        let aggr_sig2 = aggregate_signatures_and_verify(
             &params,
             &aggr_vk_1,
             &attributes,
@@ -258,7 +279,7 @@ mod tests {
 
         // aggregating threshold+1 works
         let aggr_vk_more = aggregate_verification_keys(&vks[1..], Some(&[2, 3, 4, 5])).unwrap();
-        let aggr_more = aggregate_signatures(
+        let aggr_more = aggregate_signatures_and_verify(
             &params,
             &aggr_vk_more,
             &attributes,
@@ -270,7 +291,7 @@ mod tests {
 
         // aggregating all
         let aggr_vk_all = aggregate_verification_keys(&vks, Some(&[1, 2, 3, 4, 5])).unwrap();
-        let aggr_all = aggregate_signatures(
+        let aggr_all = aggregate_signatures_and_verify(
             &params,
             &aggr_vk_all,
             &attributes,
@@ -282,7 +303,7 @@ mod tests {
 
         // not taking enough points (threshold was 3) should fail
         let aggr_vk_not_enough = aggregate_verification_keys(&vks[..2], Some(&[1, 2])).unwrap();
-        let aggr_not_enough = aggregate_signatures(
+        let aggr_not_enough = aggregate_signatures_and_verify(
             &params,
             &aggr_vk_not_enough,
             &attributes,
@@ -294,7 +315,7 @@ mod tests {
 
         // taking wrong index should fail
         let aggr_vk_bad = aggregate_verification_keys(&vks[2..], Some(&[1, 2, 3])).unwrap();
-        assert!(aggregate_signatures(
+        assert!(aggregate_signatures_and_verify(
             &params,
             &aggr_vk_bad,
             &attributes,
@@ -330,9 +351,14 @@ mod tests {
             .unzip();
 
         let aggr_vk_all = aggregate_verification_keys(&vks, None).unwrap();
-        assert!(
-            aggregate_signatures(&params, &aggr_vk_all, &attributes, &signatures, None).is_err()
-        );
+        assert!(aggregate_signatures_and_verify(
+            &params,
+            &aggr_vk_all,
+            &attributes,
+            &signatures,
+            None
+        )
+        .is_err());
     }
 
     #[test]
@@ -352,11 +378,15 @@ mod tests {
             .unzip();
         let aggr_vk_all = aggregate_verification_keys(&vks, None).unwrap();
 
-        assert!(
-            aggregate_signatures(&params, &aggr_vk_all, &attributes, &signatures, Some(&[]))
-                .is_err()
-        );
-        assert!(aggregate_signatures(
+        assert!(aggregate_signatures_and_verify(
+            &params,
+            &aggr_vk_all,
+            &attributes,
+            &signatures,
+            Some(&[])
+        )
+        .is_err());
+        assert!(aggregate_signatures_and_verify(
             &params,
             &aggr_vk_all,
             &attributes,
@@ -383,7 +413,7 @@ mod tests {
             .unzip();
         let aggr_vk_all = aggregate_verification_keys(&vks, None).unwrap();
 
-        assert!(aggregate_signatures(
+        assert!(aggregate_signatures_and_verify(
             &params,
             &aggr_vk_all,
             &attributes,

common/nymcoconut/src/scheme/issuance.rs

@@ -13,9 +13,8 @@ use crate::scheme::setup::Parameters;
 use crate::scheme::BlindedSignature;
 use crate::scheme::SecretKey;
 use crate::Attribute;
-/// Creates a Coconut Signature under a given secret key on a set of public attributes only.
-#[cfg(test)]
 use crate::Signature;
+
 // TODO: possibly completely remove those two functions.
 // They only exist to have a simpler and smaller code snippets to test
 // basic functionalities.
@@ -158,6 +157,10 @@ impl BlindSignRequest {
         )
     }
 
+    pub fn verify_commitment_hash(&self, public_attributes: &[&Attribute]) -> bool {
+        self.commitment_hash == compute_hash(self.commitment, public_attributes)
+    }
+
     pub fn get_commitment_hash(&self) -> G1Projective {
         self.commitment_hash
     }
@@ -426,9 +429,9 @@ pub fn verify_partial_blind_signature(
         .into()
 }
 
-#[cfg(test)]
+/// Creates a Coconut Signature under a given secret key on a set of public attributes only.
 pub fn sign(
-    params: &mut Parameters,
+    params: &Parameters,
     secret_key: &SecretKey,
     public_attributes: &[&Attribute],
 ) -> Result<Signature> {

common/nymcoconut/src/scheme/keygen.rs

@@ -151,10 +151,6 @@ impl Base58 for SecretKey {}
 // TODO: perhaps change points to affine representation
 // to make verification slightly more efficient?
 #[derive(Debug, PartialEq, Eq, Clone)]
-#[cfg_attr(
-    feature = "key-zeroize",
-    derive(zeroize::Zeroize, zeroize::ZeroizeOnDrop)
-)]
 pub struct VerificationKey {
     // TODO add gen2 as per the paper or imply it from the fact library is using bls381?
     pub(crate) alpha: G2Projective,
@@ -411,12 +407,23 @@ impl Bytable for VerificationKey {
 
 impl Base58 for VerificationKey {}
 
+#[derive(Debug, Clone)]
+pub struct VerificationKeyShare {
+    pub key: VerificationKey,
+    pub index: SignerIndex,
+}
+
+impl From<(VerificationKey, SignerIndex)> for VerificationKeyShare {
+    fn from(value: (VerificationKey, SignerIndex)) -> Self {
+        VerificationKeyShare {
+            key: value.0,
+            index: value.1,
+        }
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 #[cfg_attr(test, derive(PartialEq, Eq, Clone))]
-#[cfg_attr(
-    feature = "key-zeroize",
-    derive(zeroize::Zeroize, zeroize::ZeroizeOnDrop)
-)]
 pub struct KeyPair {
     secret_key: SecretKey,
     verification_key: VerificationKey,
@@ -425,6 +432,12 @@ pub struct KeyPair {
     pub index: Option<SignerIndex>,
 }
 
+impl From<KeyPair> for (SecretKey, VerificationKey) {
+    fn from(value: KeyPair) -> Self {
+        (value.secret_key, value.verification_key)
+    }
+}
+
 impl PemStorableKeyPair for KeyPair {
     type PrivatePemKey = SecretKey;
     type PublicPemKey = VerificationKey;
@@ -461,6 +474,13 @@ impl KeyPair {
         &self.verification_key
     }
 
+    pub fn to_verification_key_share(&self) -> Option<VerificationKeyShare> {
+        self.index.map(|index| VerificationKeyShare {
+            key: self.verification_key.clone(),
+            index,
+        })
+    }
+
     pub fn to_bytes(&self) -> Vec<u8> {
         // Schema is coconutkeypair[14]|secret_key_len[8]|secret_key[secret_key_len]|verification_key_len[8]|verification_key[verification_key_len]|signer_index[8] - optional
         self.to_byte_vec()

common/nymcoconut/src/scheme/mod.rs

@@ -70,6 +70,11 @@ impl Signature {
         &self.1
     }
 
+    pub fn randomise_simple(&self, params: &Parameters) -> Signature {
+        let r = params.random_scalar();
+        Signature(self.0 * r, self.1 * r)
+    }
+
     pub fn randomise(&self, params: &Parameters) -> (Signature, Scalar) {
         let r = params.random_scalar();
         let r_prime = params.random_scalar();
@@ -191,7 +196,7 @@ impl BlindedSignature {
         &self,
         partial_verification_key: &VerificationKey,
         pedersen_commitments_openings: &[Scalar],
-    ) -> Result<Signature> {
+    ) -> Signature {
         // parse the signature
         let h = &self.0;
         let c = &self.1;
@@ -204,7 +209,7 @@ impl BlindedSignature {
 
         let unblinded_c = c - blinding_removers;
 
-        Ok(Signature(*h, unblinded_c))
+        Signature(*h, unblinded_c)
     }
 
     pub fn unblind_and_verify(
@@ -216,7 +221,7 @@ impl BlindedSignature {
         commitment_hash: &G1Projective,
         pedersen_commitments_openings: &[Scalar],
     ) -> Result<Signature> {
-        let unblinded = self.unblind(partial_verification_key, pedersen_commitments_openings)?;
+        let unblinded = self.unblind(partial_verification_key, pedersen_commitments_openings);
         unblinded.verify(
             params,
             partial_verification_key,
@@ -240,6 +245,7 @@ impl BlindedSignature {
 }
 
 // perhaps this should take signature by reference? we'll see how it goes
+#[derive(Clone, Copy)]
 pub struct SignatureShare {
     signature: Signature,
     index: SignerIndex,
@@ -276,7 +282,9 @@ impl SignatureShare {
 mod tests {
     use super::*;
     use crate::hash_to_scalar;
-    use crate::scheme::aggregation::{aggregate_signatures, aggregate_verification_keys};
+    use crate::scheme::aggregation::{
+        aggregate_signatures_and_verify, aggregate_verification_keys,
+    };
     use crate::scheme::issuance::{blind_sign, compute_hash, prepare_blind_sign, sign};
     use crate::scheme::keygen::{keygen, ttp_keygen};
     use crate::scheme::verification::{prove_bandwidth_credential, verify, verify_credential};
@@ -418,13 +426,13 @@ mod tests {
 
     #[test]
     fn verification_on_two_public_attributes() {
-        let mut params = Parameters::new(2).unwrap();
+        let params = Parameters::new(2).unwrap();
         random_scalars_refs!(attributes, params, 2);
 
         let keypair1 = keygen(&params);
         let keypair2 = keygen(&params);
-        let sig1 = sign(&mut params, keypair1.secret_key(), &attributes).unwrap();
-        let sig2 = sign(&mut params, keypair2.secret_key(), &attributes).unwrap();
+        let sig1 = sign(&params, keypair1.secret_key(), &attributes).unwrap();
+        let sig2 = sign(&params, keypair2.secret_key(), &attributes).unwrap();
 
         assert!(verify(
             &params,
@@ -568,9 +576,14 @@ mod tests {
         attributes.extend_from_slice(&public_attributes);
 
         let aggr_vk = aggregate_verification_keys(&vks[..2], Some(&[1, 2])).unwrap();
-        let aggr_sig =
-            aggregate_signatures(&params, &aggr_vk, &attributes, &sigs[..2], Some(&[1, 2]))
-                .unwrap();
+        let aggr_sig = aggregate_signatures_and_verify(
+            &params,
+            &aggr_vk,
+            &attributes,
+            &sigs[..2],
+            Some(&[1, 2]),
+        )
+        .unwrap();
 
         let theta = prove_bandwidth_credential(
             &params,
@@ -590,9 +603,14 @@ mod tests {
 
         // taking different subset of keys and credentials
         let aggr_vk = aggregate_verification_keys(&vks[1..], Some(&[2, 3])).unwrap();
-        let aggr_sig =
-            aggregate_signatures(&params, &aggr_vk, &attributes, &sigs[1..], Some(&[2, 3]))
-                .unwrap();
+        let aggr_sig = aggregate_signatures_and_verify(
+            &params,
+            &aggr_vk,
+            &attributes,
+            &sigs[1..],
+            Some(&[2, 3]),
+        )
+        .unwrap();
 
         let theta = prove_bandwidth_credential(
             &params,

common/nymcoconut/src/scheme/setup.rs

@@ -10,6 +10,7 @@ use crate::error::{CoconutError, Result};
 use crate::utils::hash_g1;
 
 /// System-wide parameters used for the protocol
+#[derive(Clone)]
 pub struct Parameters {
     /// Generator of the G1 group
     g1: G1Affine,

common/nymcoconut/src/scheme/verification.rs

@@ -288,7 +288,6 @@ pub fn verify_credential(
 }
 
 // Used in tests only
-#[cfg(test)]
 pub fn verify(
     params: &Parameters,
     verification_key: &VerificationKey,

common/nymcoconut/src/tests/helpers.rs

@@ -75,8 +75,12 @@ pub fn theta_from_keys_and_attributes(
     attributes.extend_from_slice(public_attributes);
 
     // Randomize credentials and generate any cryptographic material to verify them
-    let signature =
-        aggregate_signature_shares(params, &verification_key, &attributes, &signature_shares)?;
+    let signature = aggregate_signature_shares_and_verify(
+        params,
+        &verification_key,
+        &attributes,
+        &signature_shares,
+    )?;
 
     // Generate cryptographic material to verify them
     let theta = prove_bandwidth_credential(

common/nymsphinx/Cargo.toml

@@ -9,8 +9,8 @@ repository = { workspace = true }
 
 [dependencies]
 log = { workspace = true }
-rand = { version = "0.7.3", features = ["wasm-bindgen"] }
-rand_distr = "0.3"
+rand = { workspace = true }
+rand_distr = "0.4"
 thiserror = { workspace = true }
 
 nym-sphinx-acknowledgements = { path = "acknowledgements" }

common/nymsphinx/acknowledgements/Cargo.toml

@@ -8,7 +8,7 @@ license = { workspace = true }
 repository = { workspace = true }
 
 [dependencies]
-rand = { version = "0.7.3", features = ["wasm-bindgen"] }
+rand = { workspace = true }
 serde_crate = { version = "1.0", optional = true, default_features = false, features = ["derive"], package = "serde" }
 generic-array = { workspace = true, optional = true, features = ["serde"] }
 thiserror = { workspace = true }

common/nymsphinx/addressing/Cargo.toml

@@ -14,5 +14,5 @@ serde = "1.0" # implementing serialization/deserialization for some types, like
 thiserror = { workspace = true }
 
 [dev-dependencies]
-rand = "0.7"
+rand = "0.8.5"
 nym-crypto = { path = "../../crypto", features = ["rand"] }

common/nymsphinx/addressing/src/lib.rs

@@ -3,3 +3,6 @@
 
 pub mod clients;
 pub mod nodes;
+
+pub use clients::Recipient;
+pub use nodes::NodeIdentity;

common/nymsphinx/anonymous-replies/Cargo.toml

@@ -8,7 +8,7 @@ license = { workspace = true }
 repository = { workspace = true }
 
 [dependencies]
-rand = { version = "0.7.3", features = ["wasm-bindgen"] }
+rand = { workspace = true }
 bs58 = { workspace = true }
 serde = { workspace = true }
 thiserror = { workspace = true }
@@ -24,4 +24,4 @@ nym-topology = { path = "../../topology" }
 version = "0.2.83"
 
 [dev-dependencies]
-rand_chacha = "0.2"
+rand_chacha = "0.3"

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

@@ -570,7 +570,7 @@ mod tests {
             let mut address_bytes = [0; NODE_ADDRESS_LENGTH];
             rng.fill_bytes(&mut address_bytes);
 
-            let dummy_private = PrivateKey::new_with_rng(rng);
+            let dummy_private = PrivateKey::random_from_rng(rng);
             let pub_key = (&dummy_private).into();
             Node {
                 address: NodeAddressBytes::from_bytes(address_bytes),

common/nymsphinx/chunking/Cargo.toml

@@ -11,7 +11,7 @@ repository = { workspace = true }
 
 [dependencies]
 log = { workspace = true }
-rand = { version = "0.7.3", features = ["wasm-bindgen"] }
+rand = { workspace = true }
 thiserror = { workspace = true }
 
 nym-sphinx-addressing = { path = "../addressing" }

common/nymsphinx/cover/Cargo.toml

@@ -8,7 +8,7 @@ license = { workspace = true }
 repository = { workspace = true }
 
 [dependencies]
-rand = { version = "0.7.3", features = ["wasm-bindgen"] }
+rand = { workspace = true }
 thiserror = { workspace = true }
 
 nym-crypto = { path = "../../crypto" }

common/nymsphinx/framing/src/codec.rs

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

common/nymsphinx/types/Cargo.toml

@@ -8,7 +8,7 @@ license = { workspace = true }
 repository = { workspace = true }
 
 [dependencies]
-sphinx-packet = { version = "0.1.0", optional = true }
+sphinx-packet = { version = "0.2.0", optional = true }
 nym-outfox = { path = "../../../nym-outfox", optional = true }
 thiserror = { workspace = true }
 

common/nymsphinx/types/src/lib.rs

@@ -15,13 +15,13 @@ pub use sphinx_packet::{
         self, DESTINATION_ADDRESS_LENGTH, IDENTIFIER_LENGTH, MAX_PATH_LENGTH, NODE_ADDRESS_LENGTH,
         PAYLOAD_KEY_SIZE,
     },
-    crypto::{self, EphemeralSecret, PrivateKey, PublicKey, SharedSecret},
+    crypto::{self, PrivateKey, PublicKey},
     header::{self, delays, delays::Delay, ProcessedHeader, SphinxHeader, HEADER_SIZE},
     packet::builder::DEFAULT_PAYLOAD_SIZE,
     payload::{Payload, PAYLOAD_OVERHEAD_SIZE},
     route::{Destination, DestinationAddressBytes, Node, NodeAddressBytes, SURBIdentifier},
     surb::{SURBMaterial, SURB},
-    Error as SphinxError, ProcessedPacket,
+    test_utils, Error as SphinxError, ProcessedPacket,
 };
 #[cfg(feature = "sphinx")]
 use sphinx_packet::{SphinxPacket, SphinxPacketBuilder};

common/nyxd-scraper/Cargo.toml

@@ -16,7 +16,9 @@ const_format = "0.2.32"
 cosmrs.workspace = true
 eyre = "0.6.9"
 futures.workspace = true
+humantime = "2.1.0"
 sha2 = "0.10.8"
+serde = { workspace = true, features = ["derive"] }
 sqlx = { workspace = true, features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate", "time"] }
 tendermint.workspace = true
 tendermint-rpc = { workspace = true, features = ["websocket-client", "http-client"] }
@@ -24,13 +26,13 @@ thiserror.workspace = true
 time = { workspace = true }
 tokio = { workspace = true, features = ["full"] }
 tokio-stream = "0.1.14"
-tokio-util = { version = "0.7.10", features = ["rt"]}
+tokio-util = { version = "0.7.10", features = ["rt"] }
 tracing.workspace = true
 url.workspace = true
 
 
 # TEMP
-nym-bin-common = { path = "../bin-common", features = ["basic_tracing"]}
+#nym-bin-common = { path = "../bin-common", features = ["basic_tracing"]}
 
 
 [build-dependencies]

common/nyxd-scraper/README.md

@@ -0,0 +1,23 @@
+# Nyxd Scraper
+
+## Pruning
+
+Similarly to cosmos-sdk, we incorporate pruning into our (scraped) chain data. We attempt to follow their strategies as
+closely as possible for convenience's sake. Therefore, the following are available:
+
+### Strategies
+
+The strategies are configured in `config.toml`, with the format `pruning = "<strategy>"` where the options are:
+
+* `default`: only the last 362,880 states(approximately 3.5 weeks worth of state) are kept; pruning at 10 block
+  intervals
+* `nothing`: all historic states will be saved, nothing will be deleted (i.e. archiving node)
+* `everything`: 2 latest states will be kept; pruning at 10 block intervals.
+* `custom`: allow pruning options to be manually specified through `pruning.keep_recent`, and `pruning.interval`
+
+### Custom Pruning
+
+These are applied if and only if the pruning strategy is `custom`:
+
+* `pruning.keep_recent`: N means to keep all of the last N blocks
+* `pruning.interval`: N means to delete old block data from disk every Nth block.

common/nyxd-scraper/src/block_processor/mod.rs

@@ -8,6 +8,7 @@ use crate::error::ScraperError;
 use crate::modules::{BlockModule, MsgModule, TxModule};
 use crate::rpc_client::RpcClient;
 use crate::storage::{persist_block, ScraperStorage};
+use crate::PruningOptions;
 use futures::StreamExt;
 use std::collections::{BTreeMap, HashSet, VecDeque};
 use std::ops::{Add, Range};
@@ -18,9 +19,10 @@ use tokio::sync::Notify;
 use tokio::time::{interval_at, Instant};
 use tokio_stream::wrappers::UnboundedReceiverStream;
 use tokio_util::sync::CancellationToken;
-use tracing::{debug, error, info, warn};
+use tracing::{debug, error, info, instrument, trace, warn};
 
 mod helpers;
+pub(crate) mod pruning;
 pub(crate) mod types;
 
 const MISSING_BLOCKS_CHECK_INTERVAL: Duration = Duration::from_secs(30);
@@ -40,9 +42,11 @@ impl PendingSync {
 }
 
 pub struct BlockProcessor {
+    pruning_options: PruningOptions,
     cancel: CancellationToken,
     synced: Arc<Notify>,
     last_processed_height: u32,
+    last_pruned_height: u32,
     last_processed_at: Instant,
     pending_sync: PendingSync,
     queued_blocks: BTreeMap<u32, BlockToProcess>,
@@ -62,6 +66,7 @@ pub struct BlockProcessor {
 
 impl BlockProcessor {
     pub async fn new(
+        pruning_options: PruningOptions,
         cancel: CancellationToken,
         synced: Arc<Notify>,
         incoming: UnboundedReceiver<BlockToProcess>,
@@ -70,11 +75,17 @@ impl BlockProcessor {
         rpc_client: RpcClient,
     ) -> Result<Self, ScraperError> {
         let last_processed = storage.get_last_processed_height().await?;
+        let last_processed_height = last_processed.try_into().unwrap_or_default();
+
+        let last_pruned = storage.get_pruned_height().await?;
+        let last_pruned_height = last_pruned.try_into().unwrap_or_default();
 
         Ok(BlockProcessor {
+            pruning_options,
             cancel,
             synced,
-            last_processed_height: last_processed.try_into().unwrap_or_default(),
+            last_processed_height,
+            last_pruned_height,
             last_processed_at: Instant::now(),
             pending_sync: Default::default(),
             queued_blocks: Default::default(),
@@ -131,12 +142,17 @@ impl BlockProcessor {
             }
         }
 
+        let commit_start = Instant::now();
         tx.commit()
             .await
             .map_err(|source| ScraperError::StorageTxCommitFailure { source })?;
+        crate::storage::log_db_operation_time("committing processing tx", commit_start);
 
         self.last_processed_height = full_info.block.header.height.value() as u32;
         self.last_processed_at = Instant::now();
+        if let Err(err) = self.maybe_prune_storage().await {
+            error!("failed to prune the storage: {err}");
+        }
 
         Ok(())
     }
@@ -210,6 +226,61 @@ impl BlockProcessor {
         Ok(())
     }
 
+    #[instrument(skip(self))]
+    async fn prune_storage(&mut self) -> Result<(), ScraperError> {
+        let keep_recent = self.pruning_options.strategy_keep_recent();
+        let last_to_keep = self.last_processed_height - keep_recent;
+
+        info!(
+            keep_recent,
+            oldest_to_keep = last_to_keep,
+            "pruning the storage"
+        );
+
+        let lowest: u32 = self
+            .storage
+            .lowest_block_height()
+            .await?
+            .unwrap_or_default()
+            .try_into()
+            .unwrap_or_default();
+
+        let to_prune = last_to_keep.saturating_sub(lowest);
+        match to_prune {
+            v if v > 1000 => warn!("approximately {v} blocks worth of data will be pruned"),
+            v if v > 100 => info!("approximately {v} blocks worth of data will be pruned"),
+            0 => trace!("no blocks to prune"),
+            v => debug!("approximately {v} blocks worth of data will be pruned"),
+        }
+
+        if to_prune == 0 {
+            return Ok(());
+        }
+
+        self.storage
+            .prune_storage(last_to_keep, self.last_processed_height)
+            .await?;
+
+        self.last_pruned_height = self.last_processed_height;
+        Ok(())
+    }
+
+    async fn maybe_prune_storage(&mut self) -> Result<(), ScraperError> {
+        debug!("checking for storage pruning");
+
+        if self.pruning_options.strategy.is_nothing() {
+            trace!("the current pruning strategy is 'nothing'");
+            return Ok(());
+        }
+
+        let interval = self.pruning_options.strategy_interval();
+        if self.last_pruned_height + interval <= self.last_processed_height {
+            self.prune_storage().await?;
+        }
+
+        Ok(())
+    }
+
     async fn next_incoming(&mut self, block: BlockToProcess) {
         let height = block.height;
 
@@ -279,6 +350,8 @@ impl BlockProcessor {
     async fn startup_resync(&mut self) -> Result<(), ScraperError> {
         assert!(self.pending_sync.is_empty());
 
+        self.maybe_prune_storage().await?;
+
         let latest_block = self.rpc_client.current_block_height().await? as u32;
         if latest_block > self.last_processed_height && self.last_processed_height != 0 {
             let request_range = self.last_processed_height + 1..latest_block + 1;